Clang-format of source files

1 files changed, 2807 insertions, 2738 deletions

diff --git a/src/H5Shyper.c b/src/H5Shyper.c
index 95bce29..6b3d750 100644
--- a/src/H5Shyper.c
+++ b/src/H5Shyper.c
@@ -22,21 +22,19 @@
 /* Module Setup */
 /****************/
 
-#include "H5Smodule.h"          /* This source code file is part of the H5S module */
-
+#include "H5Smodule.h" /* This source code file is part of the H5S module */
 
 /***********/
 /* Headers */
 /***********/
-#include "H5private.h"          /* Generic Functions                        */
-#include "H5CXprivate.h"        /* API Contexts                             */
-#include "H5Eprivate.h"         /* Error handling                           */
-#include "H5FLprivate.h"        /* Free Lists                               */
-#include "H5Iprivate.h"         /* ID Functions                             */
-#include "H5MMprivate.h"        /* Memory management                        */
-#include "H5Spkg.h"             /* Dataspace functions                      */
-#include "H5VMprivate.h"        /* Vector functions                         */
-
+#include "H5private.h"   /* Generic Functions                        */
+#include "H5CXprivate.h" /* API Contexts                             */
+#include "H5Eprivate.h"  /* Error handling                           */
+#include "H5FLprivate.h" /* Free Lists                               */
+#include "H5Iprivate.h"  /* ID Functions                             */
+#include "H5MMprivate.h" /* Memory management                        */
+#include "H5Spkg.h"      /* Dataspace functions                      */
+#include "H5VMprivate.h" /* Vector functions                         */
 
 /****************/
 /* Local Macros */
@@ -48,32 +46,31 @@
 #define H5S_HYPER_COMPUTE_A_NOT_B 0x04
 
 /* Macro to advance a span, possibly recycling it first */
-#define H5S_HYPER_ADVANCE_SPAN(recover, curr_span, next_span)   \
-    do {                                                        \
-        H5S_hyper_span_t *saved_next_span = (next_span);        \
-                                                                \
-        /* Check if the span should be recovered */             \
-        if(recover) {                                           \
-            H5S__hyper_free_span(curr_span);                    \
-            (recover) = FALSE;                                  \
-        } /* end if */                                          \
-                                                                \
-        /* Set the current span to saved next span */           \
-        (curr_span) = saved_next_span;                          \
-    } while(0)
+#define H5S_HYPER_ADVANCE_SPAN(recover, curr_span, next_span)                                                \
+    do {                                                                                                     \
+        H5S_hyper_span_t *saved_next_span = (next_span);                                                     \
+                                                                                                             \
+        /* Check if the span should be recovered */                                                          \
+        if (recover) {                                                                                       \
+            H5S__hyper_free_span(curr_span);                                                                 \
+            (recover) = FALSE;                                                                               \
+        } /* end if */                                                                                       \
+                                                                                                             \
+        /* Set the current span to saved next span */                                                        \
+        (curr_span) = saved_next_span;                                                                       \
+    } while (0)
 
 /* Macro to add "skipped" elements to projection during the execution of
  * H5S__hyper_project_intersect() */
-#define H5S_HYPER_PROJ_INT_ADD_SKIP(UDATA, ADD, ERR)            \
-    do {                                                        \
-        /* If there are any elements to add, we must add them   \
-         * to the projection first before adding skip */        \
-        if((UDATA)->nelem > 0)                                  \
-            if(H5S__hyper_proj_int_build_proj(UDATA) < 0)       \
+#define H5S_HYPER_PROJ_INT_ADD_SKIP(UDATA, ADD, ERR)                                                         \
+    do {                                                                                                     \
+        /* If there are any elements to add, we must add them                                                \
+         * to the projection first before adding skip */                                                     \
+        if ((UDATA)->nelem > 0)                                                                              \
+            if (H5S__hyper_proj_int_build_proj(UDATA) < 0)                                                   \
                 HGOTO_ERROR(H5E_DATASPACE, H5E_CANTAPPEND, ERR, "can't add elements to projected selection") \
-        (UDATA)->skip += (ADD);                                 \
-    } while(0) /* end H5S_HYPER_PROJ_INT_ADD_SKIP() */
-
+        (UDATA)->skip += (ADD);                                                                              \
+    } while (0) /* end H5S_HYPER_PROJ_INT_ADD_SKIP() */
 
 /******************/
 /* Local Typedefs */
@@ -86,17 +83,20 @@ typedef hsize_t hbounds_t;
 /* Struct for holding persistent information during iteration for
  * H5S__hyper_project_intersect() */
 typedef struct {
-    const H5S_hyper_span_t *ds_span[H5S_MAX_RANK]; /* Array of the current spans in the destination space in each dimension */
+    const H5S_hyper_span_t
+        *   ds_span[H5S_MAX_RANK]; /* Array of the current spans in the destination space in each dimension */
     hsize_t ds_low[H5S_MAX_RANK]; /* Array of current low bounds (of iteration) for each element in ds_span */
-    H5S_hyper_span_info_t *ps_span_info[H5S_MAX_RANK]; /* Array of span info structs for projected space during iteration */
-    uint32_t  ps_clean_bitmap; /* Bitmap of whether the nth rank has a clean projected space since the last time it was set to 1 */
-    unsigned ss_rank;       /* Rank of source space */
-    unsigned ds_rank;       /* Rank of destination space */
-    unsigned depth;         /* Current depth of iterator in destination space */
-    hsize_t skip;           /* Number of elements to skip in projected space */
-    hsize_t nelem;          /* Number of elements to add to projected space (after skip) */
-    uint64_t op_gen;        /* Operation generation for counting elements */
-    hbool_t share_selection; /* Whether span trees in dst_space can be shared with proj_space */
+    H5S_hyper_span_info_t
+        *    ps_span_info[H5S_MAX_RANK]; /* Array of span info structs for projected space during iteration */
+    uint32_t ps_clean_bitmap; /* Bitmap of whether the nth rank has a clean projected space since the last
+                                 time it was set to 1 */
+    unsigned ss_rank;         /* Rank of source space */
+    unsigned ds_rank;         /* Rank of destination space */
+    unsigned depth;           /* Current depth of iterator in destination space */
+    hsize_t  skip;            /* Number of elements to skip in projected space */
+    hsize_t  nelem;           /* Number of elements to add to projected space (after skip) */
+    uint64_t op_gen;          /* Operation generation for counting elements */
+    hbool_t  share_selection; /* Whether span trees in dst_space can be shared with proj_space */
 } H5S_hyper_project_intersect_ud_t;
 
 /* Assert that H5S_MAX_RANK is <= 32 so our trick with using a 32 bit bitmap
@@ -106,116 +106,106 @@ typedef struct {
 #error H5S_MAX_RANK too large for ps_clean_bitmap field in H5S_hyper_project_intersect_ud_t struct
 #endif
 
-
 /********************/
 /* Local Prototypes */
 /********************/
-static H5S_hyper_span_t *H5S__hyper_new_span(hsize_t low, hsize_t high,
-    H5S_hyper_span_info_t *down, H5S_hyper_span_t *next);
+static H5S_hyper_span_t *     H5S__hyper_new_span(hsize_t low, hsize_t high, H5S_hyper_span_info_t *down,
+                                                  H5S_hyper_span_t *next);
 static H5S_hyper_span_info_t *H5S__hyper_new_span_info(unsigned rank);
-static H5S_hyper_span_info_t *H5S__hyper_copy_span_helper(
-    H5S_hyper_span_info_t *spans, unsigned rank, unsigned op_info_i,
-    uint64_t op_gen);
-static H5S_hyper_span_info_t *H5S__hyper_copy_span(H5S_hyper_span_info_t *spans,
-    unsigned rank);
-static hbool_t H5S__hyper_cmp_spans(const H5S_hyper_span_info_t *span_info1,
-    const H5S_hyper_span_info_t *span_info2);
-static void H5S__hyper_free_span_info(H5S_hyper_span_info_t *span_info);
-static void H5S__hyper_free_span(H5S_hyper_span_t *span);
-static herr_t H5S__hyper_span_blocklist(const H5S_hyper_span_info_t *spans,
-    hsize_t start[], hsize_t end[], hsize_t rank, hsize_t *startblock, hsize_t *numblocks,
-    hsize_t **buf);
-static herr_t H5S__get_select_hyper_blocklist(H5S_t *space, hsize_t startblock,
-    hsize_t numblocks, hsize_t *buf);
+static H5S_hyper_span_info_t *H5S__hyper_copy_span_helper(H5S_hyper_span_info_t *spans, unsigned rank,
+                                                          unsigned op_info_i, uint64_t op_gen);
+static H5S_hyper_span_info_t *H5S__hyper_copy_span(H5S_hyper_span_info_t *spans, unsigned rank);
+static hbool_t                H5S__hyper_cmp_spans(const H5S_hyper_span_info_t *span_info1,
+                                                   const H5S_hyper_span_info_t *span_info2);
+static void                   H5S__hyper_free_span_info(H5S_hyper_span_info_t *span_info);
+static void                   H5S__hyper_free_span(H5S_hyper_span_t *span);
+static herr_t H5S__hyper_span_blocklist(const H5S_hyper_span_info_t *spans, hsize_t start[], hsize_t end[],
+                                        hsize_t rank, hsize_t *startblock, hsize_t *numblocks, hsize_t **buf);
+static herr_t H5S__get_select_hyper_blocklist(H5S_t *space, hsize_t startblock, hsize_t numblocks,
+                                              hsize_t *buf);
 static H5S_hyper_span_t *H5S__hyper_coord_to_span(unsigned rank, const hsize_t *coords);
-static herr_t H5S__hyper_append_span(H5S_hyper_span_info_t **span_tree,
-    unsigned ndims, hsize_t low, hsize_t high, H5S_hyper_span_info_t *down);
-static herr_t H5S__hyper_clip_spans(H5S_hyper_span_info_t *a_spans,
-    H5S_hyper_span_info_t *b_spans, unsigned selector,
-    unsigned ndims, H5S_hyper_span_info_t **a_not_b,
-    H5S_hyper_span_info_t **a_and_b, H5S_hyper_span_info_t **b_not_a);
-static herr_t H5S__hyper_merge_spans(H5S_t *space, H5S_hyper_span_info_t *new_spans);
-static hsize_t H5S__hyper_spans_nelem_helper(H5S_hyper_span_info_t *spans,
-    unsigned op_info_i, uint64_t op_gen);
+static herr_t  H5S__hyper_append_span(H5S_hyper_span_info_t **span_tree, unsigned ndims, hsize_t low,
+                                      hsize_t high, H5S_hyper_span_info_t *down);
+static herr_t  H5S__hyper_clip_spans(H5S_hyper_span_info_t *a_spans, H5S_hyper_span_info_t *b_spans,
+                                     unsigned selector, unsigned ndims, H5S_hyper_span_info_t **a_not_b,
+                                     H5S_hyper_span_info_t **a_and_b, H5S_hyper_span_info_t **b_not_a);
+static herr_t  H5S__hyper_merge_spans(H5S_t *space, H5S_hyper_span_info_t *new_spans);
+static hsize_t H5S__hyper_spans_nelem_helper(H5S_hyper_span_info_t *spans, unsigned op_info_i,
+                                             uint64_t op_gen);
 static hsize_t H5S__hyper_spans_nelem(H5S_hyper_span_info_t *spans);
-static herr_t H5S__hyper_add_disjoint_spans(H5S_t *space, H5S_hyper_span_info_t *new_spans);
-static H5S_hyper_span_info_t *H5S__hyper_make_spans(unsigned rank,
-    const hsize_t *start, const hsize_t *stride,
-    const hsize_t *count, const hsize_t *block);
-static herr_t H5S__hyper_update_diminfo(H5S_t *space, H5S_seloper_t op,
-    const H5S_hyper_dim_t *new_hyper_diminfo);
-static herr_t H5S__hyper_generate_spans(H5S_t *space);
-static hbool_t H5S__check_spans_overlap(const H5S_hyper_span_info_t *spans1,
-    const H5S_hyper_span_info_t *spans2);
-static herr_t H5S__fill_in_new_space(H5S_t *space1, H5S_seloper_t op,
-    H5S_hyper_span_info_t *space2_span_lst, hbool_t can_own_span2,
-    hbool_t *span2_owned, hbool_t *updated_spans, H5S_t **result);
-static herr_t H5S__generate_hyperslab(H5S_t *space, H5S_seloper_t op,
-    const hsize_t start[], const hsize_t stride[], const hsize_t count[],
-    const hsize_t block[]);
-static herr_t H5S__set_regular_hyperslab(H5S_t *space, const hsize_t start[],
-    const hsize_t *app_stride, const hsize_t app_count[], const hsize_t *app_block,
-    const hsize_t *opt_stride, const hsize_t opt_count[], const hsize_t *opt_block);
-static herr_t H5S__fill_in_select(H5S_t *space1, H5S_seloper_t op, H5S_t *space2,
-    H5S_t **result);
-static H5S_t *H5S__combine_select(H5S_t *space1, H5S_seloper_t op, H5S_t *space2);
-static herr_t H5S__hyper_iter_get_seq_list_gen(H5S_sel_iter_t *iter, size_t maxseq,
-    size_t maxelem, size_t *nseq, size_t *nelem, hsize_t *off, size_t *len);
-static herr_t H5S__hyper_iter_get_seq_list_opt(H5S_sel_iter_t *iter, size_t maxseq,
-    size_t maxelem, size_t *nseq, size_t *nelem, hsize_t *off, size_t *len);
-static herr_t H5S__hyper_iter_get_seq_list_single(H5S_sel_iter_t *iter, size_t maxseq,
-    size_t maxelem, size_t *nseq, size_t *nelem, hsize_t *off, size_t *len);
-static herr_t H5S__hyper_proj_int_build_proj(H5S_hyper_project_intersect_ud_t *udata);
-static herr_t H5S__hyper_proj_int_iterate(const H5S_hyper_span_info_t *ss_span_info,
-    const H5S_hyper_span_info_t *sis_span_info, hsize_t count, unsigned depth,
-    H5S_hyper_project_intersect_ud_t *udata);
-static void H5S__hyper_get_clip_diminfo(hsize_t start, hsize_t stride,
-    hsize_t *count, hsize_t *block, hsize_t clip_size);
-static hsize_t H5S__hyper_get_clip_extent_real(const H5S_t *clip_space,
-    hsize_t num_slices, hbool_t incl_trail);
+static herr_t  H5S__hyper_add_disjoint_spans(H5S_t *space, H5S_hyper_span_info_t *new_spans);
+static H5S_hyper_span_info_t *H5S__hyper_make_spans(unsigned rank, const hsize_t *start,
+                                                    const hsize_t *stride, const hsize_t *count,
+                                                    const hsize_t *block);
+static herr_t                 H5S__hyper_update_diminfo(H5S_t *space, H5S_seloper_t op,
+                                                        const H5S_hyper_dim_t *new_hyper_diminfo);
+static herr_t                 H5S__hyper_generate_spans(H5S_t *space);
+static hbool_t                H5S__check_spans_overlap(const H5S_hyper_span_info_t *spans1,
+                                                       const H5S_hyper_span_info_t *spans2);
+static herr_t  H5S__fill_in_new_space(H5S_t *space1, H5S_seloper_t op, H5S_hyper_span_info_t *space2_span_lst,
+                                      hbool_t can_own_span2, hbool_t *span2_owned, hbool_t *updated_spans,
+                                      H5S_t **result);
+static herr_t  H5S__generate_hyperslab(H5S_t *space, H5S_seloper_t op, const hsize_t start[],
+                                       const hsize_t stride[], const hsize_t count[], const hsize_t block[]);
+static herr_t  H5S__set_regular_hyperslab(H5S_t *space, const hsize_t start[], const hsize_t *app_stride,
+                                          const hsize_t app_count[], const hsize_t *app_block,
+                                          const hsize_t *opt_stride, const hsize_t opt_count[],
+                                          const hsize_t *opt_block);
+static herr_t  H5S__fill_in_select(H5S_t *space1, H5S_seloper_t op, H5S_t *space2, H5S_t **result);
+static H5S_t * H5S__combine_select(H5S_t *space1, H5S_seloper_t op, H5S_t *space2);
+static herr_t  H5S__hyper_iter_get_seq_list_gen(H5S_sel_iter_t *iter, size_t maxseq, size_t maxelem,
+                                                size_t *nseq, size_t *nelem, hsize_t *off, size_t *len);
+static herr_t  H5S__hyper_iter_get_seq_list_opt(H5S_sel_iter_t *iter, size_t maxseq, size_t maxelem,
+                                                size_t *nseq, size_t *nelem, hsize_t *off, size_t *len);
+static herr_t  H5S__hyper_iter_get_seq_list_single(H5S_sel_iter_t *iter, size_t maxseq, size_t maxelem,
+                                                   size_t *nseq, size_t *nelem, hsize_t *off, size_t *len);
+static herr_t  H5S__hyper_proj_int_build_proj(H5S_hyper_project_intersect_ud_t *udata);
+static herr_t  H5S__hyper_proj_int_iterate(const H5S_hyper_span_info_t *ss_span_info,
+                                           const H5S_hyper_span_info_t *sis_span_info, hsize_t count,
+                                           unsigned depth, H5S_hyper_project_intersect_ud_t *udata);
+static void    H5S__hyper_get_clip_diminfo(hsize_t start, hsize_t stride, hsize_t *count, hsize_t *block,
+                                           hsize_t clip_size);
+static hsize_t H5S__hyper_get_clip_extent_real(const H5S_t *clip_space, hsize_t num_slices,
+                                               hbool_t incl_trail);
 
 /* Selection callbacks */
-static herr_t H5S__hyper_copy(H5S_t *dst, const H5S_t *src, hbool_t share_selection);
-static herr_t H5S__hyper_release(H5S_t *space);
-static htri_t H5S__hyper_is_valid(const H5S_t *space);
-static hsize_t H5S__hyper_span_nblocks(H5S_hyper_span_info_t *spans);
+static herr_t   H5S__hyper_copy(H5S_t *dst, const H5S_t *src, hbool_t share_selection);
+static herr_t   H5S__hyper_release(H5S_t *space);
+static htri_t   H5S__hyper_is_valid(const H5S_t *space);
+static hsize_t  H5S__hyper_span_nblocks(H5S_hyper_span_info_t *spans);
 static hssize_t H5S__hyper_serial_size(const H5S_t *space);
-static herr_t H5S__hyper_serialize(const H5S_t *space, uint8_t **p);
-static herr_t H5S__hyper_deserialize(H5S_t **space, const uint8_t **p);
-static herr_t H5S__hyper_bounds(const H5S_t *space, hsize_t *start, hsize_t *end);
-static herr_t H5S__hyper_offset(const H5S_t *space, hsize_t *offset);
-static int H5S__hyper_unlim_dim(const H5S_t *space);
-static herr_t H5S__hyper_num_elem_non_unlim(const H5S_t *space,
-    hsize_t *num_elem_non_unlim);
-static htri_t H5S__hyper_is_contiguous(const H5S_t *space);
-static htri_t H5S__hyper_is_single(const H5S_t *space);
-static htri_t H5S__hyper_is_regular(const H5S_t *space);
-static htri_t H5S__hyper_shape_same(const H5S_t *space1, const H5S_t *space2);
-static htri_t H5S__hyper_intersect_block(const H5S_t *space, const hsize_t *start,
-    const hsize_t *end);
-static herr_t H5S__hyper_adjust_u(H5S_t *space, const hsize_t *offset);
-static herr_t H5S__hyper_adjust_s(H5S_t *space, const hssize_t *offset);
-static herr_t H5S__hyper_project_scalar(const H5S_t *space, hsize_t *offset);
-static herr_t H5S__hyper_project_simple(const H5S_t *space, H5S_t *new_space, hsize_t *offset);
-static herr_t H5S__hyper_iter_init(const H5S_t *space, H5S_sel_iter_t *iter);
+static herr_t   H5S__hyper_serialize(const H5S_t *space, uint8_t **p);
+static herr_t   H5S__hyper_deserialize(H5S_t **space, const uint8_t **p);
+static herr_t   H5S__hyper_bounds(const H5S_t *space, hsize_t *start, hsize_t *end);
+static herr_t   H5S__hyper_offset(const H5S_t *space, hsize_t *offset);
+static int      H5S__hyper_unlim_dim(const H5S_t *space);
+static herr_t   H5S__hyper_num_elem_non_unlim(const H5S_t *space, hsize_t *num_elem_non_unlim);
+static htri_t   H5S__hyper_is_contiguous(const H5S_t *space);
+static htri_t   H5S__hyper_is_single(const H5S_t *space);
+static htri_t   H5S__hyper_is_regular(const H5S_t *space);
+static htri_t   H5S__hyper_shape_same(const H5S_t *space1, const H5S_t *space2);
+static htri_t   H5S__hyper_intersect_block(const H5S_t *space, const hsize_t *start, const hsize_t *end);
+static herr_t   H5S__hyper_adjust_u(H5S_t *space, const hsize_t *offset);
+static herr_t   H5S__hyper_adjust_s(H5S_t *space, const hssize_t *offset);
+static herr_t   H5S__hyper_project_scalar(const H5S_t *space, hsize_t *offset);
+static herr_t   H5S__hyper_project_simple(const H5S_t *space, H5S_t *new_space, hsize_t *offset);
+static herr_t   H5S__hyper_iter_init(const H5S_t *space, H5S_sel_iter_t *iter);
 
 /* Selection iteration callbacks */
-static herr_t H5S__hyper_iter_coords(const H5S_sel_iter_t *iter, hsize_t *coords);
-static herr_t H5S__hyper_iter_block(const H5S_sel_iter_t *iter, hsize_t *start, hsize_t *end);
+static herr_t  H5S__hyper_iter_coords(const H5S_sel_iter_t *iter, hsize_t *coords);
+static herr_t  H5S__hyper_iter_block(const H5S_sel_iter_t *iter, hsize_t *start, hsize_t *end);
 static hsize_t H5S__hyper_iter_nelmts(const H5S_sel_iter_t *iter);
-static htri_t H5S__hyper_iter_has_next_block(const H5S_sel_iter_t *sel_iter);
-static herr_t H5S__hyper_iter_next(H5S_sel_iter_t *sel_iter, size_t nelem);
-static herr_t H5S__hyper_iter_next_block(H5S_sel_iter_t *sel_iter);
-static herr_t H5S__hyper_iter_get_seq_list(H5S_sel_iter_t *iter, size_t maxseq,
-    size_t maxbytes, size_t *nseq, size_t *nbytes, hsize_t *off, size_t *len);
+static htri_t  H5S__hyper_iter_has_next_block(const H5S_sel_iter_t *sel_iter);
+static herr_t  H5S__hyper_iter_next(H5S_sel_iter_t *sel_iter, size_t nelem);
+static herr_t  H5S__hyper_iter_next_block(H5S_sel_iter_t *sel_iter);
+static herr_t H5S__hyper_iter_get_seq_list(H5S_sel_iter_t *iter, size_t maxseq, size_t maxbytes, size_t *nseq,
+                                           size_t *nbytes, hsize_t *off, size_t *len);
 static herr_t H5S__hyper_iter_release(H5S_sel_iter_t *sel_iter);
 
-
 /*****************************/
 /* Library Private Variables */
 /*****************************/
 
-
 /*********************/
 /* Package Variables */
 /*********************/
@@ -249,11 +239,11 @@ const H5S_select_class_t H5S_sel_hyper[1] = {{
 
 /* Format version bounds for dataspace hyperslab selection */
 const unsigned H5O_sds_hyper_ver_bounds[] = {
-    H5S_HYPER_VERSION_1,    /* H5F_LIBVER_EARLIEST */
-    H5S_HYPER_VERSION_1,    /* H5F_LIBVER_V18 */
-    H5S_HYPER_VERSION_2,    /* H5F_LIBVER_V110 */
-    H5S_HYPER_VERSION_3,    /* H5F_LIBVER_V112 */
-    H5S_HYPER_VERSION_3     /* H5F_LIBVER_LATEST */
+    H5S_HYPER_VERSION_1, /* H5F_LIBVER_EARLIEST */
+    H5S_HYPER_VERSION_1, /* H5F_LIBVER_V18 */
+    H5S_HYPER_VERSION_2, /* H5F_LIBVER_V110 */
+    H5S_HYPER_VERSION_3, /* H5F_LIBVER_V112 */
+    H5S_HYPER_VERSION_3  /* H5F_LIBVER_LATEST */
 };
 
 /*******************/
@@ -276,16 +266,10 @@ static const H5S_sel_iter_class_t H5S_sel_iter_hyper[1] = {{
 }};
 
 /* Arrays for default stride, block, etc. */
-static const hsize_t H5S_hyper_zeros_g[H5S_MAX_RANK] = {
-    0,0,0,0, 0,0,0,0,
-    0,0,0,0, 0,0,0,0,
-    0,0,0,0, 0,0,0,0,
-    0,0,0,0, 0,0,0,0};
-static const hsize_t H5S_hyper_ones_g[H5S_MAX_RANK] = {
-    1,1,1,1, 1,1,1,1,
-    1,1,1,1, 1,1,1,1,
-    1,1,1,1, 1,1,1,1,
-    1,1,1,1, 1,1,1,1};
+static const hsize_t H5S_hyper_zeros_g[H5S_MAX_RANK] = {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+                                                        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0};
+static const hsize_t H5S_hyper_ones_g[H5S_MAX_RANK]  = {1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
+                                                       1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1};
 
 /* Declare a free list to manage the H5S_hyper_sel_t struct */
 H5FL_DEFINE_STATIC(H5S_hyper_sel_t);
@@ -303,7 +287,6 @@ H5FL_EXTERN(H5S_sel_iter_t);
 /* (Start with '1' to avoid clashing with '0' value in newly allocated structs) */
 static uint64_t H5S_hyper_op_gen_g = 1;
 
-
 /* Uncomment this to provide the debugging routines for printing selection info */
 /* #define H5S_HYPER_DEBUG */
 #ifdef H5S_HYPER_DEBUG
@@ -312,10 +295,13 @@ H5S__hyper_print_spans_helper(FILE *f, const H5S_hyper_span_t *span, unsigned de
 {
     FUNC_ENTER_STATIC_NOERR
 
-    while(span) {
-        HDfprintf(f,"%s: %*sdepth=%u, span=%p, (%Hu, %Hu), next=%p\n", FUNC, depth * 2, "", depth, span, span->low, span->high, span->next);
-        if(span->down) {
-            HDfprintf(f,"%s: %*sspans=%p, count=%u, bounds[0]={%Hu, %Hu}, head=%p\n", FUNC, (depth + 1) * 2, "", span->down, span->down->count, span->down->low_bounds[0], span->down->high_bounds[0], span->down->head);
+    while (span) {
+        HDfprintf(f, "%s: %*sdepth=%u, span=%p, (%Hu, %Hu), next=%p\n", FUNC, depth * 2, "", depth, span,
+                  span->low, span->high, span->next);
+        if (span->down) {
+            HDfprintf(f, "%s: %*sspans=%p, count=%u, bounds[0]={%Hu, %Hu}, head=%p\n", FUNC, (depth + 1) * 2,
+                      "", span->down, span->down->count, span->down->low_bounds[0],
+                      span->down->high_bounds[0], span->down->head);
             H5S__hyper_print_spans_helper(f, span->down->head, depth + 1);
         } /* end if */
         span = span->next;
@@ -329,8 +315,9 @@ H5S__hyper_print_spans(FILE *f, const H5S_hyper_span_info_t *span_lst)
 {
     FUNC_ENTER_STATIC_NOERR
 
-    if(span_lst != NULL) {
-        HDfprintf(f, "%s: spans=%p, count=%u, bounds[0]={%Hu, %Hu}, head=%p\n", FUNC, span_lst, span_lst->count, span_lst->low_bounds[0], span_lst->high_bounds[0], span_lst->head);
+    if (span_lst != NULL) {
+        HDfprintf(f, "%s: spans=%p, count=%u, bounds[0]={%Hu, %Hu}, head=%p\n", FUNC, span_lst,
+                  span_lst->count, span_lst->low_bounds[0], span_lst->high_bounds[0], span_lst->head);
         H5S__hyper_print_spans_helper(f, span_lst->head, 0);
     } /* end if */
 
@@ -350,22 +337,22 @@ H5S__space_print_spans(FILE *f, const H5S_t *space)
 static herr_t
 H5S__hyper_print_diminfo_helper(FILE *f, const char *field, unsigned ndims, const H5S_hyper_dim_t *dinfo)
 {
-    unsigned u;                 /* Local index variable */
+    unsigned u; /* Local index variable */
 
     FUNC_ENTER_STATIC_NOERR
 
-    if(dinfo != NULL) {
+    if (dinfo != NULL) {
         HDfprintf(f, "%s: %s: start=[", FUNC, field);
-        for(u = 0; u < ndims; u++)
+        for (u = 0; u < ndims; u++)
             HDfprintf(f, "%Hd%s", dinfo[u].start, (u < (ndims - 1) ? ", " : "]\n"));
         HDfprintf(f, "%s: %s: stride=[", FUNC, field);
-        for(u = 0; u < ndims; u++)
+        for (u = 0; u < ndims; u++)
             HDfprintf(f, "%Hu%s", dinfo[u].stride, (u < (ndims - 1) ? ", " : "]\n"));
         HDfprintf(f, "%s: %s: count=[", FUNC, field);
-        for(u = 0; u < ndims; u++)
+        for (u = 0; u < ndims; u++)
             HDfprintf(f, "%Hu%s", dinfo[u].count, (u < (ndims - 1) ? ", " : "]\n"));
         HDfprintf(f, "%s: %s: block=[", FUNC, field);
-        for(u = 0; u < ndims; u++)
+        for (u = 0; u < ndims; u++)
             HDfprintf(f, "%Hu%s", dinfo[u].block, (u < (ndims - 1) ? ", " : "]\n"));
     } /* end if */
     else
@@ -379,13 +366,14 @@ H5S__hyper_print_diminfo(FILE *f, const H5S_t *space)
 {
     FUNC_ENTER_STATIC_NOERR
 
-    H5S__hyper_print_diminfo_helper(f, "diminfo.opt", space->extent.rank, space->select.sel_info.hslab->diminfo.opt);
-    H5S__hyper_print_diminfo_helper(f, "diminfo.app", space->extent.rank, space->select.sel_info.hslab->diminfo.app);
+    H5S__hyper_print_diminfo_helper(f, "diminfo.opt", space->extent.rank,
+                                    space->select.sel_info.hslab->diminfo.opt);
+    H5S__hyper_print_diminfo_helper(f, "diminfo.app", space->extent.rank,
+                                    space->select.sel_info.hslab->diminfo.app);
 
     FUNC_LEAVE_NOAPI(SUCCEED)
 }
 
-
 /*--------------------------------------------------------------------------
  NAME
     H5S__hyper_print_spans_dfs
@@ -404,53 +392,52 @@ H5S__hyper_print_diminfo(FILE *f, const H5S_t *space)
  REVISION LOG
 --------------------------------------------------------------------------*/
 static herr_t
-H5S__hyper_print_spans_dfs(FILE *f, const H5S_hyper_span_info_t *span_lst,
-    unsigned depth, unsigned dims)
+H5S__hyper_print_spans_dfs(FILE *f, const H5S_hyper_span_info_t *span_lst, unsigned depth, unsigned dims)
 {
     H5S_hyper_span_t *actual_tail = NULL;
     H5S_hyper_span_t *cur_elem;
-    unsigned num_elems = 0;
-    unsigned u, elem_idx;
+    unsigned          num_elems = 0;
+    unsigned          u, elem_idx;
 
     FUNC_ENTER_STATIC_NOERR
 
     /* get the actual tail from head */
     cur_elem = span_lst->head;
     HDassert(cur_elem); /* at least 1 element */
-    while(cur_elem) {
+    while (cur_elem) {
         actual_tail = cur_elem;
-        cur_elem = cur_elem->next;
+        cur_elem    = cur_elem->next;
         num_elems++;
     } /* end while */
 
-    for(u = 0; u < depth; u++)
+    for (u = 0; u < depth; u++)
         HDfprintf(f, "\t");
     HDfprintf(f, "DIM[%u]: ref_count=%u, #elems=%u, head=%p, tail=%p, actual_tail=%p, matched=%t\n", depth,
-              span_lst->count, num_elems, span_lst->head,
-              span_lst->tail, actual_tail, (span_lst->tail == actual_tail));
+              span_lst->count, num_elems, span_lst->head, span_lst->tail, actual_tail,
+              (span_lst->tail == actual_tail));
 
-    for(u = 0; u < depth; u++)
+    for (u = 0; u < depth; u++)
         HDfprintf(f, "\t");
     HDfprintf(f, "low_bounds=[");
-    for(u = 0; u < dims - 1; u++)
+    for (u = 0; u < dims - 1; u++)
         HDfprintf(f, "%llu,", span_lst->low_bounds[u]);
     HDfprintf(f, "%llu]\n", span_lst->low_bounds[dims - 1]);
 
-    for(u = 0; u < depth; u++)
+    for (u = 0; u < depth; u++)
         HDfprintf(f, "\t");
     HDfprintf(f, "high_bounds=[");
-    for(u = 0; u < dims - 1; u++)
+    for (u = 0; u < dims - 1; u++)
         HDfprintf(f, "%llu,", span_lst->high_bounds[u]);
     HDfprintf(f, "%llu]\n", span_lst->high_bounds[dims - 1]);
 
     cur_elem = span_lst->head;
     elem_idx = 0;
-    while(cur_elem) {
-        for(u = 0; u < depth; u++)
+    while (cur_elem) {
+        for (u = 0; u < depth; u++)
             HDfprintf(f, "\t");
-        HDfprintf(f, "ELEM[%u]: ptr=%p, low=%Hu, high=%Hu, down=%p\n",
-                  elem_idx++, cur_elem, cur_elem->low, cur_elem->high, cur_elem->down);
-        if(cur_elem->down)
+        HDfprintf(f, "ELEM[%u]: ptr=%p, low=%Hu, high=%Hu, down=%p\n", elem_idx++, cur_elem, cur_elem->low,
+                  cur_elem->high, cur_elem->down);
+        if (cur_elem->down)
             H5S__hyper_print_spans_dfs(f, cur_elem->down, depth + 1, dims);
         cur_elem = cur_elem->next;
     } /* end while */
@@ -458,7 +445,6 @@ H5S__hyper_print_spans_dfs(FILE *f, const H5S_hyper_span_info_t *span_lst,
     FUNC_LEAVE_NOAPI(SUCCEED)
 } /* end H5S__hyper_print_spans_dfs() */
 
-
 /*--------------------------------------------------------------------------
  NAME
     H5S__hyper_print_space_dfs
@@ -479,51 +465,52 @@ static herr_t
 H5S__hyper_print_space_dfs(FILE *f, const H5S_t *space)
 {
     const H5S_hyper_sel_t *hslab = space->select.sel_info.hslab;
-    const unsigned dims = space->extent.rank;
-    unsigned u;
+    const unsigned         dims  = space->extent.rank;
+    unsigned               u;
 
     FUNC_ENTER_STATIC_NOERR
 
     HDassert(hslab);
 
     HDfprintf(f, "=======================\n");
-    HDfprintf(f, "SPACE: span_lst=%p, #dims=%u, offset_changed=%d\n", hslab->span_lst, dims, space->select.offset_changed);
+    HDfprintf(f, "SPACE: span_lst=%p, #dims=%u, offset_changed=%d\n", hslab->span_lst, dims,
+              space->select.offset_changed);
 
     HDfprintf(f, "       offset=[");
-    for(u = 0; u < dims - 1; u++)
+    for (u = 0; u < dims - 1; u++)
         HDfprintf(f, "%lld,", space->select.offset[u]);
     HDfprintf(f, "%lld]\n", space->select.offset[dims - 1]);
 
     HDfprintf(f, "       low_bounds=[");
-    if(space->select.sel_info.hslab->diminfo_valid == H5S_DIMINFO_VALID_YES) {
-        for(u = 0; u < dims - 1; u++)
+    if (space->select.sel_info.hslab->diminfo_valid == H5S_DIMINFO_VALID_YES) {
+        for (u = 0; u < dims - 1; u++)
             HDfprintf(f, "%llu,", space->select.sel_info.hslab->diminfo.low_bounds[u]);
         HDfprintf(f, "%llu]\n", space->select.sel_info.hslab->diminfo.low_bounds[dims - 1]);
     } /* end if */
     else {
-        for(u = 0; u < dims - 1; u++)
+        for (u = 0; u < dims - 1; u++)
             HDfprintf(f, "%llu,", space->select.sel_info.hslab->span_lst->low_bounds[u]);
         HDfprintf(f, "%llu]\n", space->select.sel_info.hslab->span_lst->low_bounds[dims - 1]);
     } /* end else */
 
     HDfprintf(f, "       high_bounds=[");
-    if(space->select.sel_info.hslab->diminfo_valid == H5S_DIMINFO_VALID_YES) {
-        for(u = 0; u < dims - 1; u++)
+    if (space->select.sel_info.hslab->diminfo_valid == H5S_DIMINFO_VALID_YES) {
+        for (u = 0; u < dims - 1; u++)
             HDfprintf(f, "%llu,", space->select.sel_info.hslab->diminfo.high_bounds[u]);
         HDfprintf(f, "%llu]\n", space->select.sel_info.hslab->diminfo.high_bounds[dims - 1]);
     } /* end if */
     else {
-        for(u = 0; u < dims - 1; u++)
+        for (u = 0; u < dims - 1; u++)
             HDfprintf(f, "%llu,", space->select.sel_info.hslab->span_lst->high_bounds[u]);
         HDfprintf(f, "%llu]\n", space->select.sel_info.hslab->span_lst->high_bounds[dims - 1]);
     } /* end else */
 
     /* Print out diminfo, if it's valid */
-    if(space->select.sel_info.hslab->diminfo_valid == H5S_DIMINFO_VALID_YES)
+    if (space->select.sel_info.hslab->diminfo_valid == H5S_DIMINFO_VALID_YES)
         H5S__hyper_print_diminfo(f, space);
 
     /* Start print out the highest-order of dimension */
-    if(hslab->span_lst)
+    if (hslab->span_lst)
         H5S__hyper_print_spans_dfs(f, hslab->span_lst, 0, dims);
     HDfprintf(f, "=======================\n\n");
 
@@ -531,7 +518,6 @@ H5S__hyper_print_space_dfs(FILE *f, const H5S_t *space)
 } /* end H5S__hyper_print_space_dfs() */
 #endif /* H5S_HYPER_DEBUG */
 
-
 /*-------------------------------------------------------------------------
  * Function:    H5S__hyper_get_op_gen
  *
@@ -555,7 +541,6 @@ H5S__hyper_get_op_gen(void)
     FUNC_LEAVE_NOAPI(H5S_hyper_op_gen_g++);
 } /* end H5S__hyper_op_gen() */
 
-
 /*-------------------------------------------------------------------------
  * Function:    H5S__hyper_iter_init
  *
@@ -576,13 +561,13 @@ H5S__hyper_get_op_gen(void)
 static herr_t
 H5S__hyper_iter_init(const H5S_t *space, H5S_sel_iter_t *iter)
 {
-    hsize_t *slab_size;         /* Pointer to the dataspace dimensions to use for calc. slab */
-    hsize_t acc;                /* Accumulator for computing cumulative sizes */
-    unsigned slab_dim;          /* Rank of the fastest changing dimension for calc. slab */
-    unsigned rank;              /* Dataspace's dimension rank */
-    unsigned u;                 /* Index variable */
-    int i;                      /* Index variable */
-    herr_t ret_value = SUCCEED; /* return value */
+    hsize_t *slab_size;           /* Pointer to the dataspace dimensions to use for calc. slab */
+    hsize_t  acc;                 /* Accumulator for computing cumulative sizes */
+    unsigned slab_dim;            /* Rank of the fastest changing dimension for calc. slab */
+    unsigned rank;                /* Dataspace's dimension rank */
+    unsigned u;                   /* Index variable */
+    int      i;                   /* Index variable */
+    herr_t   ret_value = SUCCEED; /* return value */
 
     FUNC_ENTER_STATIC
 
@@ -600,15 +585,15 @@ H5S__hyper_iter_init(const H5S_t *space, H5S_sel_iter_t *iter)
     /* Attempt to rebuild diminfo if it is invalid and has not been confirmed
      * to be impossible.
      */
-    if(space->select.sel_info.hslab->diminfo_valid == H5S_DIMINFO_VALID_NO)
-        H5S__hyper_rebuild((H5S_t *)space);     /* Casting away const OK -NAF */
+    if (space->select.sel_info.hslab->diminfo_valid == H5S_DIMINFO_VALID_NO)
+        H5S__hyper_rebuild((H5S_t *)space); /* Casting away const OK -NAF */
 
     /* Check for the special case of just one H5Sselect_hyperslab call made */
-    if(space->select.sel_info.hslab->diminfo_valid == H5S_DIMINFO_VALID_YES) {
-/* Initialize the information needed for regular hyperslab I/O */
-        const H5S_hyper_dim_t *tdiminfo;    /* Temporary pointer to diminfo information */
-        const hsize_t *mem_size;    /* Temporary pointer to dataspace extent's dimension sizes */
-        unsigned cont_dim = 0;      /* # of contiguous dimensions */
+    if (space->select.sel_info.hslab->diminfo_valid == H5S_DIMINFO_VALID_YES) {
+        /* Initialize the information needed for regular hyperslab I/O */
+        const H5S_hyper_dim_t *tdiminfo;     /* Temporary pointer to diminfo information */
+        const hsize_t *        mem_size;     /* Temporary pointer to dataspace extent's dimension sizes */
+        unsigned               cont_dim = 0; /* # of contiguous dimensions */
 
         /* Set the temporary pointer to the dimension information */
         tdiminfo = space->select.sel_info.hslab->diminfo.opt;
@@ -626,10 +611,10 @@ H5S__hyper_iter_init(const H5S_t *space, H5S_sel_iter_t *iter)
         /* Don't flatten adjacent elements into contiguous block if the
          * element size is 0.  This is for the H5S_select_shape_same() code.
          */
-        if(iter->elmt_size > 0) {
+        if (iter->elmt_size > 0) {
             /* Check for any "contiguous" blocks that can be flattened */
-            for(u = (rank - 1); u > 0; u--) {
-                if(tdiminfo[u].count == 1 && tdiminfo[u].block == mem_size[u]) {
+            for (u = (rank - 1); u > 0; u--) {
+                if (tdiminfo[u].count == 1 && tdiminfo[u].block == mem_size[u]) {
                     cont_dim++;
                     iter->u.hyp.flattened[u] = TRUE;
                 } /* end if */
@@ -640,18 +625,18 @@ H5S__hyper_iter_init(const H5S_t *space, H5S_sel_iter_t *iter)
         } /* end if */
 
         /* Check if the regular selection can be "flattened" */
-        if(cont_dim > 0) {
-            hbool_t last_dim_flattened = TRUE;  /* Flag to indicate that the last dimension was flattened */
-            unsigned flat_rank = rank-cont_dim; /* Number of dimensions after flattening */
-            unsigned curr_dim;                  /* Current dimension */
+        if (cont_dim > 0) {
+            hbool_t  last_dim_flattened = TRUE; /* Flag to indicate that the last dimension was flattened */
+            unsigned flat_rank          = rank - cont_dim; /* Number of dimensions after flattening */
+            unsigned curr_dim;                             /* Current dimension */
 
             /* Set the iterator's rank to the contiguous dimensions */
             iter->u.hyp.iter_rank = flat_rank;
 
             /* "Flatten" dataspace extent and selection information */
             curr_dim = flat_rank - 1;
-            for(i = (int)rank - 1, acc = 1; i >= 0; i--) {
-                if(tdiminfo[i].block == mem_size[i] && i > 0) {
+            for (i = (int)rank - 1, acc = 1; i >= 0; i--) {
+                if (tdiminfo[i].block == mem_size[i] && i > 0) {
                     /* "Flatten" this dimension */
                     HDassert(tdiminfo[i].start == 0);
                     acc *= mem_size[i];
@@ -660,19 +645,19 @@ H5S__hyper_iter_init(const H5S_t *space, H5S_sel_iter_t *iter)
                     last_dim_flattened = TRUE;
                 } /* end if */
                 else {
-                    if(last_dim_flattened) {
+                    if (last_dim_flattened) {
                         /* First dimension after flattened dimensions */
                         iter->u.hyp.diminfo[curr_dim].start = tdiminfo[i].start * acc;
 
                         /* Special case for single block regular selections */
-                        if(tdiminfo[i].count == 1)
+                        if (tdiminfo[i].count == 1)
                             iter->u.hyp.diminfo[curr_dim].stride = 1;
                         else
                             iter->u.hyp.diminfo[curr_dim].stride = tdiminfo[i].stride * acc;
                         iter->u.hyp.diminfo[curr_dim].count = tdiminfo[i].count;
                         iter->u.hyp.diminfo[curr_dim].block = tdiminfo[i].block * acc;
-                        iter->u.hyp.size[curr_dim] = mem_size[i] * acc;
-                        iter->u.hyp.sel_off[curr_dim] = iter->sel_off[i] * (hssize_t)acc;
+                        iter->u.hyp.size[curr_dim]          = mem_size[i] * acc;
+                        iter->u.hyp.sel_off[curr_dim]       = iter->sel_off[i] * (hssize_t)acc;
 
                         /* Reset the "last dim flattened" flag to avoid flattened any further dimensions */
                         last_dim_flattened = FALSE;
@@ -682,38 +667,40 @@ H5S__hyper_iter_init(const H5S_t *space, H5S_sel_iter_t *iter)
                     } /* end if */
                     else {
                         /* All other dimensions */
-                        iter->u.hyp.diminfo[curr_dim].start = tdiminfo[i].start;
+                        iter->u.hyp.diminfo[curr_dim].start  = tdiminfo[i].start;
                         iter->u.hyp.diminfo[curr_dim].stride = tdiminfo[i].stride;
-                        iter->u.hyp.diminfo[curr_dim].count = tdiminfo[i].count;
-                        iter->u.hyp.diminfo[curr_dim].block = tdiminfo[i].block;
-                        iter->u.hyp.size[curr_dim] = mem_size[i];
-                        iter->u.hyp.sel_off[curr_dim] = iter->sel_off[i];
+                        iter->u.hyp.diminfo[curr_dim].count  = tdiminfo[i].count;
+                        iter->u.hyp.diminfo[curr_dim].block  = tdiminfo[i].block;
+                        iter->u.hyp.size[curr_dim]           = mem_size[i];
+                        iter->u.hyp.sel_off[curr_dim]        = iter->sel_off[i];
                     } /* end else */
 
                     /* Decrement "current" flattened dimension */
                     curr_dim--;
                 } /* end if */
-            } /* end for */
+            }     /* end for */
 
-            /* Initialize "flattened" iterator offset to initial location and dataspace extent and selection information to correct values */
-            for(u = 0; u < flat_rank; u++)
+            /* Initialize "flattened" iterator offset to initial location and dataspace extent and selection
+             * information to correct values */
+            for (u = 0; u < flat_rank; u++)
                 iter->u.hyp.off[u] = iter->u.hyp.diminfo[u].start;
 
             /* Set up information for computing slab sizes */
-            slab_dim = iter->u.hyp.iter_rank - 1;
+            slab_dim  = iter->u.hyp.iter_rank - 1;
             slab_size = iter->u.hyp.size;
         } /* end if */
         else {
             /* Make local copy of the regular selection information */
-            HDcompile_assert(sizeof(iter->u.hyp.diminfo) == sizeof(space->select.sel_info.hslab->diminfo.opt));
+            HDcompile_assert(sizeof(iter->u.hyp.diminfo) ==
+                             sizeof(space->select.sel_info.hslab->diminfo.opt));
             H5MM_memcpy(iter->u.hyp.diminfo, tdiminfo, sizeof(iter->u.hyp.diminfo));
 
             /* Initialize position to initial location */
-            for(u = 0; u < rank; u++)
+            for (u = 0; u < rank; u++)
                 iter->u.hyp.off[u] = tdiminfo[u].start;
 
             /* Set up information for computing slab sizes */
-            slab_dim = iter->rank - 1;
+            slab_dim  = iter->rank - 1;
             slab_size = iter->dims;
         } /* end else */
 
@@ -722,9 +709,9 @@ H5S__hyper_iter_init(const H5S_t *space, H5S_sel_iter_t *iter)
 
         /* Initialize irregular region information also (for release) */
         iter->u.hyp.spans = NULL;
-    } /* end if */
-    else {      /* Initialize the information needed for non-regular hyperslab I/O */
-        H5S_hyper_span_info_t *spans;   /* Pointer to hyperslab span info node */
+    }                                 /* end if */
+    else {                            /* Initialize the information needed for non-regular hyperslab I/O */
+        H5S_hyper_span_info_t *spans; /* Pointer to hyperslab span info node */
 
         /* If this iterator is created from an API call, by default we clone the
          *  selection now, as the dataspace could be modified or go out of scope.
@@ -735,10 +722,10 @@ H5S__hyper_iter_init(const H5S_t *space, H5S_sel_iter_t *iter)
          *  close the dataspace that the iterator is operating on, or undefined
          *  behavior will occur.
          */
-        if((iter->flags & H5S_SEL_ITER_API_CALL) &&
-                !(iter->flags & H5S_SEL_ITER_SHARE_WITH_DATASPACE)) {
+        if ((iter->flags & H5S_SEL_ITER_API_CALL) && !(iter->flags & H5S_SEL_ITER_SHARE_WITH_DATASPACE)) {
             /* Copy the span tree */
-            if(NULL == (iter->u.hyp.spans = H5S__hyper_copy_span(space->select.sel_info.hslab->span_lst, space->extent.rank)))
+            if (NULL == (iter->u.hyp.spans = H5S__hyper_copy_span(space->select.sel_info.hslab->span_lst,
+                                                                  space->extent.rank)))
                 HGOTO_ERROR(H5E_DATASPACE, H5E_CANTCOPY, FAIL, "can't copy span tree")
         } /* end if */
         else {
@@ -750,7 +737,7 @@ H5S__hyper_iter_init(const H5S_t *space, H5S_sel_iter_t *iter)
 
         /* Initialize the starting span_info's and spans */
         spans = iter->u.hyp.spans;
-        for(u = 0; u < rank; u++) {
+        for (u = 0; u < rank; u++) {
             /* Set the pointers to the initial span in each dimension */
             HDassert(spans);
             HDassert(spans->head);
@@ -766,7 +753,7 @@ H5S__hyper_iter_init(const H5S_t *space, H5S_sel_iter_t *iter)
         } /* end for */
 
         /* Set up information for computing slab sizes */
-        slab_dim = iter->rank - 1;
+        slab_dim  = iter->rank - 1;
         slab_size = iter->dims;
 
         /* Flag the diminfo information as not valid in the iterator */
@@ -774,17 +761,18 @@ H5S__hyper_iter_init(const H5S_t *space, H5S_sel_iter_t *iter)
     } /* end else */
 
     /* Compute the cumulative size of dataspace dimensions */
-    for(i = (int)slab_dim, acc = iter->elmt_size; i >= 0; i--) {
+    for (i = (int)slab_dim, acc = iter->elmt_size; i >= 0; i--) {
         iter->u.hyp.slab[i] = acc;
         acc *= slab_size[i];
     } /* end for */
 
     /* Initialize more information for irregular hyperslab selections */
-    if(!iter->u.hyp.diminfo_valid) {
+    if (!iter->u.hyp.diminfo_valid) {
         /* Set the offset of the first element iterated on, in each dimension */
-        for(u = 0; u < rank; u++)
+        for (u = 0; u < rank; u++)
             /* Compute the sequential element offset */
-            iter->u.hyp.loc_off[u] = ((hsize_t)((hssize_t)iter->u.hyp.off[u] + iter->sel_off[u])) * iter->u.hyp.slab[u];
+            iter->u.hyp.loc_off[u] =
+                ((hsize_t)((hssize_t)iter->u.hyp.off[u] + iter->sel_off[u])) * iter->u.hyp.slab[u];
     } /* end if */
 
     /* Initialize type of selection iterator */
@@ -794,7 +782,6 @@ done:
     FUNC_LEAVE_NOAPI(ret_value)
 } /* end H5S__hyper_iter_init() */
 
-
 /*-------------------------------------------------------------------------
  * Function:    H5S__hyper_iter_coords
  *
@@ -820,34 +807,35 @@ H5S__hyper_iter_coords(const H5S_sel_iter_t *iter, hsize_t *coords)
     /* Copy the offset of the current point */
 
     /* Check for a single "regular" hyperslab */
-    if(iter->u.hyp.diminfo_valid) {
+    if (iter->u.hyp.diminfo_valid) {
         /* Check if this is a "flattened" regular hyperslab selection */
-        if(iter->u.hyp.iter_rank != 0 && iter->u.hyp.iter_rank < iter->rank) {
-            int u, v;           /* Dimension indices */
+        if (iter->u.hyp.iter_rank != 0 && iter->u.hyp.iter_rank < iter->rank) {
+            int u, v; /* Dimension indices */
 
             /* Set the starting rank of both the "natural" & "flattened" dimensions */
             u = (int)iter->rank - 1;
             v = (int)iter->u.hyp.iter_rank - 1;
 
             /* Construct the "natural" dimensions from a set of flattened coordinates */
-            while(u >= 0) {
-                if(iter->u.hyp.flattened[u]) {
-                    int begin = u;      /* The rank of the first flattened dimension */
+            while (u >= 0) {
+                if (iter->u.hyp.flattened[u]) {
+                    int begin = u; /* The rank of the first flattened dimension */
 
                     /* Walk up through as many flattened dimensions as possible */
                     do {
                         u--;
-                    } while(u >= 0 && iter->u.hyp.flattened[u]);
+                    } while (u >= 0 && iter->u.hyp.flattened[u]);
 
                     /* Compensate for possibly overshooting dim 0 */
-                    if(u < 0)
+                    if (u < 0)
                         u = 0;
 
                     /* Sanity check */
                     HDassert(v >= 0);
 
                     /* Compute the coords for the flattened dimensions */
-                    H5VM_array_calc(iter->u.hyp.off[v], (unsigned)((begin - u) + 1), &(iter->dims[u]), &(coords[u]));
+                    H5VM_array_calc(iter->u.hyp.off[v], (unsigned)((begin - u) + 1), &(iter->dims[u]),
+                                    &(coords[u]));
 
                     /* Continue to faster dimension in both indices */
                     u--;
@@ -855,7 +843,7 @@ H5S__hyper_iter_coords(const H5S_sel_iter_t *iter, hsize_t *coords)
                 } /* end if */
                 else {
                     /* Walk up through as many non-flattened dimensions as possible */
-                    while(u >= 0 && !iter->u.hyp.flattened[u]) {
+                    while (u >= 0 && !iter->u.hyp.flattened[u]) {
                         /* Sanity check */
                         HDassert(v >= 0);
 
@@ -866,8 +854,8 @@ H5S__hyper_iter_coords(const H5S_sel_iter_t *iter, hsize_t *coords)
                         u--;
                         v--;
                     } /* end while */
-                } /* end else */
-            } /* end while */
+                }     /* end else */
+            }         /* end while */
             HDassert(v < 0);
         } /* end if */
         else
@@ -879,7 +867,6 @@ H5S__hyper_iter_coords(const H5S_sel_iter_t *iter, hsize_t *coords)
     FUNC_LEAVE_NOAPI(SUCCEED)
 } /* end H5S__hyper_iter_coords() */
 
-
 /*-------------------------------------------------------------------------
  * Function:    H5S__hyper_iter_block
  *
@@ -899,7 +886,7 @@ H5S__hyper_iter_coords(const H5S_sel_iter_t *iter, hsize_t *coords)
 static herr_t
 H5S__hyper_iter_block(const H5S_sel_iter_t *iter, hsize_t *start, hsize_t *end)
 {
-    unsigned u;                 /* Local index variable */
+    unsigned u; /* Local index variable */
 
     FUNC_ENTER_STATIC_NOERR
 
@@ -911,25 +898,24 @@ H5S__hyper_iter_block(const H5S_sel_iter_t *iter, hsize_t *start, hsize_t *end)
     /* Copy the offset of the current point */
 
     /* Check for a single "regular" hyperslab */
-    if(iter->u.hyp.diminfo_valid) {
+    if (iter->u.hyp.diminfo_valid) {
         /* Copy the start and compute the end of the block */
-        for(u = 0; u < iter->rank; u++) {
+        for (u = 0; u < iter->rank; u++) {
             start[u] = iter->u.hyp.off[u];
-            end[u] = (start[u] + iter->u.hyp.diminfo[u].block) - 1;
+            end[u]   = (start[u] + iter->u.hyp.diminfo[u].block) - 1;
         }
     } /* end if */
     else {
         /* Copy the start & end of the block */
-        for(u = 0; u < iter->rank; u++) {
+        for (u = 0; u < iter->rank; u++) {
             start[u] = iter->u.hyp.span[u]->low;
-            end[u] = iter->u.hyp.span[u]->high;
+            end[u]   = iter->u.hyp.span[u]->high;
         }
     } /* end else */
 
     FUNC_LEAVE_NOAPI(SUCCEED)
 } /* end H5S__hyper_iter_block() */
 
-
 /*-------------------------------------------------------------------------
  * Function:    H5S__hyper_iter_nelmts
  *
@@ -953,7 +939,6 @@ H5S__hyper_iter_nelmts(const H5S_sel_iter_t *iter)
     FUNC_LEAVE_NOAPI(iter->elmt_left)
 } /* end H5S__hyper_iter_nelmts() */
 
-
 /*--------------------------------------------------------------------------
  NAME
     H5S__hyper_iter_has_next_block
@@ -975,7 +960,7 @@ static H5_ATTR_PURE htri_t
 H5S__hyper_iter_has_next_block(const H5S_sel_iter_t *iter)
 {
     unsigned u;                 /* Local index variable */
-    htri_t ret_value = FALSE;   /* Return value */
+    htri_t   ret_value = FALSE; /* Return value */
 
     FUNC_ENTER_STATIC_NOERR
 
@@ -983,25 +968,25 @@ H5S__hyper_iter_has_next_block(const H5S_sel_iter_t *iter)
     HDassert(iter);
 
     /* Check for a single "regular" hyperslab */
-    if(iter->u.hyp.diminfo_valid) {
-        const H5S_hyper_dim_t *tdiminfo;    /* Temporary pointer to diminfo information */
-        const hsize_t *toff;               /* Temporary offset in selection */
+    if (iter->u.hyp.diminfo_valid) {
+        const H5S_hyper_dim_t *tdiminfo; /* Temporary pointer to diminfo information */
+        const hsize_t *        toff;     /* Temporary offset in selection */
 
         /* Check if the offset of the iterator is at the last location in all dimensions */
         tdiminfo = iter->u.hyp.diminfo;
-        toff = iter->u.hyp.off;
-        for(u = 0; u < iter->rank; u++) {
+        toff     = iter->u.hyp.off;
+        for (u = 0; u < iter->rank; u++) {
             /* If there is only one block, continue */
-            if(tdiminfo[u].count == 1)
+            if (tdiminfo[u].count == 1)
                 continue;
-            if(toff[u] != (tdiminfo[u].start + ((tdiminfo[u].count - 1) * tdiminfo[u].stride)))
+            if (toff[u] != (tdiminfo[u].start + ((tdiminfo[u].count - 1) * tdiminfo[u].stride)))
                 HGOTO_DONE(TRUE);
         } /* end for */
-    } /* end if */
+    }     /* end if */
     else {
         /* Check for any levels of the tree with more sequences in them */
-        for(u = 0; u < iter->rank; u++)
-            if(iter->u.hyp.span[u]->next != NULL)
+        for (u = 0; u < iter->rank; u++)
+            if (iter->u.hyp.span[u]->next != NULL)
                 HGOTO_DONE(TRUE);
     } /* end else */
 
@@ -1009,7 +994,6 @@ done:
     FUNC_LEAVE_NOAPI(ret_value)
 } /* end H5S__hyper_iter_has_next_block() */
 
-
 /*-------------------------------------------------------------------------
  * Function:    H5S__hyper_iter_next
  *
@@ -1027,22 +1011,22 @@ done:
 static herr_t
 H5S__hyper_iter_next(H5S_sel_iter_t *iter, size_t nelem)
 {
-    unsigned ndims;     /* Number of dimensions of dataset */
-    int fast_dim;       /* Rank of the fastest changing dimension for the dataspace */
-    unsigned u;         /* Counters */
+    unsigned ndims;    /* Number of dimensions of dataset */
+    int      fast_dim; /* Rank of the fastest changing dimension for the dataspace */
+    unsigned u;        /* Counters */
 
     FUNC_ENTER_STATIC_NOERR
 
     /* Check for the special case of just one H5Sselect_hyperslab call made */
     /* (i.e. a regular hyperslab selection */
-    if(iter->u.hyp.diminfo_valid) {
-        const H5S_hyper_dim_t *tdiminfo;    /* Temporary pointer to diminfo information */
-        hsize_t iter_offset[H5S_MAX_RANK];
-        hsize_t iter_count[H5S_MAX_RANK];
-        int temp_dim;  /* Temporary rank holder */
+    if (iter->u.hyp.diminfo_valid) {
+        const H5S_hyper_dim_t *tdiminfo; /* Temporary pointer to diminfo information */
+        hsize_t                iter_offset[H5S_MAX_RANK];
+        hsize_t                iter_count[H5S_MAX_RANK];
+        int                    temp_dim; /* Temporary rank holder */
 
         /* Check if this is a "flattened" regular hyperslab selection */
-        if(iter->u.hyp.iter_rank != 0 && iter->u.hyp.iter_rank < iter->rank)
+        if (iter->u.hyp.iter_rank != 0 && iter->u.hyp.iter_rank < iter->rank)
             /* Set the aliases for the dimension rank */
             ndims = iter->u.hyp.iter_rank;
         else
@@ -1056,25 +1040,25 @@ H5S__hyper_iter_next(H5S_sel_iter_t *iter, size_t nelem)
         tdiminfo = iter->u.hyp.diminfo;
 
         /* Calculate the offset and block count for each dimension */
-        for(u = 0; u < ndims; u++) {
-            if(tdiminfo[u].count == 1) {
+        for (u = 0; u < ndims; u++) {
+            if (tdiminfo[u].count == 1) {
                 iter_offset[u] = iter->u.hyp.off[u] - tdiminfo[u].start;
-                iter_count[u] = 0;
+                iter_count[u]  = 0;
             } /* end if */
             else {
                 iter_offset[u] = (iter->u.hyp.off[u] - tdiminfo[u].start) % tdiminfo[u].stride;
-                iter_count[u] = (iter->u.hyp.off[u] - tdiminfo[u].start) / tdiminfo[u].stride;
+                iter_count[u]  = (iter->u.hyp.off[u] - tdiminfo[u].start) / tdiminfo[u].stride;
             } /* end else */
-        } /* end for */
+        }     /* end for */
 
         /* Loop through, advancing the offset & counts, until all the nelements are accounted for */
-        while(nelem > 0) {
+        while (nelem > 0) {
             /* Start with the fastest changing dimension */
             temp_dim = fast_dim;
-            while(temp_dim >= 0) {
-                if(temp_dim == fast_dim) {
-                    size_t actual_elem;     /* Actual # of elements advanced on each iteration through loop */
-                    hsize_t block_elem;     /* Number of elements left in a block */
+            while (temp_dim >= 0) {
+                if (temp_dim == fast_dim) {
+                    size_t  actual_elem; /* Actual # of elements advanced on each iteration through loop */
+                    hsize_t block_elem;  /* Number of elements left in a block */
 
                     /* Compute the number of elements left in block */
                     block_elem = tdiminfo[temp_dim].block - iter_offset[temp_dim];
@@ -1092,59 +1076,61 @@ H5S__hyper_iter_next(H5S_sel_iter_t *iter, size_t nelem)
                     /* Move to the next row in the current dimension */
                     iter_offset[temp_dim]++;
 
-                /* If this block is still in the range of blocks to output for the dimension, break out of loop */
-                if(iter_offset[temp_dim] < tdiminfo[temp_dim].block)
+                /* If this block is still in the range of blocks to output for the dimension, break out of
+                 * loop */
+                if (iter_offset[temp_dim] < tdiminfo[temp_dim].block)
                     break;
                 else {
                     /* Move to the next block in the current dimension */
                     iter_offset[temp_dim] = 0;
                     iter_count[temp_dim]++;
 
-                    /* If this block is still in the range of blocks to output for the dimension, break out of loop */
-                    if(iter_count[temp_dim] < tdiminfo[temp_dim].count)
+                    /* If this block is still in the range of blocks to output for the dimension, break out of
+                     * loop */
+                    if (iter_count[temp_dim] < tdiminfo[temp_dim].count)
                         break;
                     else
                         iter_count[temp_dim] = 0; /* reset back to the beginning of the line */
-                } /* end else */
+                }                                 /* end else */
 
                 /* Decrement dimension count */
                 temp_dim--;
             } /* end while */
-        } /* end while */
+        }     /* end while */
 
         /* Translate current iter_offset and iter_count into iterator position */
-        for(u = 0; u < ndims; u++)
+        for (u = 0; u < ndims; u++)
             iter->u.hyp.off[u] = tdiminfo[u].start + (tdiminfo[u].stride * iter_count[u]) + iter_offset[u];
     } /* end if */
     /* Must be an irregular hyperslab selection */
     else {
-        H5S_hyper_span_t *curr_span;    /* Current hyperslab span node */
-        H5S_hyper_span_t **ispan;       /* Iterator's hyperslab span nodes */
-        hsize_t *abs_arr;              /* Absolute hyperslab span position */
-        int curr_dim;                   /* Temporary rank holder */
+        H5S_hyper_span_t * curr_span; /* Current hyperslab span node */
+        H5S_hyper_span_t **ispan;     /* Iterator's hyperslab span nodes */
+        hsize_t *          abs_arr;   /* Absolute hyperslab span position */
+        int                curr_dim;  /* Temporary rank holder */
 
         /* Set the rank of the fastest changing dimension */
-        ndims = iter->rank;
+        ndims    = iter->rank;
         fast_dim = (int)ndims - 1;
 
         /* Get the pointers to the current span info and span nodes */
         abs_arr = iter->u.hyp.off;
-        ispan = iter->u.hyp.span;
+        ispan   = iter->u.hyp.span;
 
         /* Loop through, advancing the span information, until all the nelements are accounted for */
-        while(nelem > 0) {
+        while (nelem > 0) {
             /* Start at the fastest dim */
             curr_dim = fast_dim;
 
             /* Work back up through the dimensions */
-            while(curr_dim >= 0) {
+            while (curr_dim >= 0) {
                 /* Reset the current span */
                 curr_span = ispan[curr_dim];
 
                 /* Increment absolute position */
-                if(curr_dim == fast_dim) {
-                    size_t actual_elem;     /* Actual # of elements advanced on each iteration through loop */
-                    hsize_t span_elem;      /* Number of elements left in a span */
+                if (curr_dim == fast_dim) {
+                    size_t  actual_elem; /* Actual # of elements advanced on each iteration through loop */
+                    hsize_t span_elem;   /* Number of elements left in a span */
 
                     /* Compute the number of elements left in block */
                     span_elem = (curr_span->high - abs_arr[curr_dim]) + 1;
@@ -1163,7 +1149,7 @@ H5S__hyper_iter_next(H5S_sel_iter_t *iter, size_t nelem)
                     abs_arr[curr_dim]++;
 
                 /* Check if we are still within the span */
-                if(abs_arr[curr_dim] <= curr_span->high)
+                if (abs_arr[curr_dim] <= curr_span->high)
                     break;
                 /* If we walked off that span, advance to the next span */
                 else {
@@ -1171,7 +1157,7 @@ H5S__hyper_iter_next(H5S_sel_iter_t *iter, size_t nelem)
                     curr_span = curr_span->next;
 
                     /* Check if we have a valid span in this dimension still */
-                    if(curr_span != NULL) {
+                    if (curr_span != NULL) {
                         /* Reset the span in the current dimension */
                         ispan[curr_dim] = curr_span;
 
@@ -1181,15 +1167,16 @@ H5S__hyper_iter_next(H5S_sel_iter_t *iter, size_t nelem)
                         break;
                     } /* end if */
                     else
-                        /* If we finished the span list in this dimension, decrement the dimension worked on and loop again */
+                        /* If we finished the span list in this dimension, decrement the dimension worked on
+                         * and loop again */
                         curr_dim--;
                 } /* end else */
-            } /* end while */
+            }     /* end while */
 
             /* Check if we are finished with the spans in the tree */
-            if(curr_dim >= 0) {
+            if (curr_dim >= 0) {
                 /* Walk back down the iterator positions, resetting them */
-                while(curr_dim < fast_dim) {
+                while (curr_dim < fast_dim) {
                     HDassert(curr_span);
                     HDassert(curr_span->down);
                     HDassert(curr_span->down->head);
@@ -1210,13 +1197,12 @@ H5S__hyper_iter_next(H5S_sel_iter_t *iter, size_t nelem)
                 /* Verify that the curr_span points to the fastest dim */
                 HDassert(curr_span == ispan[fast_dim]);
             } /* end if */
-        } /* end while */
-    } /* end else */
+        }     /* end while */
+    }         /* end else */
 
     FUNC_LEAVE_NOAPI(SUCCEED)
 } /* end H5S__hyper_iter_next() */
 
-
 /*-------------------------------------------------------------------------
  * Function:    H5S__hyper_iter_next_block
  *
@@ -1234,22 +1220,22 @@ H5S__hyper_iter_next(H5S_sel_iter_t *iter, size_t nelem)
 static herr_t
 H5S__hyper_iter_next_block(H5S_sel_iter_t *iter)
 {
-    unsigned ndims;     /* Number of dimensions of dataset */
-    int fast_dim;       /* Rank of the fastest changing dimension for the dataspace */
-    unsigned u;         /* Counters */
+    unsigned ndims;    /* Number of dimensions of dataset */
+    int      fast_dim; /* Rank of the fastest changing dimension for the dataspace */
+    unsigned u;        /* Counters */
 
     FUNC_ENTER_STATIC_NOERR
 
     /* Check for the special case of just one H5Sselect_hyperslab call made */
     /* (i.e. a regular hyperslab selection) */
-    if(iter->u.hyp.diminfo_valid) {
-        const H5S_hyper_dim_t *tdiminfo;    /* Temporary pointer to diminfo information */
-        hsize_t iter_offset[H5S_MAX_RANK];
-        hsize_t iter_count[H5S_MAX_RANK];
-        int temp_dim;  /* Temporary rank holder */
+    if (iter->u.hyp.diminfo_valid) {
+        const H5S_hyper_dim_t *tdiminfo; /* Temporary pointer to diminfo information */
+        hsize_t                iter_offset[H5S_MAX_RANK];
+        hsize_t                iter_count[H5S_MAX_RANK];
+        int                    temp_dim; /* Temporary rank holder */
 
         /* Check if this is a "flattened" regular hyperslab selection */
-        if(iter->u.hyp.iter_rank != 0 && iter->u.hyp.iter_rank < iter->rank)
+        if (iter->u.hyp.iter_rank != 0 && iter->u.hyp.iter_rank < iter->rank)
             /* Set the aliases for the dimension rank */
             ndims = iter->u.hyp.iter_rank;
         else
@@ -1263,21 +1249,21 @@ H5S__hyper_iter_next_block(H5S_sel_iter_t *iter)
         tdiminfo = iter->u.hyp.diminfo;
 
         /* Calculate the offset and block count for each dimension */
-        for(u = 0; u < ndims; u++) {
-            if(tdiminfo[u].count == 1) {
+        for (u = 0; u < ndims; u++) {
+            if (tdiminfo[u].count == 1) {
                 iter_offset[u] = iter->u.hyp.off[u] - tdiminfo[u].start;
-                iter_count[u] = 0;
+                iter_count[u]  = 0;
             } /* end if */
             else {
                 iter_offset[u] = (iter->u.hyp.off[u] - tdiminfo[u].start) % tdiminfo[u].stride;
-                iter_count[u] = (iter->u.hyp.off[u] - tdiminfo[u].start) / tdiminfo[u].stride;
+                iter_count[u]  = (iter->u.hyp.off[u] - tdiminfo[u].start) / tdiminfo[u].stride;
             } /* end else */
-        } /* end for */
+        }     /* end for */
 
         /* Advance one block */
         temp_dim = fast_dim; /* Start with the fastest changing dimension */
-        while(temp_dim >= 0) {
-            if(temp_dim == fast_dim)
+        while (temp_dim >= 0) {
+            if (temp_dim == fast_dim)
                 /* Move iterator over current block */
                 iter_offset[temp_dim] += tdiminfo[temp_dim].block;
             else
@@ -1285,53 +1271,54 @@ H5S__hyper_iter_next_block(H5S_sel_iter_t *iter)
                 iter_offset[temp_dim]++;
 
             /* If this block is still in the range of blocks to output for the dimension, break out of loop */
-            if(iter_offset[temp_dim] < tdiminfo[temp_dim].block)
+            if (iter_offset[temp_dim] < tdiminfo[temp_dim].block)
                 break;
             else {
                 /* Move to the next block in the current dimension */
                 iter_offset[temp_dim] = 0;
                 iter_count[temp_dim]++;
 
-                /* If this block is still in the range of blocks to output for the dimension, break out of loop */
-                if(iter_count[temp_dim] < tdiminfo[temp_dim].count)
+                /* If this block is still in the range of blocks to output for the dimension, break out of
+                 * loop */
+                if (iter_count[temp_dim] < tdiminfo[temp_dim].count)
                     break;
                 else
                     iter_count[temp_dim] = 0; /* reset back to the beginning of the line */
-            } /* end else */
+            }                                 /* end else */
 
             /* Decrement dimension count */
             temp_dim--;
         } /* end while */
 
         /* Translate current iter_offset and iter_count into iterator position */
-        for(u = 0; u < ndims; u++)
+        for (u = 0; u < ndims; u++)
             iter->u.hyp.off[u] = tdiminfo[u].start + (tdiminfo[u].stride * iter_count[u]) + iter_offset[u];
     } /* end if */
     /* Must be an irregular hyperslab selection */
     else {
-        H5S_hyper_span_t *curr_span;    /* Current hyperslab span node */
-        H5S_hyper_span_t **ispan;       /* Iterator's hyperslab span nodes */
-        hsize_t *abs_arr;              /* Absolute hyperslab span position */
-        int curr_dim;                   /* Temporary rank holder */
+        H5S_hyper_span_t * curr_span; /* Current hyperslab span node */
+        H5S_hyper_span_t **ispan;     /* Iterator's hyperslab span nodes */
+        hsize_t *          abs_arr;   /* Absolute hyperslab span position */
+        int                curr_dim;  /* Temporary rank holder */
 
         /* Set the rank of the fastest changing dimension */
-        ndims = iter->rank;
+        ndims    = iter->rank;
         fast_dim = (int)ndims - 1;
 
         /* Get the pointers to the current span info and span nodes */
         abs_arr = iter->u.hyp.off;
-        ispan = iter->u.hyp.span;
+        ispan   = iter->u.hyp.span;
 
         /* Loop through, advancing the span information, until all the nelements are accounted for */
         curr_dim = fast_dim; /* Start at the fastest dim */
 
         /* Work back up through the dimensions */
-        while(curr_dim >= 0) {
+        while (curr_dim >= 0) {
             /* Reset the current span */
             curr_span = ispan[curr_dim];
 
             /* Increment absolute position */
-            if(curr_dim == fast_dim)
+            if (curr_dim == fast_dim)
                 /* Move the iterator over rest of element in span */
                 abs_arr[curr_dim] = curr_span->high + 1;
             else
@@ -1339,7 +1326,7 @@ H5S__hyper_iter_next_block(H5S_sel_iter_t *iter)
                 abs_arr[curr_dim]++;
 
             /* Check if we are still within the span */
-            if(abs_arr[curr_dim] <= curr_span->high)
+            if (abs_arr[curr_dim] <= curr_span->high)
                 break;
             /* If we walked off that span, advance to the next span */
             else {
@@ -1347,7 +1334,7 @@ H5S__hyper_iter_next_block(H5S_sel_iter_t *iter)
                 curr_span = curr_span->next;
 
                 /* Check if we have a valid span in this dimension still */
-                if(curr_span != NULL) {
+                if (curr_span != NULL) {
                     /* Reset the span in the current dimension */
                     ispan[curr_dim] = curr_span;
 
@@ -1357,15 +1344,16 @@ H5S__hyper_iter_next_block(H5S_sel_iter_t *iter)
                     break;
                 } /* end if */
                 else
-                    /* If we finished the span list in this dimension, decrement the dimension worked on and loop again */
+                    /* If we finished the span list in this dimension, decrement the dimension worked on and
+                     * loop again */
                     curr_dim--;
             } /* end else */
-        } /* end while */
+        }     /* end while */
 
         /* Check if we are finished with the spans in the tree */
-        if(curr_dim >= 0) {
+        if (curr_dim >= 0) {
             /* Walk back down the iterator positions, resetting them */
-            while(curr_dim < fast_dim) {
+            while (curr_dim < fast_dim) {
                 HDassert(curr_span);
                 HDassert(curr_span->down);
                 HDassert(curr_span->down->head);
@@ -1386,12 +1374,11 @@ H5S__hyper_iter_next_block(H5S_sel_iter_t *iter)
             /* Verify that the curr_span points to the fastest dim */
             HDassert(curr_span == ispan[fast_dim]);
         } /* end if */
-    } /* end else */
+    }     /* end else */
 
     FUNC_LEAVE_NOAPI(SUCCEED)
 } /* end H5S__hyper_iter_next_block() */
 
-
 /*--------------------------------------------------------------------------
  NAME
     H5S__hyper_iter_get_seq_list_gen
@@ -1422,28 +1409,28 @@ H5S__hyper_iter_next_block(H5S_sel_iter_t *iter)
  REVISION LOG
 --------------------------------------------------------------------------*/
 static herr_t
-H5S__hyper_iter_get_seq_list_gen(H5S_sel_iter_t *iter, size_t maxseq, size_t maxelem,
-    size_t *nseq, size_t *nelem, hsize_t *off, size_t *len)
+H5S__hyper_iter_get_seq_list_gen(H5S_sel_iter_t *iter, size_t maxseq, size_t maxelem, size_t *nseq,
+                                 size_t *nelem, hsize_t *off, size_t *len)
 {
-    H5S_hyper_span_t *curr_span;    /* Current hyperslab span node */
-    H5S_hyper_span_t **ispan;       /* Iterator's hyperslab span nodes */
-    hsize_t *slab;      /* Cumulative size of each dimension in bytes */
-    hsize_t loc_off;    /* Byte offset in the dataspace */
-    hsize_t last_span_end = 0; /* The offset of the end of the last span */
-    hsize_t *abs_arr;   /* Absolute hyperslab span position, in elements */
-    hsize_t *loc_arr;   /* Byte offset of hyperslab span position within buffer */
-    const hssize_t *sel_off;  /* Offset within the dataspace extent */
-    size_t span_elmts = 0; /* Number of elements to actually use for this span */
-    size_t span_size = 0; /* Number of bytes in current span to actually process */
-    size_t io_left;     /* Initial number of elements to process */
-    size_t io_elmts_left;   /* Number of elements left to process */
-    size_t io_used;     /* Number of elements processed */
-    size_t curr_seq = 0; /* Number of sequence/offsets stored in the arrays */
-    size_t elem_size;   /* Size of each element iterating over */
-    unsigned ndims;     /* Number of dimensions of dataset */
-    unsigned fast_dim;  /* Rank of the fastest changing dimension for the dataspace */
-    int curr_dim;       /* Current dimension being operated on */
-    unsigned u;         /* Index variable */
+    H5S_hyper_span_t * curr_span;         /* Current hyperslab span node */
+    H5S_hyper_span_t **ispan;             /* Iterator's hyperslab span nodes */
+    hsize_t *          slab;              /* Cumulative size of each dimension in bytes */
+    hsize_t            loc_off;           /* Byte offset in the dataspace */
+    hsize_t            last_span_end = 0; /* The offset of the end of the last span */
+    hsize_t *          abs_arr;           /* Absolute hyperslab span position, in elements */
+    hsize_t *          loc_arr;           /* Byte offset of hyperslab span position within buffer */
+    const hssize_t *   sel_off;           /* Offset within the dataspace extent */
+    size_t             span_elmts = 0;    /* Number of elements to actually use for this span */
+    size_t             span_size  = 0;    /* Number of bytes in current span to actually process */
+    size_t             io_left;           /* Initial number of elements to process */
+    size_t             io_elmts_left;     /* Number of elements left to process */
+    size_t             io_used;           /* Number of elements processed */
+    size_t             curr_seq = 0;      /* Number of sequence/offsets stored in the arrays */
+    size_t             elem_size;         /* Size of each element iterating over */
+    unsigned           ndims;             /* Number of dimensions of dataset */
+    unsigned           fast_dim;          /* Rank of the fastest changing dimension for the dataspace */
+    int                curr_dim;          /* Current dimension being operated on */
+    unsigned           u;                 /* Index variable */
 
     FUNC_ENTER_STATIC_NOERR
 
@@ -1457,16 +1444,16 @@ H5S__hyper_iter_get_seq_list_gen(H5S_sel_iter_t *iter, size_t maxseq, size_t max
     HDassert(len);
 
     /* Set the rank of the fastest changing dimension */
-    ndims = iter->rank;
+    ndims    = iter->rank;
     fast_dim = (ndims - 1);
 
     /* Get the pointers to the current span info and span nodes */
     curr_span = iter->u.hyp.span[fast_dim];
-    abs_arr = iter->u.hyp.off;
-    loc_arr = iter->u.hyp.loc_off;
-    slab = iter->u.hyp.slab;
-    sel_off = iter->sel_off;
-    ispan = iter->u.hyp.span;
+    abs_arr   = iter->u.hyp.off;
+    loc_arr   = iter->u.hyp.loc_off;
+    slab      = iter->u.hyp.slab;
+    sel_off   = iter->sel_off;
+    ispan     = iter->u.hyp.span;
     elem_size = iter->elmt_size;
 
     /* Set the amount of elements to perform I/O on, etc. */
@@ -1474,18 +1461,18 @@ H5S__hyper_iter_get_seq_list_gen(H5S_sel_iter_t *iter, size_t maxseq, size_t max
     io_elmts_left = io_left = MIN(maxelem, (size_t)iter->elmt_left);
 
     /* Set the offset of the first element iterated on */
-    for(u = 0, loc_off = 0; u < ndims; u++)
+    for (u = 0, loc_off = 0; u < ndims; u++)
         loc_off += loc_arr[u];
 
     /* Take care of any partial spans leftover from previous I/Os */
-    if(abs_arr[fast_dim] != curr_span->low) {
+    if (abs_arr[fast_dim] != curr_span->low) {
         /* Finish the span in the fastest changing dimension */
 
         /* Compute the number of elements to attempt in this span */
         H5_CHECKED_ASSIGN(span_elmts, size_t, ((curr_span->high - abs_arr[fast_dim]) + 1), hsize_t);
 
         /* Check number of elements against upper bounds allowed */
-        if(span_elmts > io_elmts_left)
+        if (span_elmts > io_elmts_left)
             span_elmts = io_elmts_left;
 
         /* Set the span_size, in bytes */
@@ -1505,26 +1492,27 @@ H5S__hyper_iter_get_seq_list_gen(H5S_sel_iter_t *iter, size_t maxseq, size_t max
         io_elmts_left -= span_elmts;
 
         /* Check if we are done */
-        if(io_elmts_left > 0) {
+        if (io_elmts_left > 0) {
             /* Move to next span in fastest changing dimension */
             curr_span = curr_span->next;
 
-            if(NULL != curr_span) {
+            if (NULL != curr_span) {
                 /* Move location offset of destination */
                 loc_off += (curr_span->low - abs_arr[fast_dim]) * elem_size;
 
                 /* Move iterator for fastest changing dimension */
                 abs_arr[fast_dim] = curr_span->low;
-                loc_arr[fast_dim] = ((hsize_t)((hssize_t)curr_span->low + sel_off[fast_dim])) * slab[fast_dim];
+                loc_arr[fast_dim] =
+                    ((hsize_t)((hssize_t)curr_span->low + sel_off[fast_dim])) * slab[fast_dim];
                 ispan[fast_dim] = curr_span;
             } /* end if */
-        } /* end if */
+        }     /* end if */
         else {
             /* Advance the hyperslab iterator */
             abs_arr[fast_dim] += span_elmts;
 
             /* Check if we are still within the span */
-            if(abs_arr[fast_dim] <= curr_span->high) {
+            if (abs_arr[fast_dim] <= curr_span->high) {
                 /* Sanity check */
                 HDassert(ispan[fast_dim] == curr_span);
 
@@ -1537,28 +1525,29 @@ H5S__hyper_iter_get_seq_list_gen(H5S_sel_iter_t *iter, size_t maxseq, size_t max
                 curr_span = curr_span->next;
 
                 /* Check if we have a valid span in this dimension still */
-                if(NULL != curr_span) {
+                if (NULL != curr_span) {
                     /* Reset absolute position */
                     abs_arr[fast_dim] = curr_span->low;
 
                     /* Update location offset */
-                    loc_arr[fast_dim] = ((hsize_t)((hssize_t)curr_span->low + sel_off[fast_dim])) * slab[fast_dim];
+                    loc_arr[fast_dim] =
+                        ((hsize_t)((hssize_t)curr_span->low + sel_off[fast_dim])) * slab[fast_dim];
 
                     /* Reset the span in the current dimension */
                     ispan[fast_dim] = curr_span;
                 } /* end if */
-            } /* end else */
-        } /* end else */
+            }     /* end else */
+        }         /* end else */
 
         /* Adjust iterator pointers */
 
-        if(NULL == curr_span) {
-/* Same as code in main loop */
+        if (NULL == curr_span) {
+            /* Same as code in main loop */
             /* Start at the next fastest dim */
             curr_dim = (int)(fast_dim - 1);
 
             /* Work back up through the dimensions */
-            while(curr_dim >= 0) {
+            while (curr_dim >= 0) {
                 /* Reset the current span */
                 curr_span = ispan[curr_dim];
 
@@ -1566,7 +1555,7 @@ H5S__hyper_iter_get_seq_list_gen(H5S_sel_iter_t *iter, size_t maxseq, size_t max
                 abs_arr[curr_dim]++;
 
                 /* Check if we are still within the span */
-                if(abs_arr[curr_dim] <= curr_span->high) {
+                if (abs_arr[curr_dim] <= curr_span->high) {
                     /* Update location offset */
                     loc_arr[curr_dim] += slab[curr_dim];
 
@@ -1578,7 +1567,7 @@ H5S__hyper_iter_get_seq_list_gen(H5S_sel_iter_t *iter, size_t maxseq, size_t max
                     curr_span = curr_span->next;
 
                     /* Check if we have a valid span in this dimension still */
-                    if(NULL != curr_span) {
+                    if (NULL != curr_span) {
                         /* Reset the span in the current dimension */
                         ispan[curr_dim] = curr_span;
 
@@ -1586,20 +1575,22 @@ H5S__hyper_iter_get_seq_list_gen(H5S_sel_iter_t *iter, size_t maxseq, size_t max
                         abs_arr[curr_dim] = curr_span->low;
 
                         /* Update byte location */
-                        loc_arr[curr_dim] = ((hsize_t)((hssize_t)curr_span->low + sel_off[curr_dim])) * slab[curr_dim];
+                        loc_arr[curr_dim] =
+                            ((hsize_t)((hssize_t)curr_span->low + sel_off[curr_dim])) * slab[curr_dim];
 
                         break;
                     } /* end if */
                     else
-                        /* If we finished the span list in this dimension, decrement the dimension worked on and loop again */
+                        /* If we finished the span list in this dimension, decrement the dimension worked on
+                         * and loop again */
                         curr_dim--;
                 } /* end else */
-            } /* end while */
+            }     /* end while */
 
             /* Check if we have more spans in the tree */
-            if(curr_dim >= 0) {
+            if (curr_dim >= 0) {
                 /* Walk back down the iterator positions, resetting them */
-                while((unsigned)curr_dim < fast_dim) {
+                while ((unsigned)curr_dim < fast_dim) {
                     HDassert(curr_span);
                     HDassert(curr_span->down);
                     HDassert(curr_span->down->head);
@@ -1617,25 +1608,26 @@ H5S__hyper_iter_get_seq_list_gen(H5S_sel_iter_t *iter, size_t maxseq, size_t max
                     abs_arr[curr_dim] = curr_span->low;
 
                     /* Update the location offset */
-                    loc_arr[curr_dim] = ((hsize_t)((hssize_t)curr_span->low + sel_off[curr_dim])) * slab[curr_dim];
+                    loc_arr[curr_dim] =
+                        ((hsize_t)((hssize_t)curr_span->low + sel_off[curr_dim])) * slab[curr_dim];
                 } /* end while */
 
                 /* Verify that the curr_span points to the fastest dim */
                 HDassert(curr_span == ispan[fast_dim]);
 
                 /* Reset the buffer offset */
-                for(u = 0, loc_off = 0; u < ndims; u++)
+                for (u = 0, loc_off = 0; u < ndims; u++)
                     loc_off += loc_arr[u];
             } /* end else */
             else
                 /* We had better be done with I/O or bad things are going to happen... */
                 HDassert(io_elmts_left == 0);
         } /* end if */
-    } /* end if */
+    }     /* end if */
 
     /* Perform the I/O on the elements, based on the position of the iterator */
-    while(io_elmts_left > 0 && curr_seq < maxseq) {
-        H5S_hyper_span_t *prev_span;    /* Previous hyperslab span node */
+    while (io_elmts_left > 0 && curr_seq < maxseq) {
+        H5S_hyper_span_t *prev_span; /* Previous hyperslab span node */
 
         /* Sanity check */
         HDassert(curr_span);
@@ -1644,8 +1636,8 @@ H5S__hyper_iter_get_seq_list_gen(H5S_sel_iter_t *iter, size_t maxseq, size_t max
         prev_span = curr_span;
 
         /* Loop over all the spans in the fastest changing dimension */
-        while(curr_span != NULL) {
-            hsize_t nelmts;     /* # of elements covered by current span */
+        while (curr_span != NULL) {
+            hsize_t nelmts; /* # of elements covered by current span */
 
             /* Move location offset of current span */
             loc_off += (curr_span->low - prev_span->low) * elem_size;
@@ -1655,17 +1647,17 @@ H5S__hyper_iter_get_seq_list_gen(H5S_sel_iter_t *iter, size_t maxseq, size_t max
             H5_CHECKED_ASSIGN(span_elmts, size_t, nelmts, hsize_t);
 
             /* Check number of elements against upper bounds allowed */
-            if(span_elmts >= io_elmts_left) {
+            if (span_elmts >= io_elmts_left) {
                 /* Trim the number of elements to output */
-                span_elmts = io_elmts_left;
-                span_size = span_elmts * elem_size;
+                span_elmts    = io_elmts_left;
+                span_size     = span_elmts * elem_size;
                 io_elmts_left = 0;
 
-/* COMMON */
+                /* COMMON */
                 /* Store the I/O information for the span */
 
                 /* Check if this is appending onto previous sequence */
-                if(curr_seq > 0 && last_span_end == loc_off)
+                if (curr_seq > 0 && last_span_end == loc_off)
                     len[curr_seq - 1] += span_size;
                 else {
                     off[curr_seq] = loc_off;
@@ -1674,7 +1666,7 @@ H5S__hyper_iter_get_seq_list_gen(H5S_sel_iter_t *iter, size_t maxseq, size_t max
                     /* Increment the number of sequences in arrays */
                     curr_seq++;
                 } /* end else */
-/* end COMMON */
+                  /* end COMMON */
 
                 /* Break out now, we are finished with I/O */
                 break;
@@ -1684,11 +1676,11 @@ H5S__hyper_iter_get_seq_list_gen(H5S_sel_iter_t *iter, size_t maxseq, size_t max
                 span_size = span_elmts * elem_size;
                 io_elmts_left -= span_elmts;
 
-/* COMMON */
+                /* COMMON */
                 /* Store the I/O information for the span */
 
                 /* Check if this is appending onto previous sequence */
-                if(curr_seq > 0 && last_span_end == loc_off)
+                if (curr_seq > 0 && last_span_end == loc_off)
                     len[curr_seq - 1] += span_size;
                 else {
                     off[curr_seq] = loc_off;
@@ -1697,10 +1689,10 @@ H5S__hyper_iter_get_seq_list_gen(H5S_sel_iter_t *iter, size_t maxseq, size_t max
                     /* Increment the number of sequences in arrays */
                     curr_seq++;
                 } /* end else */
-/* end COMMON */
+                  /* end COMMON */
 
                 /* If the sequence & offset arrays are full, do what? */
-                if(curr_seq >= maxseq)
+                if (curr_seq >= maxseq)
                     /* Break out now, we are finished with sequences */
                     break;
             } /* end else */
@@ -1708,13 +1700,13 @@ H5S__hyper_iter_get_seq_list_gen(H5S_sel_iter_t *iter, size_t maxseq, size_t max
             /* Set the location of the last span's end */
             last_span_end = loc_off + span_size;
 
-        /* Move to next span in fastest changing dimension */
+            /* Move to next span in fastest changing dimension */
             prev_span = curr_span;
-        curr_span = curr_span->next;
+            curr_span = curr_span->next;
         } /* end while */
 
         /* Check if we are done */
-        if(io_elmts_left == 0 || curr_seq >= maxseq) {
+        if (io_elmts_left == 0 || curr_seq >= maxseq) {
             /* Sanity checks */
             HDassert(curr_span);
 
@@ -1722,12 +1714,14 @@ H5S__hyper_iter_get_seq_list_gen(H5S_sel_iter_t *iter, size_t maxseq, size_t max
             abs_arr[fast_dim] = curr_span->low + span_elmts;
 
             /* Check if we are still within the span */
-            if(abs_arr[fast_dim] <= curr_span->high) {
+            if (abs_arr[fast_dim] <= curr_span->high) {
                 /* Reset the span for the fast dimension */
                 ispan[fast_dim] = curr_span;
 
                 /* Update location offset */
-                loc_arr[fast_dim] = ((hsize_t)((hssize_t)curr_span->low + (hssize_t)span_elmts + sel_off[fast_dim])) * slab[fast_dim];
+                loc_arr[fast_dim] =
+                    ((hsize_t)((hssize_t)curr_span->low + (hssize_t)span_elmts + sel_off[fast_dim])) *
+                    slab[fast_dim];
 
                 break;
             } /* end if */
@@ -1737,16 +1731,17 @@ H5S__hyper_iter_get_seq_list_gen(H5S_sel_iter_t *iter, size_t maxseq, size_t max
                 curr_span = curr_span->next;
 
                 /* Check if we have a valid span in this dimension still */
-                if(curr_span != NULL) {
+                if (curr_span != NULL) {
                     /* Reset absolute position */
                     abs_arr[fast_dim] = curr_span->low;
-                    loc_arr[fast_dim] = ((hsize_t)((hssize_t)curr_span->low + sel_off[fast_dim])) * slab[fast_dim];
+                    loc_arr[fast_dim] =
+                        ((hsize_t)((hssize_t)curr_span->low + sel_off[fast_dim])) * slab[fast_dim];
                     ispan[fast_dim] = curr_span;
 
                     break;
                 } /* end if */
-            } /* end else */
-        } /* end if */
+            }     /* end else */
+        }         /* end if */
 
         /* Adjust iterator pointers */
 
@@ -1754,7 +1749,7 @@ H5S__hyper_iter_get_seq_list_gen(H5S_sel_iter_t *iter, size_t maxseq, size_t max
         curr_dim = (int)(fast_dim - 1);
 
         /* Work back up through the dimensions */
-        while(curr_dim >= 0) {
+        while (curr_dim >= 0) {
             /* Reset the current span */
             curr_span = ispan[curr_dim];
 
@@ -1762,7 +1757,7 @@ H5S__hyper_iter_get_seq_list_gen(H5S_sel_iter_t *iter, size_t maxseq, size_t max
             abs_arr[curr_dim]++;
 
             /* Check if we are still within the span */
-            if(abs_arr[curr_dim] <= curr_span->high) {
+            if (abs_arr[curr_dim] <= curr_span->high) {
                 /* Update location offset */
                 loc_arr[curr_dim] += slab[curr_dim];
 
@@ -1774,7 +1769,7 @@ H5S__hyper_iter_get_seq_list_gen(H5S_sel_iter_t *iter, size_t maxseq, size_t max
                 curr_span = curr_span->next;
 
                 /* Check if we have a valid span in this dimension still */
-                if(curr_span != NULL) {
+                if (curr_span != NULL) {
                     /* Reset the span in the current dimension */
                     ispan[curr_dim] = curr_span;
 
@@ -1782,25 +1777,27 @@ H5S__hyper_iter_get_seq_list_gen(H5S_sel_iter_t *iter, size_t maxseq, size_t max
                     abs_arr[curr_dim] = curr_span->low;
 
                     /* Update location offset */
-                    loc_arr[curr_dim] = ((hsize_t)((hssize_t)curr_span->low + sel_off[curr_dim])) * slab[curr_dim];
+                    loc_arr[curr_dim] =
+                        ((hsize_t)((hssize_t)curr_span->low + sel_off[curr_dim])) * slab[curr_dim];
 
                     break;
                 } /* end if */
                 else
-                    /* If we finished the span list in this dimension, decrement the dimension worked on and loop again */
+                    /* If we finished the span list in this dimension, decrement the dimension worked on and
+                     * loop again */
                     curr_dim--;
             } /* end else */
-        } /* end while */
+        }     /* end while */
 
         /* Check if we are finished with the spans in the tree */
-        if(curr_dim < 0) {
+        if (curr_dim < 0) {
             /* We had better be done with I/O or bad things are going to happen... */
             HDassert(io_elmts_left == 0);
             break;
         } /* end if */
         else {
             /* Walk back down the iterator positions, resetting them */
-            while((unsigned)curr_dim < fast_dim) {
+            while ((unsigned)curr_dim < fast_dim) {
                 HDassert(curr_span);
                 HDassert(curr_span->down);
                 HDassert(curr_span->down->head);
@@ -1818,7 +1815,8 @@ H5S__hyper_iter_get_seq_list_gen(H5S_sel_iter_t *iter, size_t maxseq, size_t max
                 abs_arr[curr_dim] = curr_span->low;
 
                 /* Update location offset */
-                loc_arr[curr_dim] = ((hsize_t)((hssize_t)curr_span->low + sel_off[curr_dim])) * slab[curr_dim];
+                loc_arr[curr_dim] =
+                    ((hsize_t)((hssize_t)curr_span->low + sel_off[curr_dim])) * slab[curr_dim];
             } /* end while */
 
             /* Verify that the curr_span points to the fastest dim */
@@ -1826,7 +1824,7 @@ H5S__hyper_iter_get_seq_list_gen(H5S_sel_iter_t *iter, size_t maxseq, size_t max
         } /* end else */
 
         /* Reset the buffer offset */
-        for(u = 0, loc_off = 0; u < ndims; u++)
+        for (u = 0, loc_off = 0; u < ndims; u++)
             loc_off += loc_arr[u];
     } /* end while */
 
@@ -1843,7 +1841,6 @@ H5S__hyper_iter_get_seq_list_gen(H5S_sel_iter_t *iter, size_t maxseq, size_t max
     FUNC_LEAVE_NOAPI(SUCCEED)
 } /* end H5S__hyper_iter_get_seq_list_gen() */
 
-
 /*--------------------------------------------------------------------------
  NAME
     H5S__hyper_iter_get_seq_list_opt
@@ -1874,39 +1871,37 @@ H5S__hyper_iter_get_seq_list_gen(H5S_sel_iter_t *iter, size_t maxseq, size_t max
  REVISION LOG
 --------------------------------------------------------------------------*/
 static herr_t
-H5S__hyper_iter_get_seq_list_opt(H5S_sel_iter_t *iter, size_t maxseq, size_t maxelem,
-    size_t *nseq, size_t *nelem, hsize_t *off, size_t *len)
+H5S__hyper_iter_get_seq_list_opt(H5S_sel_iter_t *iter, size_t maxseq, size_t maxelem, size_t *nseq,
+                                 size_t *nelem, hsize_t *off, size_t *len)
 {
-    hsize_t *mem_size;                  /* Size of the source buffer */
-    hsize_t *slab;                      /* Hyperslab size */
-    const hssize_t *sel_off;            /* Selection offset in dataspace */
-    hsize_t offset[H5S_MAX_RANK];       /* Coordinate offset in dataspace */
-    hsize_t tmp_count[H5S_MAX_RANK];    /* Temporary block count */
-    hsize_t tmp_block[H5S_MAX_RANK];    /* Temporary block offset */
-    hsize_t wrap[H5S_MAX_RANK];         /* Bytes to wrap around at the end of a row */
-    hsize_t skip[H5S_MAX_RANK];         /* Bytes to skip between blocks */
-    const H5S_hyper_dim_t *tdiminfo;    /* Temporary pointer to diminfo information */
-    hsize_t fast_dim_start,    /* Local copies of fastest changing dimension info */
-        fast_dim_stride,
-        fast_dim_block,
-        fast_dim_offset;
-    size_t fast_dim_buf_off;    /* Local copy of amount to move fastest dimension buffer offset */
-    size_t fast_dim_count;      /* Number of blocks left in fastest changing dimension */
-    size_t tot_blk_count;       /* Total number of blocks left to output */
-    size_t act_blk_count;       /* Actual number of blocks to output */
-    size_t total_rows;          /* Total number of entire rows to output */
-    size_t curr_rows;           /* Current number of entire rows to output */
-    unsigned fast_dim;  /* Rank of the fastest changing dimension for the dataspace */
-    unsigned ndims;     /* Number of dimensions of dataset */
-    int temp_dim;       /* Temporary rank holder */
-    hsize_t loc;        /* Coordinate offset */
-    size_t curr_seq = 0; /* Current sequence being operated on */
-    size_t actual_elem; /* The actual number of elements to count */
-    size_t actual_bytes;/* The actual number of bytes to copy */
-    size_t io_left;     /* The number of elements left in I/O operation */
-    size_t start_io_left; /* The initial number of elements left in I/O operation */
-    size_t elem_size;   /* Size of each element iterating over */
-    unsigned u;         /* Local index variable */
+    hsize_t *              mem_size;                /* Size of the source buffer */
+    hsize_t *              slab;                    /* Hyperslab size */
+    const hssize_t *       sel_off;                 /* Selection offset in dataspace */
+    hsize_t                offset[H5S_MAX_RANK];    /* Coordinate offset in dataspace */
+    hsize_t                tmp_count[H5S_MAX_RANK]; /* Temporary block count */
+    hsize_t                tmp_block[H5S_MAX_RANK]; /* Temporary block offset */
+    hsize_t                wrap[H5S_MAX_RANK];      /* Bytes to wrap around at the end of a row */
+    hsize_t                skip[H5S_MAX_RANK];      /* Bytes to skip between blocks */
+    const H5S_hyper_dim_t *tdiminfo;                /* Temporary pointer to diminfo information */
+    hsize_t                fast_dim_start,          /* Local copies of fastest changing dimension info */
+        fast_dim_stride, fast_dim_block, fast_dim_offset;
+    size_t   fast_dim_buf_off; /* Local copy of amount to move fastest dimension buffer offset */
+    size_t   fast_dim_count;   /* Number of blocks left in fastest changing dimension */
+    size_t   tot_blk_count;    /* Total number of blocks left to output */
+    size_t   act_blk_count;    /* Actual number of blocks to output */
+    size_t   total_rows;       /* Total number of entire rows to output */
+    size_t   curr_rows;        /* Current number of entire rows to output */
+    unsigned fast_dim;         /* Rank of the fastest changing dimension for the dataspace */
+    unsigned ndims;            /* Number of dimensions of dataset */
+    int      temp_dim;         /* Temporary rank holder */
+    hsize_t  loc;              /* Coordinate offset */
+    size_t   curr_seq = 0;     /* Current sequence being operated on */
+    size_t   actual_elem;      /* The actual number of elements to count */
+    size_t   actual_bytes;     /* The actual number of bytes to copy */
+    size_t   io_left;          /* The number of elements left in I/O operation */
+    size_t   start_io_left;    /* The initial number of elements left in I/O operation */
+    size_t   elem_size;        /* Size of each element iterating over */
+    unsigned u;                /* Local index variable */
 
     FUNC_ENTER_STATIC_NOERR
 
@@ -1923,7 +1918,7 @@ H5S__hyper_iter_get_seq_list_opt(H5S_sel_iter_t *iter, size_t maxseq, size_t max
     tdiminfo = iter->u.hyp.diminfo;
 
     /* Check if this is a "flattened" regular hyperslab selection */
-    if(iter->u.hyp.iter_rank != 0 && iter->u.hyp.iter_rank < iter->rank) {
+    if (iter->u.hyp.iter_rank != 0 && iter->u.hyp.iter_rank < iter->rank) {
         /* Set the aliases for a few important dimension ranks */
         ndims = iter->u.hyp.iter_rank;
 
@@ -1945,9 +1940,9 @@ H5S__hyper_iter_get_seq_list_opt(H5S_sel_iter_t *iter, size_t maxseq, size_t max
     } /* end else */
 
     /* Set up some local variables */
-    fast_dim = ndims - 1;
+    fast_dim  = ndims - 1;
     elem_size = iter->elmt_size;
-    slab = iter->u.hyp.slab;
+    slab      = iter->u.hyp.slab;
 
     /* Calculate the number of elements to sequence through */
     H5_CHECK_OVERFLOW(iter->elmt_left, hsize_t, size_t);
@@ -1955,7 +1950,7 @@ H5S__hyper_iter_get_seq_list_opt(H5S_sel_iter_t *iter, size_t maxseq, size_t max
 
     /* Sanity check that there aren't any "remainder" sequences in process */
     HDassert(!((iter->u.hyp.off[fast_dim] - tdiminfo[fast_dim].start) % tdiminfo[fast_dim].stride != 0 ||
-            ((iter->u.hyp.off[fast_dim] != tdiminfo[fast_dim].start) && tdiminfo[fast_dim].count == 1)));
+               ((iter->u.hyp.off[fast_dim] != tdiminfo[fast_dim].start) && tdiminfo[fast_dim].count == 1)));
 
     /* We've cleared the "remainder" of the previous fastest dimension
      * sequence before calling this routine, so we must be at the beginning of
@@ -1970,12 +1965,12 @@ H5S__hyper_iter_get_seq_list_opt(H5S_sel_iter_t *iter, size_t maxseq, size_t max
 
     /* Copy the location of the point to get */
     /* (Add in the selection offset) */
-    for(u = 0; u < ndims; u++)
+    for (u = 0; u < ndims; u++)
         offset[u] = (hsize_t)((hssize_t)iter->u.hyp.off[u] + sel_off[u]);
 
     /* Compute the current "counts" for this location */
-    for(u = 0; u < ndims; u++) {
-        if(tdiminfo[u].count == 1) {
+    for (u = 0; u < ndims; u++) {
+        if (tdiminfo[u].count == 1) {
             tmp_count[u] = 0;
             tmp_block[u] = iter->u.hyp.off[u] - tdiminfo[u].start;
         } /* end if */
@@ -1983,10 +1978,10 @@ H5S__hyper_iter_get_seq_list_opt(H5S_sel_iter_t *iter, size_t maxseq, size_t max
             tmp_count[u] = (iter->u.hyp.off[u] - tdiminfo[u].start) / tdiminfo[u].stride;
             tmp_block[u] = (iter->u.hyp.off[u] - tdiminfo[u].start) % tdiminfo[u].stride;
         } /* end else */
-    } /* end for */
+    }     /* end for */
 
     /* Compute the initial buffer offset */
-    for(u = 0, loc = 0; u < ndims; u++)
+    for (u = 0, loc = 0; u < ndims; u++)
         loc += offset[u] * slab[u];
 
     /* Set the number of elements to write each time */
@@ -1996,9 +1991,9 @@ H5S__hyper_iter_get_seq_list_opt(H5S_sel_iter_t *iter, size_t maxseq, size_t max
     actual_bytes = actual_elem * elem_size;
 
     /* Set local copies of information for the fastest changing dimension */
-    fast_dim_start = tdiminfo[fast_dim].start;
+    fast_dim_start  = tdiminfo[fast_dim].start;
     fast_dim_stride = tdiminfo[fast_dim].stride;
-    fast_dim_block = tdiminfo[fast_dim].block;
+    fast_dim_block  = tdiminfo[fast_dim].block;
     H5_CHECKED_ASSIGN(fast_dim_buf_off, size_t, slab[fast_dim] * fast_dim_stride, hsize_t);
     fast_dim_offset = (hsize_t)((hssize_t)fast_dim_start + sel_off[fast_dim]);
 
@@ -2010,15 +2005,15 @@ H5S__hyper_iter_get_seq_list_opt(H5S_sel_iter_t *iter, size_t maxseq, size_t max
     tot_blk_count = MIN(tot_blk_count, (maxseq - curr_seq));
 
     /* Compute the amount to wrap at the end of each row */
-    for(u = 0; u < ndims; u++)
+    for (u = 0; u < ndims; u++)
         wrap[u] = (mem_size[u] - (tdiminfo[u].stride * tdiminfo[u].count)) * slab[u];
 
     /* Compute the amount to skip between blocks */
-    for(u = 0; u < ndims; u++)
+    for (u = 0; u < ndims; u++)
         skip[u] = (tdiminfo[u].stride - tdiminfo[u].block) * slab[u];
 
     /* Check if there is a partial row left (with full blocks) */
-    if(tmp_count[fast_dim] > 0) {
+    if (tmp_count[fast_dim] > 0) {
         /* Get number of blocks in fastest dimension */
         H5_CHECKED_ASSIGN(fast_dim_count, size_t, tdiminfo[fast_dim].count - tmp_count[fast_dim], hsize_t);
 
@@ -2029,7 +2024,7 @@ H5S__hyper_iter_get_seq_list_opt(H5S_sel_iter_t *iter, size_t maxseq, size_t max
         act_blk_count = fast_dim_count;
 
         /* Loop over all the blocks in the fastest changing dimension */
-        while(fast_dim_count > 0) {
+        while (fast_dim_count > 0) {
             /* Store the sequence information */
             off[curr_seq] = loc;
             len[curr_seq] = actual_bytes;
@@ -2054,23 +2049,24 @@ H5S__hyper_iter_get_seq_list_opt(H5S_sel_iter_t *iter, size_t maxseq, size_t max
         tmp_count[fast_dim] += act_blk_count;
 
         /* Check if we finished the entire row of blocks */
-        if(tmp_count[fast_dim] >= tdiminfo[fast_dim].count) {
+        if (tmp_count[fast_dim] >= tdiminfo[fast_dim].count) {
             /* Increment offset in destination buffer */
             loc += wrap[fast_dim];
 
             /* Increment information to reflect block just processed */
-            offset[fast_dim] = fast_dim_offset;    /* reset the offset in the fastest dimension */
+            offset[fast_dim]    = fast_dim_offset; /* reset the offset in the fastest dimension */
             tmp_count[fast_dim] = 0;
 
             /* Increment the offset and count for the other dimensions */
             temp_dim = (int)fast_dim - 1;
-            while(temp_dim >= 0) {
+            while (temp_dim >= 0) {
                 /* Move to the next row in the curent dimension */
                 offset[temp_dim]++;
                 tmp_block[temp_dim]++;
 
-                /* If this block is still in the range of blocks to output for the dimension, break out of loop */
-                if(tmp_block[temp_dim] < tdiminfo[temp_dim].block)
+                /* If this block is still in the range of blocks to output for the dimension, break out of
+                 * loop */
+                if (tmp_block[temp_dim] < tdiminfo[temp_dim].block)
                     break;
                 else {
                     /* Move to the next block in the current dimension */
@@ -2079,8 +2075,9 @@ H5S__hyper_iter_get_seq_list_opt(H5S_sel_iter_t *iter, size_t maxseq, size_t max
                     tmp_block[temp_dim] = 0;
                     tmp_count[temp_dim]++;
 
-                    /* If this block is still in the range of blocks to output for the dimension, break out of loop */
-                    if(tmp_count[temp_dim] < tdiminfo[temp_dim].count)
+                    /* If this block is still in the range of blocks to output for the dimension, break out of
+                     * loop */
+                    if (tmp_count[temp_dim] < tdiminfo[temp_dim].count)
                         break;
                     else {
                         offset[temp_dim] = (hsize_t)((hssize_t)tdiminfo[temp_dim].start + sel_off[temp_dim]);
@@ -2088,17 +2085,17 @@ H5S__hyper_iter_get_seq_list_opt(H5S_sel_iter_t *iter, size_t maxseq, size_t max
                         tmp_count[temp_dim] = 0; /* reset back to the beginning of the line */
                         tmp_block[temp_dim] = 0;
                     } /* end else */
-                } /* end else */
+                }     /* end else */
 
                 /* Decrement dimension count */
                 temp_dim--;
             } /* end while */
-        } /* end if */
+        }     /* end if */
         else {
             /* Update the offset in the fastest dimension */
             offset[fast_dim] += (fast_dim_stride * act_blk_count);
         } /* end else */
-    } /* end if */
+    }     /* end if */
 
     /* Compute the number of entire rows to read in */
     H5_CHECK_OVERFLOW(tot_blk_count / tdiminfo[fast_dim].count, hsize_t, size_t);
@@ -2108,28 +2105,28 @@ H5S__hyper_iter_get_seq_list_opt(H5S_sel_iter_t *iter, size_t maxseq, size_t max
     H5_CHECKED_ASSIGN(fast_dim_count, size_t, tdiminfo[fast_dim].count, hsize_t);
 
     /* Read in data until an entire sequence can't be written out any longer */
-    while(curr_rows > 0) {
-
-#define DUFF_GUTS                                                       \
-/* Store the sequence information */                                    \
-off[curr_seq] = loc;                                                    \
-len[curr_seq] = actual_bytes;                                           \
-                                                                        \
-/* Increment sequence count */                                          \
-curr_seq++;                                                             \
-                                                                        \
-/* Increment information to reflect block just processed */             \
-loc += fast_dim_buf_off;
+    while (curr_rows > 0) {
+
+#define DUFF_GUTS                                                                                            \
+    /* Store the sequence information */                                                                     \
+    off[curr_seq] = loc;                                                                                     \
+    len[curr_seq] = actual_bytes;                                                                            \
+                                                                                                             \
+    /* Increment sequence count */                                                                           \
+    curr_seq++;                                                                                              \
+                                                                                                             \
+    /* Increment information to reflect block just processed */                                              \
+    loc += fast_dim_buf_off;
 
 #ifdef NO_DUFFS_DEVICE
         /* Loop over all the blocks in the fastest changing dimension */
-        while(fast_dim_count > 0) {
+        while (fast_dim_count > 0) {
             DUFF_GUTS
 
             /* Decrement number of blocks */
             fast_dim_count--;
         } /* end while */
-#else /* NO_DUFFS_DEVICE */
+#else     /* NO_DUFFS_DEVICE */
         {
             size_t duffs_index; /* Counting index for Duff's device */
 
@@ -2139,34 +2136,33 @@ loc += fast_dim_buf_off;
                     HDassert(0 && "This Should never be executed!");
                     break;
                 case 0:
-                    do
-                      {
-                        DUFF_GUTS
-                        H5_ATTR_FALLTHROUGH
-                case 7:
-                        DUFF_GUTS
-                        H5_ATTR_FALLTHROUGH
-                case 6:
-                        DUFF_GUTS
-                        H5_ATTR_FALLTHROUGH
-                case 5:
-                        DUFF_GUTS
-                        H5_ATTR_FALLTHROUGH
-                case 4:
-                        DUFF_GUTS
-                        H5_ATTR_FALLTHROUGH
-                case 3:
-                        DUFF_GUTS
-                        H5_ATTR_FALLTHROUGH
-                case 2:
+                    do {
                         DUFF_GUTS
                         H5_ATTR_FALLTHROUGH
-                case 1:
-                        DUFF_GUTS
-                  } while (--duffs_index > 0);
+                        case 7:
+                            DUFF_GUTS
+                            H5_ATTR_FALLTHROUGH
+                        case 6:
+                            DUFF_GUTS
+                            H5_ATTR_FALLTHROUGH
+                        case 5:
+                            DUFF_GUTS
+                            H5_ATTR_FALLTHROUGH
+                        case 4:
+                            DUFF_GUTS
+                            H5_ATTR_FALLTHROUGH
+                        case 3:
+                            DUFF_GUTS
+                            H5_ATTR_FALLTHROUGH
+                        case 2:
+                            DUFF_GUTS
+                            H5_ATTR_FALLTHROUGH
+                        case 1:
+                            DUFF_GUTS
+                    } while (--duffs_index > 0);
             } /* end switch */
         }
-#endif /* NO_DUFFS_DEVICE */
+#endif    /* NO_DUFFS_DEVICE */
 #undef DUFF_GUTS
 
         /* Increment offset in destination buffer */
@@ -2174,13 +2170,13 @@ loc += fast_dim_buf_off;
 
         /* Increment the offset and count for the other dimensions */
         temp_dim = (int)fast_dim - 1;
-        while(temp_dim >= 0) {
+        while (temp_dim >= 0) {
             /* Move to the next row in the curent dimension */
             offset[temp_dim]++;
             tmp_block[temp_dim]++;
 
             /* If this block is still in the range of blocks to output for the dimension, break out of loop */
-            if(tmp_block[temp_dim] < tdiminfo[temp_dim].block)
+            if (tmp_block[temp_dim] < tdiminfo[temp_dim].block)
                 break;
             else {
                 /* Move to the next block in the current dimension */
@@ -2189,8 +2185,9 @@ loc += fast_dim_buf_off;
                 tmp_block[temp_dim] = 0;
                 tmp_count[temp_dim]++;
 
-                /* If this block is still in the range of blocks to output for the dimension, break out of loop */
-                if(tmp_count[temp_dim] < tdiminfo[temp_dim].count)
+                /* If this block is still in the range of blocks to output for the dimension, break out of
+                 * loop */
+                if (tmp_count[temp_dim] < tdiminfo[temp_dim].count)
                     break;
                 else {
                     offset[temp_dim] = (hsize_t)((hssize_t)tdiminfo[temp_dim].start + sel_off[temp_dim]);
@@ -2198,7 +2195,7 @@ loc += fast_dim_buf_off;
                     tmp_count[temp_dim] = 0; /* reset back to the beginning of the line */
                     tmp_block[temp_dim] = 0;
                 } /* end else */
-            } /* end else */
+            }     /* end else */
 
             /* Decrement dimension count */
             temp_dim--;
@@ -2219,12 +2216,12 @@ loc += fast_dim_buf_off;
     tot_blk_count -= (size_t)(total_rows * tdiminfo[fast_dim].count);
 
     /* Read in partial row of blocks */
-    if(io_left > 0 && curr_seq < maxseq) {
+    if (io_left > 0 && curr_seq < maxseq) {
         /* Get remaining number of blocks left to output */
         fast_dim_count = tot_blk_count;
 
         /* Loop over all the blocks in the fastest changing dimension */
-        while(fast_dim_count > 0) {
+        while (fast_dim_count > 0) {
             /* Store the sequence information */
             off[curr_seq] = loc;
             len[curr_seq] = actual_bytes;
@@ -2243,11 +2240,11 @@ loc += fast_dim_buf_off;
         io_left -= actual_elem * tot_blk_count;
 
         /* Increment information to reflect block just processed */
-        offset[fast_dim] += (fast_dim_stride * tot_blk_count);    /* move the offset in the fastest dimension */
+        offset[fast_dim] += (fast_dim_stride * tot_blk_count); /* move the offset in the fastest dimension */
 
         /* Handle any leftover, partial blocks in this row */
-        if(io_left > 0 && curr_seq < maxseq) {
-            actual_elem = io_left;
+        if (io_left > 0 && curr_seq < maxseq) {
+            actual_elem  = io_left;
             actual_bytes = actual_elem * elem_size;
 
             /* Store the sequence information */
@@ -2272,7 +2269,7 @@ loc += fast_dim_buf_off;
 
     /* Update the iterator with the location we stopped */
     /* (Subtract out the selection offset) */
-    for(u = 0; u < ndims; u++)
+    for (u = 0; u < ndims; u++)
         iter->u.hyp.off[u] = (hsize_t)((hssize_t)offset[u] - sel_off[u]);
 
     /* Decrement the number of elements left in selection */
@@ -2287,7 +2284,6 @@ loc += fast_dim_buf_off;
     FUNC_LEAVE_NOAPI(SUCCEED)
 } /* end H5S__hyper_iter_get_seq_list_opt() */
 
-
 /*--------------------------------------------------------------------------
  NAME
     H5S__hyper_iter_get_seq_list_single
@@ -2319,25 +2315,25 @@ loc += fast_dim_buf_off;
  REVISION LOG
 --------------------------------------------------------------------------*/
 static herr_t
-H5S__hyper_iter_get_seq_list_single(H5S_sel_iter_t *iter, size_t maxseq, size_t maxelem,
-    size_t *nseq, size_t *nelem, hsize_t *off, size_t *len)
+H5S__hyper_iter_get_seq_list_single(H5S_sel_iter_t *iter, size_t maxseq, size_t maxelem, size_t *nseq,
+                                    size_t *nelem, hsize_t *off, size_t *len)
 {
-    const H5S_hyper_dim_t *tdiminfo;    /* Temporary pointer to diminfo information */
-    const hssize_t *sel_off;    /* Selection offset in dataspace */
-    hsize_t *mem_size;          /* Size of the source buffer */
-    hsize_t base_offset[H5S_MAX_RANK];  /* Base coordinate offset in dataspace */
-    hsize_t offset[H5S_MAX_RANK];       /* Coordinate offset in dataspace */
-    hsize_t *slab;              /* Hyperslab size */
-    hsize_t fast_dim_block;     /* Local copies of fastest changing dimension info */
-    hsize_t loc;                /* Coordinate offset */
-    size_t tot_blk_count;       /* Total number of blocks left to output */
-    size_t elem_size;           /* Size of each element iterating over */
-    size_t io_left;             /* The number of elements left in I/O operation */
-    size_t actual_elem;         /* The actual number of elements to count */
-    unsigned ndims;             /* Number of dimensions of dataset */
-    unsigned fast_dim;          /* Rank of the fastest changing dimension for the dataspace */
-    unsigned skip_dim;          /* Rank of the dimension to skip along */
-    unsigned u;                 /* Local index variable */
+    const H5S_hyper_dim_t *tdiminfo;                  /* Temporary pointer to diminfo information */
+    const hssize_t *       sel_off;                   /* Selection offset in dataspace */
+    hsize_t *              mem_size;                  /* Size of the source buffer */
+    hsize_t                base_offset[H5S_MAX_RANK]; /* Base coordinate offset in dataspace */
+    hsize_t                offset[H5S_MAX_RANK];      /* Coordinate offset in dataspace */
+    hsize_t *              slab;                      /* Hyperslab size */
+    hsize_t                fast_dim_block;            /* Local copies of fastest changing dimension info */
+    hsize_t                loc;                       /* Coordinate offset */
+    size_t                 tot_blk_count;             /* Total number of blocks left to output */
+    size_t                 elem_size;                 /* Size of each element iterating over */
+    size_t                 io_left;                   /* The number of elements left in I/O operation */
+    size_t                 actual_elem;               /* The actual number of elements to count */
+    unsigned               ndims;                     /* Number of dimensions of dataset */
+    unsigned               fast_dim; /* Rank of the fastest changing dimension for the dataspace */
+    unsigned               skip_dim; /* Rank of the dimension to skip along */
+    unsigned               u;        /* Local index variable */
 
     FUNC_ENTER_STATIC_NOERR
 
@@ -2354,7 +2350,7 @@ H5S__hyper_iter_get_seq_list_single(H5S_sel_iter_t *iter, size_t maxseq, size_t
     tdiminfo = iter->u.hyp.diminfo;
 
     /* Check if this is a "flattened" regular hyperslab selection */
-    if(iter->u.hyp.iter_rank != 0 && iter->u.hyp.iter_rank < iter->rank) {
+    if (iter->u.hyp.iter_rank != 0 && iter->u.hyp.iter_rank < iter->rank) {
         /* Set the aliases for a few important dimension ranks */
         ndims = iter->u.hyp.iter_rank;
 
@@ -2376,22 +2372,22 @@ H5S__hyper_iter_get_seq_list_single(H5S_sel_iter_t *iter, size_t maxseq, size_t
     } /* end else */
 
     /* Set up some local variables */
-    fast_dim = ndims - 1;
+    fast_dim  = ndims - 1;
     elem_size = iter->elmt_size;
-    slab = iter->u.hyp.slab;
+    slab      = iter->u.hyp.slab;
 
     /* Copy the base location of the block */
     /* (Add in the selection offset) */
-    for(u = 0; u < ndims; u++)
+    for (u = 0; u < ndims; u++)
         base_offset[u] = (hsize_t)((hssize_t)tdiminfo[u].start + sel_off[u]);
 
     /* Copy the location of the point to get */
     /* (Add in the selection offset) */
-    for(u = 0; u < ndims; u++)
+    for (u = 0; u < ndims; u++)
         offset[u] = (hsize_t)((hssize_t)iter->u.hyp.off[u] + sel_off[u]);
 
     /* Compute the initial buffer offset */
-    for(u = 0, loc = 0; u < ndims; u++)
+    for (u = 0, loc = 0; u < ndims; u++)
         loc += offset[u] * slab[u];
 
     /* Set local copies of information for the fastest changing dimension */
@@ -2412,14 +2408,14 @@ H5S__hyper_iter_get_seq_list_single(H5S_sel_iter_t *iter, size_t maxseq, size_t
     H5_CHECKED_ASSIGN(actual_elem, size_t, fast_dim_block, hsize_t);
 
     /* Check for blocks to operate on */
-    if(tot_blk_count > 0) {
-        size_t actual_bytes;        /* The actual number of bytes to copy */
+    if (tot_blk_count > 0) {
+        size_t actual_bytes; /* The actual number of bytes to copy */
 
         /* Set the number of actual bytes */
         actual_bytes = actual_elem * elem_size;
 
         /* Check for 1-dim selection */
-        if(0 == fast_dim) {
+        if (0 == fast_dim) {
             /* Sanity checks */
             HDassert(1 == tot_blk_count);
             HDassert(io_left == actual_elem);
@@ -2429,24 +2425,24 @@ H5S__hyper_iter_get_seq_list_single(H5S_sel_iter_t *iter, size_t maxseq, size_t
             *len++ = actual_bytes;
         } /* end if */
         else {
-            hsize_t skip_slab;          /* Temporary copy of slab[fast_dim - 1] */
-            size_t blk_count;           /* Total number of blocks left to output */
-            int i;                      /* Local index variable */
+            hsize_t skip_slab; /* Temporary copy of slab[fast_dim - 1] */
+            size_t  blk_count; /* Total number of blocks left to output */
+            int     i;         /* Local index variable */
 
             /* Find first dimension w/block >1 */
             skip_dim = fast_dim;
-            for(i = (int)(fast_dim - 1); i >= 0; i--)
-                if(tdiminfo[i].block > 1) {
+            for (i = (int)(fast_dim - 1); i >= 0; i--)
+                if (tdiminfo[i].block > 1) {
                     skip_dim = (unsigned)i;
                     break;
                 } /* end if */
             skip_slab = slab[skip_dim];
 
             /* Check for being able to use fast algorithm for 1-D */
-            if(0 == skip_dim) {
+            if (0 == skip_dim) {
                 /* Create sequences until an entire row can't be used */
                 blk_count = tot_blk_count;
-                while(blk_count > 0) {
+                while (blk_count > 0) {
                     /* Store the sequence information */
                     *off++ = loc;
                     *len++ = actual_bytes;
@@ -2462,21 +2458,21 @@ H5S__hyper_iter_get_seq_list_single(H5S_sel_iter_t *iter, size_t maxseq, size_t
                 offset[skip_dim] += tot_blk_count;
             } /* end if */
             else {
-                hsize_t tmp_block[H5S_MAX_RANK];    /* Temporary block offset */
-                hsize_t skip[H5S_MAX_RANK]; /* Bytes to skip between blocks */
-                int temp_dim;               /* Temporary rank holder */
+                hsize_t tmp_block[H5S_MAX_RANK]; /* Temporary block offset */
+                hsize_t skip[H5S_MAX_RANK];      /* Bytes to skip between blocks */
+                int     temp_dim;                /* Temporary rank holder */
 
                 /* Set the starting block location */
-                for(u = 0; u < ndims; u++)
+                for (u = 0; u < ndims; u++)
                     tmp_block[u] = iter->u.hyp.off[u] - tdiminfo[u].start;
 
                 /* Compute the amount to skip between sequences */
-                for(u = 0; u < ndims; u++)
+                for (u = 0; u < ndims; u++)
                     skip[u] = (mem_size[u] - tdiminfo[u].block) * slab[u];
 
                 /* Create sequences until an entire row can't be used */
                 blk_count = tot_blk_count;
-                while(blk_count > 0) {
+                while (blk_count > 0) {
                     /* Store the sequence information */
                     *off++ = loc;
                     *len++ = actual_bytes;
@@ -2488,13 +2484,14 @@ H5S__hyper_iter_get_seq_list_single(H5S_sel_iter_t *iter, size_t maxseq, size_t
                     loc += skip_slab;
 
                     /* Increment the offset and count for the other dimensions */
-                    while(temp_dim >= 0) {
+                    while (temp_dim >= 0) {
                         /* Move to the next row in the curent dimension */
                         offset[temp_dim]++;
                         tmp_block[temp_dim]++;
 
-                        /* If this block is still in the range of blocks to output for the dimension, break out of loop */
-                        if(tmp_block[temp_dim] < tdiminfo[temp_dim].block)
+                        /* If this block is still in the range of blocks to output for the dimension, break
+                         * out of loop */
+                        if (tmp_block[temp_dim] < tdiminfo[temp_dim].block)
                             break;
                         else {
                             offset[temp_dim] = base_offset[temp_dim];
@@ -2509,8 +2506,8 @@ H5S__hyper_iter_get_seq_list_single(H5S_sel_iter_t *iter, size_t maxseq, size_t
                     /* Decrement block count */
                     blk_count--;
                 } /* end while */
-            } /* end else */
-        } /* end else */
+            }     /* end else */
+        }         /* end else */
 
         /* Update the iterator, if there were any blocks used */
 
@@ -2518,10 +2515,10 @@ H5S__hyper_iter_get_seq_list_single(H5S_sel_iter_t *iter, size_t maxseq, size_t
         iter->elmt_left -= tot_blk_count * actual_elem;
 
         /* Check if there are elements left in iterator */
-        if(iter->elmt_left > 0) {
+        if (iter->elmt_left > 0) {
             /* Update the iterator with the location we stopped */
             /* (Subtract out the selection offset) */
-            for(u = 0; u < ndims; u++)
+            for (u = 0; u < ndims; u++)
                 iter->u.hyp.off[u] = (hsize_t)((hssize_t)offset[u] - sel_off[u]);
         } /* end if */
 
@@ -2533,8 +2530,8 @@ H5S__hyper_iter_get_seq_list_single(H5S_sel_iter_t *iter, size_t maxseq, size_t
     } /* end if */
 
     /* Check for partial block, with room for another sequence */
-    if(io_left > (tot_blk_count * actual_elem) && tot_blk_count < maxseq) {
-        size_t elmt_remainder;  /* Elements remaining */
+    if (io_left > (tot_blk_count * actual_elem) && tot_blk_count < maxseq) {
+        size_t elmt_remainder; /* Elements remaining */
 
         /* Compute elements left */
         elmt_remainder = io_left - (tot_blk_count * actual_elem);
@@ -2565,7 +2562,6 @@ H5S__hyper_iter_get_seq_list_single(H5S_sel_iter_t *iter, size_t maxseq, size_t
     FUNC_LEAVE_NOAPI(SUCCEED)
 } /* end H5S__hyper_iter_get_seq_list_single() */
 
-
 /*--------------------------------------------------------------------------
  NAME
     H5S__hyper_iter_get_seq_list
@@ -2597,10 +2593,10 @@ H5S__hyper_iter_get_seq_list_single(H5S_sel_iter_t *iter, size_t maxseq, size_t
  REVISION LOG
 --------------------------------------------------------------------------*/
 static herr_t
-H5S__hyper_iter_get_seq_list(H5S_sel_iter_t *iter, size_t maxseq,
-    size_t maxelem, size_t *nseq, size_t *nelem, hsize_t *off, size_t *len)
+H5S__hyper_iter_get_seq_list(H5S_sel_iter_t *iter, size_t maxseq, size_t maxelem, size_t *nseq, size_t *nelem,
+                             hsize_t *off, size_t *len)
 {
-    herr_t ret_value = FAIL;    /* return value */
+    herr_t ret_value = FAIL; /* return value */
 
     FUNC_ENTER_STATIC_NOERR
 
@@ -2615,19 +2611,19 @@ H5S__hyper_iter_get_seq_list(H5S_sel_iter_t *iter, size_t maxseq,
     HDassert(len);
 
     /* Check for the special case of just one H5Sselect_hyperslab call made */
-    if(iter->u.hyp.diminfo_valid) {
-        const H5S_hyper_dim_t *tdiminfo;    /* Temporary pointer to diminfo information */
-        const hssize_t *sel_off;    /* Selection offset in dataspace */
-        unsigned ndims;         /* Number of dimensions of dataset */
-        unsigned fast_dim;      /* Rank of the fastest changing dimension for the dataspace */
-        hbool_t single_block;   /* Whether the selection is a single block */
-        unsigned u;             /* Local index variable */
+    if (iter->u.hyp.diminfo_valid) {
+        const H5S_hyper_dim_t *tdiminfo;     /* Temporary pointer to diminfo information */
+        const hssize_t *       sel_off;      /* Selection offset in dataspace */
+        unsigned               ndims;        /* Number of dimensions of dataset */
+        unsigned               fast_dim;     /* Rank of the fastest changing dimension for the dataspace */
+        hbool_t                single_block; /* Whether the selection is a single block */
+        unsigned               u;            /* Local index variable */
 
         /* Set a local copy of the diminfo pointer */
         tdiminfo = iter->u.hyp.diminfo;
 
         /* Check if this is a "flattened" regular hyperslab selection */
-        if(iter->u.hyp.iter_rank != 0 && iter->u.hyp.iter_rank < iter->rank) {
+        if (iter->u.hyp.iter_rank != 0 && iter->u.hyp.iter_rank < iter->rank) {
             /* Set the aliases for a few important dimension ranks */
             ndims = iter->u.hyp.iter_rank;
 
@@ -2644,20 +2640,27 @@ H5S__hyper_iter_get_seq_list(H5S_sel_iter_t *iter, size_t maxseq,
         fast_dim = ndims - 1;
 
         /* Check if we stopped in the middle of a sequence of elements */
-        if((iter->u.hyp.off[fast_dim] - tdiminfo[fast_dim].start) % tdiminfo[fast_dim].stride != 0 ||
-                ((iter->u.hyp.off[fast_dim] != tdiminfo[fast_dim].start) && tdiminfo[fast_dim].count == 1)) {
-            hsize_t *slab;              /* Hyperslab size */
-            hsize_t loc;                /* Coordinate offset */
-            size_t leftover;            /* The number of elements left over from the last sequence */
-            size_t actual_elem;         /* The actual number of elements to count */
-            size_t elem_size;           /* Size of each element iterating over */
+        if ((iter->u.hyp.off[fast_dim] - tdiminfo[fast_dim].start) % tdiminfo[fast_dim].stride != 0 ||
+            ((iter->u.hyp.off[fast_dim] != tdiminfo[fast_dim].start) && tdiminfo[fast_dim].count == 1)) {
+            hsize_t *slab;        /* Hyperslab size */
+            hsize_t  loc;         /* Coordinate offset */
+            size_t   leftover;    /* The number of elements left over from the last sequence */
+            size_t   actual_elem; /* The actual number of elements to count */
+            size_t   elem_size;   /* Size of each element iterating over */
 
             /* Calculate the number of elements left in the sequence */
-            if(tdiminfo[fast_dim].count == 1) {
-                H5_CHECKED_ASSIGN(leftover, size_t, tdiminfo[fast_dim].block - (iter->u.hyp.off[fast_dim] - tdiminfo[fast_dim].start), hsize_t);
+            if (tdiminfo[fast_dim].count == 1) {
+                H5_CHECKED_ASSIGN(leftover, size_t,
+                                  tdiminfo[fast_dim].block -
+                                      (iter->u.hyp.off[fast_dim] - tdiminfo[fast_dim].start),
+                                  hsize_t);
             } /* end if */
             else {
-                H5_CHECKED_ASSIGN(leftover, size_t, tdiminfo[fast_dim].block - ((iter->u.hyp.off[fast_dim] - tdiminfo[fast_dim].start) % tdiminfo[fast_dim].stride), hsize_t);
+                H5_CHECKED_ASSIGN(
+                    leftover, size_t,
+                    tdiminfo[fast_dim].block -
+                        ((iter->u.hyp.off[fast_dim] - tdiminfo[fast_dim].start) % tdiminfo[fast_dim].stride),
+                    hsize_t);
             } /* end else */
 
             /* Make certain that we don't write too many */
@@ -2665,10 +2668,10 @@ H5S__hyper_iter_get_seq_list(H5S_sel_iter_t *iter, size_t maxseq,
 
             /* Set up some local variables */
             elem_size = iter->elmt_size;
-            slab = iter->u.hyp.slab;
+            slab      = iter->u.hyp.slab;
 
             /* Compute the initial buffer offset */
-            for(u = 0, loc = 0; u < ndims; u++)
+            for (u = 0, loc = 0; u < ndims; u++)
                 loc += ((hsize_t)((hssize_t)iter->u.hyp.off[u] + sel_off[u])) * slab[u];
 
             /* Add a new sequence */
@@ -2690,29 +2693,29 @@ H5S__hyper_iter_get_seq_list(H5S_sel_iter_t *iter, size_t maxseq,
             maxseq--;
 
             /* Set the number of sequences generated and elements used */
-            *nseq = 1;
+            *nseq  = 1;
             *nelem = actual_elem;
 
             /* Check for using up all the sequences/elements */
-            if(0 == iter->elmt_left || 0 == maxelem || 0 == maxseq)
-                return(SUCCEED);
+            if (0 == iter->elmt_left || 0 == maxelem || 0 == maxseq)
+                return (SUCCEED);
         } /* end if */
         else {
             /* Reset the number of sequences generated and elements used */
-            *nseq = 0;
+            *nseq  = 0;
             *nelem = 0;
         } /* end else */
 
         /* Check for a single block selected */
         single_block = TRUE;
-        for(u = 0; u < ndims; u++)
-            if(1 != tdiminfo[u].count) {
+        for (u = 0; u < ndims; u++)
+            if (1 != tdiminfo[u].count) {
                 single_block = FALSE;
                 break;
             } /* end if */
 
         /* Check for single block selection */
-        if(single_block)
+        if (single_block)
             /* Use single-block optimized call to generate sequence list */
             ret_value = H5S__hyper_iter_get_seq_list_single(iter, maxseq, maxelem, nseq, nelem, off, len);
         else
@@ -2726,7 +2729,6 @@ H5S__hyper_iter_get_seq_list(H5S_sel_iter_t *iter, size_t maxseq,
     FUNC_LEAVE_NOAPI(ret_value)
 } /* end H5S__hyper_iter_get_seq_list() */
 
-
 /*--------------------------------------------------------------------------
  NAME
     H5S__hyper_iter_release
@@ -2753,13 +2755,12 @@ H5S__hyper_iter_release(H5S_sel_iter_t *iter)
     HDassert(iter);
 
     /* Free the copy of the hyperslab selection span tree */
-    if(iter->u.hyp.spans != NULL)
+    if (iter->u.hyp.spans != NULL)
         H5S__hyper_free_span_info(iter->u.hyp.spans);
 
     FUNC_LEAVE_NOAPI(SUCCEED)
 } /* end H5S__hyper_iter_release() */
 
-
 /*--------------------------------------------------------------------------
  NAME
     H5S__hyper_new_span
@@ -2782,32 +2783,30 @@ H5S__hyper_iter_release(H5S_sel_iter_t *iter)
  REVISION LOG
 --------------------------------------------------------------------------*/
 static H5S_hyper_span_t *
-H5S__hyper_new_span(hsize_t low, hsize_t high, H5S_hyper_span_info_t *down,
-    H5S_hyper_span_t *next)
+H5S__hyper_new_span(hsize_t low, hsize_t high, H5S_hyper_span_info_t *down, H5S_hyper_span_t *next)
 {
-    H5S_hyper_span_t *ret_value = NULL;         /* Return value */
+    H5S_hyper_span_t *ret_value = NULL; /* Return value */
 
     FUNC_ENTER_STATIC
 
     /* Allocate a new span node */
-    if(NULL == (ret_value = H5FL_MALLOC(H5S_hyper_span_t)))
+    if (NULL == (ret_value = H5FL_MALLOC(H5S_hyper_span_t)))
         HGOTO_ERROR(H5E_DATASPACE, H5E_CANTALLOC, NULL, "can't allocate hyperslab span")
 
     /* Copy the span's basic information */
-    ret_value->low = low;
+    ret_value->low  = low;
     ret_value->high = high;
     ret_value->down = down;
     ret_value->next = next;
 
     /* Increment the reference count of the 'down span' if there is one */
-    if(ret_value->down)
+    if (ret_value->down)
         ret_value->down->count++;
 
 done:
     FUNC_LEAVE_NOAPI(ret_value)
 } /* end H5S__hyper_new_span() */
 
-
 /*--------------------------------------------------------------------------
  NAME
     H5S__hyper_new_span_info
@@ -2830,7 +2829,7 @@ done:
 static H5S_hyper_span_info_t *
 H5S__hyper_new_span_info(unsigned rank)
 {
-    H5S_hyper_span_info_t *ret_value = NULL;         /* Return value */
+    H5S_hyper_span_info_t *ret_value = NULL; /* Return value */
 
     FUNC_ENTER_STATIC
 
@@ -2839,18 +2838,17 @@ H5S__hyper_new_span_info(unsigned rank)
     HDassert(rank <= H5S_MAX_RANK);
 
     /* Allocate a new span info node */
-    if(NULL == (ret_value = (H5S_hyper_span_info_t *)H5FL_ARR_CALLOC(hbounds_t, rank * 2)))
+    if (NULL == (ret_value = (H5S_hyper_span_info_t *)H5FL_ARR_CALLOC(hbounds_t, rank * 2)))
         HGOTO_ERROR(H5E_DATASPACE, H5E_CANTALLOC, NULL, "can't allocate hyperslab span info")
 
     /* Set low & high bound pointers into the 'bounds' array */
-    ret_value->low_bounds = ret_value->bounds;
+    ret_value->low_bounds  = ret_value->bounds;
     ret_value->high_bounds = &ret_value->bounds[rank];
 
 done:
     FUNC_LEAVE_NOAPI(ret_value)
 } /* end H5S__hyper_new_span_info() */
 
-
 /*--------------------------------------------------------------------------
  NAME
     H5S__hyper_copy_span_helper
@@ -2872,14 +2870,13 @@ done:
  REVISION LOG
 --------------------------------------------------------------------------*/
 static H5S_hyper_span_info_t *
-H5S__hyper_copy_span_helper(H5S_hyper_span_info_t *spans, unsigned rank,
-    unsigned op_info_i, uint64_t op_gen)
+H5S__hyper_copy_span_helper(H5S_hyper_span_info_t *spans, unsigned rank, unsigned op_info_i, uint64_t op_gen)
 {
-    H5S_hyper_span_t *span;         /* Hyperslab span */
-    H5S_hyper_span_t *new_span;     /* Temporary hyperslab span */
-    H5S_hyper_span_t *prev_span;    /* Previous hyperslab span */
-    H5S_hyper_span_info_t *new_down;    /* New down span tree */
-    H5S_hyper_span_info_t *ret_value = NULL;    /* Return value */
+    H5S_hyper_span_t *     span;             /* Hyperslab span */
+    H5S_hyper_span_t *     new_span;         /* Temporary hyperslab span */
+    H5S_hyper_span_t *     prev_span;        /* Previous hyperslab span */
+    H5S_hyper_span_info_t *new_down;         /* New down span tree */
+    H5S_hyper_span_info_t *ret_value = NULL; /* Return value */
 
     FUNC_ENTER_STATIC
 
@@ -2887,7 +2884,7 @@ H5S__hyper_copy_span_helper(H5S_hyper_span_info_t *spans, unsigned rank,
     HDassert(spans);
 
     /* Check if the span tree was already copied */
-    if(spans->op_info[op_info_i].op_gen == op_gen) {
+    if (spans->op_info[op_info_i].op_gen == op_gen) {
         /* Just return the value of the already copied span tree */
         ret_value = spans->op_info[op_info_i].u.copied;
 
@@ -2896,7 +2893,7 @@ H5S__hyper_copy_span_helper(H5S_hyper_span_info_t *spans, unsigned rank,
     } /* end if */
     else {
         /* Allocate a new span_info node */
-        if(NULL == (ret_value = H5S__hyper_new_span_info(rank)))
+        if (NULL == (ret_value = H5S__hyper_new_span_info(rank)))
             HGOTO_ERROR(H5E_DATASPACE, H5E_CANTALLOC, NULL, "can't allocate hyperslab span info")
 
         /* Set the non-zero span_info information */
@@ -2911,22 +2908,22 @@ H5S__hyper_copy_span_helper(H5S_hyper_span_info_t *spans, unsigned rank,
         spans->op_info[op_info_i].u.copied = ret_value;
 
         /* Copy over the nodes in the span list */
-        span = spans->head;
+        span      = spans->head;
         prev_span = NULL;
-        while(span != NULL) {
+        while (span != NULL) {
             /* Allocate a new node */
-            if(NULL == (new_span = H5S__hyper_new_span(span->low, span->high, NULL, NULL)))
+            if (NULL == (new_span = H5S__hyper_new_span(span->low, span->high, NULL, NULL)))
                 HGOTO_ERROR(H5E_DATASPACE, H5E_CANTALLOC, NULL, "can't allocate hyperslab span")
 
             /* Append to list of spans */
-            if(NULL == prev_span)
+            if (NULL == prev_span)
                 ret_value->head = new_span;
             else
                 prev_span->next = new_span;
 
             /* Recurse to copy the 'down' spans, if there are any */
-            if(span->down != NULL) {
-                if(NULL == (new_down = H5S__hyper_copy_span_helper(span->down, rank - 1, op_info_i, op_gen)))
+            if (span->down != NULL) {
+                if (NULL == (new_down = H5S__hyper_copy_span_helper(span->down, rank - 1, op_info_i, op_gen)))
                     HGOTO_ERROR(H5E_DATASPACE, H5E_CANTCOPY, NULL, "can't copy hyperslab spans")
                 new_span->down = new_down;
             } /* end if */
@@ -2946,7 +2943,6 @@ done:
     FUNC_LEAVE_NOAPI(ret_value)
 } /* end H5S__hyper_copy_span_helper() */
 
-
 /*--------------------------------------------------------------------------
  NAME
     H5S__hyper_copy_span
@@ -2970,8 +2966,8 @@ done:
 static H5S_hyper_span_info_t *
 H5S__hyper_copy_span(H5S_hyper_span_info_t *spans, unsigned rank)
 {
-    uint64_t op_gen;            /* Operation generation value */
-    H5S_hyper_span_info_t *ret_value = NULL;    /* Return value */
+    uint64_t               op_gen;           /* Operation generation value */
+    H5S_hyper_span_info_t *ret_value = NULL; /* Return value */
 
     FUNC_ENTER_STATIC
 
@@ -2984,14 +2980,13 @@ H5S__hyper_copy_span(H5S_hyper_span_info_t *spans, unsigned rank)
     /* Copy the hyperslab span tree */
     /* Always use op_info[0] since we own this op_info, so there can be no
      * simultaneous operations */
-    if(NULL == (ret_value = H5S__hyper_copy_span_helper(spans, rank, 0, op_gen)))
+    if (NULL == (ret_value = H5S__hyper_copy_span_helper(spans, rank, 0, op_gen)))
         HGOTO_ERROR(H5E_DATASPACE, H5E_CANTCOPY, NULL, "can't copy hyperslab span tree")
 
 done:
     FUNC_LEAVE_NOAPI(ret_value)
 } /* end H5S__hyper_copy_span() */
 
-
 /*--------------------------------------------------------------------------
  NAME
     H5S__hyper_cmp_spans
@@ -3014,23 +3009,23 @@ done:
 static H5_ATTR_PURE hbool_t
 H5S__hyper_cmp_spans(const H5S_hyper_span_info_t *span_info1, const H5S_hyper_span_info_t *span_info2)
 {
-    hbool_t ret_value = TRUE;   /* Return value */
+    hbool_t ret_value = TRUE; /* Return value */
 
     FUNC_ENTER_STATIC_NOERR
 
     /* Check for redundant comparison (or both spans being NULL) */
-    if(span_info1 != span_info2) {
+    if (span_info1 != span_info2) {
         /* Check for one span being NULL */
-        if(span_info1 == NULL || span_info2 == NULL)
+        if (span_info1 == NULL || span_info2 == NULL)
             HGOTO_DONE(FALSE)
         else {
             /* Compare low & high bounds for this span list */
             /* (Could compare lower dimensions also, but not certain if
              *      that's worth it. - QAK, 2019/01/23)
              */
-            if(span_info1->low_bounds[0] != span_info2->low_bounds[0])
+            if (span_info1->low_bounds[0] != span_info2->low_bounds[0])
                 HGOTO_DONE(FALSE)
-            else if(span_info1->high_bounds[0] != span_info2->high_bounds[0])
+            else if (span_info1->high_bounds[0] != span_info2->high_bounds[0])
                 HGOTO_DONE(FALSE)
             else {
                 const H5S_hyper_span_t *span1;
@@ -3045,40 +3040,40 @@ H5S__hyper_cmp_spans(const H5S_hyper_span_info_t *span_info1, const H5S_hyper_sp
                 HDassert(span2);
 
                 /* infinite loop which must be broken out of */
-                while(1) {
+                while (1) {
                     /* Check for both spans being NULL */
-                    if(span1 == NULL && span2 == NULL)
+                    if (span1 == NULL && span2 == NULL)
                         HGOTO_DONE(TRUE)
                     else {
                         /* Check for one span being NULL */
-                        if(span1 == NULL || span2 == NULL)
+                        if (span1 == NULL || span2 == NULL)
                             HGOTO_DONE(FALSE)
                         else {
                             /* Check if the actual low & high span information is the same */
-                            if(span1->low != span2->low || span1->high != span2->high)
+                            if (span1->low != span2->low || span1->high != span2->high)
                                 HGOTO_DONE(FALSE)
                             else {
-                                if(span1->down != NULL || span2->down != NULL) {
-                                    if(!H5S__hyper_cmp_spans(span1->down, span2->down))
+                                if (span1->down != NULL || span2->down != NULL) {
+                                    if (!H5S__hyper_cmp_spans(span1->down, span2->down))
                                         HGOTO_DONE(FALSE)
                                     else {
                                         /* Keep going... */
                                     } /* end else */
-                                } /* end if */
+                                }     /* end if */
                                 else {
                                     /* Keep going... */
                                 } /* end else */
-                            } /* end else */
-                        } /* end else */
-                    } /* end else */
+                            }     /* end else */
+                        }         /* end else */
+                    }             /* end else */
 
                     /* Advance to the next nodes in the span list */
                     span1 = span1->next;
                     span2 = span2->next;
                 } /* end while */
-            } /* end else */
-        } /* end else */
-    } /* end if */
+            }     /* end else */
+        }         /* end else */
+    }             /* end if */
 
     /* Fall through, with default return value of 'TRUE' if spans were already visited */
 
@@ -3086,7 +3081,6 @@ done:
     FUNC_LEAVE_NOAPI(ret_value)
 } /* end H5S__hyper_cmp_spans() */
 
-
 /*--------------------------------------------------------------------------
  NAME
     H5S__hyper_free_span_info
@@ -3118,13 +3112,13 @@ H5S__hyper_free_span_info(H5S_hyper_span_info_t *span_info)
     span_info->count--;
 
     /* Free the span tree if the reference count drops to zero */
-    if(span_info->count == 0) {
-        H5S_hyper_span_t *span;     /* Pointer to spans to iterate over */
+    if (span_info->count == 0) {
+        H5S_hyper_span_t *span; /* Pointer to spans to iterate over */
 
         /* Work through the list of spans pointed to by this 'info' node */
         span = span_info->head;
-        while(span != NULL) {
-            H5S_hyper_span_t *next_span;     /* Pointer to next span to iterate over */
+        while (span != NULL) {
+            H5S_hyper_span_t *next_span; /* Pointer to next span to iterate over */
 
             /* Keep a pointer to the next span */
             next_span = span->next;
@@ -3143,7 +3137,6 @@ H5S__hyper_free_span_info(H5S_hyper_span_info_t *span_info)
     FUNC_LEAVE_NOAPI_VOID
 } /* end H5S__hyper_free_span_info() */
 
-
 /*--------------------------------------------------------------------------
  NAME
     H5S__hyper_free_span
@@ -3172,7 +3165,7 @@ H5S__hyper_free_span(H5S_hyper_span_t *span)
     HDassert(span);
 
     /* Decrement the reference count of the 'down spans', freeing them if appropriate */
-    if(span->down != NULL)
+    if (span->down != NULL)
         H5S__hyper_free_span_info(span->down);
 
     /* Free this span */
@@ -3181,7 +3174,6 @@ H5S__hyper_free_span(H5S_hyper_span_t *span)
     FUNC_LEAVE_NOAPI_VOID
 } /* end H5S__hyper_free_span() */
 
-
 /*--------------------------------------------------------------------------
  NAME
     H5S__hyper_copy
@@ -3210,9 +3202,9 @@ H5S__hyper_free_span(H5S_hyper_span_t *span)
 static herr_t
 H5S__hyper_copy(H5S_t *dst, const H5S_t *src, hbool_t share_selection)
 {
-    H5S_hyper_sel_t *dst_hslab;         /* Pointer to destination hyperslab info */
-    const H5S_hyper_sel_t *src_hslab;   /* Pointer to source hyperslab info */
-    herr_t ret_value = SUCCEED;         /* Return value */
+    H5S_hyper_sel_t *      dst_hslab;           /* Pointer to destination hyperslab info */
+    const H5S_hyper_sel_t *src_hslab;           /* Pointer to source hyperslab info */
+    herr_t                 ret_value = SUCCEED; /* Return value */
 
     FUNC_ENTER_STATIC
 
@@ -3221,7 +3213,7 @@ H5S__hyper_copy(H5S_t *dst, const H5S_t *src, hbool_t share_selection)
     HDassert(dst);
 
     /* Allocate space for the hyperslab selection information */
-    if(NULL == (dst->select.sel_info.hslab = H5FL_MALLOC(H5S_hyper_sel_t)))
+    if (NULL == (dst->select.sel_info.hslab = H5FL_MALLOC(H5S_hyper_sel_t)))
         HGOTO_ERROR(H5E_DATASPACE, H5E_CANTALLOC, FAIL, "can't allocate hyperslab info")
 
     /* Set temporary pointers */
@@ -3230,33 +3222,33 @@ H5S__hyper_copy(H5S_t *dst, const H5S_t *src, hbool_t share_selection)
 
     /* Copy the hyperslab information */
     dst_hslab->diminfo_valid = src_hslab->diminfo_valid;
-    if(src_hslab->diminfo_valid == H5S_DIMINFO_VALID_YES)
+    if (src_hslab->diminfo_valid == H5S_DIMINFO_VALID_YES)
         H5MM_memcpy(&dst_hslab->diminfo, &src_hslab->diminfo, sizeof(H5S_hyper_diminfo_t));
 
     /* Check if there is hyperslab span information to copy */
     /* (Regular hyperslab information is copied with the selection structure) */
-    if(src->select.sel_info.hslab->span_lst != NULL) {
-        if(share_selection) {
+    if (src->select.sel_info.hslab->span_lst != NULL) {
+        if (share_selection) {
             /* Share the source's span tree by incrementing the reference count on it */
             dst->select.sel_info.hslab->span_lst = src->select.sel_info.hslab->span_lst;
             dst->select.sel_info.hslab->span_lst->count++;
         } /* end if */
         else
             /* Copy the hyperslab span information */
-            dst->select.sel_info.hslab->span_lst = H5S__hyper_copy_span(src->select.sel_info.hslab->span_lst, src->extent.rank);
+            dst->select.sel_info.hslab->span_lst =
+                H5S__hyper_copy_span(src->select.sel_info.hslab->span_lst, src->extent.rank);
     } /* end if */
     else
         dst->select.sel_info.hslab->span_lst = NULL;
 
     /* Copy the unlimited dimension info */
-    dst_hslab->unlim_dim = src_hslab->unlim_dim;
+    dst_hslab->unlim_dim          = src_hslab->unlim_dim;
     dst_hslab->num_elem_non_unlim = src_hslab->num_elem_non_unlim;
 
 done:
     FUNC_LEAVE_NOAPI(ret_value)
 } /* end H5S__hyper_copy() */
 
-
 /*--------------------------------------------------------------------------
  NAME
     H5S__hyper_is_valid
@@ -3280,34 +3272,34 @@ done:
 static htri_t
 H5S__hyper_is_valid(const H5S_t *space)
 {
-    const hsize_t *low_bounds, *high_bounds;    /* Pointers to the correct pair of low & high bounds */
-    unsigned u;                    /* Counter */
-    htri_t ret_value = TRUE;      /* return value */
+    const hsize_t *low_bounds, *high_bounds; /* Pointers to the correct pair of low & high bounds */
+    unsigned       u;                        /* Counter */
+    htri_t         ret_value = TRUE;         /* return value */
 
     FUNC_ENTER_STATIC_NOERR
 
     HDassert(space);
 
     /* Check for unlimited selection */
-    if(space->select.sel_info.hslab->unlim_dim >= 0)
+    if (space->select.sel_info.hslab->unlim_dim >= 0)
         HGOTO_DONE(FALSE)
 
     /* Check which set of low & high bounds we should be using */
-    if(space->select.sel_info.hslab->diminfo_valid == H5S_DIMINFO_VALID_YES) {
-        low_bounds = space->select.sel_info.hslab->diminfo.low_bounds;
+    if (space->select.sel_info.hslab->diminfo_valid == H5S_DIMINFO_VALID_YES) {
+        low_bounds  = space->select.sel_info.hslab->diminfo.low_bounds;
         high_bounds = space->select.sel_info.hslab->diminfo.high_bounds;
     } /* end if */
     else {
-        low_bounds = space->select.sel_info.hslab->span_lst->low_bounds;
+        low_bounds  = space->select.sel_info.hslab->span_lst->low_bounds;
         high_bounds = space->select.sel_info.hslab->span_lst->high_bounds;
     } /* end else */
 
     /* Check each dimension */
-    for(u = 0; u < space->extent.rank; u++) {
+    for (u = 0; u < space->extent.rank; u++) {
         /* Bounds check the selected point + offset against the extent */
-        if(((hssize_t)low_bounds[u] + space->select.offset[u]) < 0)
+        if (((hssize_t)low_bounds[u] + space->select.offset[u]) < 0)
             HGOTO_DONE(FALSE)
-        if((high_bounds[u] + (hsize_t)space->select.offset[u]) >= space->extent.size[u])
+        if ((high_bounds[u] + (hsize_t)space->select.offset[u]) >= space->extent.size[u])
             HGOTO_DONE(FALSE)
     } /* end for */
 
@@ -3315,7 +3307,6 @@ done:
     FUNC_LEAVE_NOAPI(ret_value)
 } /* end H5S__hyper_is_valid() */
 
-
 /*--------------------------------------------------------------------------
  NAME
     H5S__hyper_span_nblocks_helper
@@ -3336,10 +3327,9 @@ done:
  REVISION LOG
 --------------------------------------------------------------------------*/
 static hsize_t
-H5S__hyper_span_nblocks_helper(H5S_hyper_span_info_t *spans, unsigned op_info_i,
-    uint64_t op_gen)
+H5S__hyper_span_nblocks_helper(H5S_hyper_span_info_t *spans, unsigned op_info_i, uint64_t op_gen)
 {
-    hsize_t ret_value = 0;      /* Return value */
+    hsize_t ret_value = 0; /* Return value */
 
     FUNC_ENTER_STATIC_NOERR
 
@@ -3347,31 +3337,31 @@ H5S__hyper_span_nblocks_helper(H5S_hyper_span_info_t *spans, unsigned op_info_i,
     HDassert(spans);
 
     /* Check if the span tree was already counted */
-    if(spans->op_info[op_info_i].op_gen == op_gen)
+    if (spans->op_info[op_info_i].op_gen == op_gen)
         /* Just return the # of blocks in the already counted span tree */
         ret_value = spans->op_info[op_info_i].u.nblocks;
-    else {      /* Count the number of elements in the span tree */
-        H5S_hyper_span_t *span;     /* Hyperslab span */
+    else {                      /* Count the number of elements in the span tree */
+        H5S_hyper_span_t *span; /* Hyperslab span */
 
         span = spans->head;
-        if(span->down) {
-            while(span) {
+        if (span->down) {
+            while (span) {
                 /* If there are down spans, add the total down span blocks */
                 ret_value += H5S__hyper_span_nblocks_helper(span->down, op_info_i, op_gen);
 
                 /* Advance to next span */
                 span = span->next;
             } /* end while */
-        } /* end if */
+        }     /* end if */
         else {
-            while(span) {
+            while (span) {
                 /* If there are no down spans, just count the block in this span */
                 ret_value++;
 
                 /* Advance to next span */
                 span = span->next;
             } /* end while */
-        } /* end else */
+        }     /* end else */
 
         /* Set the operation generation for this span tree, to avoid re-computing */
         spans->op_info[op_info_i].op_gen = op_gen;
@@ -3383,7 +3373,6 @@ H5S__hyper_span_nblocks_helper(H5S_hyper_span_info_t *spans, unsigned op_info_i,
     FUNC_LEAVE_NOAPI(ret_value)
 } /* end H5S__hyper_span_nblocks_helper() */
 
-
 /*--------------------------------------------------------------------------
  NAME
     H5S__hyper_span_nblocks
@@ -3404,13 +3393,13 @@ H5S__hyper_span_nblocks_helper(H5S_hyper_span_info_t *spans, unsigned op_info_i,
 static hsize_t
 H5S__hyper_span_nblocks(H5S_hyper_span_info_t *spans)
 {
-    hsize_t ret_value = 0;      /* Return value */
+    hsize_t ret_value = 0; /* Return value */
 
     FUNC_ENTER_STATIC_NOERR
 
     /* Count the number of elements in the span tree */
-    if(spans != NULL) {
-        uint64_t op_gen;            /* Operation generation value */
+    if (spans != NULL) {
+        uint64_t op_gen; /* Operation generation value */
 
         /* Acquire an operation generation value for this operation */
         op_gen = H5S__hyper_get_op_gen();
@@ -3424,7 +3413,6 @@ H5S__hyper_span_nblocks(H5S_hyper_span_info_t *spans)
     FUNC_LEAVE_NOAPI(ret_value)
 } /* end H5S__hyper_span_nblocks() */
 
-
 /*--------------------------------------------------------------------------
  NAME
     H5S__get_select_hyper_nblocks
@@ -3446,7 +3434,7 @@ H5S__hyper_span_nblocks(H5S_hyper_span_info_t *spans)
 static hsize_t
 H5S__get_select_hyper_nblocks(const H5S_t *space, hbool_t app_ref)
 {
-    hsize_t ret_value = 0;      /* Return value */
+    hsize_t ret_value = 0; /* Return value */
 
     FUNC_ENTER_STATIC_NOERR
 
@@ -3455,13 +3443,13 @@ H5S__get_select_hyper_nblocks(const H5S_t *space, hbool_t app_ref)
 
     /* Check for a "regular" hyperslab selection */
     /* (No need to rebuild the dimension info yet -QAK) */
-    if(space->select.sel_info.hslab->diminfo_valid == H5S_DIMINFO_VALID_YES) {
-        unsigned u;                 /* Local index variable */
+    if (space->select.sel_info.hslab->diminfo_valid == H5S_DIMINFO_VALID_YES) {
+        unsigned u; /* Local index variable */
 
         /* Check each dimension */
-        for(ret_value = 1, u = 0; u < space->extent.rank; u++)
-            ret_value *= (app_ref ? space->select.sel_info.hslab->diminfo.app[u].count :
-                                    space->select.sel_info.hslab->diminfo.opt[u].count);
+        for (ret_value = 1, u = 0; u < space->extent.rank; u++)
+            ret_value *= (app_ref ? space->select.sel_info.hslab->diminfo.app[u].count
+                                  : space->select.sel_info.hslab->diminfo.opt[u].count);
     } /* end if */
     else
         ret_value = H5S__hyper_span_nblocks(space->select.sel_info.hslab->span_lst);
@@ -3469,7 +3457,6 @@ H5S__get_select_hyper_nblocks(const H5S_t *space, hbool_t app_ref)
     FUNC_LEAVE_NOAPI(ret_value)
 } /* end H5S__get_select_hyper_nblocks() */
 
-
 /*--------------------------------------------------------------------------
  NAME
     H5Sget_select_hyper_nblocks
@@ -3490,19 +3477,20 @@ H5S__get_select_hyper_nblocks(const H5S_t *space, hbool_t app_ref)
 hssize_t
 H5Sget_select_hyper_nblocks(hid_t spaceid)
 {
-    H5S_t *space;               /* Dataspace to modify selection of */
-    hssize_t ret_value;         /* return value */
+    H5S_t *  space;     /* Dataspace to modify selection of */
+    hssize_t ret_value; /* return value */
 
     FUNC_ENTER_API(FAIL)
     H5TRACE1("Hs", "i", spaceid);
 
     /* Check args */
-    if(NULL == (space = (H5S_t *)H5I_object_verify(spaceid, H5I_DATASPACE)))
+    if (NULL == (space = (H5S_t *)H5I_object_verify(spaceid, H5I_DATASPACE)))
         HGOTO_ERROR(H5E_ARGS, H5E_BADTYPE, FAIL, "not a dataspace")
-    if(H5S_GET_SELECT_TYPE(space) != H5S_SEL_HYPERSLABS)
+    if (H5S_GET_SELECT_TYPE(space) != H5S_SEL_HYPERSLABS)
         HGOTO_ERROR(H5E_ARGS, H5E_BADTYPE, FAIL, "not a hyperslab selection")
-    if(space->select.sel_info.hslab->unlim_dim >= 0)
-        HGOTO_ERROR(H5E_DATASPACE, H5E_UNSUPPORTED, FAIL, "cannot get number of blocks for unlimited selection")
+    if (space->select.sel_info.hslab->unlim_dim >= 0)
+        HGOTO_ERROR(H5E_DATASPACE, H5E_UNSUPPORTED, FAIL,
+                    "cannot get number of blocks for unlimited selection")
 
     ret_value = (hssize_t)H5S__get_select_hyper_nblocks(space, TRUE);
 
@@ -3510,7 +3498,6 @@ done:
     FUNC_LEAVE_API(ret_value)
 } /* end H5Sget_select_hyper_nblocks() */
 
-
 /*--------------------------------------------------------------------------
  NAME
     H5S__hyper_get_enc_size_real
@@ -3536,9 +3523,9 @@ H5S__hyper_get_enc_size_real(hsize_t max_size)
 
     FUNC_ENTER_STATIC_NOERR
 
-    if(max_size > H5S_UINT32_MAX)
+    if (max_size > H5S_UINT32_MAX)
         ret_value = H5S_SELECT_INFO_ENC_SIZE_8;
-    else if(max_size > H5S_UINT16_MAX)
+    else if (max_size > H5S_UINT16_MAX)
         ret_value = H5S_SELECT_INFO_ENC_SIZE_4;
     else
         ret_value = H5S_SELECT_INFO_ENC_SIZE_2;
@@ -3546,7 +3533,6 @@ H5S__hyper_get_enc_size_real(hsize_t max_size)
     FUNC_LEAVE_NOAPI(ret_value)
 } /* H5S__hyper_get_enc_size_real() */
 
-
 /*--------------------------------------------------------------------------
  NAME
     H5S__hyper_get_version_enc_size
@@ -3584,70 +3570,74 @@ H5S__hyper_get_enc_size_real(hsize_t max_size)
 static herr_t
 H5S__hyper_get_version_enc_size(const H5S_t *space, hsize_t block_count, uint32_t *version, uint8_t *enc_size)
 {
-    hsize_t bounds_start[H5S_MAX_RANK]; /* Starting coordinate of bounding box */
-    hsize_t bounds_end[H5S_MAX_RANK];   /* Opposite coordinate of bounding box */
-    hbool_t count_up_version = FALSE;   /* Whether number of blocks exceed H5S_UINT32_MAX */
-    hbool_t bound_up_version = FALSE;   /* Whether high bounds exceed H5S_UINT32_MAX */
-    H5F_libver_t    low_bound;          /* The 'low' bound of library format versions */
-    H5F_libver_t    high_bound;         /* The 'high' bound of library format versions */
-    htri_t is_regular;                  /* A regular hyperslab or not */
-    uint32_t tmp_version;               /* Local temporay version */
-    unsigned u;                         /* Local index variable */
-    herr_t ret_value = SUCCEED;         /* Return value */
+    hsize_t      bounds_start[H5S_MAX_RANK]; /* Starting coordinate of bounding box */
+    hsize_t      bounds_end[H5S_MAX_RANK];   /* Opposite coordinate of bounding box */
+    hbool_t      count_up_version = FALSE;   /* Whether number of blocks exceed H5S_UINT32_MAX */
+    hbool_t      bound_up_version = FALSE;   /* Whether high bounds exceed H5S_UINT32_MAX */
+    H5F_libver_t low_bound;                  /* The 'low' bound of library format versions */
+    H5F_libver_t high_bound;                 /* The 'high' bound of library format versions */
+    htri_t       is_regular;                 /* A regular hyperslab or not */
+    uint32_t     tmp_version;                /* Local temporay version */
+    unsigned     u;                          /* Local index variable */
+    herr_t       ret_value = SUCCEED;        /* Return value */
 
     FUNC_ENTER_STATIC
 
     /* Get bounding box for the selection */
     HDmemset(bounds_end, 0, sizeof(bounds_end));
 
-    if(space->select.sel_info.hslab->unlim_dim < 0) /* ! H5S_UNLIMITED */
+    if (space->select.sel_info.hslab->unlim_dim < 0) /* ! H5S_UNLIMITED */
         /* Get bounding box for the selection */
-        if(H5S__hyper_bounds(space, bounds_start, bounds_end) < 0)
+        if (H5S__hyper_bounds(space, bounds_start, bounds_end) < 0)
             HGOTO_ERROR(H5E_DATASPACE, H5E_CANTGET, FAIL, "can't get selection bounds")
 
     /* Determine whether the number of blocks or the high bounds in the selection exceed (2^32 - 1) */
-    if(block_count > H5S_UINT32_MAX)
+    if (block_count > H5S_UINT32_MAX)
         count_up_version = TRUE;
     else {
-        for(u = 0; u < space->extent.rank; u++)
-            if(bounds_end[u] > H5S_UINT32_MAX) {
+        for (u = 0; u < space->extent.rank; u++)
+            if (bounds_end[u] > H5S_UINT32_MAX) {
                 bound_up_version = TRUE;
                 break;
             } /* end if */
-    } /* end else */
+    }         /* end else */
 
     /* Get the file's low_bound and high_bound */
-    if(H5CX_get_libver_bounds(&low_bound, &high_bound) < 0)
+    if (H5CX_get_libver_bounds(&low_bound, &high_bound) < 0)
         HGOTO_ERROR(H5E_DATASET, H5E_CANTGET, FAIL, "can't get low/high bounds from API context")
 
     /* Determine regular hyperslab */
     is_regular = H5S__hyper_is_regular(space);
 
-    if(low_bound >= H5F_LIBVER_V112 || space->select.sel_info.hslab->unlim_dim >= 0)
+    if (low_bound >= H5F_LIBVER_V112 || space->select.sel_info.hslab->unlim_dim >= 0)
         tmp_version = MAX(H5S_HYPER_VERSION_2, H5O_sds_hyper_ver_bounds[low_bound]);
     else {
-        if(count_up_version || bound_up_version)
+        if (count_up_version || bound_up_version)
             tmp_version = is_regular ? H5S_HYPER_VERSION_2 : H5S_HYPER_VERSION_3;
         else
-            tmp_version = (is_regular &&  block_count >= 4) ? H5O_sds_hyper_ver_bounds[low_bound] : H5S_HYPER_VERSION_1;
+            tmp_version =
+                (is_regular && block_count >= 4) ? H5O_sds_hyper_ver_bounds[low_bound] : H5S_HYPER_VERSION_1;
     } /* end else */
 
     /* Version bounds check */
-    if(tmp_version > H5O_sds_hyper_ver_bounds[high_bound]) {
-         /* Fail for irregular hyperslab if exceeds 32 bits */
-        if(count_up_version)
-            HGOTO_ERROR(H5E_DATASPACE, H5E_BADVALUE, FAIL, "The number of blocks in hyperslab selection exceeds 2^32")
-        else if(bound_up_version)
-            HGOTO_ERROR(H5E_DATASPACE, H5E_BADVALUE, FAIL, "The end of bounding box in hyperslab selection exceeds 2^32")
+    if (tmp_version > H5O_sds_hyper_ver_bounds[high_bound]) {
+        /* Fail for irregular hyperslab if exceeds 32 bits */
+        if (count_up_version)
+            HGOTO_ERROR(H5E_DATASPACE, H5E_BADVALUE, FAIL,
+                        "The number of blocks in hyperslab selection exceeds 2^32")
+        else if (bound_up_version)
+            HGOTO_ERROR(H5E_DATASPACE, H5E_BADVALUE, FAIL,
+                        "The end of bounding box in hyperslab selection exceeds 2^32")
         else
-            HGOTO_ERROR(H5E_DATASPACE, H5E_BADRANGE, FAIL, "Dataspace hyperslab selection version out of bounds")
+            HGOTO_ERROR(H5E_DATASPACE, H5E_BADRANGE, FAIL,
+                        "Dataspace hyperslab selection version out of bounds")
     } /* end if */
 
     /* Set the message version */
     *version = tmp_version;
 
     /* Determine the encoded size based on version */
-    switch(tmp_version) {
+    switch (tmp_version) {
         case H5S_HYPER_VERSION_1:
             *enc_size = H5S_SELECT_INFO_ENC_SIZE_4;
             break;
@@ -3657,18 +3647,18 @@ H5S__hyper_get_version_enc_size(const H5S_t *space, hsize_t block_count, uint32_
             break;
 
         case H5S_HYPER_VERSION_3:
-            if(is_regular) {
+            if (is_regular) {
                 uint8_t enc1, enc2;
                 hsize_t max1 = 0;
                 hsize_t max2 = 0;
 
                 /* Find max for count[] and block[] */
-                for(u = 0; u < space->extent.rank; u++) {
-                    if(space->select.sel_info.hslab->diminfo.opt[u].count != H5S_UNLIMITED &&
-                            space->select.sel_info.hslab->diminfo.opt[u].count > max1)
+                for (u = 0; u < space->extent.rank; u++) {
+                    if (space->select.sel_info.hslab->diminfo.opt[u].count != H5S_UNLIMITED &&
+                        space->select.sel_info.hslab->diminfo.opt[u].count > max1)
                         max1 = space->select.sel_info.hslab->diminfo.opt[u].count;
-                    if(space->select.sel_info.hslab->diminfo.opt[u].block != H5S_UNLIMITED &&
-                            space->select.sel_info.hslab->diminfo.opt[u].block > max1)
+                    if (space->select.sel_info.hslab->diminfo.opt[u].block != H5S_UNLIMITED &&
+                        space->select.sel_info.hslab->diminfo.opt[u].block > max1)
                         max1 = space->select.sel_info.hslab->diminfo.opt[u].block;
                 } /* end for */
 
@@ -3676,10 +3666,10 @@ H5S__hyper_get_version_enc_size(const H5S_t *space, hsize_t block_count, uint32_
                 enc1 = H5S__hyper_get_enc_size_real(++max1);
 
                 /* Find max for start[] and stride[] */
-                for(u = 0; u < space->extent.rank; u++) {
-                    if(space->select.sel_info.hslab->diminfo.opt[u].start > max2)
+                for (u = 0; u < space->extent.rank; u++) {
+                    if (space->select.sel_info.hslab->diminfo.opt[u].start > max2)
                         max2 = space->select.sel_info.hslab->diminfo.opt[u].start;
-                    if(space->select.sel_info.hslab->diminfo.opt[u].stride > max2)
+                    if (space->select.sel_info.hslab->diminfo.opt[u].stride > max2)
                         max2 = space->select.sel_info.hslab->diminfo.opt[u].stride;
                 } /* end for */
 
@@ -3693,12 +3683,12 @@ H5S__hyper_get_version_enc_size(const H5S_t *space, hsize_t block_count, uint32_
                 HDassert(space->select.sel_info.hslab->unlim_dim < 0);
 
                 /* Find max for block_count and bounds_end[] */
-                for(u = 0; u < space->extent.rank; u++)
-                    if(bounds_end[u] > max_size)
+                for (u = 0; u < space->extent.rank; u++)
+                    if (bounds_end[u] > max_size)
                         max_size = bounds_end[u];
 
                 /* Determine the encoding size */
-                *enc_size  = H5S__hyper_get_enc_size_real(max_size);
+                *enc_size = H5S__hyper_get_enc_size_real(max_size);
             } /* end else */
             break;
 
@@ -3711,7 +3701,6 @@ done:
     FUNC_LEAVE_NOAPI(ret_value)
 } /* H5S__hyper_get_version_enc_size() */
 
-
 /*--------------------------------------------------------------------------
  NAME
     H5S__hyper_serial_size
@@ -3734,24 +3723,24 @@ done:
 static hssize_t
 H5S__hyper_serial_size(const H5S_t *space)
 {
-    hsize_t block_count = 0;    /* block counter for regular hyperslabs */
-    uint32_t version;           /* Version number */
-    uint8_t enc_size;           /* Encoded size of hyperslab selection info */
-    hssize_t ret_value = -1;    /* return value */
+    hsize_t  block_count = 0; /* block counter for regular hyperslabs */
+    uint32_t version;         /* Version number */
+    uint8_t  enc_size;        /* Encoded size of hyperslab selection info */
+    hssize_t ret_value = -1;  /* return value */
 
     FUNC_ENTER_STATIC
 
     HDassert(space);
 
     /* Determine the number of blocks */
-    if(space->select.sel_info.hslab->unlim_dim < 0) /* ! H5S_UNLIMITED */
+    if (space->select.sel_info.hslab->unlim_dim < 0) /* ! H5S_UNLIMITED */
         block_count = H5S__get_select_hyper_nblocks(space, FALSE);
 
     /* Determine the version and the encoded size */
-    if(H5S__hyper_get_version_enc_size(space, block_count, &version, &enc_size) < 0)
+    if (H5S__hyper_get_version_enc_size(space, block_count, &version, &enc_size) < 0)
         HGOTO_ERROR(H5E_DATASPACE, H5E_CANTGET, FAIL, "can't determine hyper version & enc_size")
 
-    if(version == H5S_HYPER_VERSION_3) {
+    if (version == H5S_HYPER_VERSION_3) {
         /* Version 3: regular */
         /* Size required is always:
          * <type (4 bytes)> + <version (4 bytes)> + <flags (1 byte)> +
@@ -3759,9 +3748,8 @@ H5S__hyper_serial_size(const H5S_t *space)
          * (4 (start/stride/count/block) * <enc_size> * <rank>) =
          * 14 + (4 * enc_size * rank) bytes
          */
-        if(H5S__hyper_is_regular(space))
-            ret_value = (hssize_t)14 +
-                         ((hssize_t)4 * (hssize_t)enc_size * (hssize_t)space->extent.rank);
+        if (H5S__hyper_is_regular(space))
+            ret_value = (hssize_t)14 + ((hssize_t)4 * (hssize_t)enc_size * (hssize_t)space->extent.rank);
         else {
             /* Version 3: irregular */
             /* Size required is always:
@@ -3775,8 +3763,8 @@ H5S__hyper_serial_size(const H5S_t *space)
             H5_CHECK_OVERFLOW(((unsigned)2 * enc_size * space->extent.rank * block_count), hsize_t, hssize_t);
             ret_value += (hssize_t)((unsigned)2 * enc_size * space->extent.rank * block_count);
         } /* end else */
-    } /* end if */
-    else if(version == H5S_HYPER_VERSION_2) {
+    }     /* end if */
+    else if (version == H5S_HYPER_VERSION_2) {
         /* Version 2 */
         /* Size required is always:
          * <type (4 bytes)> + <version (4 bytes)> + <flags (1 byte)> +
@@ -3806,7 +3794,6 @@ done:
     FUNC_LEAVE_NOAPI(ret_value)
 } /* end H5S__hyper_serial_size() */
 
-
 /*--------------------------------------------------------------------------
  NAME
     H5S__hyper_serialize_helper
@@ -3831,11 +3818,11 @@ done:
  REVISION LOG
 --------------------------------------------------------------------------*/
 static void
-H5S__hyper_serialize_helper(const H5S_hyper_span_info_t *spans,
-        hsize_t *start, hsize_t *end, hsize_t rank, uint8_t enc_size, uint8_t **p)
+H5S__hyper_serialize_helper(const H5S_hyper_span_info_t *spans, hsize_t *start, hsize_t *end, hsize_t rank,
+                            uint8_t enc_size, uint8_t **p)
 {
-    H5S_hyper_span_t *curr;     /* Pointer to current hyperslab span */
-    uint8_t *pp = (*p);         /* Local pointer for decoding */
+    H5S_hyper_span_t *curr;      /* Pointer to current hyperslab span */
+    uint8_t *         pp = (*p); /* Local pointer for decoding */
 
     FUNC_ENTER_STATIC_NOERR
 
@@ -3848,31 +3835,31 @@ H5S__hyper_serialize_helper(const H5S_hyper_span_info_t *spans,
 
     /* Walk through the list of spans, recursing or outputting them */
     curr = spans->head;
-    while(curr != NULL) {
+    while (curr != NULL) {
         /* Recurse if this node has down spans */
-        if(curr->down != NULL) {
+        if (curr->down != NULL) {
             /* Add the starting and ending points for this span to the list */
             start[rank] = curr->low;
-            end[rank] = curr->high;
+            end[rank]   = curr->high;
 
             /* Recurse down to the next dimension */
             H5S__hyper_serialize_helper(curr->down, start, end, rank + 1, enc_size, &pp);
         } /* end if */
         else {
-            hsize_t u;                  /* Index variable */
+            hsize_t u; /* Index variable */
 
             /* Encode all the previous dimensions starting & ending points */
-            switch(enc_size) {
+            switch (enc_size) {
                 case H5S_SELECT_INFO_ENC_SIZE_2:
                     /* Encode previous starting points */
-                    for(u=0; u<rank; u++)
+                    for (u = 0; u < rank; u++)
                         UINT16ENCODE(pp, (uint16_t)start[u]);
 
                     /* Encode starting point for this span */
                     UINT16ENCODE(pp, (uint16_t)curr->low);
 
                     /* Encode previous ending points */
-                    for(u=0; u<rank; u++)
+                    for (u = 0; u < rank; u++)
                         UINT16ENCODE(pp, (uint16_t)end[u]);
 
                     /* Encode starting point for this span */
@@ -3881,14 +3868,14 @@ H5S__hyper_serialize_helper(const H5S_hyper_span_info_t *spans,
 
                 case H5S_SELECT_INFO_ENC_SIZE_4:
                     /* Encode previous starting points */
-                    for(u=0; u<rank; u++)
+                    for (u = 0; u < rank; u++)
                         UINT32ENCODE(pp, (uint32_t)start[u]);
 
                     /* Encode starting point for this span */
                     UINT32ENCODE(pp, (uint32_t)curr->low);
 
-                     /* Encode previous ending points */
-                    for(u=0; u<rank; u++)
+                    /* Encode previous ending points */
+                    for (u = 0; u < rank; u++)
                         UINT32ENCODE(pp, (uint32_t)end[u]);
 
                     /* Encode starting point for this span */
@@ -3897,14 +3884,14 @@ H5S__hyper_serialize_helper(const H5S_hyper_span_info_t *spans,
 
                 case H5S_SELECT_INFO_ENC_SIZE_8:
                     /* Encode previous starting points */
-                    for(u=0; u<rank; u++)
+                    for (u = 0; u < rank; u++)
                         UINT64ENCODE(pp, (uint64_t)start[u]);
 
                     /* Encode starting point for this span */
                     UINT64ENCODE(pp, (uint64_t)curr->low);
 
                     /* Encode previous ending points */
-                    for(u=0; u<rank; u++)
+                    for (u = 0; u < rank; u++)
                         UINT64ENCODE(pp, (uint64_t)end[u]);
 
                     /* Encode starting point for this span */
@@ -3915,7 +3902,7 @@ H5S__hyper_serialize_helper(const H5S_hyper_span_info_t *spans,
                     HDassert(0 && "Unknown enc size?!?");
 
             } /* end switch */
-        } /* end else */
+        }     /* end else */
 
         /* Advance to next node */
         curr = curr->next;
@@ -3927,7 +3914,6 @@ H5S__hyper_serialize_helper(const H5S_hyper_span_info_t *spans,
     FUNC_LEAVE_NOAPI_VOID
 } /* end H5S__hyper_serialize_helper() */
 
-
 /*--------------------------------------------------------------------------
  NAME
     H5S__hyper_serialize
@@ -3952,24 +3938,24 @@ H5S__hyper_serialize_helper(const H5S_hyper_span_info_t *spans,
 static herr_t
 H5S__hyper_serialize(const H5S_t *space, uint8_t **p)
 {
-    const H5S_hyper_dim_t *diminfo;     /* Alias for dataspace's diminfo information */
-    hsize_t tmp_count[H5S_MAX_RANK];    /* Temporary hyperslab counts */
-    hsize_t offset[H5S_MAX_RANK];       /* Offset of element in dataspace */
-    hsize_t start[H5S_MAX_RANK];        /* Location of start of hyperslab */
-    hsize_t end[H5S_MAX_RANK];          /* Location of end of hyperslab */
-    uint8_t *pp;                        /* Local pointer for encoding */
-    uint8_t *lenp = NULL;   /* pointer to length location for later storage */
-    uint32_t len = 0;       /* number of bytes used */
-    uint32_t version;       /* Version number */
-    uint8_t flags = 0;      /* Flags for message */
-    hsize_t block_count = 0;    /* block counter for regular hyperslabs */
-    unsigned fast_dim;      /* Rank of the fastest changing dimension for the dataspace */
-    unsigned ndims;         /* Rank of the dataspace */
-    unsigned u;             /* Local counting variable */
-    hbool_t complete = FALSE;   /* Whether we are done with the iteration */
-    hbool_t is_regular;     /* Whether selection is regular */
-    uint8_t enc_size;       /* Encoded size */
-    herr_t ret_value = SUCCEED; /* return value */
+    const H5S_hyper_dim_t *diminfo;                 /* Alias for dataspace's diminfo information */
+    hsize_t                tmp_count[H5S_MAX_RANK]; /* Temporary hyperslab counts */
+    hsize_t                offset[H5S_MAX_RANK];    /* Offset of element in dataspace */
+    hsize_t                start[H5S_MAX_RANK];     /* Location of start of hyperslab */
+    hsize_t                end[H5S_MAX_RANK];       /* Location of end of hyperslab */
+    uint8_t *              pp;                      /* Local pointer for encoding */
+    uint8_t *              lenp = NULL;             /* pointer to length location for later storage */
+    uint32_t               len  = 0;                /* number of bytes used */
+    uint32_t               version;                 /* Version number */
+    uint8_t                flags       = 0;         /* Flags for message */
+    hsize_t                block_count = 0;         /* block counter for regular hyperslabs */
+    unsigned               fast_dim;            /* Rank of the fastest changing dimension for the dataspace */
+    unsigned               ndims;               /* Rank of the dataspace */
+    unsigned               u;                   /* Local counting variable */
+    hbool_t                complete = FALSE;    /* Whether we are done with the iteration */
+    hbool_t                is_regular;          /* Whether selection is regular */
+    uint8_t                enc_size;            /* Encoded size */
+    herr_t                 ret_value = SUCCEED; /* return value */
 
     FUNC_ENTER_STATIC
 
@@ -3980,61 +3966,60 @@ H5S__hyper_serialize(const H5S_t *space, uint8_t **p)
     HDassert(pp);
 
     /* Set some convienence values */
-    ndims = space->extent.rank;
+    ndims   = space->extent.rank;
     diminfo = space->select.sel_info.hslab->diminfo.opt;
 
     /* Calculate the # of blocks */
-    if(space->select.sel_info.hslab->unlim_dim < 0) /* ! H5S_UNLIMITED */
+    if (space->select.sel_info.hslab->unlim_dim < 0) /* ! H5S_UNLIMITED */
         block_count = H5S__get_select_hyper_nblocks(space, FALSE);
 
     /* Determine the version and the encoded size */
-    if(H5S__hyper_get_version_enc_size(space, block_count, &version, &enc_size) < 0)
+    if (H5S__hyper_get_version_enc_size(space, block_count, &version, &enc_size) < 0)
         HGOTO_ERROR(H5E_DATASPACE, H5E_CANTGET, FAIL, "can't determine hyper version & enc_size")
 
-    is_regular =  H5S__hyper_is_regular(space);
-    if(is_regular &&
-            (version == H5S_HYPER_VERSION_2 || version == H5S_HYPER_VERSION_3))
+    is_regular = H5S__hyper_is_regular(space);
+    if (is_regular && (version == H5S_HYPER_VERSION_2 || version == H5S_HYPER_VERSION_3))
         flags |= H5S_HYPER_REGULAR;
 
     /* Store the preamble information */
     UINT32ENCODE(pp, (uint32_t)H5S_GET_SELECT_TYPE(space)); /* Store the type of selection */
-    UINT32ENCODE(pp, version); /* Store the version number */
+    UINT32ENCODE(pp, version);                              /* Store the version number */
 
-    if(version >= 3) {
+    if (version >= 3) {
         *(pp)++ = flags;    /* Store the flags */
         *(pp)++ = enc_size; /* Store size of offset info */
-    } /* end if */
+    }                       /* end if */
     else {
-        if(version == 2)
+        if (version == 2)
             *(pp)++ = flags; /* Store the flags */
         else
             UINT32ENCODE(pp, (uint32_t)0); /* Store the un-used padding */
-        lenp = pp;           /* keep the pointer to the length location for later */
-        pp += 4;             /* skip over space for length */
+        lenp = pp;                         /* keep the pointer to the length location for later */
+        pp += 4;                           /* skip over space for length */
 
-        len += 4;           /* ndims */
-    } /* end else */
+        len += 4; /* ndims */
+    }             /* end else */
 
     /* Encode number of dimensions */
     UINT32ENCODE(pp, (uint32_t)ndims);
 
-    if(is_regular) {
-        if(version >= H5S_HYPER_VERSION_2) {
+    if (is_regular) {
+        if (version >= H5S_HYPER_VERSION_2) {
             HDassert(H5S_UNLIMITED == HSIZE_UNDEF);
 
             /* Iterate over dimensions */
             /* Encode start/stride/block/count */
-            switch(enc_size) {
+            switch (enc_size) {
                 case H5S_SELECT_INFO_ENC_SIZE_2:
                     HDassert(version == H5S_HYPER_VERSION_3);
-                    for(u = 0; u < space->extent.rank; u++) {
+                    for (u = 0; u < space->extent.rank; u++) {
                         UINT16ENCODE(pp, diminfo[u].start);
                         UINT16ENCODE(pp, diminfo[u].stride);
-                        if(diminfo[u].count == H5S_UNLIMITED)
+                        if (diminfo[u].count == H5S_UNLIMITED)
                             UINT16ENCODE(pp, H5S_UINT16_MAX)
                         else
                             UINT16ENCODE(pp, diminfo[u].count)
-                        if(diminfo[u].block == H5S_UNLIMITED)
+                        if (diminfo[u].block == H5S_UNLIMITED)
                             UINT16ENCODE(pp, H5S_UINT16_MAX)
                         else
                             UINT16ENCODE(pp, diminfo[u].block)
@@ -4043,14 +4028,14 @@ H5S__hyper_serialize(const H5S_t *space, uint8_t **p)
 
                 case H5S_SELECT_INFO_ENC_SIZE_4:
                     HDassert(version == H5S_HYPER_VERSION_3);
-                    for(u = 0; u < space->extent.rank; u++) {
+                    for (u = 0; u < space->extent.rank; u++) {
                         UINT32ENCODE(pp, diminfo[u].start);
                         UINT32ENCODE(pp, diminfo[u].stride);
-                        if(diminfo[u].count == H5S_UNLIMITED)
+                        if (diminfo[u].count == H5S_UNLIMITED)
                             UINT32ENCODE(pp, H5S_UINT32_MAX)
                         else
                             UINT32ENCODE(pp, diminfo[u].count)
-                        if(diminfo[u].block == H5S_UNLIMITED)
+                        if (diminfo[u].block == H5S_UNLIMITED)
                             UINT32ENCODE(pp, H5S_UINT32_MAX)
                         else
                             UINT32ENCODE(pp, diminfo[u].block)
@@ -4059,26 +4044,27 @@ H5S__hyper_serialize(const H5S_t *space, uint8_t **p)
 
                 case H5S_SELECT_INFO_ENC_SIZE_8:
                     HDassert(version == H5S_HYPER_VERSION_2 || version == H5S_HYPER_VERSION_3);
-                    for(u = 0; u < space->extent.rank; u++) {
+                    for (u = 0; u < space->extent.rank; u++) {
                         UINT64ENCODE(pp, diminfo[u].start);
                         UINT64ENCODE(pp, diminfo[u].stride);
-                        if(diminfo[u].count == H5S_UNLIMITED)
+                        if (diminfo[u].count == H5S_UNLIMITED)
                             UINT64ENCODE(pp, H5S_UINT64_MAX)
                         else
                             UINT64ENCODE(pp, diminfo[u].count)
-                        if(diminfo[u].block == H5S_UNLIMITED)
+                        if (diminfo[u].block == H5S_UNLIMITED)
                             UINT64ENCODE(pp, H5S_UINT64_MAX)
                         else
                             UINT64ENCODE(pp, diminfo[u].block)
                     } /* end for */
-                    if(version == H5S_HYPER_VERSION_2)
+                    if (version == H5S_HYPER_VERSION_2)
                         len += (4 * space->extent.rank * 8);
                     break;
                 default:
-                    HGOTO_ERROR(H5E_DATASPACE, H5E_UNSUPPORTED, FAIL, "unknown offset info size for hyperslab")
+                    HGOTO_ERROR(H5E_DATASPACE, H5E_UNSUPPORTED, FAIL,
+                                "unknown offset info size for hyperslab")
                     break;
             } /* end switch */
-        } /* end if */
+        }     /* end if */
         else {
             HDassert(version == H5S_HYPER_VERSION_1);
 
@@ -4093,52 +4079,52 @@ H5S__hyper_serialize(const H5S_t *space, uint8_t **p)
             /* Now serialize the information for the regular hyperslab */
 
             /* Build the tables of count sizes as well as the initial offset */
-            for(u = 0; u < ndims; u++) {
+            for (u = 0; u < ndims; u++) {
                 tmp_count[u] = diminfo[u].count;
-                offset[u] = diminfo[u].start;
+                offset[u]    = diminfo[u].start;
             } /* end for */
 
             /* Go iterate over the hyperslabs */
-            while(complete == FALSE) {
+            while (complete == FALSE) {
                 /* Iterate over the blocks in the fastest dimension */
-                while(tmp_count[fast_dim] > 0) {
+                while (tmp_count[fast_dim] > 0) {
                     /* Add 8 bytes times the rank for each hyperslab selected */
                     len += 8 * ndims;
 
                     /* Encode hyperslab starting location */
-                    for(u = 0; u < ndims; u++)
+                    for (u = 0; u < ndims; u++)
                         UINT32ENCODE(pp, (uint32_t)offset[u]);
 
                     /* Encode hyperslab ending location */
-                    for(u = 0; u < ndims; u++)
+                    for (u = 0; u < ndims; u++)
                         UINT32ENCODE(pp, (uint32_t)(offset[u] + (diminfo[u].block - 1)));
 
                     /* Move the offset to the next sequence to start */
-                    offset[fast_dim]+=diminfo[fast_dim].stride;
+                    offset[fast_dim] += diminfo[fast_dim].stride;
 
                     /* Decrement the block count */
                     tmp_count[fast_dim]--;
                 } /* end while */
 
                 /* Work on other dimensions if necessary */
-                if(fast_dim > 0) {
-                    int temp_dim;           /* Temporary rank holder */
+                if (fast_dim > 0) {
+                    int temp_dim; /* Temporary rank holder */
 
                     /* Reset the block counts */
                     tmp_count[fast_dim] = diminfo[fast_dim].count;
 
                     /* Bubble up the decrement to the slower changing dimensions */
                     temp_dim = (int)fast_dim - 1;
-                    while(temp_dim >= 0 && complete == FALSE) {
+                    while (temp_dim >= 0 && complete == FALSE) {
                         /* Decrement the block count */
                         tmp_count[temp_dim]--;
 
                         /* Check if we have more blocks left */
-                        if(tmp_count[temp_dim] > 0)
+                        if (tmp_count[temp_dim] > 0)
                             break;
 
                         /* Check for getting out of iterator */
-                        if(temp_dim == 0)
+                        if (temp_dim == 0)
                             complete = TRUE;
 
                         /* Reset the block count in this dimension */
@@ -4147,19 +4133,19 @@ H5S__hyper_serialize(const H5S_t *space, uint8_t **p)
                         /* Wrapped a dimension, go up to next dimension */
                         temp_dim--;
                     } /* end while */
-                } /* end if */
+                }     /* end if */
                 else
-                    break;  /* Break out now, for 1-D selections */
+                    break; /* Break out now, for 1-D selections */
 
                 /* Re-compute offset array */
-                for(u = 0; u < ndims; u++)
+                for (u = 0; u < ndims; u++)
                     offset[u] = diminfo[u].start + diminfo[u].stride * (diminfo[u].count - tmp_count[u]);
             } /* end while */
-        } /* end else */
-    } /* end if */
-    else { /* irregular */
+        }     /* end else */
+    }         /* end if */
+    else {    /* irregular */
         /* Encode number of hyperslabs */
-        switch(enc_size) {
+        switch (enc_size) {
             case H5S_SELECT_INFO_ENC_SIZE_2:
                 HDassert(version == H5S_HYPER_VERSION_3);
                 H5_CHECK_OVERFLOW(block_count, hsize_t, uint16_t);
@@ -4182,7 +4168,7 @@ H5S__hyper_serialize(const H5S_t *space, uint8_t **p)
                 break;
         } /* end switch */
 
-        if(version == H5S_HYPER_VERSION_1) {
+        if (version == H5S_HYPER_VERSION_1) {
             len += 4; /* block_count */
 
             /* Add 8 bytes times the rank for each hyperslab selected */
@@ -4190,12 +4176,13 @@ H5S__hyper_serialize(const H5S_t *space, uint8_t **p)
             len += (uint32_t)(8 * ndims * block_count);
         } /* end if */
 
-        H5S__hyper_serialize_helper(space->select.sel_info.hslab->span_lst, start, end, (hsize_t)0, enc_size, &pp);
+        H5S__hyper_serialize_helper(space->select.sel_info.hslab->span_lst, start, end, (hsize_t)0, enc_size,
+                                    &pp);
     } /* end else */
 
     /* Encode length */
-    if(version <= H5S_HYPER_VERSION_2)
-        UINT32ENCODE(lenp, (uint32_t)len);  /* Store the length of the extra information */
+    if (version <= H5S_HYPER_VERSION_2)
+        UINT32ENCODE(lenp, (uint32_t)len); /* Store the length of the extra information */
 
     /* Update encoding pointer */
     *p = pp;
@@ -4204,7 +4191,6 @@ done:
     FUNC_LEAVE_NOAPI(ret_value)
 } /* end H5S__hyper_serialize() */
 
-
 /*--------------------------------------------------------------------------
  NAME
     H5S__hyper_deserialize
@@ -4230,18 +4216,18 @@ done:
 static herr_t
 H5S__hyper_deserialize(H5S_t **space, const uint8_t **p)
 {
-    H5S_t *tmp_space = NULL;        /* Pointer to actual dataspace to use,
-                                       either *space or a newly allocated one */
-    hsize_t dims[H5S_MAX_RANK];     /* Dimenion sizes */
-    hsize_t start[H5S_MAX_RANK];    /* hyperslab start information */
-    hsize_t block[H5S_MAX_RANK];    /* hyperslab block information */
-    uint32_t version;               /* Version number */
-    uint8_t flags = 0;              /* Flags */
-    uint8_t enc_size = 0;           /* Encoded size of selection info */
-    unsigned rank;                  /* rank of points */
-    const uint8_t *pp;              /* Local pointer for decoding */
-    unsigned u;                     /* Local counting variable */
-    herr_t ret_value=FAIL;          /* return value */
+    H5S_t *tmp_space = NULL;            /* Pointer to actual dataspace to use,
+                                           either *space or a newly allocated one */
+    hsize_t        dims[H5S_MAX_RANK];  /* Dimenion sizes */
+    hsize_t        start[H5S_MAX_RANK]; /* hyperslab start information */
+    hsize_t        block[H5S_MAX_RANK]; /* hyperslab block information */
+    uint32_t       version;             /* Version number */
+    uint8_t        flags    = 0;        /* Flags */
+    uint8_t        enc_size = 0;        /* Encoded size of selection info */
+    unsigned       rank;                /* rank of points */
+    const uint8_t *pp;                  /* Local pointer for decoding */
+    unsigned       u;                   /* Local counting variable */
+    herr_t         ret_value = FAIL;    /* return value */
 
     FUNC_ENTER_STATIC
 
@@ -4255,8 +4241,8 @@ H5S__hyper_deserialize(H5S_t **space, const uint8_t **p)
        is moved from H5S_select_deserialize() in H5Sselect.c to here.
        This is needed for decoding virtual layout in H5O__layout_decode() */
     /* Allocate space if not provided */
-    if(!*space) {
-        if(NULL == (tmp_space = H5S_create(H5S_SIMPLE)))
+    if (!*space) {
+        if (NULL == (tmp_space = H5S_create(H5S_SIMPLE)))
             HGOTO_ERROR(H5E_DATASPACE, H5E_CANTCREATE, FAIL, "can't create dataspace")
     } /* end if */
     else
@@ -4265,14 +4251,14 @@ H5S__hyper_deserialize(H5S_t **space, const uint8_t **p)
     /* Decode version */
     UINT32DECODE(pp, version);
 
-    if(version < H5S_HYPER_VERSION_1 || version > H5S_HYPER_VERSION_LATEST)
+    if (version < H5S_HYPER_VERSION_1 || version > H5S_HYPER_VERSION_LATEST)
         HGOTO_ERROR(H5E_DATASPACE, H5E_BADVALUE, FAIL, "bad version number for hyperslab selection")
 
-    if(version >= (uint32_t)H5S_HYPER_VERSION_2) {
+    if (version >= (uint32_t)H5S_HYPER_VERSION_2) {
         /* Decode flags */
         flags = *(pp)++;
 
-        if(version >= (uint32_t)H5S_HYPER_VERSION_3)
+        if (version >= (uint32_t)H5S_HYPER_VERSION_3)
             /* decode size of offset info */
             enc_size = *(pp)++;
         else {
@@ -4281,85 +4267,86 @@ H5S__hyper_deserialize(H5S_t **space, const uint8_t **p)
             enc_size = H5S_SELECT_INFO_ENC_SIZE_8;
         } /* end else */
 
-         /* Check for unknown flags */
-        if(flags & ~H5S_SELECT_FLAG_BITS)
+        /* Check for unknown flags */
+        if (flags & ~H5S_SELECT_FLAG_BITS)
             HGOTO_ERROR(H5E_DATASPACE, H5E_CANTLOAD, FAIL, "unknown flag for selection")
-     }
-     else {
+    }
+    else {
         /* Skip over the remainder of the header */
         pp += 8;
         enc_size = H5S_SELECT_INFO_ENC_SIZE_4;
-     } /* end else */
+    } /* end else */
 
-     /* Check encoded */
-     if(enc_size & ~H5S_SELECT_INFO_ENC_SIZE_BITS)
+    /* Check encoded */
+    if (enc_size & ~H5S_SELECT_INFO_ENC_SIZE_BITS)
         HGOTO_ERROR(H5E_DATASPACE, H5E_CANTLOAD, FAIL, "unknown size of point/offset info for selection")
 
     /* Decode the rank of the point selection */
-    UINT32DECODE(pp,rank);
+    UINT32DECODE(pp, rank);
 
-    if(!*space) {
+    if (!*space) {
         /* Patch the rank of the allocated dataspace */
         HDmemset(dims, 0, (size_t)rank * sizeof(dims[0]));
-        if(H5S_set_extent_simple(tmp_space, rank, dims, NULL) < 0)
+        if (H5S_set_extent_simple(tmp_space, rank, dims, NULL) < 0)
             HGOTO_ERROR(H5E_DATASPACE, H5E_CANTINIT, FAIL, "can't set dimensions")
     } /* end if */
     else
         /* Verify the rank of the provided dataspace */
-        if(rank != tmp_space->extent.rank)
-            HGOTO_ERROR(H5E_DATASPACE, H5E_BADRANGE, FAIL, "rank of serialized selection does not match dataspace")
+        if (rank != tmp_space->extent.rank)
+        HGOTO_ERROR(H5E_DATASPACE, H5E_BADRANGE, FAIL,
+                    "rank of serialized selection does not match dataspace")
 
-    if(flags & H5S_HYPER_REGULAR) {
-        hsize_t stride[H5S_MAX_RANK];   /* Hyperslab stride information */
-        hsize_t count[H5S_MAX_RANK];    /* Hyperslab count information */
+    if (flags & H5S_HYPER_REGULAR) {
+        hsize_t stride[H5S_MAX_RANK]; /* Hyperslab stride information */
+        hsize_t count[H5S_MAX_RANK];  /* Hyperslab count information */
 
         /* Sanity checks */
         HDassert(H5S_UNLIMITED == HSIZE_UNDEF);
         HDassert(version >= H5S_HYPER_VERSION_2);
 
-         /* Decode start/stride/block/count */
-        switch(enc_size) {
+        /* Decode start/stride/block/count */
+        switch (enc_size) {
             case H5S_SELECT_INFO_ENC_SIZE_2:
-                for(u = 0; u < tmp_space->extent.rank; u++) {
+                for (u = 0; u < tmp_space->extent.rank; u++) {
                     UINT16DECODE(pp, start[u]);
                     UINT16DECODE(pp, stride[u]);
 
                     UINT16DECODE(pp, count[u]);
-                    if((uint16_t)count[u] == H5S_UINT16_MAX)
+                    if ((uint16_t)count[u] == H5S_UINT16_MAX)
                         count[u] = H5S_UNLIMITED;
 
                     UINT16DECODE(pp, block[u]);
-                    if((uint16_t)block[u] == H5S_UINT16_MAX)
+                    if ((uint16_t)block[u] == H5S_UINT16_MAX)
                         block[u] = H5S_UNLIMITED;
                 } /* end for */
                 break;
 
             case H5S_SELECT_INFO_ENC_SIZE_4:
-                for(u = 0; u < tmp_space->extent.rank; u++) {
+                for (u = 0; u < tmp_space->extent.rank; u++) {
                     UINT32DECODE(pp, start[u]);
                     UINT32DECODE(pp, stride[u]);
 
                     UINT32DECODE(pp, count[u]);
-                    if((uint32_t)count[u] == H5S_UINT32_MAX)
+                    if ((uint32_t)count[u] == H5S_UINT32_MAX)
                         count[u] = H5S_UNLIMITED;
 
                     UINT32DECODE(pp, block[u]);
-                    if((uint32_t)block[u] == H5S_UINT32_MAX)
+                    if ((uint32_t)block[u] == H5S_UINT32_MAX)
                         block[u] = H5S_UNLIMITED;
                 } /* end for */
                 break;
 
             case H5S_SELECT_INFO_ENC_SIZE_8:
-                for(u = 0; u < tmp_space->extent.rank; u++) {
+                for (u = 0; u < tmp_space->extent.rank; u++) {
                     UINT64DECODE(pp, start[u]);
                     UINT64DECODE(pp, stride[u]);
 
                     UINT64DECODE(pp, count[u]);
-                    if((uint64_t)count[u] == H5S_UINT64_MAX)
+                    if ((uint64_t)count[u] == H5S_UINT64_MAX)
                         count[u] = H5S_UNLIMITED;
 
                     UINT64DECODE(pp, block[u]);
-                    if((uint64_t)block[u] == H5S_UINT64_MAX)
+                    if ((uint64_t)block[u] == H5S_UINT64_MAX)
                         block[u] = H5S_UNLIMITED;
                 } /* end for */
                 break;
@@ -4370,21 +4357,21 @@ H5S__hyper_deserialize(H5S_t **space, const uint8_t **p)
         } /* end switch */
 
         /* Select the hyperslab to the current selection */
-        if((ret_value = H5S_select_hyperslab(tmp_space, H5S_SELECT_SET, start, stride, count, block)) < 0)
+        if ((ret_value = H5S_select_hyperslab(tmp_space, H5S_SELECT_SET, start, stride, count, block)) < 0)
             HGOTO_ERROR(H5E_DATASPACE, H5E_CANTSET, FAIL, "can't change selection")
     } /* end if */
     else {
-        const hsize_t *stride;  /* Hyperslab stride information */
-        const hsize_t *count;   /* Hyperslab count information */
-        hsize_t end[H5S_MAX_RANK];  /* Hyperslab end information */
-        hsize_t *tstart;        /* Temporary hyperslab pointers */
-        hsize_t *tend;          /* Temporary hyperslab pointers */
-        hsize_t *tblock;        /* Temporary hyperslab pointers */
-        size_t num_elem;        /* Number of elements in selection */
-        unsigned v;             /* Local counting variable */
+        const hsize_t *stride;            /* Hyperslab stride information */
+        const hsize_t *count;             /* Hyperslab count information */
+        hsize_t        end[H5S_MAX_RANK]; /* Hyperslab end information */
+        hsize_t *      tstart;            /* Temporary hyperslab pointers */
+        hsize_t *      tend;              /* Temporary hyperslab pointers */
+        hsize_t *      tblock;            /* Temporary hyperslab pointers */
+        size_t         num_elem;          /* Number of elements in selection */
+        unsigned       v;                 /* Local counting variable */
 
         /* Decode the number of blocks */
-        switch(enc_size) {
+        switch (enc_size) {
             case H5S_SELECT_INFO_ENC_SIZE_2:
                 UINT16DECODE(pp, num_elem);
                 break;
@@ -4406,62 +4393,63 @@ H5S__hyper_deserialize(H5S_t **space, const uint8_t **p)
         stride = count = H5S_hyper_ones_g;
 
         /* Retrieve the coordinates from the buffer */
-        for(u = 0; u < num_elem; u++) {
+        for (u = 0; u < num_elem; u++) {
             /* Decode the starting and ending points */
-            switch(enc_size) {
+            switch (enc_size) {
                 case H5S_SELECT_INFO_ENC_SIZE_2:
-                    for(tstart = start, v = 0; v < rank; v++, tstart++)
+                    for (tstart = start, v = 0; v < rank; v++, tstart++)
                         UINT16DECODE(pp, *tstart);
-                    for(tend = end, v = 0; v < rank; v++, tend++)
+                    for (tend = end, v = 0; v < rank; v++, tend++)
                         UINT16DECODE(pp, *tend);
                     break;
 
                 case H5S_SELECT_INFO_ENC_SIZE_4:
-                    for(tstart = start,v = 0; v < rank; v++, tstart++)
+                    for (tstart = start, v = 0; v < rank; v++, tstart++)
                         UINT32DECODE(pp, *tstart);
-                    for(tend = end, v = 0; v < rank; v++, tend++)
+                    for (tend = end, v = 0; v < rank; v++, tend++)
                         UINT32DECODE(pp, *tend);
                     break;
 
                 case H5S_SELECT_INFO_ENC_SIZE_8:
-                    for(tstart = start, v = 0; v < rank; v++, tstart++)
+                    for (tstart = start, v = 0; v < rank; v++, tstart++)
                         UINT64DECODE(pp, *tstart);
-                    for(tend = end, v = 0; v < rank; v++, tend++)
+                    for (tend = end, v = 0; v < rank; v++, tend++)
                         UINT64DECODE(pp, *tend);
                     break;
 
                 default:
-                    HGOTO_ERROR(H5E_DATASPACE, H5E_UNSUPPORTED, FAIL, "unknown offset info size for hyperslab")
+                    HGOTO_ERROR(H5E_DATASPACE, H5E_UNSUPPORTED, FAIL,
+                                "unknown offset info size for hyperslab")
                     break;
             } /* end switch */
 
             /* Change the ending points into blocks */
-            for(tblock = block, tstart = start, tend = end, v = 0; v < rank; v++, tstart++, tend++, tblock++)
+            for (tblock = block, tstart = start, tend = end, v = 0; v < rank; v++, tstart++, tend++, tblock++)
                 *tblock = (*tend - *tstart) + 1;
 
             /* Select or add the hyperslab to the current selection */
-            if((ret_value = H5S_select_hyperslab(tmp_space, (u == 0 ? H5S_SELECT_SET : H5S_SELECT_OR), start, stride, count, block)) < 0)
+            if ((ret_value = H5S_select_hyperslab(tmp_space, (u == 0 ? H5S_SELECT_SET : H5S_SELECT_OR), start,
+                                                  stride, count, block)) < 0)
                 HGOTO_ERROR(H5E_DATASPACE, H5E_CANTSET, FAIL, "can't change selection")
         } /* end for */
-    } /* end else */
+    }     /* end else */
 
     /* Update decoding pointer */
     *p = pp;
 
     /* Return space to the caller if allocated */
-    if(!*space)
+    if (!*space)
         *space = tmp_space;
 
 done:
     /* Free temporary space if not passed to caller (only happens on error) */
-    if(!*space && tmp_space)
-        if(H5S_close(tmp_space) < 0)
+    if (!*space && tmp_space)
+        if (H5S_close(tmp_space) < 0)
             HDONE_ERROR(H5E_DATASPACE, H5E_CANTFREE, FAIL, "can't close dataspace")
 
     FUNC_LEAVE_NOAPI(ret_value)
 } /* end H5S__hyper_deserialize() */
 
-
 /*--------------------------------------------------------------------------
  NAME
     H5S__hyper_span_blocklist
@@ -4496,12 +4484,11 @@ done:
  REVISION LOG
 --------------------------------------------------------------------------*/
 static herr_t
-H5S__hyper_span_blocklist(const H5S_hyper_span_info_t *spans, hsize_t start[],
-    hsize_t end[], hsize_t rank, hsize_t *startblock, hsize_t *numblocks,
-    hsize_t **buf)
+H5S__hyper_span_blocklist(const H5S_hyper_span_info_t *spans, hsize_t start[], hsize_t end[], hsize_t rank,
+                          hsize_t *startblock, hsize_t *numblocks, hsize_t **buf)
 {
-    const H5S_hyper_span_t *curr;     /* Pointer to current hyperslab span */
-    herr_t ret_value = SUCCEED; /* return value */
+    const H5S_hyper_span_t *curr;                /* Pointer to current hyperslab span */
+    herr_t                  ret_value = SUCCEED; /* return value */
 
     FUNC_ENTER_STATIC
 
@@ -4516,20 +4503,20 @@ H5S__hyper_span_blocklist(const H5S_hyper_span_info_t *spans, hsize_t start[],
 
     /* Walk through the list of spans, recursing or outputting them */
     curr = spans->head;
-    while(curr != NULL && *numblocks > 0) {
+    while (curr != NULL && *numblocks > 0) {
         /* Recurse if this node has down spans */
-        if(curr->down != NULL) {
+        if (curr->down != NULL) {
             /* Add the starting and ending points for this span to the list */
             start[rank] = curr->low;
-            end[rank] = curr->high;
+            end[rank]   = curr->high;
 
             /* Recurse down to the next dimension */
-            if(H5S__hyper_span_blocklist(curr->down, start, end, (rank + 1), startblock, numblocks, buf) < 0)
+            if (H5S__hyper_span_blocklist(curr->down, start, end, (rank + 1), startblock, numblocks, buf) < 0)
                 HGOTO_ERROR(H5E_INTERNAL, H5E_CANTFREE, FAIL, "failed to release hyperslab spans")
         } /* end if */
         else {
             /* Skip this block if we haven't skipped all the startblocks yet */
-            if(*startblock > 0) {
+            if (*startblock > 0) {
                 /* Decrement the starting block */
                 (*startblock)--;
             } /* end if */
@@ -4556,7 +4543,7 @@ H5S__hyper_span_blocklist(const H5S_hyper_span_info_t *spans, hsize_t start[],
                 /* Decrement the number of blocks processed */
                 (*numblocks)--;
             } /* end else */
-        } /* end else */
+        }     /* end else */
 
         /* Advance to next node */
         curr = curr->next;
@@ -4566,7 +4553,6 @@ done:
     FUNC_LEAVE_NOAPI(ret_value)
 } /* end H5S__hyper_span_blocklist() */
 
-
 /*--------------------------------------------------------------------------
  NAME
     H5S__get_select_hyper_blocklist
@@ -4598,8 +4584,7 @@ done:
  REVISION LOG
 --------------------------------------------------------------------------*/
 static herr_t
-H5S__get_select_hyper_blocklist(H5S_t *space, hsize_t startblock,
-    hsize_t numblocks, hsize_t *buf)
+H5S__get_select_hyper_blocklist(H5S_t *space, hsize_t startblock, hsize_t numblocks, hsize_t *buf)
 {
     herr_t ret_value = SUCCEED; /* Return value */
 
@@ -4612,26 +4597,26 @@ H5S__get_select_hyper_blocklist(H5S_t *space, hsize_t startblock,
     /* Attempt to rebuild diminfo if it is invalid and has not been confirmed
      * to be impossible.
      */
-    if(space->select.sel_info.hslab->diminfo_valid == H5S_DIMINFO_VALID_NO)
+    if (space->select.sel_info.hslab->diminfo_valid == H5S_DIMINFO_VALID_NO)
         H5S__hyper_rebuild(space);
 
     /* Check for a "regular" hyperslab selection */
-    if(space->select.sel_info.hslab->diminfo_valid == H5S_DIMINFO_VALID_YES) {
-        const H5S_hyper_dim_t *diminfo; /* Alias for dataspace's diminfo information */
-        hsize_t tmp_count[H5S_MAX_RANK]; /* Temporary hyperslab counts */
-        hsize_t offset[H5S_MAX_RANK];   /* Offset of element in dataspace */
-        hsize_t end[H5S_MAX_RANK];  /* End of elements in dataspace */
-        unsigned fast_dim;          /* Rank of the fastest changing dimension for the dataspace */
-        unsigned ndims;             /* Rank of the dataspace */
-        hbool_t done;               /* Whether we are done with the iteration */
-        unsigned u;                 /* Counter */
+    if (space->select.sel_info.hslab->diminfo_valid == H5S_DIMINFO_VALID_YES) {
+        const H5S_hyper_dim_t *diminfo;                 /* Alias for dataspace's diminfo information */
+        hsize_t                tmp_count[H5S_MAX_RANK]; /* Temporary hyperslab counts */
+        hsize_t                offset[H5S_MAX_RANK];    /* Offset of element in dataspace */
+        hsize_t                end[H5S_MAX_RANK];       /* End of elements in dataspace */
+        unsigned               fast_dim; /* Rank of the fastest changing dimension for the dataspace */
+        unsigned               ndims;    /* Rank of the dataspace */
+        hbool_t                done;     /* Whether we are done with the iteration */
+        unsigned               u;        /* Counter */
 
         /* Set some convienence values */
-        ndims = space->extent.rank;
+        ndims    = space->extent.rank;
         fast_dim = ndims - 1;
 
         /* Check which set of dimension information to use */
-        if(space->select.sel_info.hslab->unlim_dim >= 0)
+        if (space->select.sel_info.hslab->unlim_dim >= 0)
             /*
              * There is an unlimited dimension so we must use diminfo.opt as
              * it has been "clipped" to the current extent.
@@ -4646,21 +4631,21 @@ H5S__get_select_hyper_blocklist(H5S_t *space, hsize_t startblock,
             diminfo = space->select.sel_info.hslab->diminfo.app;
 
         /* Build the tables of count sizes as well as the initial offset */
-        for(u = 0; u < ndims; u++) {
+        for (u = 0; u < ndims; u++) {
             tmp_count[u] = diminfo[u].count;
-            offset[u] = diminfo[u].start;
-            end[u] = diminfo[u].start + (diminfo[u].block - 1);
+            offset[u]    = diminfo[u].start;
+            end[u]       = diminfo[u].start + (diminfo[u].block - 1);
         } /* end for */
 
         /* We're not done with the iteration */
         done = FALSE;
 
         /* Go iterate over the hyperslabs */
-        while(!done && numblocks > 0) {
+        while (!done && numblocks > 0) {
             /* Skip over initial blocks */
-            if(startblock > 0) {
+            if (startblock > 0) {
                 /* Skip all blocks in row */
-                if(startblock >= tmp_count[fast_dim]) {
+                if (startblock >= tmp_count[fast_dim]) {
                     startblock -= tmp_count[fast_dim];
                     tmp_count[fast_dim] = 0;
                 } /* end if */
@@ -4675,10 +4660,10 @@ H5S__get_select_hyper_blocklist(H5S_t *space, hsize_t startblock,
                     /* Done with starting blocks */
                     startblock = 0;
                 } /* end else */
-            } /* end if */
+            }     /* end if */
 
             /* Iterate over the blocks in the fastest dimension */
-            while(tmp_count[fast_dim] > 0 && numblocks > 0) {
+            while (tmp_count[fast_dim] > 0 && numblocks > 0) {
                 /* Sanity check */
                 HDassert(startblock == 0);
 
@@ -4702,53 +4687,53 @@ H5S__get_select_hyper_blocklist(H5S_t *space, hsize_t startblock,
             } /* end while */
 
             /* Work on other dimensions if necessary */
-            if(fast_dim > 0 && numblocks > 0) {
-                int temp_dim;               /* Temporary rank holder */
+            if (fast_dim > 0 && numblocks > 0) {
+                int temp_dim; /* Temporary rank holder */
 
                 /* Reset the block counts */
                 tmp_count[fast_dim] = diminfo[fast_dim].count;
 
                 /* Bubble up the decrement to the slower changing dimensions */
                 temp_dim = (int)(fast_dim - 1);
-                while(temp_dim >= 0 && !done) {
+                while (temp_dim >= 0 && !done) {
                     /* Decrement the block count */
                     tmp_count[temp_dim]--;
 
                     /* Check if we have more blocks left */
-                    if(tmp_count[temp_dim] > 0)
+                    if (tmp_count[temp_dim] > 0)
                         break;
 
                     /* Reset the block count in this dimension */
                     tmp_count[temp_dim] = diminfo[temp_dim].count;
 
                     /* Check for getting out of iterator */
-                    if(temp_dim == 0)
+                    if (temp_dim == 0)
                         done = TRUE;
 
                     /* Wrapped a dimension, go up to next dimension */
                     temp_dim--;
                 } /* end while */
-            } /* end if */
+            }     /* end if */
 
             /* Re-compute offset & end arrays */
-            if(!done)
-                for(u = 0; u < ndims; u++) {
+            if (!done)
+                for (u = 0; u < ndims; u++) {
                     offset[u] = diminfo[u].start + diminfo[u].stride * (diminfo[u].count - tmp_count[u]);
-                    end[u] = offset[u] + (diminfo[u].block - 1);
+                    end[u]    = offset[u] + (diminfo[u].block - 1);
                 } /* end for */
-        } /* end while */
-    } /* end if */
+        }         /* end while */
+    }             /* end if */
     else {
-        hsize_t start[H5S_MAX_RANK];    /* Location of start of hyperslab */
-        hsize_t end[H5S_MAX_RANK];      /* Location of end of hyperslab */
+        hsize_t start[H5S_MAX_RANK]; /* Location of start of hyperslab */
+        hsize_t end[H5S_MAX_RANK];   /* Location of end of hyperslab */
 
-        ret_value = H5S__hyper_span_blocklist(space->select.sel_info.hslab->span_lst, start, end, (hsize_t)0, &startblock, &numblocks, &buf);
+        ret_value = H5S__hyper_span_blocklist(space->select.sel_info.hslab->span_lst, start, end, (hsize_t)0,
+                                              &startblock, &numblocks, &buf);
     } /* end else */
 
     FUNC_LEAVE_NOAPI(ret_value)
 } /* end H5S__get_select_hyper_blocklist() */
 
-
 /*--------------------------------------------------------------------------
  NAME
     H5Sget_select_hyper_blocklist
@@ -4780,36 +4765,35 @@ H5S__get_select_hyper_blocklist(H5S_t *space, hsize_t startblock,
  REVISION LOG
 --------------------------------------------------------------------------*/
 herr_t
-H5Sget_select_hyper_blocklist(hid_t spaceid, hsize_t startblock,
-    hsize_t numblocks, hsize_t buf[/*numblocks*/])
+H5Sget_select_hyper_blocklist(hid_t spaceid, hsize_t startblock, hsize_t numblocks,
+                              hsize_t buf[/*numblocks*/])
 {
-    H5S_t *space;               /* Dataspace to modify selection of */
-    herr_t ret_value;           /* return value */
+    H5S_t *space;     /* Dataspace to modify selection of */
+    herr_t ret_value; /* return value */
 
     FUNC_ENTER_API(FAIL)
     H5TRACE4("e", "ihh*[a2]h", spaceid, startblock, numblocks, buf);
 
     /* Check args */
-    if(buf == NULL)
+    if (buf == NULL)
         HGOTO_ERROR(H5E_ARGS, H5E_BADVALUE, FAIL, "invalid pointer")
-    if(NULL == (space = (H5S_t *)H5I_object_verify(spaceid, H5I_DATASPACE)))
+    if (NULL == (space = (H5S_t *)H5I_object_verify(spaceid, H5I_DATASPACE)))
         HGOTO_ERROR(H5E_ARGS, H5E_BADTYPE, FAIL, "not a dataspace")
-    if(H5S_GET_SELECT_TYPE(space)!=H5S_SEL_HYPERSLABS)
+    if (H5S_GET_SELECT_TYPE(space) != H5S_SEL_HYPERSLABS)
         HGOTO_ERROR(H5E_ARGS, H5E_BADTYPE, FAIL, "not a hyperslab selection")
-    if(space->select.sel_info.hslab->unlim_dim >= 0)
+    if (space->select.sel_info.hslab->unlim_dim >= 0)
         HGOTO_ERROR(H5E_DATASPACE, H5E_UNSUPPORTED, FAIL, "cannot get blocklist for unlimited selection")
 
     /* Go get the correct number of blocks */
-    if(numblocks > 0)
+    if (numblocks > 0)
         ret_value = H5S__get_select_hyper_blocklist(space, startblock, numblocks, buf);
     else
-        ret_value = SUCCEED;      /* Successfully got 0 blocks... */
+        ret_value = SUCCEED; /* Successfully got 0 blocks... */
 
 done:
     FUNC_LEAVE_API(ret_value)
 } /* end H5Sget_select_hyper_blocklist() */
 
-
 /*--------------------------------------------------------------------------
  NAME
     H5S__hyper_bounds
@@ -4839,8 +4823,8 @@ done:
 static herr_t
 H5S__hyper_bounds(const H5S_t *space, hsize_t *start, hsize_t *end)
 {
-    const hsize_t *low_bounds, *high_bounds;    /* Pointers to the correct pair of low & high bounds */
-    herr_t ret_value = SUCCEED; /* Return value */
+    const hsize_t *low_bounds, *high_bounds; /* Pointers to the correct pair of low & high bounds */
+    herr_t         ret_value = SUCCEED;      /* Return value */
 
     FUNC_ENTER_STATIC
 
@@ -4850,36 +4834,36 @@ H5S__hyper_bounds(const H5S_t *space, hsize_t *start, hsize_t *end)
     HDassert(end);
 
     /* Check which set of low & high bounds we should be using */
-    if(space->select.sel_info.hslab->diminfo_valid == H5S_DIMINFO_VALID_YES) {
-        low_bounds = space->select.sel_info.hslab->diminfo.low_bounds;
+    if (space->select.sel_info.hslab->diminfo_valid == H5S_DIMINFO_VALID_YES) {
+        low_bounds  = space->select.sel_info.hslab->diminfo.low_bounds;
         high_bounds = space->select.sel_info.hslab->diminfo.high_bounds;
     } /* end if */
     else {
-        low_bounds = space->select.sel_info.hslab->span_lst->low_bounds;
+        low_bounds  = space->select.sel_info.hslab->span_lst->low_bounds;
         high_bounds = space->select.sel_info.hslab->span_lst->high_bounds;
     } /* end else */
 
     /* Check for offset set */
-    if(space->select.offset_changed) {
-        unsigned u;                 /* Local index variable */
+    if (space->select.offset_changed) {
+        unsigned u; /* Local index variable */
 
         /* Loop over dimensions */
-        for(u = 0; u < space->extent.rank; u++) {
+        for (u = 0; u < space->extent.rank; u++) {
             /* Sanity check */
             HDassert(low_bounds[u] <= high_bounds[u]);
 
             /* Check for offset moving selection negative */
-            if(((hssize_t)low_bounds[u] + space->select.offset[u]) < 0)
+            if (((hssize_t)low_bounds[u] + space->select.offset[u]) < 0)
                 HGOTO_ERROR(H5E_DATASPACE, H5E_BADRANGE, FAIL, "offset moves selection out of bounds")
 
             /* Set the low & high bounds in this dimension */
             start[u] = (hsize_t)((hssize_t)low_bounds[u] + space->select.offset[u]);
-            if((int)u == space->select.sel_info.hslab->unlim_dim)
+            if ((int)u == space->select.sel_info.hslab->unlim_dim)
                 end[u] = H5S_UNLIMITED;
             else
                 end[u] = (hsize_t)((hssize_t)high_bounds[u] + space->select.offset[u]);
         } /* end for */
-    } /* end if */
+    }     /* end if */
     else {
         /* Offset vector is still zeros, just copy low & high bounds */
         H5MM_memcpy(start, low_bounds, sizeof(hsize_t) * space->extent.rank);
@@ -4890,7 +4874,6 @@ done:
     FUNC_LEAVE_NOAPI(ret_value)
 } /* end H5S__hyper_bounds() */
 
-
 /*--------------------------------------------------------------------------
  NAME
     H5S__hyper_offset
@@ -4914,38 +4897,40 @@ done:
 static herr_t
 H5S__hyper_offset(const H5S_t *space, hsize_t *offset)
 {
-    const hssize_t *sel_offset; /* Pointer to the selection's offset */
-    const hsize_t *dim_size;    /* Pointer to a dataspace's extent */
-    hsize_t accum;              /* Accumulator for dimension sizes */
-    unsigned rank;              /* Dataspace rank */
-    int i;                      /* index variable */
-    herr_t ret_value = SUCCEED; /* Return value */
+    const hssize_t *sel_offset;          /* Pointer to the selection's offset */
+    const hsize_t * dim_size;            /* Pointer to a dataspace's extent */
+    hsize_t         accum;               /* Accumulator for dimension sizes */
+    unsigned        rank;                /* Dataspace rank */
+    int             i;                   /* index variable */
+    herr_t          ret_value = SUCCEED; /* Return value */
 
     FUNC_ENTER_STATIC
 
-    HDassert(space && space->extent.rank>0);
+    HDassert(space && space->extent.rank > 0);
     HDassert(offset);
 
     /* Start at linear offset 0 */
     *offset = 0;
 
     /* Set up pointers to arrays of values */
-    rank = space->extent.rank;
+    rank       = space->extent.rank;
     sel_offset = space->select.offset;
-    dim_size = space->extent.size;
+    dim_size   = space->extent.size;
 
     /* Check for a "regular" hyperslab selection */
     /* (No need to rebuild the dimension info yet -QAK) */
-    if(space->select.sel_info.hslab->diminfo_valid == H5S_DIMINFO_VALID_YES) {
-        const H5S_hyper_dim_t *diminfo = space->select.sel_info.hslab->diminfo.opt; /* Local alias for diminfo */
+    if (space->select.sel_info.hslab->diminfo_valid == H5S_DIMINFO_VALID_YES) {
+        const H5S_hyper_dim_t *diminfo =
+            space->select.sel_info.hslab->diminfo.opt; /* Local alias for diminfo */
 
         /* Loop through starting coordinates, calculating the linear offset */
         accum = 1;
-        for(i = (int)(rank - 1); i >= 0; i--) {
-            hssize_t hyp_offset = (hssize_t)diminfo[i].start + sel_offset[i]; /* Hyperslab's offset in this dimension */
+        for (i = (int)(rank - 1); i >= 0; i--) {
+            hssize_t hyp_offset =
+                (hssize_t)diminfo[i].start + sel_offset[i]; /* Hyperslab's offset in this dimension */
 
             /* Check for offset moving selection out of the dataspace */
-            if(hyp_offset < 0 || (hsize_t)hyp_offset >= dim_size[i])
+            if (hyp_offset < 0 || (hsize_t)hyp_offset >= dim_size[i])
                 HGOTO_ERROR(H5E_DATASPACE, H5E_BADRANGE, FAIL, "offset moves selection out of bounds")
 
             /* Add the hyperslab's offset in this dimension to the total linear offset */
@@ -4954,14 +4939,14 @@ H5S__hyper_offset(const H5S_t *space, hsize_t *offset)
             /* Increase the accumulator */
             accum *= dim_size[i];
         } /* end for */
-    } /* end if */
+    }     /* end if */
     else {
-        const H5S_hyper_span_t *span;           /* Hyperslab span node */
-        hsize_t dim_accum[H5S_MAX_RANK];        /* Accumulators, for each dimension */
+        const H5S_hyper_span_t *span;                    /* Hyperslab span node */
+        hsize_t                 dim_accum[H5S_MAX_RANK]; /* Accumulators, for each dimension */
 
         /* Calculate the accumulator for each dimension */
         accum = 1;
-        for(i = (int)(rank - 1); i >= 0; i--) {
+        for (i = (int)(rank - 1); i >= 0; i--) {
             /* Set the accumulator for this dimension */
             dim_accum[i] = accum;
 
@@ -4974,18 +4959,19 @@ H5S__hyper_offset(const H5S_t *space, hsize_t *offset)
 
         /* Work down the spans, computing the linear offset */
         i = 0;
-        while(span) {
-            hssize_t hyp_offset = (hssize_t)span->low + sel_offset[i]; /* Hyperslab's offset in this dimension */
+        while (span) {
+            hssize_t hyp_offset =
+                (hssize_t)span->low + sel_offset[i]; /* Hyperslab's offset in this dimension */
 
             /* Check for offset moving selection out of the dataspace */
-            if(hyp_offset < 0 || (hsize_t)hyp_offset >= dim_size[i])
+            if (hyp_offset < 0 || (hsize_t)hyp_offset >= dim_size[i])
                 HGOTO_ERROR(H5E_DATASPACE, H5E_BADRANGE, FAIL, "offset moves selection out of bounds")
 
             /* Add the hyperslab's offset in this dimension to the total linear offset */
             *offset += (hsize_t)(hyp_offset * (hssize_t)dim_accum[i]);
 
             /* Advance to first span in "down" dimension */
-            if(span->down) {
+            if (span->down) {
                 HDassert(span->down->head);
                 span = span->down->head;
             } /* end if */
@@ -4993,13 +4979,12 @@ H5S__hyper_offset(const H5S_t *space, hsize_t *offset)
                 span = NULL;
             i++;
         } /* end while */
-    } /* end else */
+    }     /* end else */
 
 done:
     FUNC_LEAVE_NOAPI(ret_value)
 } /* end H5S__hyper_offset() */
 
-
 /*--------------------------------------------------------------------------
  NAME
     H5S__hyper_unlim_dim
@@ -5026,7 +5011,6 @@ H5S__hyper_unlim_dim(const H5S_t *space)
     FUNC_LEAVE_NOAPI(space->select.sel_info.hslab->unlim_dim);
 } /* end H5S__hyper_unlim_dim() */
 
-
 /*--------------------------------------------------------------------------
  NAME
     H5S__hyper_num_elem_non_unlim
@@ -5059,7 +5043,7 @@ H5S__hyper_num_elem_non_unlim(const H5S_t *space, hsize_t *num_elem_non_unlim)
     HDassert(num_elem_non_unlim);
 
     /* Get number of elements in the non-unlimited dimensions */
-    if(space->select.sel_info.hslab->unlim_dim >= 0)
+    if (space->select.sel_info.hslab->unlim_dim >= 0)
         *num_elem_non_unlim = space->select.sel_info.hslab->num_elem_non_unlim;
     else
         HGOTO_ERROR(H5E_DATASPACE, H5E_BADVALUE, FAIL, "selection has no unlimited dimension")
@@ -5068,7 +5052,6 @@ done:
     FUNC_LEAVE_NOAPI(ret_value)
 } /* end H5S__hyper_num_elem_non_unlim() */
 
-
 /*--------------------------------------------------------------------------
  NAME
     H5S__hyper_is_contiguous
@@ -5090,10 +5073,10 @@ done:
 static H5_ATTR_PURE htri_t
 H5S__hyper_is_contiguous(const H5S_t *space)
 {
-    hbool_t small_contiguous,       /* Flag for small contiguous block */
-        large_contiguous;           /* Flag for large contiguous block */
-    unsigned u;                     /* index variable */
-    htri_t ret_value = FALSE;       /* Return value */
+    hbool_t small_contiguous,   /* Flag for small contiguous block */
+        large_contiguous;       /* Flag for large contiguous block */
+    unsigned u;                 /* index variable */
+    htri_t   ret_value = FALSE; /* Return value */
 
     FUNC_ENTER_STATIC_NOERR
 
@@ -5101,8 +5084,9 @@ H5S__hyper_is_contiguous(const H5S_t *space)
 
     /* Check for a "regular" hyperslab selection */
     /* (No need to rebuild the dimension info yet -QAK) */
-    if(space->select.sel_info.hslab->diminfo_valid == H5S_DIMINFO_VALID_YES) {
-        const H5S_hyper_dim_t *diminfo=space->select.sel_info.hslab->diminfo.opt; /* local alias for diminfo */
+    if (space->select.sel_info.hslab->diminfo_valid == H5S_DIMINFO_VALID_YES) {
+        const H5S_hyper_dim_t *diminfo =
+            space->select.sel_info.hslab->diminfo.opt; /* local alias for diminfo */
 
         /*
          * For a regular hyperslab to be contiguous, it must have only one
@@ -5118,43 +5102,43 @@ H5S__hyper_is_contiguous(const H5S_t *space)
          */
 
         /* Initialize flags */
-        large_contiguous = TRUE;    /* assume true and reset if the dimensions don't match */
-        small_contiguous = FALSE;    /* assume false initially */
+        large_contiguous = TRUE;  /* assume true and reset if the dimensions don't match */
+        small_contiguous = FALSE; /* assume false initially */
 
         /* Check for a "large contigous" block */
-        for(u = 0; u < space->extent.rank; u++) {
-            if(diminfo[u].count > 1) {
+        for (u = 0; u < space->extent.rank; u++) {
+            if (diminfo[u].count > 1) {
                 large_contiguous = FALSE;
                 break;
             } /* end if */
-            if(u > 0 && diminfo[u].block != space->extent.size[u]) {
+            if (u > 0 && diminfo[u].block != space->extent.size[u]) {
                 large_contiguous = FALSE;
                 break;
             } /* end if */
-        } /* end for */
+        }     /* end for */
 
         /* If we didn't find a large contiguous block, check for a small one */
-        if(!large_contiguous) {
+        if (!large_contiguous) {
             small_contiguous = TRUE;
-            for(u = 0; u < space->extent.rank; u++) {
-                if(diminfo[u].count > 1) {
+            for (u = 0; u < space->extent.rank; u++) {
+                if (diminfo[u].count > 1) {
                     small_contiguous = FALSE;
                     break;
                 } /* end if */
-                if(u < (space->extent.rank - 1) && diminfo[u].block != 1) {
+                if (u < (space->extent.rank - 1) && diminfo[u].block != 1) {
                     small_contiguous = FALSE;
                     break;
                 } /* end if */
-            } /* end for */
-        } /* end if */
+            }     /* end for */
+        }         /* end if */
 
         /* Indicate true if it's either a large or small contiguous block */
-        if(large_contiguous || small_contiguous)
+        if (large_contiguous || small_contiguous)
             ret_value = TRUE;
     } /* end if */
     else {
-        H5S_hyper_span_info_t *spans;   /* Hyperslab span info node */
-        H5S_hyper_span_t *span;         /* Hyperslab span node */
+        H5S_hyper_span_info_t *spans; /* Hyperslab span info node */
+        H5S_hyper_span_t *     span;  /* Hyperslab span node */
 
         /*
          * For a hyperslab to be contiguous, it must have only one block and
@@ -5164,36 +5148,37 @@ H5S__hyper_is_contiguous(const H5S_t *space)
          *      block size must be 1 in all but the fastest changing dimension.
          */
         /* Initialize flags */
-        large_contiguous = TRUE;    /* assume true and reset if the dimensions don't match */
-        small_contiguous = FALSE;    /* assume false initially */
+        large_contiguous = TRUE;  /* assume true and reset if the dimensions don't match */
+        small_contiguous = FALSE; /* assume false initially */
 
         /* Get information for slowest changing information */
         spans = space->select.sel_info.hslab->span_lst;
-        span = spans->head;
+        span  = spans->head;
 
         /* If there are multiple spans in the slowest changing dimension, the selection isn't contiguous */
-        if(span->next != NULL)
+        if (span->next != NULL)
             large_contiguous = FALSE;
         else {
             /* Now check the rest of the dimensions */
-            if(span->down != NULL) {
-                u = 1;    /* Current dimension working on */
+            if (span->down != NULL) {
+                u = 1; /* Current dimension working on */
 
                 /* Get the span information for the next fastest dimension */
                 spans = span->down;
 
                 /* Cycle down the spans until we run out of down spans or find a non-contiguous span */
-                while(spans != NULL) {
+                while (spans != NULL) {
                     span = spans->head;
 
                     /* Check that this is the only span and it spans the entire dimension */
-                    if(span->next != NULL) {
+                    if (span->next != NULL) {
                         large_contiguous = FALSE;
                         break;
                     } /* end if */
                     else {
-                        /* If this span doesn't cover the entire dimension, then this selection isn't contiguous */
-                        if(((span->high - span->low) + 1) != space->extent.size[u]) {
+                        /* If this span doesn't cover the entire dimension, then this selection isn't
+                         * contiguous */
+                        if (((span->high - span->low) + 1) != space->extent.size[u]) {
                             large_contiguous = FALSE;
                             break;
                         } /* end if */
@@ -5204,34 +5189,35 @@ H5S__hyper_is_contiguous(const H5S_t *space)
                             /* Increment dimension */
                             u++;
                         } /* end else */
-                    } /* end else */
-                } /* end while */
-            } /* end if */
-        } /* end else */
+                    }     /* end else */
+                }         /* end while */
+            }             /* end if */
+        }                 /* end else */
 
         /* If we didn't find a large contiguous block, check for a small one */
-        if(!large_contiguous) {
+        if (!large_contiguous) {
             small_contiguous = TRUE;
 
             /* Get information for slowest changing information */
             spans = space->select.sel_info.hslab->span_lst;
-            span = spans->head;
+            span  = spans->head;
 
             /* Current dimension working on */
             u = 0;
 
             /* Cycle down the spans until we run out of down spans or find a non-contiguous span */
-            while(spans != NULL) {
+            while (spans != NULL) {
                 span = spans->head;
 
                 /* Check that this is the only span and it spans the entire dimension */
-                if(span->next != NULL) {
+                if (span->next != NULL) {
                     small_contiguous = FALSE;
                     break;
                 } /* end if */
                 else {
-                    /* If this span doesn't cover the entire dimension, then this selection isn't contiguous */
-                    if(u < (space->extent.rank - 1) && ((span->high-span->low) + 1) != 1) {
+                    /* If this span doesn't cover the entire dimension, then this selection isn't contiguous
+                     */
+                    if (u < (space->extent.rank - 1) && ((span->high - span->low) + 1) != 1) {
                         small_contiguous = FALSE;
                         break;
                     } /* end if */
@@ -5242,19 +5228,18 @@ H5S__hyper_is_contiguous(const H5S_t *space)
                         /* Increment dimension */
                         u++;
                     } /* end else */
-                } /* end else */
-            } /* end while */
-        } /* end if */
+                }     /* end else */
+            }         /* end while */
+        }             /* end if */
 
         /* Indicate true if it's either a large or small contiguous block */
-        if(large_contiguous || small_contiguous)
+        if (large_contiguous || small_contiguous)
             ret_value = TRUE;
     } /* end else */
 
     FUNC_LEAVE_NOAPI(ret_value)
 } /* end H5S__hyper_is_contiguous() */
 
-
 /*--------------------------------------------------------------------------
  NAME
     H5S__hyper_is_single
@@ -5276,7 +5261,7 @@ H5S__hyper_is_contiguous(const H5S_t *space)
 static H5_ATTR_PURE htri_t
 H5S__hyper_is_single(const H5S_t *space)
 {
-    htri_t ret_value = TRUE;        /* return value */
+    htri_t ret_value = TRUE; /* return value */
 
     FUNC_ENTER_STATIC_NOERR
 
@@ -5286,8 +5271,8 @@ H5S__hyper_is_single(const H5S_t *space)
     /* (No need to rebuild the dimension info yet, since the span-tree
      *  algorithm is fast -QAK)
      */
-    if(space->select.sel_info.hslab->diminfo_valid == H5S_DIMINFO_VALID_YES) {
-        unsigned u;                     /* index variable */
+    if (space->select.sel_info.hslab->diminfo_valid == H5S_DIMINFO_VALID_YES) {
+        unsigned u; /* index variable */
 
         /*
          * For a regular hyperslab to be single, it must have only one
@@ -5295,12 +5280,12 @@ H5S__hyper_is_single(const H5S_t *space)
          */
 
         /* Check for a single block */
-        for(u = 0; u < space->extent.rank; u++)
-            if(space->select.sel_info.hslab->diminfo.opt[u].count > 1)
+        for (u = 0; u < space->extent.rank; u++)
+            if (space->select.sel_info.hslab->diminfo.opt[u].count > 1)
                 HGOTO_DONE(FALSE)
     } /* end if */
     else {
-        H5S_hyper_span_info_t *spans;   /* Hyperslab span info node */
+        H5S_hyper_span_info_t *spans; /* Hyperslab span info node */
 
         /*
          * For a region to be single, it must have only one block
@@ -5309,25 +5294,24 @@ H5S__hyper_is_single(const H5S_t *space)
         spans = space->select.sel_info.hslab->span_lst;
 
         /* Cycle down the spans until we run out of down spans or find a non-contiguous span */
-        while(spans != NULL) {
-            H5S_hyper_span_t *span;         /* Hyperslab span node */
+        while (spans != NULL) {
+            H5S_hyper_span_t *span; /* Hyperslab span node */
 
             span = spans->head;
 
             /* Check that this is the only span and it spans the entire dimension */
-            if(span->next != NULL)
+            if (span->next != NULL)
                 HGOTO_DONE(FALSE)
             else
                 /* Walk down to the next span */
                 spans = span->down;
         } /* end while */
-    } /* end else */
+    }     /* end else */
 
 done:
     FUNC_LEAVE_NOAPI(ret_value)
 } /* end H5S__hyper_is_single() */
 
-
 /*--------------------------------------------------------------------------
  NAME
     H5S__hyper_is_regular
@@ -5350,7 +5334,7 @@ done:
 static htri_t
 H5S__hyper_is_regular(const H5S_t *space)
 {
-    htri_t ret_value = FAIL;    /* return value */
+    htri_t ret_value = FAIL; /* return value */
 
     FUNC_ENTER_STATIC_NOERR
 
@@ -5360,11 +5344,11 @@ H5S__hyper_is_regular(const H5S_t *space)
     /* Attempt to rebuild diminfo if it is invalid and has not been confirmed
      * to be impossible.
      */
-    if(space->select.sel_info.hslab->diminfo_valid == H5S_DIMINFO_VALID_NO)
-        H5S__hyper_rebuild((H5S_t *)space);     /* Casting away const OK -NAF */
+    if (space->select.sel_info.hslab->diminfo_valid == H5S_DIMINFO_VALID_NO)
+        H5S__hyper_rebuild((H5S_t *)space); /* Casting away const OK -NAF */
 
     /* Only simple check for regular hyperslabs for now... */
-    if(space->select.sel_info.hslab->diminfo_valid == H5S_DIMINFO_VALID_YES)
+    if (space->select.sel_info.hslab->diminfo_valid == H5S_DIMINFO_VALID_YES)
         ret_value = TRUE;
     else
         ret_value = FALSE;
@@ -5372,7 +5356,6 @@ H5S__hyper_is_regular(const H5S_t *space)
     FUNC_LEAVE_NOAPI(ret_value)
 } /* end H5S__hyper_is_regular() */
 
-
 /*--------------------------------------------------------------------------
  NAME
     H5S__hyper_spans_shape_same_helper
@@ -5400,10 +5383,10 @@ H5S__hyper_is_regular(const H5S_t *space)
 --------------------------------------------------------------------------*/
 static H5_ATTR_PURE hbool_t
 H5S__hyper_spans_shape_same_helper(const H5S_hyper_span_info_t *span_info1,
-    const H5S_hyper_span_info_t *span_info2, hssize_t offset[],
-    hbool_t rest_zeros[])
+                                   const H5S_hyper_span_info_t *span_info2, hssize_t offset[],
+                                   hbool_t rest_zeros[])
 {
-    hbool_t ret_value = TRUE;   /* Return value */
+    hbool_t ret_value = TRUE; /* Return value */
 
     FUNC_ENTER_STATIC_NOERR
 
@@ -5417,9 +5400,9 @@ H5S__hyper_spans_shape_same_helper(const H5S_hyper_span_info_t *span_info1,
     /* (Could compare lower dimensions also, but not certain if
      *      that's worth it. - QAK, 2019/01/23)
      */
-    if((hsize_t)((hssize_t)span_info1->low_bounds[0] + offset[0]) != span_info2->low_bounds[0])
+    if ((hsize_t)((hssize_t)span_info1->low_bounds[0] + offset[0]) != span_info2->low_bounds[0])
         HGOTO_DONE(FALSE)
-    else if((hsize_t)((hssize_t)span_info1->high_bounds[0] + offset[0]) != span_info2->high_bounds[0])
+    else if ((hsize_t)((hssize_t)span_info1->high_bounds[0] + offset[0]) != span_info2->high_bounds[0])
         HGOTO_DONE(FALSE)
     else {
         const H5S_hyper_span_t *span1;
@@ -5434,37 +5417,39 @@ H5S__hyper_spans_shape_same_helper(const H5S_hyper_span_info_t *span_info1,
         HDassert(span2);
 
         /* infinite loop which must be broken out of */
-        while(1) {
+        while (1) {
             /* Check for both spans being NULL */
-            if(span1 == NULL && span2 == NULL)
+            if (span1 == NULL && span2 == NULL)
                 HGOTO_DONE(TRUE)
 
             /* Check for one span being NULL */
-            if(span1 == NULL || span2 == NULL)
+            if (span1 == NULL || span2 == NULL)
                 HGOTO_DONE(FALSE)
 
             /* Check if the actual low & high span information is the same */
-            if((hsize_t)((hssize_t)span1->low + offset[0]) != span2->low || (hsize_t)((hssize_t)span1->high + offset[0]) != span2->high)
+            if ((hsize_t)((hssize_t)span1->low + offset[0]) != span2->low ||
+                (hsize_t)((hssize_t)span1->high + offset[0]) != span2->high)
                 HGOTO_DONE(FALSE)
 
             /* Check for down tree for this span */
-            if(span1->down != NULL || span2->down != NULL) {
+            if (span1->down != NULL || span2->down != NULL) {
                 /* If the rest of the span trees have a zero offset, use the faster comparison routine */
-                if(rest_zeros[0]) {
-                    if(!H5S__hyper_cmp_spans(span1->down, span2->down))
+                if (rest_zeros[0]) {
+                    if (!H5S__hyper_cmp_spans(span1->down, span2->down))
                         HGOTO_DONE(FALSE)
                     else {
                         /* Keep going... */
                     } /* end else */
-                } /* end if */
+                }     /* end if */
                 else {
-                    if(!H5S__hyper_spans_shape_same_helper(span1->down, span2->down, &offset[1], &rest_zeros[1]))
+                    if (!H5S__hyper_spans_shape_same_helper(span1->down, span2->down, &offset[1],
+                                                            &rest_zeros[1]))
                         HGOTO_DONE(FALSE)
                     else {
                         /* Keep going... */
                     } /* end else */
-                } /* end else */
-            } /* end if */
+                }     /* end else */
+            }         /* end if */
             else {
                 /* Keep going... */
             } /* end else */
@@ -5473,7 +5458,7 @@ H5S__hyper_spans_shape_same_helper(const H5S_hyper_span_info_t *span_info1,
             span1 = span1->next;
             span2 = span2->next;
         } /* end while */
-    } /* end else */
+    }     /* end else */
 
     /* Fall through, with default return value of 'TRUE' if spans were already visited */
 
@@ -5481,7 +5466,6 @@ done:
     FUNC_LEAVE_NOAPI(ret_value)
 } /* end H5S__hyper_spans_shape_same_helper() */
 
-
 /*--------------------------------------------------------------------------
  NAME
     H5S__hyper_spans_shape_same
@@ -5503,16 +5487,16 @@ done:
  REVISION LOG
 --------------------------------------------------------------------------*/
 static H5_ATTR_PURE hbool_t
-H5S__hyper_spans_shape_same(const H5S_hyper_span_info_t *span_info1,
-    const H5S_hyper_span_info_t *span_info2, unsigned ndims)
+H5S__hyper_spans_shape_same(const H5S_hyper_span_info_t *span_info1, const H5S_hyper_span_info_t *span_info2,
+                            unsigned ndims)
 {
-    const H5S_hyper_span_t *span1;  /* Pointer to spans in first span tree */
-    const H5S_hyper_span_t *span2;  /* Pointer to spans in second span tree */
-    hssize_t offset[H5S_MAX_RANK];  /* Offset vector for selections */
-    hbool_t rest_zeros[H5S_MAX_RANK]; /* Vector of flags to indicate when remaining offset is all zero */
-    hbool_t zero_offset;            /* Whether the two selections have a non-zero offset */
-    unsigned u;                     /* Local index variable */
-    hbool_t ret_value = TRUE;       /* Return value */
+    const H5S_hyper_span_t *span1;                /* Pointer to spans in first span tree */
+    const H5S_hyper_span_t *span2;                /* Pointer to spans in second span tree */
+    hssize_t                offset[H5S_MAX_RANK]; /* Offset vector for selections */
+    hbool_t  rest_zeros[H5S_MAX_RANK]; /* Vector of flags to indicate when remaining offset is all zero */
+    hbool_t  zero_offset;              /* Whether the two selections have a non-zero offset */
+    unsigned u;                        /* Local index variable */
+    hbool_t  ret_value = TRUE;         /* Return value */
 
     FUNC_ENTER_STATIC_NOERR
 
@@ -5526,16 +5510,16 @@ H5S__hyper_spans_shape_same(const H5S_hyper_span_info_t *span_info1,
     HDmemset(rest_zeros, 0, sizeof(rest_zeros));
 
     /* Check for an offset between the two selections */
-    span1 = span_info1->head;
-    span2 = span_info2->head;
+    span1       = span_info1->head;
+    span2       = span_info2->head;
     zero_offset = TRUE;
-    for(u = 0; u < ndims; u++) {
+    for (u = 0; u < ndims; u++) {
         /* Check for offset in this dimension */
-        if(span1->low != span2->low) {
+        if (span1->low != span2->low) {
             offset[u] = (hssize_t)span2->low - (hssize_t)span1->low;
 
             /* Indicate that the offset vector is not all zeros */
-            if(zero_offset)
+            if (zero_offset)
                 zero_offset = FALSE;
         } /* end if */
 
@@ -5544,19 +5528,19 @@ H5S__hyper_spans_shape_same(const H5S_hyper_span_info_t *span_info1,
         HDassert((span1->down && span2->down) || (NULL == span1->down && NULL == span2->down));
 
         /* Advance to next dimension */
-        if(span1->down) {
+        if (span1->down) {
             span1 = span1->down->head;
             span2 = span2->down->head;
         } /* end if */
-    } /* end for */
+    }     /* end for */
 
     /* Check if there's a "tail" of all zeros in a non-zero offset vector */
-    if(!zero_offset) {
-        int i;          /* Local index variable */
+    if (!zero_offset) {
+        int i; /* Local index variable */
 
         /* Find first non-zero offset, from the fastest dimension up */
-        for(i = (int)(ndims - 1); i >= 0; i--)
-            if(offset[i]) {
+        for (i = (int)(ndims - 1); i >= 0; i--)
+            if (offset[i]) {
                 rest_zeros[i] = TRUE;
                 break;
             } /* end if */
@@ -5570,7 +5554,7 @@ H5S__hyper_spans_shape_same(const H5S_hyper_span_info_t *span_info1,
      *  comparison routine.  Otherwise, use a generalized version of that
      *  routine.
      */
-    if(zero_offset)
+    if (zero_offset)
         ret_value = H5S__hyper_cmp_spans(span_info1, span_info2);
     else
         ret_value = H5S__hyper_spans_shape_same_helper(span_info1, span_info2, offset, rest_zeros);
@@ -5578,7 +5562,6 @@ H5S__hyper_spans_shape_same(const H5S_hyper_span_info_t *span_info1,
     FUNC_LEAVE_NOAPI(ret_value)
 } /* end H5S__hyper_spans_shape_same() */
 
-
 /*--------------------------------------------------------------------------
  NAME
     H5S__hyper_shape_same
@@ -5606,9 +5589,9 @@ H5S__hyper_spans_shape_same(const H5S_hyper_span_info_t *span_info1,
 static htri_t
 H5S__hyper_shape_same(const H5S_t *space1, const H5S_t *space2)
 {
-    unsigned space1_rank;       /* Number of dimensions of first dataspace */
-    unsigned space2_rank;       /* Number of dimensions of second dataspace */
-    htri_t ret_value = TRUE;    /* Return value */
+    unsigned space1_rank;      /* Number of dimensions of first dataspace */
+    unsigned space2_rank;      /* Number of dimensions of second dataspace */
+    htri_t   ret_value = TRUE; /* Return value */
 
     FUNC_ENTER_STATIC
 
@@ -5626,16 +5609,16 @@ H5S__hyper_shape_same(const H5S_t *space1, const H5S_t *space2)
 
     /* Rebuild diminfo if it is invalid and has not been confirmed to be
      * impossible */
-    if(space1->select.sel_info.hslab->diminfo_valid == H5S_DIMINFO_VALID_NO)
-        H5S__hyper_rebuild((H5S_t *)space1);    /* Casting away const OK -QAK */
-    if(space2->select.sel_info.hslab->diminfo_valid == H5S_DIMINFO_VALID_NO)
-        H5S__hyper_rebuild((H5S_t *)space2);    /* Casting away const OK -QAK */
+    if (space1->select.sel_info.hslab->diminfo_valid == H5S_DIMINFO_VALID_NO)
+        H5S__hyper_rebuild((H5S_t *)space1); /* Casting away const OK -QAK */
+    if (space2->select.sel_info.hslab->diminfo_valid == H5S_DIMINFO_VALID_NO)
+        H5S__hyper_rebuild((H5S_t *)space2); /* Casting away const OK -QAK */
 
     /* If both are regular hyperslabs, compare their diminfo values */
-    if(space1->select.sel_info.hslab->diminfo_valid == H5S_DIMINFO_VALID_YES
-            && space2->select.sel_info.hslab->diminfo_valid == H5S_DIMINFO_VALID_YES) {
-        int space1_dim;         /* Current dimension in first dataspace */
-        int space2_dim;         /* Current dimension in second dataspace */
+    if (space1->select.sel_info.hslab->diminfo_valid == H5S_DIMINFO_VALID_YES &&
+        space2->select.sel_info.hslab->diminfo_valid == H5S_DIMINFO_VALID_YES) {
+        int space1_dim; /* Current dimension in first dataspace */
+        int space2_dim; /* Current dimension in second dataspace */
 
         /* Initialize dimensions */
         space1_dim = (int)space1_rank - 1;
@@ -5644,63 +5627,65 @@ H5S__hyper_shape_same(const H5S_t *space1, const H5S_t *space2)
         /* Check that the shapes are the same in the common dimensions, and that
          * block == 1 in all dimensions that appear only in space1.
          */
-        while(space2_dim >= 0) {
-            if(space1->select.sel_info.hslab->diminfo.opt[space1_dim].stride !=
-                    space2->select.sel_info.hslab->diminfo.opt[space2_dim].stride)
+        while (space2_dim >= 0) {
+            if (space1->select.sel_info.hslab->diminfo.opt[space1_dim].stride !=
+                space2->select.sel_info.hslab->diminfo.opt[space2_dim].stride)
                 HGOTO_DONE(FALSE)
 
-            if(space1->select.sel_info.hslab->diminfo.opt[space1_dim].count !=
-                    space2->select.sel_info.hslab->diminfo.opt[space2_dim].count)
+            if (space1->select.sel_info.hslab->diminfo.opt[space1_dim].count !=
+                space2->select.sel_info.hslab->diminfo.opt[space2_dim].count)
                 HGOTO_DONE(FALSE)
 
-            if(space1->select.sel_info.hslab->diminfo.opt[space1_dim].block !=
-                    space2->select.sel_info.hslab->diminfo.opt[space2_dim].block)
+            if (space1->select.sel_info.hslab->diminfo.opt[space1_dim].block !=
+                space2->select.sel_info.hslab->diminfo.opt[space2_dim].block)
                 HGOTO_DONE(FALSE)
 
             space1_dim--;
             space2_dim--;
         } /* end while */
 
-        while(space1_dim >= 0) {
-            if(space1->select.sel_info.hslab->diminfo.opt[space1_dim].block != 1)
+        while (space1_dim >= 0) {
+            if (space1->select.sel_info.hslab->diminfo.opt[space1_dim].block != 1)
                 HGOTO_DONE(FALSE)
 
             space1_dim--;
         } /* end while */
-    } /* end if */
+    }     /* end if */
     /* If both aren't regular, use fast irregular comparison */
     else {
-        H5S_hyper_span_info_t *spans1;     /* Hyperslab spans for first dataspace */
+        H5S_hyper_span_info_t *spans1; /* Hyperslab spans for first dataspace */
 
         /* Make certain that both selections have span trees */
-        if(NULL == space1->select.sel_info.hslab->span_lst)
-            if(H5S__hyper_generate_spans((H5S_t *)space1) < 0)  /* Casting away const OK -QAK */
-                HGOTO_ERROR(H5E_DATASPACE, H5E_UNINITIALIZED, FAIL, "can't construct span tree for hyperslab selection")
-        if(NULL == space2->select.sel_info.hslab->span_lst)
-            if(H5S__hyper_generate_spans((H5S_t *)space2) < 0)  /* Casting away const OK -QAK */
-                HGOTO_ERROR(H5E_DATASPACE, H5E_UNINITIALIZED, FAIL, "can't construct span tree for hyperslab selection")
+        if (NULL == space1->select.sel_info.hslab->span_lst)
+            if (H5S__hyper_generate_spans((H5S_t *)space1) < 0) /* Casting away const OK -QAK */
+                HGOTO_ERROR(H5E_DATASPACE, H5E_UNINITIALIZED, FAIL,
+                            "can't construct span tree for hyperslab selection")
+        if (NULL == space2->select.sel_info.hslab->span_lst)
+            if (H5S__hyper_generate_spans((H5S_t *)space2) < 0) /* Casting away const OK -QAK */
+                HGOTO_ERROR(H5E_DATASPACE, H5E_UNINITIALIZED, FAIL,
+                            "can't construct span tree for hyperslab selection")
 
         /* If rank of space A is different (guaranteed greater) than
          *      rank of space B, walk down the span tree, verifying
          *      that the block size is 1 on the way down.
          */
-        if(space1_rank > space2_rank) {
-            unsigned diff_rank = space1_rank - space2_rank;   /* Difference in ranks */
+        if (space1_rank > space2_rank) {
+            unsigned diff_rank = space1_rank - space2_rank; /* Difference in ranks */
 
             /* Walk down the dimensions */
             spans1 = space1->select.sel_info.hslab->span_lst;
-            while(diff_rank > 0) {
-                H5S_hyper_span_t *span;         /* Span for this dimension */
+            while (diff_rank > 0) {
+                H5S_hyper_span_t *span; /* Span for this dimension */
 
                 /* Get pointer to first span in tree */
                 span = spans1->head;
 
                 /* Check for more spans in this dimension */
-                if(span->next)
+                if (span->next)
                     HGOTO_DONE(FALSE)
 
                 /* Check for span size > 1 element */
-                if(span->low != span->high)
+                if (span->low != span->high)
                     HGOTO_DONE(FALSE)
 
                 /* Walk down to the next dimension */
@@ -5724,7 +5709,6 @@ done:
     FUNC_LEAVE_NOAPI(ret_value)
 } /* end H5S__hyper_shape_same() */
 
-
 /*--------------------------------------------------------------------------
  NAME
     H5S__hyper_release
@@ -5754,8 +5738,8 @@ H5S__hyper_release(H5S_t *space)
     space->select.num_elem = 0;
 
     /* Release irregular hyperslab information */
-    if(space->select.sel_info.hslab) {
-        if(space->select.sel_info.hslab->span_lst != NULL)
+    if (space->select.sel_info.hslab) {
+        if (space->select.sel_info.hslab->span_lst != NULL)
             H5S__hyper_free_span_info(space->select.sel_info.hslab->span_lst);
 
         /* Release space for the hyperslab selection information */
@@ -5765,7 +5749,6 @@ H5S__hyper_release(H5S_t *space)
     FUNC_LEAVE_NOAPI(SUCCEED)
 } /* end H5S__hyper_release() */
 
-
 /*--------------------------------------------------------------------------
  NAME
     H5S__hyper_coord_to_span
@@ -5787,9 +5770,9 @@ H5S__hyper_release(H5S_t *space)
 static H5S_hyper_span_t *
 H5S__hyper_coord_to_span(unsigned rank, const hsize_t *coords)
 {
-    H5S_hyper_span_t *new_span;         /* Pointer to new span tree for coordinate */
-    H5S_hyper_span_info_t *down = NULL; /* Pointer to new span tree for next level down */
-    H5S_hyper_span_t *ret_value = NULL; /* Return value */
+    H5S_hyper_span_t *     new_span;         /* Pointer to new span tree for coordinate */
+    H5S_hyper_span_info_t *down      = NULL; /* Pointer to new span tree for next level down */
+    H5S_hyper_span_t *     ret_value = NULL; /* Return value */
 
     FUNC_ENTER_STATIC
 
@@ -5797,9 +5780,9 @@ H5S__hyper_coord_to_span(unsigned rank, const hsize_t *coords)
     HDassert(coords);
 
     /* Search for location to insert new element in tree */
-    if(rank > 1) {
+    if (rank > 1) {
         /* Allocate a span info node for coordinates below this one */
-        if(NULL == (down = H5S__hyper_new_span_info(rank - 1)))
+        if (NULL == (down = H5S__hyper_new_span_info(rank - 1)))
             HGOTO_ERROR(H5E_DATASPACE, H5E_CANTALLOC, NULL, "can't allocate hyperslab span")
 
         /* Set the low & high bounds for this span info node */
@@ -5807,28 +5790,27 @@ H5S__hyper_coord_to_span(unsigned rank, const hsize_t *coords)
         H5MM_memcpy(down->high_bounds, &coords[1], (rank - 1) * sizeof(hsize_t));
 
         /* Build span tree for coordinates below this one */
-        if(NULL == (down->head = H5S__hyper_coord_to_span(rank - 1, &coords[1])))
+        if (NULL == (down->head = H5S__hyper_coord_to_span(rank - 1, &coords[1])))
             HGOTO_ERROR(H5E_DATASPACE, H5E_CANTALLOC, NULL, "can't allocate hyperslab span")
 
-       /* Update the tail pointer of the down dimension, and it's a single span element */
-       down->tail = down->head;
+        /* Update the tail pointer of the down dimension, and it's a single span element */
+        down->tail = down->head;
     } /* end if */
 
     /* Build span for this coordinate */
-    if(NULL == (new_span = H5S__hyper_new_span(coords[0], coords[0], down, NULL)))
+    if (NULL == (new_span = H5S__hyper_new_span(coords[0], coords[0], down, NULL)))
         HGOTO_ERROR(H5E_DATASPACE, H5E_CANTALLOC, NULL, "can't allocate hyperslab span")
 
     /* Set return value */
     ret_value = new_span;
 
 done:
-    if(ret_value == NULL && down != NULL)
+    if (ret_value == NULL && down != NULL)
         H5S__hyper_free_span_info(down);
 
     FUNC_LEAVE_NOAPI(ret_value)
 } /* end H5S__hyper_coord_to_span() */
 
-
 /*--------------------------------------------------------------------------
  NAME
     H5S__hyper_add_span_element_helper
@@ -5851,11 +5833,11 @@ done:
  REVISION LOG
 --------------------------------------------------------------------------*/
 static herr_t
-H5S__hyper_add_span_element_helper(H5S_hyper_span_info_t *span_tree,
-    unsigned rank, const hsize_t *coords, int *first_dim_modified)
+H5S__hyper_add_span_element_helper(H5S_hyper_span_info_t *span_tree, unsigned rank, const hsize_t *coords,
+                                   int *first_dim_modified)
 {
-    H5S_hyper_span_t *tail_span;        /* Pointer to the tail span of one dimension */
-    herr_t ret_value = SUCCEED;         /* Return value */
+    H5S_hyper_span_t *tail_span;           /* Pointer to the tail span of one dimension */
+    herr_t            ret_value = SUCCEED; /* Return value */
 
     FUNC_ENTER_STATIC
 
@@ -5870,24 +5852,24 @@ H5S__hyper_add_span_element_helper(H5S_hyper_span_info_t *span_tree,
 
     /* Determine if tail span includes a portion of the coordinate */
     /* (Should never happen with the lowest level in the span tree) */
-    if(coords[0] >= tail_span->low && coords[0] <= tail_span->high) {
-        H5S_hyper_span_t *prev_down_tail_span;  /* Pointer to previous down spans' tail pointer */
-        hsize_t prev_down_tail_span_high;       /* Value of previous down spans' tail's high value */
+    if (coords[0] >= tail_span->low && coords[0] <= tail_span->high) {
+        H5S_hyper_span_t *prev_down_tail_span;      /* Pointer to previous down spans' tail pointer */
+        hsize_t           prev_down_tail_span_high; /* Value of previous down spans' tail's high value */
 
         /* Retain into about down spans' tail */
-        prev_down_tail_span = tail_span->down->tail;
+        prev_down_tail_span      = tail_span->down->tail;
         prev_down_tail_span_high = tail_span->down->tail->high;
 
         /* Drop down a dimension */
         HDassert(rank > 1);
-        if(H5S__hyper_add_span_element_helper(tail_span->down, rank - 1, &coords[1], first_dim_modified) < 0)
+        if (H5S__hyper_add_span_element_helper(tail_span->down, rank - 1, &coords[1], first_dim_modified) < 0)
             HGOTO_ERROR(H5E_DATASET, H5E_CANTINSERT, FAIL, "can't insert coordinate into span tree")
 
         /* Check & update high bounds for lower dimensions */
-        if(*first_dim_modified >= 0) {
-            unsigned first_dim; /* First dimension modified, relative to this span tree */
-            hbool_t first_dim_set = FALSE;      /* Whether first dimension modified is set */
-            unsigned u;         /* Local index variable */
+        if (*first_dim_modified >= 0) {
+            unsigned first_dim;             /* First dimension modified, relative to this span tree */
+            hbool_t  first_dim_set = FALSE; /* Whether first dimension modified is set */
+            unsigned u;                     /* Local index variable */
 
             /* Adjust first dimension modified to be relative to this span tree */
             first_dim = (unsigned)(*first_dim_modified + 1);
@@ -5896,33 +5878,33 @@ H5S__hyper_add_span_element_helper(H5S_hyper_span_info_t *span_tree,
             *first_dim_modified = -1;
 
             /* Iterate through coordinates */
-            for(u = first_dim; u < rank; u++) {
+            for (u = first_dim; u < rank; u++) {
                 /* Check if coordinate is outside the bounds for this span tree */
-                if(coords[u] > span_tree->high_bounds[u]) {
+                if (coords[u] > span_tree->high_bounds[u]) {
                     /* Update high bounds for this tree */
                     span_tree->high_bounds[u] = coords[u];
 
                     /* Need to signal to higher dimensions if high bounds changed */
-                    if(!first_dim_set) {
+                    if (!first_dim_set) {
                         *first_dim_modified = (int)u;
-                        first_dim_set = TRUE;
+                        first_dim_set       = TRUE;
                     } /* end if */
-                } /* end if */
-            } /* end for */
-        } /* end if */
+                }     /* end if */
+            }         /* end for */
+        }             /* end if */
 
         /* Check if previous tail span in down spans is different than current
          * tail span, or if its high value changed, in which case we should
          * check if the updated node can share down spans with other nodes.
          */
-        if(tail_span->down->tail != prev_down_tail_span ||
-                prev_down_tail_span_high != tail_span->down->tail->high) {
+        if (tail_span->down->tail != prev_down_tail_span ||
+            prev_down_tail_span_high != tail_span->down->tail->high) {
             H5S_hyper_span_t *stop_span; /* Pointer to span to stop at */
-            H5S_hyper_span_t *tmp_span; /* Temporary pointer to a span */
-            uint64_t op_gen;            /* Operation generation value */
+            H5S_hyper_span_t *tmp_span;  /* Temporary pointer to a span */
+            uint64_t          op_gen;    /* Operation generation value */
 
             /* Determine which span to stop at */
-            if(tail_span->down->tail != prev_down_tail_span) {
+            if (tail_span->down->tail != prev_down_tail_span) {
                 /* Sanity check */
                 HDassert(prev_down_tail_span->next == tail_span->down->tail);
 
@@ -5948,23 +5930,23 @@ H5S__hyper_add_span_element_helper(H5S_hyper_span_info_t *span_tree,
              * information.
              */
             tmp_span = tail_span->down->head;
-            while(tmp_span != stop_span) {
-                hbool_t attempt_merge_spans = FALSE;    /* Whether to merge spans */
+            while (tmp_span != stop_span) {
+                hbool_t attempt_merge_spans = FALSE; /* Whether to merge spans */
 
                 /* Different tests for when to run the 'merge' algorithm,
                  * depending whether there's "down trees" or not.
                  */
-                if(NULL == tmp_span->down) {
+                if (NULL == tmp_span->down) {
                     /* Spin through spans until we find the one before the 'stop' span */
-                    if(tmp_span->next == stop_span)
+                    if (tmp_span->next == stop_span)
                         attempt_merge_spans = TRUE;
                 } /* end if */
                 else {
                     /* Check if we've compared the 'stop' span's "down tree" to
                      *      this span's "down tree" already.
                      */
-                    if(tmp_span->down->op_info[0].op_gen != op_gen) {
-                        if(H5S__hyper_cmp_spans(tmp_span->down, stop_span->down))
+                    if (tmp_span->down->op_info[0].op_gen != op_gen) {
+                        if (H5S__hyper_cmp_spans(tmp_span->down, stop_span->down))
                             attempt_merge_spans = TRUE;
 
                         /* Remember that we visited this span's "down tree" already */
@@ -5973,16 +5955,16 @@ H5S__hyper_add_span_element_helper(H5S_hyper_span_info_t *span_tree,
                          */
                         tmp_span->down->op_info[0].op_gen = op_gen;
                     } /* end if */
-                } /* end else */
+                }     /* end else */
 
                 /* Check for merging into previous span */
-                if(attempt_merge_spans) {
-                    if(tmp_span->high + 1 == stop_span->low) {
+                if (attempt_merge_spans) {
+                    if (tmp_span->high + 1 == stop_span->low) {
                         /* Increase size of previous span */
                         tmp_span->high++;
 
                         /* Update pointers appropriately */
-                        if(stop_span == prev_down_tail_span) {
+                        if (stop_span == prev_down_tail_span) {
                             /* Sanity check */
                             HDassert(stop_span->next == tail_span->down->tail);
 
@@ -5992,7 +5974,7 @@ H5S__hyper_add_span_element_helper(H5S_hyper_span_info_t *span_tree,
                             /* Sanity check */
                             HDassert(tmp_span->next == tail_span->down->tail);
 
-                            tmp_span->next = NULL;
+                            tmp_span->next        = NULL;
                             tail_span->down->tail = tmp_span;
                         } /* end else */
 
@@ -6001,7 +5983,7 @@ H5S__hyper_add_span_element_helper(H5S_hyper_span_info_t *span_tree,
                     } /* end if */
                     /* Span is disjoint, but has the same "down tree" selection */
                     /* (If it has a "down tree") */
-                    else if(stop_span->down) {
+                    else if (stop_span->down) {
                         /* Release "down tree" information */
                         H5S__hyper_free_span_info(stop_span->down);
 
@@ -6019,23 +6001,24 @@ H5S__hyper_add_span_element_helper(H5S_hyper_span_info_t *span_tree,
                 /* Advance to next span to check */
                 tmp_span = tmp_span->next;
             } /* end while */
-        } /* end if */
-    } /* end if */
+        }     /* end if */
+    }         /* end if */
     else {
-        unsigned u;                     /* Local index variable */
+        unsigned u; /* Local index variable */
 
         /* Check if we made it all the way to the bottom span list in the tree
          *      and the new coordinate adjoins the current tail span.
          */
-        if(rank == 1 && (tail_span->high + 1) == coords[0])
+        if (rank == 1 && (tail_span->high + 1) == coords[0])
             /* Append element to current tail span */
             tail_span->high++;
         else {
-            H5S_hyper_span_t *new_span;     /* New span created for element */
+            H5S_hyper_span_t *new_span; /* New span created for element */
 
             /* Make span tree for current coordinate(s) */
-            if(NULL == (new_span = H5S__hyper_coord_to_span(rank, coords)))
-                HGOTO_ERROR(H5E_DATASPACE, H5E_CANTALLOC, FAIL, "can't allocate hyperslab spans for coordinate")
+            if (NULL == (new_span = H5S__hyper_coord_to_span(rank, coords)))
+                HGOTO_ERROR(H5E_DATASPACE, H5E_CANTALLOC, FAIL,
+                            "can't allocate hyperslab spans for coordinate")
 
             /* Add new span to span tree list */
             tail_span->next = new_span;
@@ -6047,8 +6030,8 @@ H5S__hyper_add_span_element_helper(H5S_hyper_span_info_t *span_tree,
         span_tree->high_bounds[0] = coords[0];
 
         /* Update high bounds for dimensions below this one */
-        for(u = 1; u < rank; u++)
-            if(coords[u] > span_tree->high_bounds[u])
+        for (u = 1; u < rank; u++)
+            if (coords[u] > span_tree->high_bounds[u])
                 span_tree->high_bounds[u] = coords[u];
 
         /* Need to signal to higher dimensions that high bounds changed */
@@ -6059,7 +6042,6 @@ done:
     FUNC_LEAVE_NOAPI(ret_value)
 } /* end H5S__hyper_add_span_element_helper() */
 
-
 /*--------------------------------------------------------------------------
  NAME
     H5S_hyper_add_span_element
@@ -6101,8 +6083,8 @@ done:
 herr_t
 H5S_hyper_add_span_element(H5S_t *space, unsigned rank, const hsize_t *coords)
 {
-    H5S_hyper_span_info_t *head = NULL;    /* Pointer to new head of span tree */
-    herr_t      ret_value = SUCCEED;       /* Return value */
+    H5S_hyper_span_info_t *head      = NULL;    /* Pointer to new head of span tree */
+    herr_t                 ret_value = SUCCEED; /* Return value */
 
     FUNC_ENTER_NOAPI(FAIL)
 
@@ -6112,9 +6094,9 @@ H5S_hyper_add_span_element(H5S_t *space, unsigned rank, const hsize_t *coords)
     HDassert(space->extent.rank == rank);
 
     /* Check if this is the first element in the selection */
-    if(NULL == space->select.sel_info.hslab) {
+    if (NULL == space->select.sel_info.hslab) {
         /* Allocate a span info node */
-        if(NULL == (head = H5S__hyper_new_span_info(rank)))
+        if (NULL == (head = H5S__hyper_new_span_info(rank)))
             HGOTO_ERROR(H5E_DATASPACE, H5E_CANTALLOC, FAIL, "can't allocate hyperslab span info")
 
         /* Set the low & high bounds for this span info node */
@@ -6125,14 +6107,14 @@ H5S_hyper_add_span_element(H5S_t *space, unsigned rank, const hsize_t *coords)
         head->count = 1;
 
         /* Build span tree for this coordinate */
-        if(NULL == (head->head = H5S__hyper_coord_to_span(rank, coords)))
+        if (NULL == (head->head = H5S__hyper_coord_to_span(rank, coords)))
             HGOTO_ERROR(H5E_DATASPACE, H5E_CANTALLOC, FAIL, "can't allocate hyperslab spans for coordinate")
 
         /* Update the tail pointer of this newly created span in dimension "rank" */
         head->tail = head->head;
 
         /* Allocate selection info */
-        if(NULL == (space->select.sel_info.hslab = H5FL_MALLOC(H5S_hyper_sel_t)))
+        if (NULL == (space->select.sel_info.hslab = H5FL_MALLOC(H5S_hyper_sel_t)))
             HGOTO_ERROR(H5E_DATASPACE, H5E_CANTALLOC, FAIL, "can't allocate hyperslab selection")
 
         /* Set the selection to the new span tree */
@@ -6151,10 +6133,11 @@ H5S_hyper_add_span_element(H5S_t *space, unsigned rank, const hsize_t *coords)
         space->select.num_elem = 1;
     } /* end if */
     else {
-        int first_dim_modified = -1;            /* Index of first dimension modified */
+        int first_dim_modified = -1; /* Index of first dimension modified */
 
         /* Add the element to the current set of spans */
-        if(H5S__hyper_add_span_element_helper(space->select.sel_info.hslab->span_lst, rank, coords, &first_dim_modified) < 0)
+        if (H5S__hyper_add_span_element_helper(space->select.sel_info.hslab->span_lst, rank, coords,
+                                               &first_dim_modified) < 0)
             HGOTO_ERROR(H5E_DATASPACE, H5E_CANTINSERT, FAIL, "can't insert coordinate into span tree")
 
         /* Increment # of elements in selection */
@@ -6162,14 +6145,13 @@ H5S_hyper_add_span_element(H5S_t *space, unsigned rank, const hsize_t *coords)
     } /* end else */
 
 done:
-    if(ret_value < 0)
-        if(head)
+    if (ret_value < 0)
+        if (head)
             H5S__hyper_free_span_info(head);
 
     FUNC_LEAVE_NOAPI(ret_value)
 } /* end H5S_hyper_add_span_element() */
 
-
 /*--------------------------------------------------------------------------
  NAME
     H5S__hyper_intersect_block_helper
@@ -6193,11 +6175,10 @@ done:
  REVISION LOG
 --------------------------------------------------------------------------*/
 static hbool_t
-H5S__hyper_intersect_block_helper(H5S_hyper_span_info_t *spans,
-    unsigned rank, const hsize_t *start, const hsize_t *end, unsigned op_info_i,
-    uint64_t op_gen)
+H5S__hyper_intersect_block_helper(H5S_hyper_span_info_t *spans, unsigned rank, const hsize_t *start,
+                                  const hsize_t *end, unsigned op_info_i, uint64_t op_gen)
 {
-    hbool_t ret_value = FALSE;      /* Return value */
+    hbool_t ret_value = FALSE; /* Return value */
 
     FUNC_ENTER_STATIC_NOERR
 
@@ -6207,47 +6188,48 @@ H5S__hyper_intersect_block_helper(H5S_hyper_span_info_t *spans,
     HDassert(end);
 
     /* Check if we've already visited this span tree */
-    if(spans->op_info[op_info_i].op_gen != op_gen) {
-        H5S_hyper_span_t *curr;         /* Pointer to current span in 1st span tree */
-        unsigned u;                     /* Local index variable */
+    if (spans->op_info[op_info_i].op_gen != op_gen) {
+        H5S_hyper_span_t *curr; /* Pointer to current span in 1st span tree */
+        unsigned          u;    /* Local index variable */
 
         /* Verify that there is a possibility of an overlap by checking the block
          *  against the low & high bounds for the span tree.
          */
-        for(u = 0; u < rank; u++)
-            if(start[u] > spans->high_bounds[u] || end[u] < spans->low_bounds[u])
+        for (u = 0; u < rank; u++)
+            if (start[u] > spans->high_bounds[u] || end[u] < spans->low_bounds[u])
                 HGOTO_DONE(FALSE)
 
         /* Get the span list for spans in this tree */
         curr = spans->head;
 
         /* Iterate over the spans in the tree */
-        while(curr != NULL) {
+        while (curr != NULL) {
             /* Check for span entirely before block */
-            if(curr->high < *start)
+            if (curr->high < *start)
                 /* Advance to next span in this dimension */
                 curr = curr->next;
             /* If this span is past the end of the block, then we're done in this dimension */
-            else if(curr->low > *end)
+            else if (curr->low > *end)
                 HGOTO_DONE(FALSE)
             /* block & span overlap */
             else {
                 /* If this is the bottom dimension, then the span tree overlaps the block */
-                if(curr->down == NULL)
+                if (curr->down == NULL)
                     HGOTO_DONE(TRUE)
                 /* Recursively check spans in next dimension down */
                 else {
                     /* If there is an intersection in the "down" dimensions,
                      * the span trees overlap.
                      */
-                    if(H5S__hyper_intersect_block_helper(curr->down, rank - 1, start + 1, end + 1, op_info_i, op_gen))
+                    if (H5S__hyper_intersect_block_helper(curr->down, rank - 1, start + 1, end + 1, op_info_i,
+                                                          op_gen))
                         HGOTO_DONE(TRUE)
 
                     /* No intersection in down dimensions, advance to next span */
                     curr = curr->next;
                 } /* end else */
-            } /* end else */
-        } /* end while */
+            }     /* end else */
+        }         /* end while */
 
         /* Set the tree's operation generation */
         spans->op_info[op_info_i].op_gen = op_gen;
@@ -6259,7 +6241,6 @@ done:
     FUNC_LEAVE_NOAPI(ret_value)
 } /* end H5S__hyper_intersect_block_helper() */
 
-
 /*--------------------------------------------------------------------------
  NAME
     H5S__hyper_intersect_block
@@ -6284,7 +6265,7 @@ done:
 static htri_t
 H5S__hyper_intersect_block(const H5S_t *space, const hsize_t *start, const hsize_t *end)
 {
-    htri_t ret_value = FAIL;    /* Return value */
+    htri_t ret_value = FAIL; /* Return value */
 
     FUNC_ENTER_STATIC_NOERR
 
@@ -6297,43 +6278,43 @@ H5S__hyper_intersect_block(const H5S_t *space, const hsize_t *start, const hsize
     /* Attempt to rebuild diminfo if it is invalid and has not been confirmed
      * to be impossible.
      */
-    if(space->select.sel_info.hslab->diminfo_valid == H5S_DIMINFO_VALID_NO)
-        H5S__hyper_rebuild((H5S_t *)space);     /* Casting away const OK -QAK */
+    if (space->select.sel_info.hslab->diminfo_valid == H5S_DIMINFO_VALID_NO)
+        H5S__hyper_rebuild((H5S_t *)space); /* Casting away const OK -QAK */
 
     /* Check for regular hyperslab intersection */
-    if(space->select.sel_info.hslab->diminfo_valid == H5S_DIMINFO_VALID_YES) {
-        hbool_t single_block;   /* Whether the regular selection is a single block */
-        unsigned u;             /* Local index variable */
+    if (space->select.sel_info.hslab->diminfo_valid == H5S_DIMINFO_VALID_YES) {
+        hbool_t  single_block; /* Whether the regular selection is a single block */
+        unsigned u;            /* Local index variable */
 
         /* Check for a single block */
         /* For a regular hyperslab to be single, it must have only one block
          * (i.e. count == 1 in all dimensions).
          */
         single_block = TRUE;
-        for(u = 0; u < space->extent.rank; u++)
-            if(space->select.sel_info.hslab->diminfo.opt[u].count > 1)
+        for (u = 0; u < space->extent.rank; u++)
+            if (space->select.sel_info.hslab->diminfo.opt[u].count > 1)
                 single_block = FALSE;
 
         /* Single blocks have already been "compared" above, in the low / high
          * bound checking, so just return TRUE if we've reached here - they
          * would have been rejected earlier, if they didn't intersect.
          */
-        if(single_block)
+        if (single_block)
             HGOTO_DONE(TRUE)
         else {
             /* Loop over the dimensions, checking for an intersection */
-            for(u = 0; u < space->extent.rank; u++) {
+            for (u = 0; u < space->extent.rank; u++) {
                 /* If the block's start is <= the hyperslab start, they intersect */
                 /* (So, if the start is > the hyperslab start, check more conditions) */
-                if(start[u] > space->select.sel_info.hslab->diminfo.opt[u].start) {
-                    hsize_t adj_start;  /* Start coord, adjusted for hyperslab selection parameters */
-                    hsize_t nstride;    /* Number of strides into the selection */
+                if (start[u] > space->select.sel_info.hslab->diminfo.opt[u].start) {
+                    hsize_t adj_start; /* Start coord, adjusted for hyperslab selection parameters */
+                    hsize_t nstride;   /* Number of strides into the selection */
 
                     /* Adjust start coord for selection's 'start' offset */
                     adj_start = start[u] - space->select.sel_info.hslab->diminfo.opt[u].start;
 
                     /* Compute # of strides into the selection */
-                    if(space->select.sel_info.hslab->diminfo.opt[u].count > 1)
+                    if (space->select.sel_info.hslab->diminfo.opt[u].count > 1)
                         nstride = adj_start / space->select.sel_info.hslab->diminfo.opt[u].stride;
                     else
                         nstride = 0;
@@ -6349,8 +6330,8 @@ H5S__hyper_intersect_block(const H5S_t *space, const hsize_t *start, const hsize
                     /* If the adjusted start doesn't fall within the first hyperslab
                      *  span, check for the block overlapping with the next one.
                      */
-                    if(adj_start >= space->select.sel_info.hslab->diminfo.opt[u].block) {
-                        hsize_t adj_end;    /* End coord, adjusted for hyperslab selection parameters */
+                    if (adj_start >= space->select.sel_info.hslab->diminfo.opt[u].block) {
+                        hsize_t adj_end; /* End coord, adjusted for hyperslab selection parameters */
 
                         /* Adjust end coord for selection's 'start' offset */
                         adj_end = end[u] - space->select.sel_info.hslab->diminfo.opt[u].start;
@@ -6363,20 +6344,20 @@ H5S__hyper_intersect_block(const H5S_t *space, const hsize_t *start, const hsize
                         /* If block doesn't extend over beginning of next span,
                          *  it doesn't intersect.
                          */
-                        if(adj_end < space->select.sel_info.hslab->diminfo.opt[u].stride)
+                        if (adj_end < space->select.sel_info.hslab->diminfo.opt[u].stride)
                             HGOTO_DONE(FALSE)
                     } /* end if */
-                } /* end if */
-            } /* end for */
+                }     /* end if */
+            }         /* end for */
 
             /* If we've looped through all dimensions and none of them didn't
              *  overlap, then all of them do, so we report TRUE.
              */
             HGOTO_DONE(TRUE)
         } /* end else */
-    } /* end if */
+    }     /* end if */
     else {
-        uint64_t op_gen;            /* Operation generation value */
+        uint64_t op_gen; /* Operation generation value */
 
         /* Acquire an operation generation value for this operation */
         op_gen = H5S__hyper_get_op_gen();
@@ -6384,14 +6365,14 @@ H5S__hyper_intersect_block(const H5S_t *space, const hsize_t *start, const hsize
         /* Perform the span-by-span intersection check */
         /* Always use op_info[0] since we own this op_info, so there can be no
          * simultaneous operations */
-        ret_value = H5S__hyper_intersect_block_helper(space->select.sel_info.hslab->span_lst, space->extent.rank, start, end, 0, op_gen);
+        ret_value = H5S__hyper_intersect_block_helper(space->select.sel_info.hslab->span_lst,
+                                                      space->extent.rank, start, end, 0, op_gen);
     } /* end else */
 
 done:
     FUNC_LEAVE_NOAPI(ret_value)
 } /* end H5S__hyper_intersect_block() */
 
-
 /*--------------------------------------------------------------------------
  NAME
     H5S__hyper_adjust_u_helper
@@ -6414,8 +6395,8 @@ done:
  REVISION LOG
 --------------------------------------------------------------------------*/
 static void
-H5S__hyper_adjust_u_helper(H5S_hyper_span_info_t *spans, unsigned rank,
-    const hsize_t *offset, unsigned op_info_i, uint64_t op_gen)
+H5S__hyper_adjust_u_helper(H5S_hyper_span_info_t *spans, unsigned rank, const hsize_t *offset,
+                           unsigned op_info_i, uint64_t op_gen)
 {
     FUNC_ENTER_STATIC_NOERR
 
@@ -6424,12 +6405,12 @@ H5S__hyper_adjust_u_helper(H5S_hyper_span_info_t *spans, unsigned rank,
     HDassert(offset);
 
     /* Check if we've already set this span tree */
-    if(spans->op_info[op_info_i].op_gen != op_gen) {
-        H5S_hyper_span_t *span;     /* Pointer to current span in span tree */
-        unsigned u;                 /* Local index variable */
+    if (spans->op_info[op_info_i].op_gen != op_gen) {
+        H5S_hyper_span_t *span; /* Pointer to current span in span tree */
+        unsigned          u;    /* Local index variable */
 
         /* Adjust the span tree's low & high bounds */
-        for(u = 0; u < rank; u++) {
+        for (u = 0; u < rank; u++) {
             HDassert(spans->low_bounds[u] >= offset[u]);
             spans->low_bounds[u] -= offset[u];
             spans->high_bounds[u] -= offset[u];
@@ -6437,14 +6418,14 @@ H5S__hyper_adjust_u_helper(H5S_hyper_span_info_t *spans, unsigned rank,
 
         /* Iterate over the spans in tree */
         span = spans->head;
-        while(span != NULL) {
+        while (span != NULL) {
             /* Adjust span offset */
             HDassert(span->low >= *offset);
             span->low -= *offset;
             span->high -= *offset;
 
             /* Recursively adjust spans in next dimension down */
-            if(span->down != NULL)
+            if (span->down != NULL)
                 H5S__hyper_adjust_u_helper(span->down, rank - 1, offset + 1, op_info_i, op_gen);
 
             /* Advance to next span in this dimension */
@@ -6458,7 +6439,6 @@ H5S__hyper_adjust_u_helper(H5S_hyper_span_info_t *spans, unsigned rank,
     FUNC_LEAVE_NOAPI_VOID
 } /* end H5S__hyper_adjust_u_helper() */
 
-
 /*--------------------------------------------------------------------------
  NAME
     H5S__hyper_adjust_u
@@ -6480,8 +6460,8 @@ H5S__hyper_adjust_u_helper(H5S_hyper_span_info_t *spans, unsigned rank,
 static herr_t
 H5S__hyper_adjust_u(H5S_t *space, const hsize_t *offset)
 {
-    hbool_t non_zero_offset = FALSE;    /* Whether any offset is non-zero */
-    unsigned u;                         /* Local index variable */
+    hbool_t  non_zero_offset = FALSE; /* Whether any offset is non-zero */
+    unsigned u;                       /* Local index variable */
 
     FUNC_ENTER_STATIC_NOERR
 
@@ -6490,18 +6470,18 @@ H5S__hyper_adjust_u(H5S_t *space, const hsize_t *offset)
     HDassert(offset);
 
     /* Check for an all-zero offset vector */
-    for(u = 0; u < space->extent.rank; u++)
-        if(0 != offset[u]) {
+    for (u = 0; u < space->extent.rank; u++)
+        if (0 != offset[u]) {
             non_zero_offset = TRUE;
             break;
         }
 
     /* Only perform operation if the offset is non-zero */
-    if(non_zero_offset) {
+    if (non_zero_offset) {
         /* Subtract the offset from the "regular" coordinates, if they exist */
         /* (No need to rebuild the dimension info yet -QAK) */
-        if(space->select.sel_info.hslab->diminfo_valid == H5S_DIMINFO_VALID_YES) {
-            for(u = 0; u < space->extent.rank; u++) {
+        if (space->select.sel_info.hslab->diminfo_valid == H5S_DIMINFO_VALID_YES) {
+            for (u = 0; u < space->extent.rank; u++) {
                 HDassert(space->select.sel_info.hslab->diminfo.opt[u].start >= offset[u]);
                 space->select.sel_info.hslab->diminfo.opt[u].start -= offset[u];
 
@@ -6510,11 +6490,11 @@ H5S__hyper_adjust_u(H5S_t *space, const hsize_t *offset)
                 space->select.sel_info.hslab->diminfo.low_bounds[u] -= offset[u];
                 space->select.sel_info.hslab->diminfo.high_bounds[u] -= offset[u];
             } /* end for */
-        } /* end if */
+        }     /* end if */
 
         /* Subtract the offset from the span tree coordinates, if they exist */
-        if(space->select.sel_info.hslab->span_lst) {
-            uint64_t op_gen;            /* Operation generation value */
+        if (space->select.sel_info.hslab->span_lst) {
+            uint64_t op_gen; /* Operation generation value */
 
             /* Acquire an operation generation value for this operation */
             op_gen = H5S__hyper_get_op_gen();
@@ -6522,14 +6502,14 @@ H5S__hyper_adjust_u(H5S_t *space, const hsize_t *offset)
             /* Perform adjustment */
             /* Always use op_info[0] since we own this op_info, so there can be no
              * simultaneous operations */
-            H5S__hyper_adjust_u_helper(space->select.sel_info.hslab->span_lst, space->extent.rank, offset, 0, op_gen);
+            H5S__hyper_adjust_u_helper(space->select.sel_info.hslab->span_lst, space->extent.rank, offset, 0,
+                                       op_gen);
         } /* end if */
-    } /* end if */
+    }     /* end if */
 
     FUNC_LEAVE_NOAPI(SUCCEED)
 } /* end H5S__hyper_adjust_u() */
 
-
 /*-------------------------------------------------------------------------
  * Function:    H5S__hyper_project_scalar
  *
@@ -6546,7 +6526,7 @@ H5S__hyper_adjust_u(H5S_t *space, const hsize_t *offset)
 static herr_t
 H5S__hyper_project_scalar(const H5S_t *space, hsize_t *offset)
 {
-    hsize_t block[H5S_MAX_RANK];        /* Block selected in base dataspace */
+    hsize_t block[H5S_MAX_RANK]; /* Block selected in base dataspace */
 
     FUNC_ENTER_STATIC_NOERR
 
@@ -6556,12 +6536,13 @@ H5S__hyper_project_scalar(const H5S_t *space, hsize_t *offset)
 
     /* Check for a "regular" hyperslab selection */
     /* (No need to rebuild the dimension info yet -QAK) */
-    if(space->select.sel_info.hslab->diminfo_valid == H5S_DIMINFO_VALID_YES) {
-        const H5S_hyper_dim_t *diminfo = space->select.sel_info.hslab->diminfo.opt; /* Alias for dataspace's diminfo information */
-        unsigned u;                 /* Counter */
+    if (space->select.sel_info.hslab->diminfo_valid == H5S_DIMINFO_VALID_YES) {
+        const H5S_hyper_dim_t *diminfo =
+            space->select.sel_info.hslab->diminfo.opt; /* Alias for dataspace's diminfo information */
+        unsigned u;                                    /* Counter */
 
         /* Build the table of the initial offset */
-        for(u = 0; u < space->extent.rank; u++) {
+        for (u = 0; u < space->extent.rank; u++) {
             /* Sanity check diminfo */
             HDassert(1 == diminfo[u].count);
             HDassert(1 == diminfo[u].block);
@@ -6572,15 +6553,15 @@ H5S__hyper_project_scalar(const H5S_t *space, hsize_t *offset)
             /* Keep the offset for later */
             block[u] = diminfo[u].start;
         } /* end for */
-    } /* end if */
+    }     /* end if */
     else {
-        const H5S_hyper_span_t *curr;           /* Pointer to current hyperslab span */
-        unsigned curr_dim;                      /* Current dimension being operated on */
+        const H5S_hyper_span_t *curr;     /* Pointer to current hyperslab span */
+        unsigned                curr_dim; /* Current dimension being operated on */
 
         /* Advance down selected spans */
-        curr = space->select.sel_info.hslab->span_lst->head;
+        curr     = space->select.sel_info.hslab->span_lst->head;
         curr_dim = 0;
-        while(1) {
+        while (1) {
             /* Sanity checks */
             HDassert(NULL == curr->next);
             HDassert(curr->low == curr->high);
@@ -6590,14 +6571,14 @@ H5S__hyper_project_scalar(const H5S_t *space, hsize_t *offset)
             block[curr_dim] = curr->low;
 
             /* Advance down to next dimension */
-            if(curr->down) {
+            if (curr->down) {
                 curr = curr->down->head;
                 curr_dim++;
             } /* end if */
             else
                 break;
         } /* end while */
-    } /* end else */
+    }     /* end else */
 
     /* Calculate offset of selection in projected buffer */
     *offset = H5VM_array_offset(space->extent.rank, space->extent.size, block);
@@ -6605,7 +6586,6 @@ H5S__hyper_project_scalar(const H5S_t *space, hsize_t *offset)
     FUNC_LEAVE_NOAPI(SUCCEED)
 } /* end H5S__hyper_project_scalar() */
 
-
 /*-------------------------------------------------------------------------
  * Function:    H5S__hyper_project_simple_lower
  *
@@ -6622,8 +6602,8 @@ H5S__hyper_project_scalar(const H5S_t *space, hsize_t *offset)
 static herr_t
 H5S__hyper_project_simple_lower(const H5S_t *base_space, H5S_t *new_space)
 {
-    H5S_hyper_span_info_t *down;        /* Pointer to list of spans */
-    unsigned curr_dim;                  /* Current dimension being operated on */
+    H5S_hyper_span_info_t *down;     /* Pointer to list of spans */
+    unsigned               curr_dim; /* Current dimension being operated on */
 
     FUNC_ENTER_STATIC_NOERR
 
@@ -6633,9 +6613,9 @@ H5S__hyper_project_simple_lower(const H5S_t *base_space, H5S_t *new_space)
     HDassert(new_space->extent.rank < base_space->extent.rank);
 
     /* Walk down the span tree until we reach the selection to project */
-    down = base_space->select.sel_info.hslab->span_lst;
+    down     = base_space->select.sel_info.hslab->span_lst;
     curr_dim = 0;
-    while(down && curr_dim < (base_space->extent.rank - new_space->extent.rank)) {
+    while (down && curr_dim < (base_space->extent.rank - new_space->extent.rank)) {
         /* Sanity check */
         HDassert(NULL == down->head->next);
 
@@ -6652,7 +6632,6 @@ H5S__hyper_project_simple_lower(const H5S_t *base_space, H5S_t *new_space)
     FUNC_LEAVE_NOAPI(SUCCEED)
 } /* end H5S__hyper_project_simple_lower() */
 
-
 /*-------------------------------------------------------------------------
  * Function:    H5S__hyper_project_simple_higher
  *
@@ -6669,11 +6648,11 @@ H5S__hyper_project_simple_lower(const H5S_t *base_space, H5S_t *new_space)
 static herr_t
 H5S__hyper_project_simple_higher(const H5S_t *base_space, H5S_t *new_space)
 {
-    H5S_hyper_span_t *prev_span = NULL; /* Pointer to previous list of spans */
-    unsigned delta_rank;                /* Difference in dataspace ranks */
-    unsigned curr_dim;                  /* Current dimension being operated on */
-    unsigned u;                         /* Local index variable */
-    herr_t ret_value = SUCCEED;         /* Return value */
+    H5S_hyper_span_t *prev_span = NULL;    /* Pointer to previous list of spans */
+    unsigned          delta_rank;          /* Difference in dataspace ranks */
+    unsigned          curr_dim;            /* Current dimension being operated on */
+    unsigned          u;                   /* Local index variable */
+    herr_t            ret_value = SUCCEED; /* Return value */
 
     FUNC_ENTER_STATIC
 
@@ -6684,48 +6663,50 @@ H5S__hyper_project_simple_higher(const H5S_t *base_space, H5S_t *new_space)
 
     /* Create nodes until reaching the correct # of dimensions */
     new_space->select.sel_info.hslab->span_lst = NULL;
-    curr_dim = 0;
-    delta_rank = (new_space->extent.rank - base_space->extent.rank);
-    while(curr_dim < delta_rank) {
-        H5S_hyper_span_info_t *new_span_info;  /* Pointer to list of spans */
-        H5S_hyper_span_t *new_span;     /* Temporary hyperslab span */
+    curr_dim                                   = 0;
+    delta_rank                                 = (new_space->extent.rank - base_space->extent.rank);
+    while (curr_dim < delta_rank) {
+        H5S_hyper_span_info_t *new_span_info; /* Pointer to list of spans */
+        H5S_hyper_span_t *     new_span;      /* Temporary hyperslab span */
 
         /* Allocate a new span_info node */
-        if(NULL == (new_span_info = H5S__hyper_new_span_info(new_space->extent.rank))) {
-            if(prev_span)
+        if (NULL == (new_span_info = H5S__hyper_new_span_info(new_space->extent.rank))) {
+            if (prev_span)
                 H5S__hyper_free_span(prev_span);
             HGOTO_ERROR(H5E_DATASPACE, H5E_CANTALLOC, FAIL, "can't allocate hyperslab span info")
         } /* end if */
 
         /* Check for linking into higher span */
-        if(prev_span)
+        if (prev_span)
             prev_span->down = new_span_info;
 
         /* Allocate a new node */
-        if(NULL == (new_span = H5S__hyper_new_span((hsize_t)0, (hsize_t)0, NULL, NULL))) {
+        if (NULL == (new_span = H5S__hyper_new_span((hsize_t)0, (hsize_t)0, NULL, NULL))) {
             HDassert(new_span_info);
-            if(!prev_span)
+            if (!prev_span)
                 (void)H5FL_ARR_FREE(hbounds_t, new_span_info);
             HGOTO_ERROR(H5E_DATASPACE, H5E_CANTALLOC, FAIL, "can't allocate hyperslab span")
         } /* end if */
 
         /* Set the span_info information */
         new_span_info->count = 1;
-        new_span_info->head = new_span;
-        new_span_info->tail = new_span;
+        new_span_info->head  = new_span;
+        new_span_info->tail  = new_span;
 
         /* Set the bounding box */
-        for(u = 0; u < delta_rank; u++) {
-            new_span_info->low_bounds[u] = 0;
+        for (u = 0; u < delta_rank; u++) {
+            new_span_info->low_bounds[u]  = 0;
             new_span_info->high_bounds[u] = 0;
         } /* end for */
-        for(; u < new_space->extent.rank; u++) {
-            new_span_info->low_bounds[u] = base_space->select.sel_info.hslab->span_lst->low_bounds[u - delta_rank];
-            new_span_info->high_bounds[u] = base_space->select.sel_info.hslab->span_lst->high_bounds[u - delta_rank];
+        for (; u < new_space->extent.rank; u++) {
+            new_span_info->low_bounds[u] =
+                base_space->select.sel_info.hslab->span_lst->low_bounds[u - delta_rank];
+            new_span_info->high_bounds[u] =
+                base_space->select.sel_info.hslab->span_lst->high_bounds[u - delta_rank];
         } /* end for */
 
         /* Attach to new space, if top span info */
-        if(NULL == new_space->select.sel_info.hslab->span_lst)
+        if (NULL == new_space->select.sel_info.hslab->span_lst)
             new_space->select.sel_info.hslab->span_lst = new_span_info;
 
         /* Remember previous span info */
@@ -6742,17 +6723,17 @@ H5S__hyper_project_simple_higher(const H5S_t *base_space, H5S_t *new_space)
     prev_span->down->count++;
 
 done:
-    if(ret_value < 0 && new_space->select.sel_info.hslab->span_lst) {
-        if(new_space->select.sel_info.hslab->span_lst->head)
+    if (ret_value < 0 && new_space->select.sel_info.hslab->span_lst) {
+        if (new_space->select.sel_info.hslab->span_lst->head)
             H5S__hyper_free_span(new_space->select.sel_info.hslab->span_lst->head);
 
-        new_space->select.sel_info.hslab->span_lst = (H5S_hyper_span_info_t *)H5FL_ARR_FREE(hbounds_t, new_space->select.sel_info.hslab->span_lst);
+        new_space->select.sel_info.hslab->span_lst =
+            (H5S_hyper_span_info_t *)H5FL_ARR_FREE(hbounds_t, new_space->select.sel_info.hslab->span_lst);
     } /* end if */
 
     FUNC_LEAVE_NOAPI(ret_value)
 } /* end H5S__hyper_project_simple_higher() */
 
-
 /*-------------------------------------------------------------------------
  * Function:    H5S__hyper_project_simple
  *
@@ -6767,10 +6748,9 @@ done:
  *-------------------------------------------------------------------------
  */
 static herr_t
-H5S__hyper_project_simple(const H5S_t *base_space, H5S_t *new_space,
-    hsize_t *offset)
+H5S__hyper_project_simple(const H5S_t *base_space, H5S_t *new_space, hsize_t *offset)
 {
-    herr_t ret_value = SUCCEED;         /* Return value */
+    herr_t ret_value = SUCCEED; /* Return value */
 
     FUNC_ENTER_STATIC
 
@@ -6780,11 +6760,11 @@ H5S__hyper_project_simple(const H5S_t *base_space, H5S_t *new_space,
     HDassert(offset);
 
     /* We are setting a new selection, remove any current selection in new dataspace */
-    if(H5S_SELECT_RELEASE(new_space) < 0)
+    if (H5S_SELECT_RELEASE(new_space) < 0)
         HGOTO_ERROR(H5E_DATASPACE, H5E_CANTDELETE, FAIL, "can't release selection")
 
     /* Allocate space for the hyperslab selection information */
-    if(NULL == (new_space->select.sel_info.hslab = H5FL_MALLOC(H5S_hyper_sel_t)))
+    if (NULL == (new_space->select.sel_info.hslab = H5FL_MALLOC(H5S_hyper_sel_t)))
         HGOTO_ERROR(H5E_DATASPACE, H5E_CANTALLOC, FAIL, "can't allocate hyperslab info")
 
     /* Set unlim_dim */
@@ -6792,25 +6772,26 @@ H5S__hyper_project_simple(const H5S_t *base_space, H5S_t *new_space,
 
     /* Check for a "regular" hyperslab selection */
     /* (No need to rebuild the dimension info yet -QAK) */
-    if(base_space->select.sel_info.hslab->diminfo_valid == H5S_DIMINFO_VALID_YES) {
-        unsigned base_space_dim;    /* Current dimension in the base dataspace */
-        unsigned new_space_dim;     /* Current dimension in the new dataspace */
-        unsigned u;                 /* Local index variable */
+    if (base_space->select.sel_info.hslab->diminfo_valid == H5S_DIMINFO_VALID_YES) {
+        unsigned base_space_dim; /* Current dimension in the base dataspace */
+        unsigned new_space_dim;  /* Current dimension in the new dataspace */
+        unsigned u;              /* Local index variable */
 
         /* Check if the new space's rank is < or > base space's rank */
-        if(new_space->extent.rank < base_space->extent.rank) {
-            const H5S_hyper_dim_t *opt_diminfo = base_space->select.sel_info.hslab->diminfo.opt; /* Alias for dataspace's diminfo information */
-            hsize_t block[H5S_MAX_RANK];     /* Block selected in base dataspace */
+        if (new_space->extent.rank < base_space->extent.rank) {
+            const H5S_hyper_dim_t *opt_diminfo = base_space->select.sel_info.hslab->diminfo
+                                                     .opt; /* Alias for dataspace's diminfo information */
+            hsize_t block[H5S_MAX_RANK];                   /* Block selected in base dataspace */
 
             /* Compute the offset for the down-projection */
             HDmemset(block, 0, sizeof(block));
-            for(u = 0; u < (base_space->extent.rank - new_space->extent.rank); u++)
+            for (u = 0; u < (base_space->extent.rank - new_space->extent.rank); u++)
                 block[u] = opt_diminfo[u].start;
             *offset = H5VM_array_offset(base_space->extent.rank, base_space->extent.size, block);
 
             /* Set the correct dimensions for the base & new spaces */
             base_space_dim = base_space->extent.rank - new_space->extent.rank;
-            new_space_dim = 0;
+            new_space_dim  = 0;
         } /* end if */
         else {
             HDassert(new_space->extent.rank > base_space->extent.rank);
@@ -6819,16 +6800,17 @@ H5S__hyper_project_simple(const H5S_t *base_space, H5S_t *new_space,
             *offset = 0;
 
             /* Set the diminfo information for the higher dimensions */
-            for(new_space_dim = 0; new_space_dim < (new_space->extent.rank - base_space->extent.rank); new_space_dim++) {
-                new_space->select.sel_info.hslab->diminfo.app[new_space_dim].start = 0;
+            for (new_space_dim = 0; new_space_dim < (new_space->extent.rank - base_space->extent.rank);
+                 new_space_dim++) {
+                new_space->select.sel_info.hslab->diminfo.app[new_space_dim].start  = 0;
                 new_space->select.sel_info.hslab->diminfo.app[new_space_dim].stride = 1;
-                new_space->select.sel_info.hslab->diminfo.app[new_space_dim].count = 1;
-                new_space->select.sel_info.hslab->diminfo.app[new_space_dim].block = 1;
+                new_space->select.sel_info.hslab->diminfo.app[new_space_dim].count  = 1;
+                new_space->select.sel_info.hslab->diminfo.app[new_space_dim].block  = 1;
 
-                new_space->select.sel_info.hslab->diminfo.opt[new_space_dim].start = 0;
+                new_space->select.sel_info.hslab->diminfo.opt[new_space_dim].start  = 0;
                 new_space->select.sel_info.hslab->diminfo.opt[new_space_dim].stride = 1;
-                new_space->select.sel_info.hslab->diminfo.opt[new_space_dim].count = 1;
-                new_space->select.sel_info.hslab->diminfo.opt[new_space_dim].block = 1;
+                new_space->select.sel_info.hslab->diminfo.opt[new_space_dim].count  = 1;
+                new_space->select.sel_info.hslab->diminfo.opt[new_space_dim].block  = 1;
             } /* end for */
 
             /* Start at beginning of base space's dimension info */
@@ -6836,24 +6818,24 @@ H5S__hyper_project_simple(const H5S_t *base_space, H5S_t *new_space,
         } /* end else */
 
         /* Copy the diminfo */
-        while(base_space_dim < base_space->extent.rank) {
+        while (base_space_dim < base_space->extent.rank) {
             new_space->select.sel_info.hslab->diminfo.app[new_space_dim].start =
-                    base_space->select.sel_info.hslab->diminfo.app[base_space_dim].start;
+                base_space->select.sel_info.hslab->diminfo.app[base_space_dim].start;
             new_space->select.sel_info.hslab->diminfo.app[new_space_dim].stride =
-                    base_space->select.sel_info.hslab->diminfo.app[base_space_dim].stride;
+                base_space->select.sel_info.hslab->diminfo.app[base_space_dim].stride;
             new_space->select.sel_info.hslab->diminfo.app[new_space_dim].count =
-                    base_space->select.sel_info.hslab->diminfo.app[base_space_dim].count;
+                base_space->select.sel_info.hslab->diminfo.app[base_space_dim].count;
             new_space->select.sel_info.hslab->diminfo.app[new_space_dim].block =
-                    base_space->select.sel_info.hslab->diminfo.app[base_space_dim].block;
+                base_space->select.sel_info.hslab->diminfo.app[base_space_dim].block;
 
             new_space->select.sel_info.hslab->diminfo.opt[new_space_dim].start =
-                    base_space->select.sel_info.hslab->diminfo.opt[base_space_dim].start;
+                base_space->select.sel_info.hslab->diminfo.opt[base_space_dim].start;
             new_space->select.sel_info.hslab->diminfo.opt[new_space_dim].stride =
-                    base_space->select.sel_info.hslab->diminfo.opt[base_space_dim].stride;
+                base_space->select.sel_info.hslab->diminfo.opt[base_space_dim].stride;
             new_space->select.sel_info.hslab->diminfo.opt[new_space_dim].count =
-                    base_space->select.sel_info.hslab->diminfo.opt[base_space_dim].count;
+                base_space->select.sel_info.hslab->diminfo.opt[base_space_dim].count;
             new_space->select.sel_info.hslab->diminfo.opt[new_space_dim].block =
-                    base_space->select.sel_info.hslab->diminfo.opt[base_space_dim].block;
+                base_space->select.sel_info.hslab->diminfo.opt[base_space_dim].block;
 
             /* Advance to next dimensions */
             base_space_dim++;
@@ -6861,9 +6843,14 @@ H5S__hyper_project_simple(const H5S_t *base_space, H5S_t *new_space,
         } /* end for */
 
         /* Update the bounding box */
-        for(u = 0; u < new_space->extent.rank; u++) {
-            new_space->select.sel_info.hslab->diminfo.low_bounds[u] = new_space->select.sel_info.hslab->diminfo.opt[u].start;
-            new_space->select.sel_info.hslab->diminfo.high_bounds[u] = new_space->select.sel_info.hslab->diminfo.low_bounds[u] + new_space->select.sel_info.hslab->diminfo.opt[u].stride * (new_space->select.sel_info.hslab->diminfo.opt[u].count - 1) + (new_space->select.sel_info.hslab->diminfo.opt[u].block - 1);
+        for (u = 0; u < new_space->extent.rank; u++) {
+            new_space->select.sel_info.hslab->diminfo.low_bounds[u] =
+                new_space->select.sel_info.hslab->diminfo.opt[u].start;
+            new_space->select.sel_info.hslab->diminfo.high_bounds[u] =
+                new_space->select.sel_info.hslab->diminfo.low_bounds[u] +
+                new_space->select.sel_info.hslab->diminfo.opt[u].stride *
+                    (new_space->select.sel_info.hslab->diminfo.opt[u].count - 1) +
+                (new_space->select.sel_info.hslab->diminfo.opt[u].block - 1);
         } /* end for */
 
         /* Indicate that the dimension information is valid */
@@ -6874,18 +6861,18 @@ H5S__hyper_project_simple(const H5S_t *base_space, H5S_t *new_space,
     } /* end if */
     else {
         /* Check if the new space's rank is < or > base space's rank */
-        if(new_space->extent.rank < base_space->extent.rank) {
-            const H5S_hyper_span_t *curr;    /* Pointer to current hyperslab span */
-            hsize_t block[H5S_MAX_RANK];     /* Block selected in base dataspace */
-            unsigned curr_dim;               /* Current dimension being operated on */
+        if (new_space->extent.rank < base_space->extent.rank) {
+            const H5S_hyper_span_t *curr;                /* Pointer to current hyperslab span */
+            hsize_t                 block[H5S_MAX_RANK]; /* Block selected in base dataspace */
+            unsigned                curr_dim;            /* Current dimension being operated on */
 
             /* Clear the block buffer */
             HDmemset(block, 0, sizeof(block));
 
             /* Advance down selected spans */
-            curr = base_space->select.sel_info.hslab->span_lst->head;
+            curr     = base_space->select.sel_info.hslab->span_lst->head;
             curr_dim = 0;
-            while(curr && curr_dim < (base_space->extent.rank - new_space->extent.rank)) {
+            while (curr && curr_dim < (base_space->extent.rank - new_space->extent.rank)) {
                 /* Save the location of the selection in current dimension */
                 block[curr_dim] = curr->low;
 
@@ -6898,8 +6885,9 @@ H5S__hyper_project_simple(const H5S_t *base_space, H5S_t *new_space,
             *offset = H5VM_array_offset(base_space->extent.rank, base_space->extent.size, block);
 
             /* Project the base space's selection down in less dimensions */
-            if(H5S__hyper_project_simple_lower(base_space, new_space) < 0)
-                HGOTO_ERROR(H5E_DATASPACE, H5E_CANTSELECT, FAIL, "can't project hyperslab selection into less dimensions")
+            if (H5S__hyper_project_simple_lower(base_space, new_space) < 0)
+                HGOTO_ERROR(H5E_DATASPACE, H5E_CANTSELECT, FAIL,
+                            "can't project hyperslab selection into less dimensions")
         } /* end if */
         else {
             HDassert(new_space->extent.rank > base_space->extent.rank);
@@ -6908,8 +6896,9 @@ H5S__hyper_project_simple(const H5S_t *base_space, H5S_t *new_space,
             *offset = 0;
 
             /* Project the base space's selection down in more dimensions */
-            if(H5S__hyper_project_simple_higher(base_space, new_space) < 0)
-                HGOTO_ERROR(H5E_DATASPACE, H5E_CANTSELECT, FAIL, "can't project hyperslab selection into less dimensions")
+            if (H5S__hyper_project_simple_higher(base_space, new_space) < 0)
+                HGOTO_ERROR(H5E_DATASPACE, H5E_CANTSELECT, FAIL,
+                            "can't project hyperslab selection into less dimensions")
         } /* end else */
 
         /* Copy the status of the dimension information */
@@ -6926,7 +6915,6 @@ done:
     FUNC_LEAVE_NOAPI(ret_value)
 } /* end H5S__hyper_project_simple() */
 
-
 /*--------------------------------------------------------------------------
  NAME
     H5S__hyper_adjust_s_helper
@@ -6949,8 +6937,8 @@ done:
  REVISION LOG
 --------------------------------------------------------------------------*/
 static void
-H5S__hyper_adjust_s_helper(H5S_hyper_span_info_t *spans, unsigned rank,
-    const hssize_t *offset, unsigned op_info_i, uint64_t op_gen)
+H5S__hyper_adjust_s_helper(H5S_hyper_span_info_t *spans, unsigned rank, const hssize_t *offset,
+                           unsigned op_info_i, uint64_t op_gen)
 {
     FUNC_ENTER_STATIC_NOERR
 
@@ -6959,27 +6947,27 @@ H5S__hyper_adjust_s_helper(H5S_hyper_span_info_t *spans, unsigned rank,
     HDassert(offset);
 
     /* Check if we've already set this span tree */
-    if(spans->op_info[op_info_i].op_gen != op_gen) {
-        H5S_hyper_span_t *span;     /* Pointer to current span in span tree */
-        unsigned u;                 /* Local index variable */
+    if (spans->op_info[op_info_i].op_gen != op_gen) {
+        H5S_hyper_span_t *span; /* Pointer to current span in span tree */
+        unsigned          u;    /* Local index variable */
 
         /* Adjust the span tree's low & high bounds */
-        for(u = 0; u < rank; u++) {
+        for (u = 0; u < rank; u++) {
             HDassert((hssize_t)spans->low_bounds[u] >= offset[u]);
-            spans->low_bounds[u] = (hsize_t)((hssize_t)spans->low_bounds[u] - offset[u]);
+            spans->low_bounds[u]  = (hsize_t)((hssize_t)spans->low_bounds[u] - offset[u]);
             spans->high_bounds[u] = (hsize_t)((hssize_t)spans->high_bounds[u] - offset[u]);
         } /* end for */
 
         /* Iterate over the spans in tree */
         span = spans->head;
-        while(span != NULL) {
+        while (span != NULL) {
             /* Adjust span offset */
             HDassert((hssize_t)span->low >= *offset);
-            span->low = (hsize_t)((hssize_t)span->low - *offset);
+            span->low  = (hsize_t)((hssize_t)span->low - *offset);
             span->high = (hsize_t)((hssize_t)span->high - *offset);
 
             /* Recursively adjust spans in next dimension down */
-            if(span->down != NULL)
+            if (span->down != NULL)
                 H5S__hyper_adjust_s_helper(span->down, rank - 1, offset + 1, op_info_i, op_gen);
 
             /* Advance to next span in this dimension */
@@ -6993,7 +6981,6 @@ H5S__hyper_adjust_s_helper(H5S_hyper_span_info_t *spans, unsigned rank,
     FUNC_LEAVE_NOAPI_VOID
 } /* end H5S__hyper_adjust_s_helper() */
 
-
 /*--------------------------------------------------------------------------
  NAME
     H5S__hyper_adjust_s
@@ -7015,8 +7002,8 @@ H5S__hyper_adjust_s_helper(H5S_hyper_span_info_t *spans, unsigned rank,
 static herr_t
 H5S__hyper_adjust_s(H5S_t *space, const hssize_t *offset)
 {
-    hbool_t non_zero_offset = FALSE;    /* Whether any offset is non-zero */
-    unsigned u;                         /* Local index variable */
+    hbool_t  non_zero_offset = FALSE; /* Whether any offset is non-zero */
+    unsigned u;                       /* Local index variable */
 
     FUNC_ENTER_STATIC_NOERR
 
@@ -7025,31 +7012,34 @@ H5S__hyper_adjust_s(H5S_t *space, const hssize_t *offset)
     HDassert(offset);
 
     /* Check for an all-zero offset vector */
-    for(u = 0; u < space->extent.rank; u++)
-        if(0 != offset[u]) {
+    for (u = 0; u < space->extent.rank; u++)
+        if (0 != offset[u]) {
             non_zero_offset = TRUE;
             break;
         } /* end if */
 
     /* Only perform operation if the offset is non-zero */
-    if(non_zero_offset) {
+    if (non_zero_offset) {
         /* Subtract the offset from the "regular" coordinates, if they exist */
         /* (No need to rebuild the dimension info yet -QAK) */
-        if(space->select.sel_info.hslab->diminfo_valid == H5S_DIMINFO_VALID_YES) {
-            for(u = 0; u < space->extent.rank; u++) {
+        if (space->select.sel_info.hslab->diminfo_valid == H5S_DIMINFO_VALID_YES) {
+            for (u = 0; u < space->extent.rank; u++) {
                 HDassert((hssize_t)space->select.sel_info.hslab->diminfo.opt[u].start >= offset[u]);
-                space->select.sel_info.hslab->diminfo.opt[u].start = (hsize_t)((hssize_t)space->select.sel_info.hslab->diminfo.opt[u].start - offset[u]);
+                space->select.sel_info.hslab->diminfo.opt[u].start =
+                    (hsize_t)((hssize_t)space->select.sel_info.hslab->diminfo.opt[u].start - offset[u]);
 
                 /* Adjust the low & high bounds */
                 HDassert((hssize_t)space->select.sel_info.hslab->diminfo.low_bounds[u] >= offset[u]);
-                space->select.sel_info.hslab->diminfo.low_bounds[u] = (hsize_t)((hssize_t)space->select.sel_info.hslab->diminfo.low_bounds[u] - offset[u]);
-                space->select.sel_info.hslab->diminfo.high_bounds[u] = (hsize_t)((hssize_t)space->select.sel_info.hslab->diminfo.high_bounds[u] - offset[u]);
+                space->select.sel_info.hslab->diminfo.low_bounds[u] =
+                    (hsize_t)((hssize_t)space->select.sel_info.hslab->diminfo.low_bounds[u] - offset[u]);
+                space->select.sel_info.hslab->diminfo.high_bounds[u] =
+                    (hsize_t)((hssize_t)space->select.sel_info.hslab->diminfo.high_bounds[u] - offset[u]);
             } /* end for */
-        } /* end if */
+        }     /* end if */
 
         /* Subtract the offset from the span tree coordinates, if they exist */
-        if(space->select.sel_info.hslab->span_lst) {
-            uint64_t op_gen;            /* Operation generation value */
+        if (space->select.sel_info.hslab->span_lst) {
+            uint64_t op_gen; /* Operation generation value */
 
             /* Acquire an operation generation value for this operation */
             op_gen = H5S__hyper_get_op_gen();
@@ -7057,14 +7047,14 @@ H5S__hyper_adjust_s(H5S_t *space, const hssize_t *offset)
             /* Perform the adjustment */
             /* Always use op_info[0] since we own this op_info, so there can be no
              * simultaneous operations */
-            H5S__hyper_adjust_s_helper(space->select.sel_info.hslab->span_lst, space->extent.rank, offset, 0, op_gen);
+            H5S__hyper_adjust_s_helper(space->select.sel_info.hslab->span_lst, space->extent.rank, offset, 0,
+                                       op_gen);
         } /* end if */
     }
 
     FUNC_LEAVE_NOAPI(SUCCEED)
 } /* end H5S__hyper_adjust_s() */
 
-
 /*--------------------------------------------------------------------------
  NAME
     H5S_hyper_normalize_offset
@@ -7089,7 +7079,7 @@ H5S__hyper_adjust_s(H5S_t *space, const hssize_t *offset)
 htri_t
 H5S_hyper_normalize_offset(H5S_t *space, hssize_t *old_offset)
 {
-    htri_t ret_value = FALSE;          /* Return value */
+    htri_t ret_value = FALSE; /* Return value */
 
     FUNC_ENTER_NOAPI(FAIL)
 
@@ -7098,17 +7088,17 @@ H5S_hyper_normalize_offset(H5S_t *space, hssize_t *old_offset)
     HDassert(old_offset);
 
     /* Check for hyperslab selection & offset changed */
-    if(H5S_GET_SELECT_TYPE(space) == H5S_SEL_HYPERSLABS && space->select.offset_changed) {
-        unsigned u;                         /* Local index variable */
+    if (H5S_GET_SELECT_TYPE(space) == H5S_SEL_HYPERSLABS && space->select.offset_changed) {
+        unsigned u; /* Local index variable */
 
         /* Copy & invert the selection offset */
-        for(u = 0; u < space->extent.rank; u++) {
-            old_offset[u] = space->select.offset[u];
+        for (u = 0; u < space->extent.rank; u++) {
+            old_offset[u]           = space->select.offset[u];
             space->select.offset[u] = -space->select.offset[u];
         } /* end for */
 
         /* Call the 'adjust' routine */
-        if(H5S__hyper_adjust_s(space, space->select.offset) < 0)
+        if (H5S__hyper_adjust_s(space, space->select.offset) < 0)
             HGOTO_ERROR(H5E_DATASPACE, H5E_CANTSET, FAIL, "can't adjust selection")
 
         /* Zero out the selection offset */
@@ -7122,7 +7112,6 @@ done:
     FUNC_LEAVE_NOAPI(ret_value)
 } /* end H5S_hyper_normalize_offset() */
 
-
 /*--------------------------------------------------------------------------
  NAME
     H5S_hyper_denormalize_offset
@@ -7147,7 +7136,7 @@ done:
 herr_t
 H5S_hyper_denormalize_offset(H5S_t *space, const hssize_t *old_offset)
 {
-    herr_t ret_value = SUCCEED;         /* Return value */
+    herr_t ret_value = SUCCEED; /* Return value */
 
     FUNC_ENTER_NOAPI(FAIL)
 
@@ -7156,7 +7145,7 @@ H5S_hyper_denormalize_offset(H5S_t *space, const hssize_t *old_offset)
     HDassert(H5S_GET_SELECT_TYPE(space) == H5S_SEL_HYPERSLABS);
 
     /* Call the 'adjust' routine */
-    if(H5S__hyper_adjust_s(space, old_offset) < 0)
+    if (H5S__hyper_adjust_s(space, old_offset) < 0)
         HGOTO_ERROR(H5E_DATASPACE, H5E_CANTSET, FAIL, "can't adjust selection")
 
     /* Copy the selection offset over */
@@ -7166,7 +7155,6 @@ done:
     FUNC_LEAVE_NOAPI(ret_value)
 } /* end H5S_hyper_denormalize_offset() */
 
-
 /*--------------------------------------------------------------------------
  NAME
     H5S__hyper_append_span
@@ -7189,11 +7177,11 @@ done:
  REVISION LOG
 --------------------------------------------------------------------------*/
 static herr_t
-H5S__hyper_append_span(H5S_hyper_span_info_t **span_tree, unsigned ndims,
-    hsize_t low, hsize_t high, H5S_hyper_span_info_t *down)
+H5S__hyper_append_span(H5S_hyper_span_info_t **span_tree, unsigned ndims, hsize_t low, hsize_t high,
+                       H5S_hyper_span_info_t *down)
 {
-    H5S_hyper_span_t *new_span = NULL;
-    herr_t      ret_value = SUCCEED;       /* Return value */
+    H5S_hyper_span_t *new_span  = NULL;
+    herr_t            ret_value = SUCCEED; /* Return value */
 
     FUNC_ENTER_STATIC
 
@@ -7201,40 +7189,40 @@ H5S__hyper_append_span(H5S_hyper_span_info_t **span_tree, unsigned ndims,
     HDassert(span_tree);
 
     /* Check for adding first node to merged spans */
-    if(*span_tree == NULL) {
+    if (*span_tree == NULL) {
         /* Allocate new span node to append to list */
-        if(NULL == (new_span = H5S__hyper_new_span(low, high, down, NULL)))
+        if (NULL == (new_span = H5S__hyper_new_span(low, high, down, NULL)))
             HGOTO_ERROR(H5E_DATASPACE, H5E_CANTALLOC, FAIL, "can't allocate hyperslab span")
 
         /* Make new span the first node in span list */
 
         /* Allocate a new span_info node */
-        if(NULL == (*span_tree = H5S__hyper_new_span_info(ndims)))
+        if (NULL == (*span_tree = H5S__hyper_new_span_info(ndims)))
             HGOTO_ERROR(H5E_DATASPACE, H5E_CANTALLOC, FAIL, "can't allocate hyperslab span")
 
         /* Set the span tree's basic information */
         (*span_tree)->count = 1;
-        (*span_tree)->head = new_span;
-        (*span_tree)->tail = new_span;
+        (*span_tree)->head  = new_span;
+        (*span_tree)->tail  = new_span;
 
         /* Set low & high bounds for new span tree */
-        (*span_tree)->low_bounds[0] = low;
+        (*span_tree)->low_bounds[0]  = low;
         (*span_tree)->high_bounds[0] = high;
-        if(down) {
+        if (down) {
             /* Sanity check */
             HDassert(ndims > 1);
 
             H5MM_memcpy(&((*span_tree)->low_bounds[1]), down->low_bounds, sizeof(hsize_t) * (ndims - 1));
             H5MM_memcpy(&((*span_tree)->high_bounds[1]), down->high_bounds, sizeof(hsize_t) * (ndims - 1));
         } /* end if */
-    } /* end if */
+    }     /* end if */
     /* Merge or append to existing merged spans list */
     else {
-        htri_t down_cmp = (-1);         /* Comparison value for down spans */
+        htri_t down_cmp = (-1); /* Comparison value for down spans */
 
         /* Check if span can just extend the previous merged span */
-        if((((*span_tree)->tail->high + 1) == low) &&
-                (down_cmp = H5S__hyper_cmp_spans(down, (*span_tree)->tail->down))) {
+        if ((((*span_tree)->tail->high + 1) == low) &&
+            (down_cmp = H5S__hyper_cmp_spans(down, (*span_tree)->tail->down))) {
             /* Extend previous merged span to include new high bound */
             (*span_tree)->tail->high = high;
 
@@ -7243,17 +7231,17 @@ H5S__hyper_append_span(H5S_hyper_span_info_t **span_tree, unsigned ndims,
             (*span_tree)->high_bounds[0] = high;
         } /* end if */
         else {
-            H5S_hyper_span_info_t *new_down;    /* Down pointer for new span node */
+            H5S_hyper_span_info_t *new_down; /* Down pointer for new span node */
 
             /* Sanity check */
             /* (If down_cmp was set to TRUE above, we won't be in this branch) */
             HDassert(down_cmp != TRUE);
 
             /* Check if there is actually a down span */
-            if(down) {
+            if (down) {
                 /* Check if the down spans for the new span node are the same as the previous span node */
                 /* (Uses the 'down span comparison' from earlier, if already computed) */
-                if(down_cmp < 0 && (down_cmp = H5S__hyper_cmp_spans(down, (*span_tree)->tail->down)))
+                if (down_cmp < 0 && (down_cmp = H5S__hyper_cmp_spans(down, (*span_tree)->tail->down)))
                     /* Share the previous span's down span tree */
                     new_down = (*span_tree)->tail->down;
                 else
@@ -7263,48 +7251,47 @@ H5S__hyper_append_span(H5S_hyper_span_info_t **span_tree, unsigned ndims,
                 new_down = NULL;
 
             /* Allocate new span node to append to list */
-            if(NULL == (new_span = H5S__hyper_new_span(low, high, new_down, NULL)))
+            if (NULL == (new_span = H5S__hyper_new_span(low, high, new_down, NULL)))
                 HGOTO_ERROR(H5E_DATASPACE, H5E_CANTALLOC, FAIL, "can't allocate hyperslab span")
 
             /* Update the high bounds for current dimension */
             (*span_tree)->high_bounds[0] = high;
 
             /* Update low & high bounds in lower dimensions, if there are any */
-            if(down) {
+            if (down) {
                 /* Sanity checks */
                 HDassert(ndims > 1);
                 HDassert(down_cmp >= 0);
 
                 /* Check if we are sharing down spans with a previous node */
                 /* (Only need to check for bounds changing if down spans aren't shared) */
-                if(down_cmp == FALSE) {
-                    unsigned u;     /* Local index variable */
+                if (down_cmp == FALSE) {
+                    unsigned u; /* Local index variable */
 
                     /* Loop over lower dimensions, checking & updating low & high bounds */
-                    for(u = 0; u < (ndims - 1); u++) {
-                        if(down->low_bounds[u] < (*span_tree)->low_bounds[u + 1])
+                    for (u = 0; u < (ndims - 1); u++) {
+                        if (down->low_bounds[u] < (*span_tree)->low_bounds[u + 1])
                             (*span_tree)->low_bounds[u + 1] = down->low_bounds[u];
-                        if(down->high_bounds[u] > (*span_tree)->high_bounds[u + 1])
+                        if (down->high_bounds[u] > (*span_tree)->high_bounds[u + 1])
                             (*span_tree)->high_bounds[u + 1] = down->high_bounds[u];
                     } /* end for */
-                } /* end if */
-            } /* end if */
+                }     /* end if */
+            }         /* end if */
 
             /* Append to end of merged spans list */
             (*span_tree)->tail->next = new_span;
-            (*span_tree)->tail = new_span;
+            (*span_tree)->tail       = new_span;
         } /* end else */
-    } /* end else */
+    }     /* end else */
 
 done:
-    if(ret_value < 0)
-        if(new_span)
+    if (ret_value < 0)
+        if (new_span)
             H5S__hyper_free_span(new_span);
 
     FUNC_LEAVE_NOAPI(ret_value)
 } /* end H5S__hyper_append_span() */
 
-
 /*--------------------------------------------------------------------------
  NAME
     H5S__hyper_clip_spans
@@ -7346,15 +7333,14 @@ done:
  REVISION LOG
 --------------------------------------------------------------------------*/
 static herr_t
-H5S__hyper_clip_spans(H5S_hyper_span_info_t *a_spans, H5S_hyper_span_info_t *b_spans,
-    unsigned selector, unsigned ndims,
-    H5S_hyper_span_info_t **a_not_b, H5S_hyper_span_info_t **a_and_b,
-    H5S_hyper_span_info_t **b_not_a)
+H5S__hyper_clip_spans(H5S_hyper_span_info_t *a_spans, H5S_hyper_span_info_t *b_spans, unsigned selector,
+                      unsigned ndims, H5S_hyper_span_info_t **a_not_b, H5S_hyper_span_info_t **a_and_b,
+                      H5S_hyper_span_info_t **b_not_a)
 {
-    hbool_t need_a_not_b;           /* Whether to generate a_not_b list */
-    hbool_t need_a_and_b;           /* Whether to generate a_and_b list */
-    hbool_t need_b_not_a;           /* Whether to generate b_not_a list */
-    herr_t ret_value = SUCCEED;     /* Return value */
+    hbool_t need_a_not_b;        /* Whether to generate a_not_b list */
+    hbool_t need_a_and_b;        /* Whether to generate a_and_b list */
+    hbool_t need_b_not_a;        /* Whether to generate b_not_a list */
+    herr_t  ret_value = SUCCEED; /* Return value */
 
     FUNC_ENTER_STATIC
 
@@ -7371,28 +7357,28 @@ H5S__hyper_clip_spans(H5S_hyper_span_info_t *a_spans, H5S_hyper_span_info_t *b_s
     need_b_not_a = ((selector & H5S_HYPER_COMPUTE_B_NOT_A) != 0);
 
     /* Check if both span trees are not defined */
-    if(a_spans == NULL && b_spans == NULL) {
+    if (a_spans == NULL && b_spans == NULL) {
         *a_not_b = NULL;
         *a_and_b = NULL;
         *b_not_a = NULL;
     } /* end if */
     /* If span 'a' is not defined, but 'b' is, copy 'b' and set the other return span trees to empty */
-    else if(a_spans == NULL) {
+    else if (a_spans == NULL) {
         *a_not_b = NULL;
         *a_and_b = NULL;
-        if(need_b_not_a) {
-            if(NULL == (*b_not_a = H5S__hyper_copy_span(b_spans, ndims)))
+        if (need_b_not_a) {
+            if (NULL == (*b_not_a = H5S__hyper_copy_span(b_spans, ndims)))
                 HGOTO_ERROR(H5E_INTERNAL, H5E_CANTCOPY, FAIL, "can't copy hyperslab span tree")
         } /* end if */
         else
             *b_not_a = NULL;
     } /* end if */
     /* If span 'b' is not defined, but 'a' is, copy 'a' and set the other return span trees to empty */
-    else if(b_spans == NULL) {
+    else if (b_spans == NULL) {
         *a_and_b = NULL;
         *b_not_a = NULL;
-        if(need_a_not_b) {
-            if(NULL == (*a_not_b = H5S__hyper_copy_span(a_spans, ndims)))
+        if (need_a_not_b) {
+            if (NULL == (*a_not_b = H5S__hyper_copy_span(a_spans, ndims)))
                 HGOTO_ERROR(H5E_INTERNAL, H5E_CANTCOPY, FAIL, "can't copy hyperslab span tree")
         } /* end if */
         else
@@ -7401,20 +7387,20 @@ H5S__hyper_clip_spans(H5S_hyper_span_info_t *a_spans, H5S_hyper_span_info_t *b_s
     /* If span 'a' and 'b' are both defined, calculate the proper span trees */
     else {
         /* Check if both span trees completely overlap */
-        if(H5S__hyper_cmp_spans(a_spans, b_spans)) {
+        if (H5S__hyper_cmp_spans(a_spans, b_spans)) {
             *a_not_b = NULL;
             *b_not_a = NULL;
-            if(need_a_and_b) {
-                if(NULL == (*a_and_b = H5S__hyper_copy_span(a_spans, ndims)))
+            if (need_a_and_b) {
+                if (NULL == (*a_and_b = H5S__hyper_copy_span(a_spans, ndims)))
                     HGOTO_ERROR(H5E_INTERNAL, H5E_CANTCOPY, FAIL, "can't copy hyperslab span tree")
             } /* end if */
             else
                 *a_and_b = NULL;
         } /* end if */
         else {
-            H5S_hyper_span_t *span_a;       /* Pointer to a node in span tree 'a' */
-            H5S_hyper_span_t *span_b;       /* Pointer to a node in span tree 'b' */
-            hbool_t recover_a, recover_b;     /* Flags to indicate when to recover temporary spans */
+            H5S_hyper_span_t *span_a;               /* Pointer to a node in span tree 'a' */
+            H5S_hyper_span_t *span_b;               /* Pointer to a node in span tree 'b' */
+            hbool_t           recover_a, recover_b; /* Flags to indicate when to recover temporary spans */
 
             /* Get the pointers to the new and old span lists */
             span_a = a_spans->head;
@@ -7424,22 +7410,26 @@ H5S__hyper_clip_spans(H5S_hyper_span_info_t *a_spans, H5S_hyper_span_info_t *b_s
             recover_a = recover_b = FALSE;
 
             /* Work through the list of spans in the new list */
-            while(span_a != NULL && span_b != NULL) {
-                H5S_hyper_span_info_t *down_a_not_b; /* Temporary pointer to a_not_b span tree of down spans for overlapping nodes */
-                H5S_hyper_span_info_t *down_a_and_b; /* Temporary pointer to a_and_b span tree of down spans for overlapping nodes */
-                H5S_hyper_span_info_t *down_b_not_a; /* Temporary pointer to b_and_a span tree of down spans for overlapping nodes */
-                H5S_hyper_span_t *tmp_span; /* Temporary pointer to new span */
+            while (span_a != NULL && span_b != NULL) {
+                H5S_hyper_span_info_t *down_a_not_b; /* Temporary pointer to a_not_b span tree of down spans
+                                                        for overlapping nodes */
+                H5S_hyper_span_info_t *down_a_and_b; /* Temporary pointer to a_and_b span tree of down spans
+                                                        for overlapping nodes */
+                H5S_hyper_span_info_t *down_b_not_a; /* Temporary pointer to b_and_a span tree of down spans
+                                                        for overlapping nodes */
+                H5S_hyper_span_t *tmp_span;          /* Temporary pointer to new span */
 
                 /* Check if span 'a' is completely before span 'b' */
                 /*    AAAAAAA                            */
                 /* <-----------------------------------> */
                 /*             BBBBBBBBBB                */
-                if(span_a->high < span_b->low) {
+                if (span_a->high < span_b->low) {
                     /* Copy span 'a' and add to a_not_b list */
 
                     /* Merge/add span 'a' with/to a_not_b list */
-                    if(need_a_not_b)
-                        if(H5S__hyper_append_span(a_not_b, ndims, span_a->low, span_a->high, span_a->down) < 0)
+                    if (need_a_not_b)
+                        if (H5S__hyper_append_span(a_not_b, ndims, span_a->low, span_a->high, span_a->down) <
+                            0)
                             HGOTO_ERROR(H5E_DATASPACE, H5E_CANTAPPEND, FAIL, "can't allocate hyperslab span")
 
                     /* Advance span 'a', leave span 'b' */
@@ -7450,27 +7440,32 @@ H5S__hyper_clip_spans(H5S_hyper_span_info_t *a_spans, H5S_hyper_span_info_t *b_s
                 /*    AAAAAAAAAAAA                       */
                 /* <-----------------------------------> */
                 /*             BBBBBBBBBB                */
-                else if(span_a->low < span_b->low && (span_a->high >= span_b->low && span_a->high <= span_b->high)) {
+                else if (span_a->low < span_b->low &&
+                         (span_a->high >= span_b->low && span_a->high <= span_b->high)) {
                     /* Split span 'a' into two parts at the low bound of span 'b' */
 
                     /* Merge/add lower part of span 'a' with/to a_not_b list */
-                    if(need_a_not_b)
-                        if(H5S__hyper_append_span(a_not_b, ndims, span_a->low, span_b->low - 1, span_a->down) < 0)
+                    if (need_a_not_b)
+                        if (H5S__hyper_append_span(a_not_b, ndims, span_a->low, span_b->low - 1,
+                                                   span_a->down) < 0)
                             HGOTO_ERROR(H5E_DATASPACE, H5E_CANTAPPEND, FAIL, "can't allocate hyperslab span")
 
                     /* Check for overlaps between upper part of span 'a' and lower part of span 'b' */
 
                     /* Make certain both spans either have a down span or both don't have one */
-                    HDassert((span_a->down != NULL && span_b->down != NULL) || (span_a->down == NULL && span_b->down == NULL));
+                    HDassert((span_a->down != NULL && span_b->down != NULL) ||
+                             (span_a->down == NULL && span_b->down == NULL));
 
                     /* If there are no down spans, just add the overlapping area to the a_and_b list */
-                    if(span_a->down == NULL) {
+                    if (span_a->down == NULL) {
                         /* Merge/add overlapped part with/to a_and_b list */
-                        if(need_a_and_b)
-                            if(H5S__hyper_append_span(a_and_b, ndims, span_b->low, span_a->high, NULL) < 0)
-                                HGOTO_ERROR(H5E_DATASPACE, H5E_CANTAPPEND, FAIL, "can't allocate hyperslab span")
+                        if (need_a_and_b)
+                            if (H5S__hyper_append_span(a_and_b, ndims, span_b->low, span_a->high, NULL) < 0)
+                                HGOTO_ERROR(H5E_DATASPACE, H5E_CANTAPPEND, FAIL,
+                                            "can't allocate hyperslab span")
                     } /* end if */
-                    /* If there are down spans, check for the overlap in them and add to each appropriate list */
+                    /* If there are down spans, check for the overlap in them and add to each appropriate list
+                     */
                     else {
                         /* NULL out the temporary pointers to clipped areas in down spans */
                         down_a_not_b = NULL;
@@ -7482,52 +7477,60 @@ H5S__hyper_clip_spans(H5S_hyper_span_info_t *a_spans, H5S_hyper_span_info_t *b_s
                          *  has been updated in the following clip function (via
                          *  all_clips_bounds), there's no need updating the bound box
                          *  after each append call in the following codes */
-                        if(H5S__hyper_clip_spans(span_a->down, span_b->down, selector, ndims - 1, &down_a_not_b, &down_a_and_b, &down_b_not_a) < 0)
+                        if (H5S__hyper_clip_spans(span_a->down, span_b->down, selector, ndims - 1,
+                                                  &down_a_not_b, &down_a_and_b, &down_b_not_a) < 0)
                             HGOTO_ERROR(H5E_DATASPACE, H5E_CANTCLIP, FAIL, "can't clip hyperslab information")
 
                         /* Check for additions to the a_not_b list */
-                        if(down_a_not_b) {
+                        if (down_a_not_b) {
                             HDassert(need_a_not_b == TRUE);
 
                             /* Merge/add overlapped part with/to a_not_b list */
-                            if(H5S__hyper_append_span(a_not_b, ndims, span_b->low, span_a->high, down_a_not_b) < 0)
-                                HGOTO_ERROR(H5E_DATASPACE, H5E_CANTAPPEND, FAIL, "can't allocate hyperslab span")
+                            if (H5S__hyper_append_span(a_not_b, ndims, span_b->low, span_a->high,
+                                                       down_a_not_b) < 0)
+                                HGOTO_ERROR(H5E_DATASPACE, H5E_CANTAPPEND, FAIL,
+                                            "can't allocate hyperslab span")
 
                             /* Release the down span tree generated */
                             H5S__hyper_free_span_info(down_a_not_b);
                         } /* end if */
 
                         /* Check for additions to the a_and_b list */
-                        if(down_a_and_b) {
+                        if (down_a_and_b) {
                             HDassert(need_a_and_b == TRUE);
 
                             /* Merge/add overlapped part with/to a_and_b list */
-                            if(H5S__hyper_append_span(a_and_b, ndims, span_b->low, span_a->high, down_a_and_b) < 0)
-                                HGOTO_ERROR(H5E_DATASPACE, H5E_CANTAPPEND, FAIL, "can't allocate hyperslab span")
+                            if (H5S__hyper_append_span(a_and_b, ndims, span_b->low, span_a->high,
+                                                       down_a_and_b) < 0)
+                                HGOTO_ERROR(H5E_DATASPACE, H5E_CANTAPPEND, FAIL,
+                                            "can't allocate hyperslab span")
 
                             /* Release the down span tree generated */
                             H5S__hyper_free_span_info(down_a_and_b);
                         } /* end if */
 
                         /* Check for additions to the b_not_a list */
-                        if(down_b_not_a) {
+                        if (down_b_not_a) {
                             HDassert(need_b_not_a == TRUE);
 
                             /* Merge/add overlapped part with/to b_not_a list */
-                            if(H5S__hyper_append_span(b_not_a, ndims, span_b->low, span_a->high, down_b_not_a) < 0)
-                                HGOTO_ERROR(H5E_DATASPACE, H5E_CANTAPPEND, FAIL, "can't allocate hyperslab span")
+                            if (H5S__hyper_append_span(b_not_a, ndims, span_b->low, span_a->high,
+                                                       down_b_not_a) < 0)
+                                HGOTO_ERROR(H5E_DATASPACE, H5E_CANTAPPEND, FAIL,
+                                            "can't allocate hyperslab span")
 
                             /* Release the down span tree generated */
                             H5S__hyper_free_span_info(down_b_not_a);
                         } /* end if */
-                    } /* end else */
+                    }     /* end else */
 
                     /* Split off upper part of span 'b' at upper span of span 'a' */
 
                     /* Check if there is actually an upper part of span 'b' to split off */
-                    if(span_a->high < span_b->high) {
+                    if (span_a->high < span_b->high) {
                         /* Allocate new span node for upper part of span 'b' */
-                        if(NULL == (tmp_span = H5S__hyper_new_span(span_a->high + 1, span_b->high, span_b->down, span_b->next)))
+                        if (NULL == (tmp_span = H5S__hyper_new_span(span_a->high + 1, span_b->high,
+                                                                    span_b->down, span_b->next)))
                             HGOTO_ERROR(H5E_DATASPACE, H5E_NOSPACE, FAIL, "can't allocate hyperslab span")
 
                         /* Advance span 'a' */
@@ -7543,33 +7546,37 @@ H5S__hyper_clip_spans(H5S_hyper_span_info_t *a_spans, H5S_hyper_span_info_t *b_s
                         H5S_HYPER_ADVANCE_SPAN(recover_a, span_a, span_a->next);
                         H5S_HYPER_ADVANCE_SPAN(recover_b, span_b, span_b->next);
                     } /* end else */
-                } /* end if */
+                }     /* end if */
                 /* Check if span 'a' overlaps the lower & upper bound */
                 /*  of span 'b' */
                 /*    AAAAAAAAAAAAAAAAAAAAA              */
                 /* <-----------------------------------> */
                 /*             BBBBBBBBBB                */
-                else if(span_a->low < span_b->low && span_a->high > span_b->high) {
+                else if (span_a->low < span_b->low && span_a->high > span_b->high) {
                     /* Split off lower part of span 'a' at lower span of span 'b' */
 
                     /* Merge/add lower part of span 'a' with/to a_not_b list */
-                    if(need_a_not_b)
-                        if(H5S__hyper_append_span(a_not_b, ndims, span_a->low, span_b->low - 1, span_a->down) < 0)
+                    if (need_a_not_b)
+                        if (H5S__hyper_append_span(a_not_b, ndims, span_a->low, span_b->low - 1,
+                                                   span_a->down) < 0)
                             HGOTO_ERROR(H5E_DATASPACE, H5E_CANTAPPEND, FAIL, "can't allocate hyperslab span")
 
                     /* Check for overlaps between middle part of span 'a' and span 'b' */
 
                     /* Make certain both spans either have a down span or both don't have one */
-                    HDassert((span_a->down != NULL && span_b->down != NULL) || (span_a->down == NULL && span_b->down == NULL));
+                    HDassert((span_a->down != NULL && span_b->down != NULL) ||
+                             (span_a->down == NULL && span_b->down == NULL));
 
                     /* If there are no down spans, just add the overlapping area to the a_and_b list */
-                    if(span_a->down == NULL) {
+                    if (span_a->down == NULL) {
                         /* Merge/add overlapped part with/to a_and_b list */
-                        if(need_a_and_b)
-                            if(H5S__hyper_append_span(a_and_b, ndims, span_b->low, span_b->high, NULL) < 0)
-                                HGOTO_ERROR(H5E_DATASPACE, H5E_CANTAPPEND, FAIL, "can't allocate hyperslab span")
+                        if (need_a_and_b)
+                            if (H5S__hyper_append_span(a_and_b, ndims, span_b->low, span_b->high, NULL) < 0)
+                                HGOTO_ERROR(H5E_DATASPACE, H5E_CANTAPPEND, FAIL,
+                                            "can't allocate hyperslab span")
                     } /* end if */
-                    /* If there are down spans, check for the overlap in them and add to each appropriate list */
+                    /* If there are down spans, check for the overlap in them and add to each appropriate list
+                     */
                     else {
                         /* NULL out the temporary pointers to clipped areas in down spans */
                         down_a_not_b = NULL;
@@ -7577,50 +7584,58 @@ H5S__hyper_clip_spans(H5S_hyper_span_info_t *a_spans, H5S_hyper_span_info_t *b_s
                         down_b_not_a = NULL;
 
                         /* Check for overlaps in the 'down spans' of span 'a' & 'b' */
-                        if(H5S__hyper_clip_spans(span_a->down, span_b->down, selector, ndims - 1, &down_a_not_b, &down_a_and_b, &down_b_not_a) < 0)
+                        if (H5S__hyper_clip_spans(span_a->down, span_b->down, selector, ndims - 1,
+                                                  &down_a_not_b, &down_a_and_b, &down_b_not_a) < 0)
                             HGOTO_ERROR(H5E_DATASPACE, H5E_CANTCLIP, FAIL, "can't clip hyperslab information")
 
                         /* Check for additions to the a_not_b list */
-                        if(down_a_not_b) {
+                        if (down_a_not_b) {
                             HDassert(need_a_not_b == TRUE);
 
                             /* Merge/add overlapped part with/to a_not_b list */
-                            if(H5S__hyper_append_span(a_not_b, ndims, span_b->low, span_b->high, down_a_not_b) < 0)
-                                HGOTO_ERROR(H5E_DATASPACE, H5E_CANTAPPEND, FAIL, "can't allocate hyperslab span")
+                            if (H5S__hyper_append_span(a_not_b, ndims, span_b->low, span_b->high,
+                                                       down_a_not_b) < 0)
+                                HGOTO_ERROR(H5E_DATASPACE, H5E_CANTAPPEND, FAIL,
+                                            "can't allocate hyperslab span")
 
                             /* Release the down span tree generated */
                             H5S__hyper_free_span_info(down_a_not_b);
                         } /* end if */
 
                         /* Check for additions to the a_and_b list */
-                        if(down_a_and_b) {
+                        if (down_a_and_b) {
                             HDassert(need_a_and_b == TRUE);
 
                             /* Merge/add overlapped part with/to a_and_b list */
-                            if(H5S__hyper_append_span(a_and_b, ndims, span_b->low, span_b->high, down_a_and_b) < 0)
-                                HGOTO_ERROR(H5E_DATASPACE, H5E_CANTAPPEND, FAIL, "can't allocate hyperslab span")
+                            if (H5S__hyper_append_span(a_and_b, ndims, span_b->low, span_b->high,
+                                                       down_a_and_b) < 0)
+                                HGOTO_ERROR(H5E_DATASPACE, H5E_CANTAPPEND, FAIL,
+                                            "can't allocate hyperslab span")
 
                             /* Release the down span tree generated */
                             H5S__hyper_free_span_info(down_a_and_b);
                         } /* end if */
 
                         /* Check for additions to the b_not_a list */
-                        if(down_b_not_a) {
+                        if (down_b_not_a) {
                             HDassert(need_b_not_a == TRUE);
 
                             /* Merge/add overlapped part with/to b_not_a list */
-                            if(H5S__hyper_append_span(b_not_a, ndims, span_b->low, span_b->high, down_b_not_a) < 0)
-                                HGOTO_ERROR(H5E_DATASPACE, H5E_CANTAPPEND, FAIL, "can't allocate hyperslab span")
+                            if (H5S__hyper_append_span(b_not_a, ndims, span_b->low, span_b->high,
+                                                       down_b_not_a) < 0)
+                                HGOTO_ERROR(H5E_DATASPACE, H5E_CANTAPPEND, FAIL,
+                                            "can't allocate hyperslab span")
 
                             /* Release the down span tree generated */
                             H5S__hyper_free_span_info(down_b_not_a);
                         } /* end if */
-                    } /* end else */
+                    }     /* end else */
 
                     /* Split off upper part of span 'a' at upper span of span 'b' */
 
                     /* Allocate new span node for upper part of span 'a' */
-                    if(NULL == (tmp_span = H5S__hyper_new_span(span_b->high + 1, span_a->high, span_a->down, span_a->next)))
+                    if (NULL == (tmp_span = H5S__hyper_new_span(span_b->high + 1, span_a->high, span_a->down,
+                                                                span_a->next)))
                         HGOTO_ERROR(H5E_DATASPACE, H5E_NOSPACE, FAIL, "can't allocate hyperslab span")
 
                     /* Make upper part of span 'a' the new span 'a' */
@@ -7634,15 +7649,17 @@ H5S__hyper_clip_spans(H5S_hyper_span_info_t *a_spans, H5S_hyper_span_info_t *b_s
                 /*                AAAAA                  */
                 /* <-----------------------------------> */
                 /*             BBBBBBBBBB                */
-                else if(span_a->low >= span_b->low && span_a->high <= span_b->high) {
+                else if (span_a->low >= span_b->low && span_a->high <= span_b->high) {
                     /* Split off lower part of span 'b' at lower span of span 'a' */
 
                     /* Check if there is actually a lower part of span 'b' to split off */
-                    if(span_a->low > span_b->low) {
+                    if (span_a->low > span_b->low) {
                         /* Merge/add lower part of span 'b' with/to b_not_a list */
-                        if(need_b_not_a)
-                            if(H5S__hyper_append_span(b_not_a, ndims, span_b->low, span_a->low - 1, span_b->down) < 0)
-                                HGOTO_ERROR(H5E_DATASPACE, H5E_CANTAPPEND, FAIL, "can't allocate hyperslab span")
+                        if (need_b_not_a)
+                            if (H5S__hyper_append_span(b_not_a, ndims, span_b->low, span_a->low - 1,
+                                                       span_b->down) < 0)
+                                HGOTO_ERROR(H5E_DATASPACE, H5E_CANTAPPEND, FAIL,
+                                            "can't allocate hyperslab span")
                     } /* end if */
                     else {
                         /* Keep going, nothing to split off */
@@ -7651,16 +7668,19 @@ H5S__hyper_clip_spans(H5S_hyper_span_info_t *a_spans, H5S_hyper_span_info_t *b_s
                     /* Check for overlaps between span 'a' and midle of span 'b' */
 
                     /* Make certain both spans either have a down span or both don't have one */
-                    HDassert((span_a->down != NULL && span_b->down != NULL) || (span_a->down == NULL && span_b->down == NULL));
+                    HDassert((span_a->down != NULL && span_b->down != NULL) ||
+                             (span_a->down == NULL && span_b->down == NULL));
 
                     /* If there are no down spans, just add the overlapping area to the a_and_b list */
-                    if(span_a->down == NULL) {
+                    if (span_a->down == NULL) {
                         /* Merge/add overlapped part with/to a_and_b list */
-                        if(need_a_and_b)
-                            if(H5S__hyper_append_span(a_and_b, ndims, span_a->low, span_a->high, NULL) < 0)
-                                HGOTO_ERROR(H5E_DATASPACE, H5E_CANTAPPEND, FAIL, "can't allocate hyperslab span")
+                        if (need_a_and_b)
+                            if (H5S__hyper_append_span(a_and_b, ndims, span_a->low, span_a->high, NULL) < 0)
+                                HGOTO_ERROR(H5E_DATASPACE, H5E_CANTAPPEND, FAIL,
+                                            "can't allocate hyperslab span")
                     } /* end if */
-                    /* If there are down spans, check for the overlap in them and add to each appropriate list */
+                    /* If there are down spans, check for the overlap in them and add to each appropriate list
+                     */
                     else {
                         /* NULL out the temporary pointers to clipped areas in down spans */
                         down_a_not_b = NULL;
@@ -7668,52 +7688,60 @@ H5S__hyper_clip_spans(H5S_hyper_span_info_t *a_spans, H5S_hyper_span_info_t *b_s
                         down_b_not_a = NULL;
 
                         /* Check for overlaps in the 'down spans' of span 'a' & 'b' */
-                        if(H5S__hyper_clip_spans(span_a->down, span_b->down, selector, ndims - 1, &down_a_not_b, &down_a_and_b, &down_b_not_a) < 0)
+                        if (H5S__hyper_clip_spans(span_a->down, span_b->down, selector, ndims - 1,
+                                                  &down_a_not_b, &down_a_and_b, &down_b_not_a) < 0)
                             HGOTO_ERROR(H5E_DATASPACE, H5E_CANTCLIP, FAIL, "can't clip hyperslab information")
 
                         /* Check for additions to the a_not_b list */
-                        if(down_a_not_b) {
+                        if (down_a_not_b) {
                             HDassert(need_a_not_b == TRUE);
 
                             /* Merge/add overlapped part with/to a_not_b list */
-                            if(H5S__hyper_append_span(a_not_b, ndims, span_a->low, span_a->high, down_a_not_b) < 0)
-                                HGOTO_ERROR(H5E_DATASPACE, H5E_CANTAPPEND, FAIL, "can't allocate hyperslab span")
+                            if (H5S__hyper_append_span(a_not_b, ndims, span_a->low, span_a->high,
+                                                       down_a_not_b) < 0)
+                                HGOTO_ERROR(H5E_DATASPACE, H5E_CANTAPPEND, FAIL,
+                                            "can't allocate hyperslab span")
 
                             /* Release the down span tree generated */
                             H5S__hyper_free_span_info(down_a_not_b);
                         } /* end if */
 
                         /* Check for additions to the a_and_b list */
-                        if(down_a_and_b) {
+                        if (down_a_and_b) {
                             HDassert(need_a_and_b == TRUE);
 
                             /* Merge/add overlapped part with/to a_and_b list */
-                            if(H5S__hyper_append_span(a_and_b, ndims, span_a->low, span_a->high, down_a_and_b) < 0)
-                                HGOTO_ERROR(H5E_DATASPACE, H5E_CANTAPPEND, FAIL, "can't allocate hyperslab span")
+                            if (H5S__hyper_append_span(a_and_b, ndims, span_a->low, span_a->high,
+                                                       down_a_and_b) < 0)
+                                HGOTO_ERROR(H5E_DATASPACE, H5E_CANTAPPEND, FAIL,
+                                            "can't allocate hyperslab span")
 
                             /* Release the down span tree generated */
                             H5S__hyper_free_span_info(down_a_and_b);
                         } /* end if */
 
                         /* Check for additions to the b_not_a list */
-                        if(down_b_not_a) {
+                        if (down_b_not_a) {
                             HDassert(need_b_not_a == TRUE);
 
                             /* Merge/add overlapped part with/to b_not_a list */
-                            if(H5S__hyper_append_span(b_not_a, ndims, span_a->low, span_a->high, down_b_not_a) < 0)
-                                HGOTO_ERROR(H5E_DATASPACE, H5E_CANTAPPEND, FAIL, "can't allocate hyperslab span")
+                            if (H5S__hyper_append_span(b_not_a, ndims, span_a->low, span_a->high,
+                                                       down_b_not_a) < 0)
+                                HGOTO_ERROR(H5E_DATASPACE, H5E_CANTAPPEND, FAIL,
+                                            "can't allocate hyperslab span")
 
                             /* Release the down span tree generated */
                             H5S__hyper_free_span_info(down_b_not_a);
                         } /* end if */
-                    } /* end else */
+                    }     /* end else */
 
                     /* Check if there is actually an upper part of span 'b' to split off */
-                    if(span_a->high < span_b->high) {
+                    if (span_a->high < span_b->high) {
                         /* Split off upper part of span 'b' at upper span of span 'a' */
 
                         /* Allocate new span node for upper part of spans 'a' */
-                        if(NULL == (tmp_span = H5S__hyper_new_span(span_a->high + 1, span_b->high, span_b->down, span_b->next)))
+                        if (NULL == (tmp_span = H5S__hyper_new_span(span_a->high + 1, span_b->high,
+                                                                    span_b->down, span_b->next)))
                             HGOTO_ERROR(H5E_DATASPACE, H5E_CANTALLOC, FAIL, "can't allocate hyperslab span")
 
                         /* And advance span 'a' */
@@ -7728,21 +7756,24 @@ H5S__hyper_clip_spans(H5S_hyper_span_info_t *a_spans, H5S_hyper_span_info_t *b_s
                         H5S_HYPER_ADVANCE_SPAN(recover_a, span_a, span_a->next);
                         H5S_HYPER_ADVANCE_SPAN(recover_b, span_b, span_b->next);
                     } /* end else */
-                } /* end if */
+                }     /* end if */
                 /* Check if span 'a' overlaps only the upper bound */
                 /*  of span 'b' */
                 /*                AAAAAAAAAA             */
                 /* <-----------------------------------> */
                 /*             BBBBBBBBBB                */
-                else if((span_a->low >= span_b->low && span_a->low <= span_b->high) && span_a->high > span_b->high) {
+                else if ((span_a->low >= span_b->low && span_a->low <= span_b->high) &&
+                         span_a->high > span_b->high) {
                     /* Check if there is actually a lower part of span 'b' to split off */
-                    if(span_a->low > span_b->low) {
+                    if (span_a->low > span_b->low) {
                         /* Split off lower part of span 'b' at lower span of span 'a' */
 
                         /* Merge/add lower part of span 'b' with/to b_not_a list */
-                        if(need_b_not_a)
-                            if(H5S__hyper_append_span(b_not_a, ndims, span_b->low, span_a->low - 1, span_b->down) < 0)
-                                HGOTO_ERROR(H5E_DATASPACE, H5E_CANTAPPEND, FAIL, "can't allocate hyperslab span")
+                        if (need_b_not_a)
+                            if (H5S__hyper_append_span(b_not_a, ndims, span_b->low, span_a->low - 1,
+                                                       span_b->down) < 0)
+                                HGOTO_ERROR(H5E_DATASPACE, H5E_CANTAPPEND, FAIL,
+                                            "can't allocate hyperslab span")
                     } /* end if */
                     else {
                         /* Keep going, nothing to split off */
@@ -7751,16 +7782,19 @@ H5S__hyper_clip_spans(H5S_hyper_span_info_t *a_spans, H5S_hyper_span_info_t *b_s
                     /* Check for overlaps between lower part of span 'a' and upper part of span 'b' */
 
                     /* Make certain both spans either have a down span or both don't have one */
-                    HDassert((span_a->down != NULL && span_b->down != NULL) || (span_a->down == NULL && span_b->down == NULL));
+                    HDassert((span_a->down != NULL && span_b->down != NULL) ||
+                             (span_a->down == NULL && span_b->down == NULL));
 
                     /* If there are no down spans, just add the overlapping area to the a_and_b list */
-                    if(span_a->down == NULL) {
+                    if (span_a->down == NULL) {
                         /* Merge/add overlapped part with/to a_and_b list */
-                        if(need_a_and_b)
-                            if(H5S__hyper_append_span(a_and_b, ndims, span_a->low, span_b->high, NULL) < 0)
-                                HGOTO_ERROR(H5E_DATASPACE, H5E_CANTAPPEND, FAIL, "can't allocate hyperslab span")
+                        if (need_a_and_b)
+                            if (H5S__hyper_append_span(a_and_b, ndims, span_a->low, span_b->high, NULL) < 0)
+                                HGOTO_ERROR(H5E_DATASPACE, H5E_CANTAPPEND, FAIL,
+                                            "can't allocate hyperslab span")
                     } /* end if */
-                    /* If there are down spans, check for the overlap in them and add to each appropriate list */
+                    /* If there are down spans, check for the overlap in them and add to each appropriate list
+                     */
                     else {
                         /* NULL out the temporary pointers to clipped areas in down spans */
                         down_a_not_b = NULL;
@@ -7768,50 +7802,58 @@ H5S__hyper_clip_spans(H5S_hyper_span_info_t *a_spans, H5S_hyper_span_info_t *b_s
                         down_b_not_a = NULL;
 
                         /* Check for overlaps in the 'down spans' of span 'a' & 'b' */
-                        if(H5S__hyper_clip_spans(span_a->down, span_b->down, selector, ndims - 1, &down_a_not_b, &down_a_and_b, &down_b_not_a) < 0)
+                        if (H5S__hyper_clip_spans(span_a->down, span_b->down, selector, ndims - 1,
+                                                  &down_a_not_b, &down_a_and_b, &down_b_not_a) < 0)
                             HGOTO_ERROR(H5E_DATASPACE, H5E_CANTCLIP, FAIL, "can't clip hyperslab information")
 
                         /* Check for additions to the a_not_b list */
-                        if(down_a_not_b) {
+                        if (down_a_not_b) {
                             HDassert(need_a_not_b == TRUE);
 
                             /* Merge/add overlapped part with/to a_not_b list */
-                            if(H5S__hyper_append_span(a_not_b, ndims, span_a->low, span_b->high, down_a_not_b) < 0)
-                                HGOTO_ERROR(H5E_DATASPACE, H5E_CANTAPPEND, FAIL, "can't allocate hyperslab span")
+                            if (H5S__hyper_append_span(a_not_b, ndims, span_a->low, span_b->high,
+                                                       down_a_not_b) < 0)
+                                HGOTO_ERROR(H5E_DATASPACE, H5E_CANTAPPEND, FAIL,
+                                            "can't allocate hyperslab span")
 
                             /* Release the down span tree generated */
                             H5S__hyper_free_span_info(down_a_not_b);
                         } /* end if */
 
                         /* Check for additions to the a_and_b list */
-                        if(down_a_and_b) {
+                        if (down_a_and_b) {
                             HDassert(need_a_and_b == TRUE);
 
                             /* Merge/add overlapped part with/to a_and_b list */
-                            if(H5S__hyper_append_span(a_and_b, ndims, span_a->low, span_b->high, down_a_and_b) < 0)
-                                HGOTO_ERROR(H5E_DATASPACE, H5E_CANTAPPEND, FAIL, "can't allocate hyperslab span")
+                            if (H5S__hyper_append_span(a_and_b, ndims, span_a->low, span_b->high,
+                                                       down_a_and_b) < 0)
+                                HGOTO_ERROR(H5E_DATASPACE, H5E_CANTAPPEND, FAIL,
+                                            "can't allocate hyperslab span")
 
                             /* Release the down span tree generated */
                             H5S__hyper_free_span_info(down_a_and_b);
                         } /* end if */
 
                         /* Check for additions to the b_not_a list */
-                        if(down_b_not_a) {
+                        if (down_b_not_a) {
                             HDassert(need_b_not_a == TRUE);
 
                             /* Merge/add overlapped part with/to b_not_a list */
-                            if(H5S__hyper_append_span(b_not_a, ndims, span_a->low, span_b->high, down_b_not_a) < 0)
-                                HGOTO_ERROR(H5E_DATASPACE, H5E_CANTAPPEND, FAIL, "can't allocate hyperslab span")
+                            if (H5S__hyper_append_span(b_not_a, ndims, span_a->low, span_b->high,
+                                                       down_b_not_a) < 0)
+                                HGOTO_ERROR(H5E_DATASPACE, H5E_CANTAPPEND, FAIL,
+                                            "can't allocate hyperslab span")
 
                             /* Release the down span tree generated */
                             H5S__hyper_free_span_info(down_b_not_a);
                         } /* end if */
-                    } /* end else */
+                    }     /* end else */
 
                     /* Split off upper part of span 'a' at upper span of span 'b' */
 
                     /* Allocate new span node for upper part of span 'a' */
-                    if(NULL == (tmp_span = H5S__hyper_new_span(span_b->high + 1, span_a->high, span_a->down, span_a->next)))
+                    if (NULL == (tmp_span = H5S__hyper_new_span(span_b->high + 1, span_a->high, span_a->down,
+                                                                span_a->next)))
                         HGOTO_ERROR(H5E_DATASPACE, H5E_CANTALLOC, FAIL, "can't allocate hyperslab span")
 
                     /* Make upper part of span 'a' into new span 'a' */
@@ -7829,19 +7871,20 @@ H5S__hyper_clip_spans(H5S_hyper_span_info_t *a_spans, H5S_hyper_span_info_t *b_s
                     /* Copy span 'b' and add to b_not_a list */
 
                     /* Merge/add span 'b' with/to b_not_a list */
-                    if(need_b_not_a)
-                        if(H5S__hyper_append_span(b_not_a, ndims, span_b->low, span_b->high, span_b->down) < 0)
+                    if (need_b_not_a)
+                        if (H5S__hyper_append_span(b_not_a, ndims, span_b->low, span_b->high, span_b->down) <
+                            0)
                             HGOTO_ERROR(H5E_DATASPACE, H5E_CANTAPPEND, FAIL, "can't allocate hyperslab span")
 
                     /* Advance span 'b', leave span 'a' */
                     H5S_HYPER_ADVANCE_SPAN(recover_b, span_b, span_b->next);
                 } /* end else */
-            } /* end while */
+            }     /* end while */
 
             /* Clean up 'a' spans which haven't been covered yet */
-            if(span_a != NULL && span_b == NULL) {
+            if (span_a != NULL && span_b == NULL) {
                 /* Check if need to merge/add 'a' spans with/to a_not_b list */
-                if(need_a_not_b) {
+                if (need_a_not_b) {
                     /* (This loop, and the similar one below for 'b' spans,
                      *  could be replaced with an optimized routine that quickly
                      *  appended the remaining spans to the 'not' list, but
@@ -7849,25 +7892,26 @@ H5S__hyper_clip_spans(H5S_hyper_span_info_t *a_spans, H5S_hyper_span_info_t *b_s
                      *  important use case, it's been left generic, and similar
                      *  to other code above. -QAK, 2019/02/01)
                      */
-                    while(span_a != NULL) {
+                    while (span_a != NULL) {
                         /* Copy span 'a' and add to a_not_b list */
-                        if(H5S__hyper_append_span(a_not_b, ndims, span_a->low, span_a->high, span_a->down) < 0)
+                        if (H5S__hyper_append_span(a_not_b, ndims, span_a->low, span_a->high, span_a->down) <
+                            0)
                             HGOTO_ERROR(H5E_DATASPACE, H5E_CANTAPPEND, FAIL, "can't allocate hyperslab span")
 
                         /* Advance to the next 'a' span */
                         H5S_HYPER_ADVANCE_SPAN(recover_a, span_a, span_a->next);
                     } /* end while */
-                } /* end if */
+                }     /* end if */
                 else {
                     /* Free the span, if it's generated */
-                    if(recover_a)
+                    if (recover_a)
                         H5S__hyper_free_span(span_a);
                 } /* end else */
-            } /* end if */
+            }     /* end if */
             /* Clean up 'b' spans which haven't been covered yet */
-            else if(span_a == NULL && span_b != NULL) {
+            else if (span_a == NULL && span_b != NULL) {
                 /* Check if need to merge/add 'b' spans with/to b_not_a list */
-                if(need_b_not_a) {
+                if (need_b_not_a) {
                     /* (This loop, and the similar one above for 'a' spans,
                      *  could be replaced with an optimized routine that quickly
                      *  appended the remaining spans to the 'not' list, but
@@ -7875,32 +7919,32 @@ H5S__hyper_clip_spans(H5S_hyper_span_info_t *a_spans, H5S_hyper_span_info_t *b_s
                      *  important use case, it's been left generic, and similar
                      *  to other code above. -QAK, 2019/02/01)
                      */
-                    while(span_b != NULL) {
+                    while (span_b != NULL) {
                         /* Copy span 'b' and add to b_not_a list */
-                        if(H5S__hyper_append_span(b_not_a, ndims, span_b->low, span_b->high, span_b->down) < 0)
+                        if (H5S__hyper_append_span(b_not_a, ndims, span_b->low, span_b->high, span_b->down) <
+                            0)
                             HGOTO_ERROR(H5E_DATASPACE, H5E_CANTAPPEND, FAIL, "can't allocate hyperslab span")
 
                         /* Advance to the next 'b' span */
                         H5S_HYPER_ADVANCE_SPAN(recover_b, span_b, span_b->next);
                     } /* end while */
-                } /* end if */
+                }     /* end if */
                 else {
                     /* Free the span, if it's generated */
-                    if(recover_b)
+                    if (recover_b)
                         H5S__hyper_free_span(span_b);
                 } /* end else */
-            } /* end if */
+            }     /* end if */
             else
                 /* Sanity check */
                 HDassert(span_a == NULL && span_b == NULL);
         } /* end else */
-    } /* end else */
+    }     /* end else */
 
 done:
     FUNC_LEAVE_NOAPI(ret_value)
 } /* end H5S__hyper_clip_spans() */
 
-
 /*--------------------------------------------------------------------------
  NAME
     H5S__hyper_merge_spans_helper
@@ -7925,11 +7969,10 @@ done:
  REVISION LOG
 --------------------------------------------------------------------------*/
 static H5S_hyper_span_info_t *
-H5S__hyper_merge_spans_helper(H5S_hyper_span_info_t *a_spans, H5S_hyper_span_info_t *b_spans,
-    unsigned ndims)
+H5S__hyper_merge_spans_helper(H5S_hyper_span_info_t *a_spans, H5S_hyper_span_info_t *b_spans, unsigned ndims)
 {
     H5S_hyper_span_info_t *merged_spans = NULL; /* Pointer to the merged span tree */
-    H5S_hyper_span_info_t *ret_value = NULL;    /* Return value */
+    H5S_hyper_span_info_t *ret_value    = NULL; /* Return value */
 
     FUNC_ENTER_STATIC
 
@@ -7937,19 +7980,19 @@ H5S__hyper_merge_spans_helper(H5S_hyper_span_info_t *a_spans, H5S_hyper_span_inf
     HDassert((a_spans != NULL && b_spans != NULL) || (a_spans == NULL && b_spans == NULL));
 
     /* Check if the span trees for the 'a' span and the 'b' span are the same */
-    if(H5S__hyper_cmp_spans(a_spans, b_spans)) {
-        if(a_spans == NULL)
+    if (H5S__hyper_cmp_spans(a_spans, b_spans)) {
+        if (a_spans == NULL)
             merged_spans = NULL;
         else {
             /* Copy one of the span trees to return */
-            if(NULL == (merged_spans = H5S__hyper_copy_span(a_spans, ndims)))
+            if (NULL == (merged_spans = H5S__hyper_copy_span(a_spans, ndims)))
                 HGOTO_ERROR(H5E_INTERNAL, H5E_CANTCOPY, NULL, "can't copy hyperslab span tree")
         } /* end else */
-    } /* end if */
+    }     /* end if */
     else {
-        H5S_hyper_span_t *span_a;           /* Pointer to current span 'a' working on */
-        H5S_hyper_span_t *span_b;           /* Pointer to current span 'b' working on */
-        hbool_t recover_a, recover_b;       /* Flags to indicate when to recover temporary spans */
+        H5S_hyper_span_t *span_a;               /* Pointer to current span 'a' working on */
+        H5S_hyper_span_t *span_b;               /* Pointer to current span 'b' working on */
+        hbool_t           recover_a, recover_b; /* Flags to indicate when to recover temporary spans */
 
         /* Get the pointers to the 'a' and 'b' span lists */
         span_a = a_spans->head;
@@ -7959,17 +8002,17 @@ H5S__hyper_merge_spans_helper(H5S_hyper_span_info_t *a_spans, H5S_hyper_span_inf
         recover_a = recover_b = FALSE;
 
         /* Work through the list of spans in the new list */
-        while(span_a != NULL && span_b != NULL) {
-            H5S_hyper_span_info_t *tmp_spans;   /* Pointer to temporary new span tree */
-            H5S_hyper_span_t *tmp_span;         /* Pointer to temporary new span */
+        while (span_a != NULL && span_b != NULL) {
+            H5S_hyper_span_info_t *tmp_spans; /* Pointer to temporary new span tree */
+            H5S_hyper_span_t *     tmp_span;  /* Pointer to temporary new span */
 
             /* Check if the 'a' span is completely before 'b' span */
             /*    AAAAAAA                            */
             /* <-----------------------------------> */
             /*             BBBBBBBBBB                */
-            if(span_a->high < span_b->low) {
+            if (span_a->high < span_b->low) {
                 /* Merge/add span 'a' with/to the merged spans */
-                if(H5S__hyper_append_span(&merged_spans, ndims, span_a->low, span_a->high, span_a->down) < 0)
+                if (H5S__hyper_append_span(&merged_spans, ndims, span_a->low, span_a->high, span_a->down) < 0)
                     HGOTO_ERROR(H5E_DATASPACE, H5E_CANTAPPEND, NULL, "can't allocate hyperslab span")
 
                 /* Advance span 'a' */
@@ -7980,23 +8023,27 @@ H5S__hyper_merge_spans_helper(H5S_hyper_span_info_t *a_spans, H5S_hyper_span_inf
             /*    AAAAAAAAAAAA                       */
             /* <-----------------------------------> */
             /*             BBBBBBBBBB                */
-            else if(span_a->low < span_b->low && (span_a->high >= span_b->low && span_a->high <= span_b->high)) {
+            else if (span_a->low < span_b->low &&
+                     (span_a->high >= span_b->low && span_a->high <= span_b->high)) {
                 /* Check if span 'a' and span 'b' down spans are equal */
-                if(H5S__hyper_cmp_spans(span_a->down, span_b->down)) {
+                if (H5S__hyper_cmp_spans(span_a->down, span_b->down)) {
                     /* Merge/add copy of span 'a' with/to merged spans */
-                    if(H5S__hyper_append_span(&merged_spans, ndims, span_a->low, span_a->high, span_a->down) < 0)
+                    if (H5S__hyper_append_span(&merged_spans, ndims, span_a->low, span_a->high,
+                                               span_a->down) < 0)
                         HGOTO_ERROR(H5E_DATASPACE, H5E_CANTAPPEND, NULL, "can't allocate hyperslab span")
                 } /* end if */
                 else {
                     /* Merge/add lower part of span 'a' with/to merged spans */
-                    if(H5S__hyper_append_span(&merged_spans, ndims, span_a->low, span_b->low - 1, span_a->down) < 0)
+                    if (H5S__hyper_append_span(&merged_spans, ndims, span_a->low, span_b->low - 1,
+                                               span_a->down) < 0)
                         HGOTO_ERROR(H5E_DATASPACE, H5E_CANTAPPEND, NULL, "can't allocate hyperslab span")
 
                     /* Get merged span tree for overlapped section */
                     tmp_spans = H5S__hyper_merge_spans_helper(span_a->down, span_b->down, ndims - 1);
 
                     /* Merge/add overlapped section to merged spans */
-                    if(H5S__hyper_append_span(&merged_spans, ndims, span_b->low, span_a->high, tmp_spans) < 0)
+                    if (H5S__hyper_append_span(&merged_spans, ndims, span_b->low, span_a->high, tmp_spans) <
+                        0)
                         HGOTO_ERROR(H5E_DATASPACE, H5E_CANTAPPEND, NULL, "can't allocate hyperslab span")
 
                     /* Release merged span tree for overlapped section */
@@ -8004,11 +8051,12 @@ H5S__hyper_merge_spans_helper(H5S_hyper_span_info_t *a_spans, H5S_hyper_span_inf
                 } /* end else */
 
                 /* Check if there is an upper part of span 'b' */
-                if(span_a->high < span_b->high) {
+                if (span_a->high < span_b->high) {
                     /* Copy upper part of span 'b' as new span 'b' */
 
                     /* Allocate new span node to append to list */
-                    if(NULL == (tmp_span = H5S__hyper_new_span(span_a->high + 1, span_b->high, span_b->down, span_b->next)))
+                    if (NULL == (tmp_span = H5S__hyper_new_span(span_a->high + 1, span_b->high, span_b->down,
+                                                                span_b->next)))
                         HGOTO_ERROR(H5E_DATASPACE, H5E_CANTALLOC, NULL, "can't allocate hyperslab span")
 
                     /* Advance span 'a' */
@@ -8023,29 +8071,32 @@ H5S__hyper_merge_spans_helper(H5S_hyper_span_info_t *a_spans, H5S_hyper_span_inf
                     H5S_HYPER_ADVANCE_SPAN(recover_a, span_a, span_a->next);
                     H5S_HYPER_ADVANCE_SPAN(recover_b, span_b, span_b->next);
                 } /* end else */
-            } /* end if */
+            }     /* end if */
             /* Check if span 'a' overlaps the lower & upper bound */
             /*  of span 'b' */
             /*    AAAAAAAAAAAAAAAAAAAAA              */
             /* <-----------------------------------> */
             /*             BBBBBBBBBB                */
-            else if(span_a->low < span_b->low && span_a->high > span_b->high) {
+            else if (span_a->low < span_b->low && span_a->high > span_b->high) {
                 /* Check if span 'a' and span 'b' down spans are equal */
-                if(H5S__hyper_cmp_spans(span_a->down, span_b->down)) {
+                if (H5S__hyper_cmp_spans(span_a->down, span_b->down)) {
                     /* Merge/add copy of lower & middle parts of span 'a' to merged spans */
-                    if(H5S__hyper_append_span(&merged_spans, ndims, span_a->low, span_b->high, span_a->down) < 0)
+                    if (H5S__hyper_append_span(&merged_spans, ndims, span_a->low, span_b->high,
+                                               span_a->down) < 0)
                         HGOTO_ERROR(H5E_DATASPACE, H5E_CANTAPPEND, NULL, "can't allocate hyperslab span")
                 } /* end if */
                 else {
                     /* Merge/add lower part of span 'a' to merged spans */
-                    if(H5S__hyper_append_span(&merged_spans, ndims, span_a->low, span_b->low - 1, span_a->down) < 0)
+                    if (H5S__hyper_append_span(&merged_spans, ndims, span_a->low, span_b->low - 1,
+                                               span_a->down) < 0)
                         HGOTO_ERROR(H5E_DATASPACE, H5E_CANTAPPEND, NULL, "can't allocate hyperslab span")
 
                     /* Get merged span tree for overlapped section */
                     tmp_spans = H5S__hyper_merge_spans_helper(span_a->down, span_b->down, ndims - 1);
 
                     /* Merge/add overlapped section to merged spans */
-                    if(H5S__hyper_append_span(&merged_spans, ndims, span_b->low, span_b->high, tmp_spans) < 0)
+                    if (H5S__hyper_append_span(&merged_spans, ndims, span_b->low, span_b->high, tmp_spans) <
+                        0)
                         HGOTO_ERROR(H5E_DATASPACE, H5E_CANTAPPEND, NULL, "can't allocate hyperslab span")
 
                     /* Release merged span tree for overlapped section */
@@ -8055,7 +8106,8 @@ H5S__hyper_merge_spans_helper(H5S_hyper_span_info_t *a_spans, H5S_hyper_span_inf
                 /* Copy upper part of span 'a' as new span 'a' (remember to free) */
 
                 /* Allocate new span node to append to list */
-                if(NULL == (tmp_span = H5S__hyper_new_span(span_b->high + 1, span_a->high, span_a->down, span_a->next)))
+                if (NULL == (tmp_span = H5S__hyper_new_span(span_b->high + 1, span_a->high, span_a->down,
+                                                            span_a->next)))
                     HGOTO_ERROR(H5E_DATASPACE, H5E_CANTALLOC, NULL, "can't allocate hyperslab span")
 
                 /* Set new span 'a' to tmp_span */
@@ -8069,18 +8121,20 @@ H5S__hyper_merge_spans_helper(H5S_hyper_span_info_t *a_spans, H5S_hyper_span_inf
             /*                AAAAA                  */
             /* <-----------------------------------> */
             /*             BBBBBBBBBB                */
-            else if(span_a->low >= span_b->low && span_a->high <= span_b->high) {
+            else if (span_a->low >= span_b->low && span_a->high <= span_b->high) {
                 /* Check if span 'a' and span 'b' down spans are equal */
-                if(H5S__hyper_cmp_spans(span_a->down, span_b->down)) {
+                if (H5S__hyper_cmp_spans(span_a->down, span_b->down)) {
                     /* Merge/add copy of lower & middle parts of span 'b' to merged spans */
-                    if(H5S__hyper_append_span(&merged_spans, ndims, span_b->low, span_a->high, span_a->down) < 0)
+                    if (H5S__hyper_append_span(&merged_spans, ndims, span_b->low, span_a->high,
+                                               span_a->down) < 0)
                         HGOTO_ERROR(H5E_DATASPACE, H5E_CANTAPPEND, NULL, "can't allocate hyperslab span")
                 } /* end if */
                 else {
                     /* Check if there is a lower part of span 'b' */
-                    if(span_a->low > span_b->low) {
+                    if (span_a->low > span_b->low) {
                         /* Merge/add lower part of span 'b' to merged spans */
-                        if(H5S__hyper_append_span(&merged_spans, ndims, span_b->low, span_a->low - 1, span_b->down) < 0)
+                        if (H5S__hyper_append_span(&merged_spans, ndims, span_b->low, span_a->low - 1,
+                                                   span_b->down) < 0)
                             HGOTO_ERROR(H5E_DATASPACE, H5E_CANTAPPEND, NULL, "can't allocate hyperslab span")
                     } /* end if */
                     else {
@@ -8091,7 +8145,8 @@ H5S__hyper_merge_spans_helper(H5S_hyper_span_info_t *a_spans, H5S_hyper_span_inf
                     tmp_spans = H5S__hyper_merge_spans_helper(span_a->down, span_b->down, ndims - 1);
 
                     /* Merge/add overlapped section to merged spans */
-                    if(H5S__hyper_append_span(&merged_spans, ndims, span_a->low, span_a->high, tmp_spans) < 0)
+                    if (H5S__hyper_append_span(&merged_spans, ndims, span_a->low, span_a->high, tmp_spans) <
+                        0)
                         HGOTO_ERROR(H5E_DATASPACE, H5E_CANTAPPEND, NULL, "can't allocate hyperslab span")
 
                     /* Release merged span tree for overlapped section */
@@ -8099,11 +8154,12 @@ H5S__hyper_merge_spans_helper(H5S_hyper_span_info_t *a_spans, H5S_hyper_span_inf
                 } /* end else */
 
                 /* Check if there is an upper part of span 'b' */
-                if(span_a->high < span_b->high) {
+                if (span_a->high < span_b->high) {
                     /* Copy upper part of span 'b' as new span 'b' (remember to free) */
 
                     /* Allocate new span node to append to list */
-                    if(NULL == (tmp_span = H5S__hyper_new_span(span_a->high + 1, span_b->high, span_b->down, span_b->next)))
+                    if (NULL == (tmp_span = H5S__hyper_new_span(span_a->high + 1, span_b->high, span_b->down,
+                                                                span_b->next)))
                         HGOTO_ERROR(H5E_DATASPACE, H5E_CANTALLOC, NULL, "can't allocate hyperslab span")
 
                     /* Advance span 'a' */
@@ -8118,24 +8174,27 @@ H5S__hyper_merge_spans_helper(H5S_hyper_span_info_t *a_spans, H5S_hyper_span_inf
                     H5S_HYPER_ADVANCE_SPAN(recover_a, span_a, span_a->next);
                     H5S_HYPER_ADVANCE_SPAN(recover_b, span_b, span_b->next);
                 } /* end else */
-            } /* end if */
+            }     /* end if */
             /* Check if span 'a' overlaps only the upper bound */
             /*  of span 'b' */
             /*                AAAAAAAAAA             */
             /* <-----------------------------------> */
             /*             BBBBBBBBBB                */
-            else if((span_a->low >= span_b->low && span_a->low <= span_b->high) && span_a->high > span_b->high) {
+            else if ((span_a->low >= span_b->low && span_a->low <= span_b->high) &&
+                     span_a->high > span_b->high) {
                 /* Check if span 'a' and span 'b' down spans are equal */
-                if(H5S__hyper_cmp_spans(span_a->down, span_b->down)) {
+                if (H5S__hyper_cmp_spans(span_a->down, span_b->down)) {
                     /* Merge/add copy of span 'b' to merged spans if so */
-                    if(H5S__hyper_append_span(&merged_spans, ndims, span_b->low, span_b->high, span_b->down) < 0)
+                    if (H5S__hyper_append_span(&merged_spans, ndims, span_b->low, span_b->high,
+                                               span_b->down) < 0)
                         HGOTO_ERROR(H5E_DATASPACE, H5E_CANTAPPEND, NULL, "can't allocate hyperslab span")
                 } /* end if */
                 else {
                     /* Check if there is a lower part of span 'b' */
-                    if(span_a->low > span_b->low) {
+                    if (span_a->low > span_b->low) {
                         /* Merge/add lower part of span 'b' to merged spans */
-                        if(H5S__hyper_append_span(&merged_spans, ndims, span_b->low, span_a->low - 1, span_b->down) < 0)
+                        if (H5S__hyper_append_span(&merged_spans, ndims, span_b->low, span_a->low - 1,
+                                                   span_b->down) < 0)
                             HGOTO_ERROR(H5E_DATASPACE, H5E_CANTAPPEND, NULL, "can't allocate hyperslab span")
                     } /* end if */
                     else {
@@ -8146,7 +8205,8 @@ H5S__hyper_merge_spans_helper(H5S_hyper_span_info_t *a_spans, H5S_hyper_span_inf
                     tmp_spans = H5S__hyper_merge_spans_helper(span_a->down, span_b->down, ndims - 1);
 
                     /* Merge/add overlapped section to merged spans */
-                    if(H5S__hyper_append_span(&merged_spans, ndims, span_a->low, span_b->high, tmp_spans) < 0)
+                    if (H5S__hyper_append_span(&merged_spans, ndims, span_a->low, span_b->high, tmp_spans) <
+                        0)
                         HGOTO_ERROR(H5E_DATASPACE, H5E_CANTAPPEND, NULL, "can't allocate hyperslab span")
 
                     /* Release merged span tree for overlapped section */
@@ -8156,7 +8216,8 @@ H5S__hyper_merge_spans_helper(H5S_hyper_span_info_t *a_spans, H5S_hyper_span_inf
                 /* Copy upper part of span 'a' as new span 'a' */
 
                 /* Allocate new span node to append to list */
-                if(NULL == (tmp_span = H5S__hyper_new_span(span_b->high + 1, span_a->high, span_a->down, span_a->next)))
+                if (NULL == (tmp_span = H5S__hyper_new_span(span_b->high + 1, span_a->high, span_a->down,
+                                                            span_a->next)))
                     HGOTO_ERROR(H5E_DATASPACE, H5E_CANTALLOC, NULL, "can't allocate hyperslab span")
 
                 /* Set new span 'a' to tmp_span */
@@ -8172,51 +8233,50 @@ H5S__hyper_merge_spans_helper(H5S_hyper_span_info_t *a_spans, H5S_hyper_span_inf
             /*             BBBBBBBBBB                */
             else {
                 /* Merge/add span 'b' with the merged spans */
-                if(H5S__hyper_append_span(&merged_spans, ndims, span_b->low, span_b->high, span_b->down) < 0)
+                if (H5S__hyper_append_span(&merged_spans, ndims, span_b->low, span_b->high, span_b->down) < 0)
                     HGOTO_ERROR(H5E_DATASPACE, H5E_CANTAPPEND, NULL, "can't allocate hyperslab span")
 
                 /* Advance span 'b' */
                 H5S_HYPER_ADVANCE_SPAN(recover_b, span_b, span_b->next);
             } /* end else */
-        } /* end while */
+        }     /* end while */
 
         /* Clean up 'a' spans which haven't been added to the list of merged spans */
-        if(span_a != NULL && span_b == NULL) {
-            while(span_a != NULL) {
+        if (span_a != NULL && span_b == NULL) {
+            while (span_a != NULL) {
                 /* Merge/add all 'a' spans into the merged spans */
-                if(H5S__hyper_append_span(&merged_spans, ndims, span_a->low, span_a->high, span_a->down) < 0)
+                if (H5S__hyper_append_span(&merged_spans, ndims, span_a->low, span_a->high, span_a->down) < 0)
                     HGOTO_ERROR(H5E_DATASPACE, H5E_CANTAPPEND, NULL, "can't allocate hyperslab span")
 
                 /* Advance to next 'a' span, until all processed */
                 H5S_HYPER_ADVANCE_SPAN(recover_a, span_a, span_a->next);
             } /* end while */
-        } /* end if */
+        }     /* end if */
 
         /* Clean up 'b' spans which haven't been added to the list of merged spans */
-        if(span_a == NULL && span_b != NULL) {
-            while(span_b != NULL) {
+        if (span_a == NULL && span_b != NULL) {
+            while (span_b != NULL) {
                 /* Merge/add all 'b' spans into the merged spans */
-                if(H5S__hyper_append_span(&merged_spans, ndims, span_b->low, span_b->high, span_b->down) < 0)
+                if (H5S__hyper_append_span(&merged_spans, ndims, span_b->low, span_b->high, span_b->down) < 0)
                     HGOTO_ERROR(H5E_DATASPACE, H5E_CANTAPPEND, NULL, "can't allocate hyperslab span")
 
                 /* Advance to next 'b' span, until all processed */
                 H5S_HYPER_ADVANCE_SPAN(recover_b, span_b, span_b->next);
             } /* end while */
-        } /* end if */
-    } /* end else */
+        }     /* end if */
+    }         /* end else */
 
     /* Set return value */
     ret_value = merged_spans;
 
 done:
-    if(ret_value == NULL)
-        if(merged_spans)
+    if (ret_value == NULL)
+        if (merged_spans)
             H5S__hyper_free_span_info(merged_spans);
 
     FUNC_LEAVE_NOAPI(ret_value)
 } /* end H5S__hyper_merge_spans_helper() */
 
-
 /*--------------------------------------------------------------------------
  NAME
     H5S__hyper_merge_spans
@@ -8240,7 +8300,7 @@ done:
 static herr_t
 H5S__hyper_merge_spans(H5S_t *space, H5S_hyper_span_info_t *new_spans)
 {
-    herr_t ret_value = SUCCEED;     /* Return value */
+    herr_t ret_value = SUCCEED; /* Return value */
 
     FUNC_ENTER_STATIC
 
@@ -8249,7 +8309,7 @@ H5S__hyper_merge_spans(H5S_t *space, H5S_hyper_span_info_t *new_spans)
     HDassert(new_spans);
 
     /* If this is the first span tree in the hyperslab selection, just use it */
-    if(space->select.sel_info.hslab->span_lst == NULL) {
+    if (space->select.sel_info.hslab->span_lst == NULL) {
         space->select.sel_info.hslab->span_lst = new_spans;
         space->select.sel_info.hslab->span_lst->count++;
     } /* end if */
@@ -8257,7 +8317,8 @@ H5S__hyper_merge_spans(H5S_t *space, H5S_hyper_span_info_t *new_spans)
         H5S_hyper_span_info_t *merged_spans;
 
         /* Get the merged spans */
-        if(NULL == (merged_spans = H5S__hyper_merge_spans_helper(space->select.sel_info.hslab->span_lst, new_spans, space->extent.rank)))
+        if (NULL == (merged_spans = H5S__hyper_merge_spans_helper(space->select.sel_info.hslab->span_lst,
+                                                                  new_spans, space->extent.rank)))
             HGOTO_ERROR(H5E_DATASPACE, H5E_CANTMERGE, FAIL, "can't merge hyperslab spans")
 
         /* Free the previous spans */
@@ -8271,7 +8332,6 @@ done:
     FUNC_LEAVE_NOAPI(ret_value)
 } /* end H5S__hyper_merge_spans() */
 
-
 /*--------------------------------------------------------------------------
  NAME
     H5S__hyper_spans_nelem_helper
@@ -8292,10 +8352,9 @@ done:
  REVISION LOG
 --------------------------------------------------------------------------*/
 static hsize_t
-H5S__hyper_spans_nelem_helper(H5S_hyper_span_info_t *spans, unsigned op_info_i,
-    uint64_t op_gen)
+H5S__hyper_spans_nelem_helper(H5S_hyper_span_info_t *spans, unsigned op_info_i, uint64_t op_gen)
 {
-    hsize_t ret_value = 0;          /* Return value */
+    hsize_t ret_value = 0; /* Return value */
 
     FUNC_ENTER_STATIC_NOERR
 
@@ -8303,25 +8362,25 @@ H5S__hyper_spans_nelem_helper(H5S_hyper_span_info_t *spans, unsigned op_info_i,
     HDassert(spans);
 
     /* Check if the span tree was already counted */
-    if(spans->op_info[op_info_i].op_gen == op_gen)
+    if (spans->op_info[op_info_i].op_gen == op_gen)
         /* Just return the # of elements in the already counted span tree */
         ret_value = spans->op_info[op_info_i].u.nelmts;
-    else {      /* Count the number of elements in the span tree */
-        const H5S_hyper_span_t *span;     /* Hyperslab span */
+    else {                            /* Count the number of elements in the span tree */
+        const H5S_hyper_span_t *span; /* Hyperslab span */
 
         span = spans->head;
-        if(NULL == span->down) {
-            while(span != NULL) {
+        if (NULL == span->down) {
+            while (span != NULL) {
                 /* Compute # of elements covered */
                 ret_value += (span->high - span->low) + 1;
 
                 /* Advance to next span */
                 span = span->next;
             } /* end while */
-        } /* end if */
+        }     /* end if */
         else {
-            while(span != NULL) {
-                hsize_t nelmts;     /* # of elements covered by current span */
+            while (span != NULL) {
+                hsize_t nelmts; /* # of elements covered by current span */
 
                 /* Compute # of elements covered */
                 nelmts = (span->high - span->low) + 1;
@@ -8332,7 +8391,7 @@ H5S__hyper_spans_nelem_helper(H5S_hyper_span_info_t *spans, unsigned op_info_i,
                 /* Advance to next span */
                 span = span->next;
             } /* end while */
-        } /* end else */
+        }     /* end else */
 
         /* Set the operation generation for this span tree, to avoid re-computing */
         spans->op_info[op_info_i].op_gen = op_gen;
@@ -8344,7 +8403,6 @@ H5S__hyper_spans_nelem_helper(H5S_hyper_span_info_t *spans, unsigned op_info_i,
     FUNC_LEAVE_NOAPI(ret_value)
 } /* end H5S__hyper_spans_nelem_helper() */
 
-
 /*--------------------------------------------------------------------------
  NAME
     H5S__hyper_spans_nelem
@@ -8365,8 +8423,8 @@ H5S__hyper_spans_nelem_helper(H5S_hyper_span_info_t *spans, unsigned op_info_i,
 static hsize_t
 H5S__hyper_spans_nelem(H5S_hyper_span_info_t *spans)
 {
-    uint64_t op_gen;            /* Operation generation value */
-    hsize_t ret_value = 0;      /* Return value */
+    uint64_t op_gen;        /* Operation generation value */
+    hsize_t  ret_value = 0; /* Return value */
 
     FUNC_ENTER_STATIC_NOERR
 
@@ -8384,7 +8442,6 @@ H5S__hyper_spans_nelem(H5S_hyper_span_info_t *spans)
     FUNC_LEAVE_NOAPI(ret_value)
 } /* end H5S__hyper_spans_nelem() */
 
-
 /*--------------------------------------------------------------------------
  NAME
     H5S__hyper_add_disjoint_spans
@@ -8411,7 +8468,7 @@ H5S__hyper_spans_nelem(H5S_hyper_span_info_t *spans)
 static herr_t
 H5S__hyper_add_disjoint_spans(H5S_t *space, H5S_hyper_span_info_t *new_spans)
 {
-    herr_t ret_value = SUCCEED;     /* Return value */
+    herr_t ret_value = SUCCEED; /* Return value */
 
     FUNC_ENTER_STATIC
 
@@ -8423,7 +8480,7 @@ H5S__hyper_add_disjoint_spans(H5S_t *space, H5S_hyper_span_info_t *new_spans)
     space->select.num_elem += H5S__hyper_spans_nelem(new_spans);
 
     /* Add the new spans to the existing selection in the dataspace */
-    if(H5S__hyper_merge_spans(space, new_spans) < 0)
+    if (H5S__hyper_merge_spans(space, new_spans) < 0)
         HGOTO_ERROR(H5E_DATASPACE, H5E_CANTINSERT, FAIL, "can't merge hyperslabs")
 
     /* Free the memory space for new spans */
@@ -8433,7 +8490,6 @@ done:
     FUNC_LEAVE_NOAPI(ret_value)
 } /* end H5S__hyper_add_disjoint_spans */
 
-
 /*--------------------------------------------------------------------------
  NAME
     H5S__hyper_make_spans
@@ -8460,14 +8516,14 @@ done:
  REVISION LOG
 --------------------------------------------------------------------------*/
 static H5S_hyper_span_info_t *
-H5S__hyper_make_spans(unsigned rank, const hsize_t *start, const hsize_t *stride,
-    const hsize_t *count, const hsize_t *block)
+H5S__hyper_make_spans(unsigned rank, const hsize_t *start, const hsize_t *stride, const hsize_t *count,
+                      const hsize_t *block)
 {
-    H5S_hyper_span_info_t *down = NULL;     /* Pointer to spans in next dimension down */
-    H5S_hyper_span_t      *last_span;       /* Current position in hyperslab span list */
-    H5S_hyper_span_t      *head = NULL;     /* Head of new hyperslab span list */
-    int                    i;               /* Counters */
-    H5S_hyper_span_info_t *ret_value = NULL;    /* Return value */
+    H5S_hyper_span_info_t *down = NULL;      /* Pointer to spans in next dimension down */
+    H5S_hyper_span_t *     last_span;        /* Current position in hyperslab span list */
+    H5S_hyper_span_t *     head = NULL;      /* Head of new hyperslab span list */
+    int                    i;                /* Counters */
+    H5S_hyper_span_info_t *ret_value = NULL; /* Return value */
 
     FUNC_ENTER_STATIC
 
@@ -8479,32 +8535,32 @@ H5S__hyper_make_spans(unsigned rank, const hsize_t *start, const hsize_t *stride
     HDassert(block);
 
     /* Start creating spans in fastest changing dimension */
-    for(i = (int)(rank - 1); i >= 0; i--) {
-        hsize_t curr_low, curr_high;    /* Current low & high values */
-        hsize_t dim_stride;             /* Current dim's stride */
-        unsigned u;                     /* Local index variable */
+    for (i = (int)(rank - 1); i >= 0; i--) {
+        hsize_t  curr_low, curr_high; /* Current low & high values */
+        hsize_t  dim_stride;          /* Current dim's stride */
+        unsigned u;                   /* Local index variable */
 
         /* Sanity check */
-        if(0 == count[i])
+        if (0 == count[i])
             HGOTO_ERROR(H5E_DATASPACE, H5E_BADVALUE, NULL, "count == 0 is invalid")
 
         /* Start a new list in this dimension */
-        head = NULL;
+        head      = NULL;
         last_span = NULL;
 
         /* Generate all the span segments for this dimension */
-        curr_low = start[i];
-        curr_high = start[i] + (block[i] - 1);
+        curr_low   = start[i];
+        curr_high  = start[i] + (block[i] - 1);
         dim_stride = stride[i];
-        for(u = 0; u < count[i]; u++, curr_low += dim_stride, curr_high += dim_stride) {
-            H5S_hyper_span_t      *span;            /* New hyperslab span */
+        for (u = 0; u < count[i]; u++, curr_low += dim_stride, curr_high += dim_stride) {
+            H5S_hyper_span_t *span; /* New hyperslab span */
 
             /* Allocate a span node */
-            if(NULL == (span = H5FL_MALLOC(H5S_hyper_span_t)))
+            if (NULL == (span = H5FL_MALLOC(H5S_hyper_span_t)))
                 HGOTO_ERROR(H5E_DATASPACE, H5E_CANTALLOC, NULL, "can't allocate hyperslab span")
 
             /* Set the span's basic information */
-            span->low = curr_low;
+            span->low  = curr_low;
             span->high = curr_high;
             span->next = NULL;
 
@@ -8513,7 +8569,7 @@ H5S__hyper_make_spans(unsigned rank, const hsize_t *start, const hsize_t *stride
             span->down = down;
 
             /* Append to the list of spans in this dimension */
-            if(head == NULL)
+            if (head == NULL)
                 head = span;
             else
                 last_span->next = span;
@@ -8523,11 +8579,11 @@ H5S__hyper_make_spans(unsigned rank, const hsize_t *start, const hsize_t *stride
         } /* end for */
 
         /* Increment ref. count of shared span */
-        if(down != NULL)
+        if (down != NULL)
             down->count = (unsigned)count[i];
 
         /* Allocate a span info node */
-        if(NULL == (down = H5S__hyper_new_span_info(rank)))
+        if (NULL == (down = H5S__hyper_new_span_info(rank)))
             HGOTO_ERROR(H5E_DATASPACE, H5E_CANTALLOC, NULL, "can't allocate hyperslab span")
 
         /* Keep the pointer to the next dimension down's completed list */
@@ -8537,19 +8593,21 @@ H5S__hyper_make_spans(unsigned rank, const hsize_t *start, const hsize_t *stride
         down->tail = last_span;
 
         /* Set the low & high bounds for this dimension */
-        down->low_bounds[0] = down->head->low;
+        down->low_bounds[0]  = down->head->low;
         down->high_bounds[0] = down->tail->high;
 
         /* Copy bounds from lower dimensions */
         /* (head & tail pointers share lower dimensions, so using either is OK) */
-        if(head->down) {
-            H5MM_memcpy(&down->low_bounds[1], &head->down->low_bounds[0], sizeof(hsize_t) * ((rank - 1) - (unsigned)i));
-            H5MM_memcpy(&down->high_bounds[1], &head->down->high_bounds[0], sizeof(hsize_t) * ((rank - 1) - (unsigned)i));
+        if (head->down) {
+            H5MM_memcpy(&down->low_bounds[1], &head->down->low_bounds[0],
+                        sizeof(hsize_t) * ((rank - 1) - (unsigned)i));
+            H5MM_memcpy(&down->high_bounds[1], &head->down->high_bounds[0],
+                        sizeof(hsize_t) * ((rank - 1) - (unsigned)i));
         } /* end if */
-    } /* end for */
+    }     /* end for */
 
     /* Indicate that there is a pointer to this tree */
-    if(down)
+    if (down)
         down->count = 1;
 
     /* Success!  Return the head of the list in the slowest changing dimension */
@@ -8557,32 +8615,31 @@ H5S__hyper_make_spans(unsigned rank, const hsize_t *start, const hsize_t *stride
 
 done:
     /* cleanup if error (ret_value will be NULL) */
-    if(!ret_value) {
-        if(head || down) {
-            if(head && down)
-                if(down->head != head)
+    if (!ret_value) {
+        if (head || down) {
+            if (head && down)
+                if (down->head != head)
                     down = NULL;
 
             do {
-                if(down) {
+                if (down) {
                     head = down->head;
                     down = (H5S_hyper_span_info_t *)H5FL_ARR_FREE(hbounds_t, down);
                 } /* end if */
                 down = head->down;
 
-                while(head) {
+                while (head) {
                     last_span = head->next;
-                    head = H5FL_FREE(H5S_hyper_span_t, head);
-                    head = last_span;
+                    head      = H5FL_FREE(H5S_hyper_span_t, head);
+                    head      = last_span;
                 } /* end while */
-            } while(down);
+            } while (down);
         } /* end if */
-    } /* end if */
+    }     /* end if */
 
     FUNC_LEAVE_NOAPI(ret_value)
 } /* end H5S__hyper_make_spans() */
 
-
 /*--------------------------------------------------------------------------
  NAME
     H5S__hyper_update_diminfo
@@ -8612,10 +8669,9 @@ done:
  REVISION LOG
 --------------------------------------------------------------------------*/
 static herr_t
-H5S__hyper_update_diminfo(H5S_t *space, H5S_seloper_t op,
-    const H5S_hyper_dim_t *new_hyper_diminfo)
+H5S__hyper_update_diminfo(H5S_t *space, H5S_seloper_t op, const H5S_hyper_dim_t *new_hyper_diminfo)
 {
-    herr_t ret_value = SUCCEED;      /* Return value */
+    herr_t ret_value = SUCCEED; /* Return value */
 
     FUNC_ENTER_STATIC_NOERR
 
@@ -8625,182 +8681,180 @@ H5S__hyper_update_diminfo(H5S_t *space, H5S_seloper_t op,
 
     /* Check for conditions that prevent us from using the fast algorithm here */
     /* (and instead require H5S__hyper_rebuild) */
-    if(!((op == H5S_SELECT_OR) || (op == H5S_SELECT_XOR))
-            || space->select.sel_info.hslab->diminfo_valid != H5S_DIMINFO_VALID_YES
-            || !space->select.sel_info.hslab->span_lst->head)
+    if (!((op == H5S_SELECT_OR) || (op == H5S_SELECT_XOR)) ||
+        space->select.sel_info.hslab->diminfo_valid != H5S_DIMINFO_VALID_YES ||
+        !space->select.sel_info.hslab->span_lst->head)
         space->select.sel_info.hslab->diminfo_valid = H5S_DIMINFO_VALID_NO;
     else {
-        H5S_hyper_dim_t tmp_diminfo[H5S_MAX_RANK];  /* Temporary dimension info */
-        hbool_t found_nonidentical_dim = FALSE;
-        unsigned curr_dim;
+        H5S_hyper_dim_t tmp_diminfo[H5S_MAX_RANK]; /* Temporary dimension info */
+        hbool_t         found_nonidentical_dim = FALSE;
+        unsigned        curr_dim;
 
         /* Copy current diminfo.opt values */
         H5MM_memcpy(tmp_diminfo, space->select.sel_info.hslab->diminfo.opt, sizeof(tmp_diminfo));
 
         /* Loop over dimensions */
-        for(curr_dim = 0; curr_dim < space->extent.rank; curr_dim++) {
+        for (curr_dim = 0; curr_dim < space->extent.rank; curr_dim++) {
             /* Check for this being identical */
-            if((tmp_diminfo[curr_dim].start != new_hyper_diminfo[curr_dim].start)
-                    || (tmp_diminfo[curr_dim].stride != new_hyper_diminfo[curr_dim].stride)
-                    || (tmp_diminfo[curr_dim].count != new_hyper_diminfo[curr_dim].count)
-                    || (tmp_diminfo[curr_dim].block != new_hyper_diminfo[curr_dim].block)) {
-                hsize_t high_start, high_count, high_block;         /* The start, count & block values for the higher block */
+            if ((tmp_diminfo[curr_dim].start != new_hyper_diminfo[curr_dim].start) ||
+                (tmp_diminfo[curr_dim].stride != new_hyper_diminfo[curr_dim].stride) ||
+                (tmp_diminfo[curr_dim].count != new_hyper_diminfo[curr_dim].count) ||
+                (tmp_diminfo[curr_dim].block != new_hyper_diminfo[curr_dim].block)) {
+                hsize_t high_start, high_count,
+                    high_block; /* The start, count & block values for the higher block */
 
                 /* Dimension is not identical */
                 /* Check if we already found a nonidentical dim - only one is
                  * allowed */
-                if(found_nonidentical_dim) {
+                if (found_nonidentical_dim) {
                     space->select.sel_info.hslab->diminfo_valid = H5S_DIMINFO_VALID_NO;
                     break;
                 } /* end if */
 
                 /* Check that strides are the same, or count is 1 for one of the
                  * slabs */
-                if((tmp_diminfo[curr_dim].stride != new_hyper_diminfo[curr_dim].stride)
-                        && (tmp_diminfo[curr_dim].count > 1)
-                        && (new_hyper_diminfo[curr_dim].count > 1)) {
+                if ((tmp_diminfo[curr_dim].stride != new_hyper_diminfo[curr_dim].stride) &&
+                    (tmp_diminfo[curr_dim].count > 1) && (new_hyper_diminfo[curr_dim].count > 1)) {
                     space->select.sel_info.hslab->diminfo_valid = H5S_DIMINFO_VALID_NO;
                     break;
                 } /* end if */
 
                 /* Patch tmp_diminfo.stride if its count is 1 */
-                if((tmp_diminfo[curr_dim].count == 1)
-                        && (new_hyper_diminfo[curr_dim].count > 1))
+                if ((tmp_diminfo[curr_dim].count == 1) && (new_hyper_diminfo[curr_dim].count > 1))
                     tmp_diminfo[curr_dim].stride = new_hyper_diminfo[curr_dim].stride;
 
                 /* Determine lowest start, and set tmp_diminfo.start, count and
                  *  block to use the lowest, and high_start, high_count and
                  *  high_block to use the highest
                  */
-                if(tmp_diminfo[curr_dim].start < new_hyper_diminfo[curr_dim].start) {
+                if (tmp_diminfo[curr_dim].start < new_hyper_diminfo[curr_dim].start) {
                     high_start = new_hyper_diminfo[curr_dim].start;
                     high_count = new_hyper_diminfo[curr_dim].count;
                     high_block = new_hyper_diminfo[curr_dim].block;
                 } /* end if */
                 else {
-                    high_start = tmp_diminfo[curr_dim].start;
+                    high_start                  = tmp_diminfo[curr_dim].start;
                     tmp_diminfo[curr_dim].start = new_hyper_diminfo[curr_dim].start;
-                    high_count = tmp_diminfo[curr_dim].count;
+                    high_count                  = tmp_diminfo[curr_dim].count;
                     tmp_diminfo[curr_dim].count = new_hyper_diminfo[curr_dim].count;
-                    high_block = tmp_diminfo[curr_dim].block;
+                    high_block                  = tmp_diminfo[curr_dim].block;
                     tmp_diminfo[curr_dim].block = new_hyper_diminfo[curr_dim].block;
                 } /* end else */
 
                 /* If count is 1 for both slabs, take different actions */
-                if((tmp_diminfo[curr_dim].count == 1) && (high_count == 1)) {
+                if ((tmp_diminfo[curr_dim].count == 1) && (high_count == 1)) {
                     /* Check for overlap */
-                    if((tmp_diminfo[curr_dim].start + tmp_diminfo[curr_dim].block)
-                            > high_start) {
+                    if ((tmp_diminfo[curr_dim].start + tmp_diminfo[curr_dim].block) > high_start) {
                         /* Check operation type */
-                        if(op == H5S_SELECT_OR)
+                        if (op == H5S_SELECT_OR)
                             /* Merge blocks */
-                            tmp_diminfo[curr_dim].block = ((high_start + high_block)
-                                    >= (tmp_diminfo[curr_dim].start + tmp_diminfo[curr_dim].block))
+                            tmp_diminfo[curr_dim].block =
+                                ((high_start + high_block) >=
+                                 (tmp_diminfo[curr_dim].start + tmp_diminfo[curr_dim].block))
                                     ? (high_start + high_block - tmp_diminfo[curr_dim].start)
                                     : tmp_diminfo[curr_dim].block;
                         else {
                             /* Block values must be the same */
-                            if(tmp_diminfo[curr_dim].block != high_block) {
+                            if (tmp_diminfo[curr_dim].block != high_block) {
                                 space->select.sel_info.hslab->diminfo_valid = H5S_DIMINFO_VALID_NO;
                                 break;
                             } /* end if */
 
                             /* XOR - overlap creates 2 blocks */
                             tmp_diminfo[curr_dim].stride = high_block;
-                            tmp_diminfo[curr_dim].count = 2;
-                            tmp_diminfo[curr_dim].block = high_start - tmp_diminfo[curr_dim].start;
+                            tmp_diminfo[curr_dim].count  = 2;
+                            tmp_diminfo[curr_dim].block  = high_start - tmp_diminfo[curr_dim].start;
                         } /* end else */
-                    } /* end if */
-                    else if((tmp_diminfo[curr_dim].start + tmp_diminfo[curr_dim].block)
-                            == high_start)
+                    }     /* end if */
+                    else if ((tmp_diminfo[curr_dim].start + tmp_diminfo[curr_dim].block) == high_start)
                         /* Blocks border, merge them */
                         tmp_diminfo[curr_dim].block += high_block;
                     else {
                         /* Distinct blocks */
                         /* Block values must be the same */
-                        if(tmp_diminfo[curr_dim].block != high_block) {
+                        if (tmp_diminfo[curr_dim].block != high_block) {
                             space->select.sel_info.hslab->diminfo_valid = H5S_DIMINFO_VALID_NO;
                             break;
                         } /* end if */
 
                         /* Create strided selection */
                         tmp_diminfo[curr_dim].stride = high_start - tmp_diminfo[curr_dim].start;
-                        tmp_diminfo[curr_dim].count = 2;
+                        tmp_diminfo[curr_dim].count  = 2;
                     } /* end else */
-                } /* end if */
+                }     /* end if */
                 else {
                     /* Check if block values are the same */
-                    if(tmp_diminfo[curr_dim].block != new_hyper_diminfo[curr_dim].block) {
+                    if (tmp_diminfo[curr_dim].block != new_hyper_diminfo[curr_dim].block) {
                         space->select.sel_info.hslab->diminfo_valid = H5S_DIMINFO_VALID_NO;
                         break;
                     } /* end if */
 
                     /* Check phase of strides */
-                    if((tmp_diminfo[curr_dim].start % tmp_diminfo[curr_dim].stride)
-                            != (new_hyper_diminfo[curr_dim].start % tmp_diminfo[curr_dim].stride)) {
+                    if ((tmp_diminfo[curr_dim].start % tmp_diminfo[curr_dim].stride) !=
+                        (new_hyper_diminfo[curr_dim].start % tmp_diminfo[curr_dim].stride)) {
                         space->select.sel_info.hslab->diminfo_valid = H5S_DIMINFO_VALID_NO;
                         break;
                     } /* end if */
 
                     /* Check operation type */
-                    if(op == H5S_SELECT_OR) {
+                    if (op == H5S_SELECT_OR) {
                         /* Make sure the slabs border or overlap */
-                        if(high_start > (tmp_diminfo[curr_dim].start
-                                + (tmp_diminfo[curr_dim].count
-                                * tmp_diminfo[curr_dim].stride))) {
+                        if (high_start > (tmp_diminfo[curr_dim].start +
+                                          (tmp_diminfo[curr_dim].count * tmp_diminfo[curr_dim].stride))) {
                             space->select.sel_info.hslab->diminfo_valid = H5S_DIMINFO_VALID_NO;
                             break;
                         } /* end if */
-                    } /* end if */
+                    }     /* end if */
                     else
                         /* XOR: Make sure the slabs border */
-                        if(high_start != (tmp_diminfo[curr_dim].start
-                                + (tmp_diminfo[curr_dim].count
-                                * tmp_diminfo[curr_dim].stride))) {
-                            space->select.sel_info.hslab->diminfo_valid = H5S_DIMINFO_VALID_NO;
-                            break;
-                        } /* end if */
+                        if (high_start != (tmp_diminfo[curr_dim].start +
+                                           (tmp_diminfo[curr_dim].count * tmp_diminfo[curr_dim].stride))) {
+                        space->select.sel_info.hslab->diminfo_valid = H5S_DIMINFO_VALID_NO;
+                        break;
+                    } /* end if */
 
                     /* Set count for combined selection */
-                    tmp_diminfo[curr_dim].count = ((high_start
-                            - tmp_diminfo[curr_dim].start)
-                            / tmp_diminfo[curr_dim].stride) + high_count;
+                    tmp_diminfo[curr_dim].count =
+                        ((high_start - tmp_diminfo[curr_dim].start) / tmp_diminfo[curr_dim].stride) +
+                        high_count;
                 } /* end else */
 
                 /* Indicate that we found a nonidentical dim */
                 found_nonidentical_dim = TRUE;
             } /* end if */
-        } /* end for */
+        }     /* end for */
 
         /* Check if we succeeded, if so, set the new diminfo values */
-        if(space->select.sel_info.hslab->diminfo_valid == H5S_DIMINFO_VALID_YES)
-            for(curr_dim = 0; curr_dim < space->extent.rank; curr_dim++) {
+        if (space->select.sel_info.hslab->diminfo_valid == H5S_DIMINFO_VALID_YES)
+            for (curr_dim = 0; curr_dim < space->extent.rank; curr_dim++) {
                 hsize_t tmp_high_bound;
 
                 /* Set the new diminfo values */
-                space->select.sel_info.hslab->diminfo.app[curr_dim].start  = space->select.sel_info.hslab->diminfo.opt[curr_dim].start = tmp_diminfo[curr_dim].start;
+                space->select.sel_info.hslab->diminfo.app[curr_dim].start =
+                    space->select.sel_info.hslab->diminfo.opt[curr_dim].start = tmp_diminfo[curr_dim].start;
                 HDassert(tmp_diminfo[curr_dim].stride > 0);
-                space->select.sel_info.hslab->diminfo.app[curr_dim].stride = space->select.sel_info.hslab->diminfo.opt[curr_dim].stride = tmp_diminfo[curr_dim].stride;
+                space->select.sel_info.hslab->diminfo.app[curr_dim].stride =
+                    space->select.sel_info.hslab->diminfo.opt[curr_dim].stride = tmp_diminfo[curr_dim].stride;
                 HDassert(tmp_diminfo[curr_dim].count > 0);
-                space->select.sel_info.hslab->diminfo.app[curr_dim].count  = space->select.sel_info.hslab->diminfo.opt[curr_dim].count = tmp_diminfo[curr_dim].count;
+                space->select.sel_info.hslab->diminfo.app[curr_dim].count =
+                    space->select.sel_info.hslab->diminfo.opt[curr_dim].count = tmp_diminfo[curr_dim].count;
                 HDassert(tmp_diminfo[curr_dim].block > 0);
-                space->select.sel_info.hslab->diminfo.app[curr_dim].block  = space->select.sel_info.hslab->diminfo.opt[curr_dim].block = tmp_diminfo[curr_dim].block;
+                space->select.sel_info.hslab->diminfo.app[curr_dim].block =
+                    space->select.sel_info.hslab->diminfo.opt[curr_dim].block = tmp_diminfo[curr_dim].block;
 
                 /* Check for updating the low & high bounds */
-                if(tmp_diminfo[curr_dim].start < space->select.sel_info.hslab->diminfo.low_bounds[curr_dim])
+                if (tmp_diminfo[curr_dim].start < space->select.sel_info.hslab->diminfo.low_bounds[curr_dim])
                     space->select.sel_info.hslab->diminfo.low_bounds[curr_dim] = tmp_diminfo[curr_dim].start;
-                tmp_high_bound = tmp_diminfo[curr_dim].start +
-                    (tmp_diminfo[curr_dim].block - 1) +
-                    (tmp_diminfo[curr_dim].stride * (tmp_diminfo[curr_dim].count - 1));
-                if(tmp_high_bound > space->select.sel_info.hslab->diminfo.low_bounds[curr_dim])
+                tmp_high_bound = tmp_diminfo[curr_dim].start + (tmp_diminfo[curr_dim].block - 1) +
+                                 (tmp_diminfo[curr_dim].stride * (tmp_diminfo[curr_dim].count - 1));
+                if (tmp_high_bound > space->select.sel_info.hslab->diminfo.low_bounds[curr_dim])
                     space->select.sel_info.hslab->diminfo.high_bounds[curr_dim] = tmp_high_bound;
             } /* end for */
-    } /* end else */
+    }         /* end else */
 
     FUNC_LEAVE_NOAPI(ret_value)
 } /* end H5S__hyper_update_diminfo() */
 
-
 /*--------------------------------------------------------------------------
  NAME
     H5S__hyper_rebuild_helper
@@ -8827,14 +8881,14 @@ H5S__hyper_update_diminfo(H5S_t *space, H5S_seloper_t op,
 static hbool_t
 H5S__hyper_rebuild_helper(const H5S_hyper_span_info_t *spans, H5S_hyper_dim_t span_slab_info[])
 {
-    const H5S_hyper_span_t *span;       /* Hyperslab span */
-    const H5S_hyper_span_t *prev_span;  /* Previous span in list */
-    hsize_t start;              /* Starting element for this dimension */
-    hsize_t stride;             /* Stride for this dimension */
-    hsize_t block;              /* Block size for this dimension */
-    hsize_t prev_low;           /* Low bound for previous span */
-    size_t spancount;           /* Number of spans encountered in this dimension */
-    hbool_t ret_value = TRUE;   /* Return value */
+    const H5S_hyper_span_t *span;             /* Hyperslab span */
+    const H5S_hyper_span_t *prev_span;        /* Previous span in list */
+    hsize_t                 start;            /* Starting element for this dimension */
+    hsize_t                 stride;           /* Stride for this dimension */
+    hsize_t                 block;            /* Block size for this dimension */
+    hsize_t                 prev_low;         /* Low bound for previous span */
+    size_t                  spancount;        /* Number of spans encountered in this dimension */
+    hbool_t                 ret_value = TRUE; /* Return value */
 
     FUNC_ENTER_STATIC_NOERR
 
@@ -8842,15 +8896,15 @@ H5S__hyper_rebuild_helper(const H5S_hyper_span_info_t *spans, H5S_hyper_dim_t sp
     HDassert(spans);
 
     /* Initialization */
-    span = spans->head;
-    stride = 1;
-    prev_low = 0;
+    span      = spans->head;
+    stride    = 1;
+    prev_low  = 0;
     spancount = 0;
 
     /* Get "canonical" down span information */
-    if(span->down)
+    if (span->down)
         /* Go to the next down span and check whether the selection can be rebuilt */
-        if(!H5S__hyper_rebuild_helper(span->down, &span_slab_info[1]))
+        if (!H5S__hyper_rebuild_helper(span->down, &span_slab_info[1]))
             HGOTO_DONE(FALSE)
 
     /* Assign the initial starting point & block size for this dimension */
@@ -8859,31 +8913,31 @@ H5S__hyper_rebuild_helper(const H5S_hyper_span_info_t *spans, H5S_hyper_dim_t sp
 
     /* Loop the spans */
     prev_span = NULL;
-    while(span) {
-        if(spancount > 0) {
-            hsize_t curr_stride;    /* Current stride from previous span */
-            hsize_t curr_block;     /* Block size of current span */
+    while (span) {
+        if (spancount > 0) {
+            hsize_t curr_stride; /* Current stride from previous span */
+            hsize_t curr_block;  /* Block size of current span */
 
             /* Sanity check */
             HDassert(prev_span);
 
             /* Check that down spans match current slab info */
             /* (Can skip check if previous span's down pointer is same as current one) */
-            if(span->down && prev_span->down != span->down)
-                if(!H5S__hyper_cmp_spans(span->down, prev_span->down))
+            if (span->down && prev_span->down != span->down)
+                if (!H5S__hyper_cmp_spans(span->down, prev_span->down))
                     HGOTO_DONE(FALSE)
 
             /* Obtain values for stride and block */
             curr_stride = span->low - prev_low;
-            curr_block = (span->high - span->low) + 1;
+            curr_block  = (span->high - span->low) + 1;
 
             /* Compare stride and block for this span.  To compare stride,
              * three spans are needed.  Account for the first two spans.
              */
-            if(curr_block != block)
+            if (curr_block != block)
                 HGOTO_DONE(FALSE)
-            if(spancount > 1) {
-                if(stride != curr_stride)
+            if (spancount > 1) {
+                if (stride != curr_stride)
                     HGOTO_DONE(FALSE)
             } /* end if */
             else
@@ -8895,7 +8949,7 @@ H5S__hyper_rebuild_helper(const H5S_hyper_span_info_t *spans, H5S_hyper_dim_t sp
 
         /* Advance to next span */
         prev_span = span;
-        span = span->next;
+        span      = span->next;
         spancount++;
     } /* end while */
 
@@ -8909,7 +8963,6 @@ done:
     FUNC_LEAVE_NOAPI(ret_value)
 } /* end H5S__hyper_rebuild_helper() */
 
-
 /*--------------------------------------------------------------------------
  NAME
     H5S__hyper_rebuild
@@ -8944,14 +8997,17 @@ H5S__hyper_rebuild(H5S_t *space)
 
     /* Check whether the slab can be rebuilt */
     /* (Only regular selection can be rebuilt. If yes, fill in correct values) */
-    if(FALSE == H5S__hyper_rebuild_helper(space->select.sel_info.hslab->span_lst, rebuilt_slab_info))
+    if (FALSE == H5S__hyper_rebuild_helper(space->select.sel_info.hslab->span_lst, rebuilt_slab_info))
         space->select.sel_info.hslab->diminfo_valid = H5S_DIMINFO_VALID_IMPOSSIBLE;
     else {
         /* Set the dimension info & bounds for the dataspace, from the rebuilt info */
         H5MM_memcpy(space->select.sel_info.hslab->diminfo.app, rebuilt_slab_info, sizeof(rebuilt_slab_info));
         H5MM_memcpy(space->select.sel_info.hslab->diminfo.opt, rebuilt_slab_info, sizeof(rebuilt_slab_info));
-        H5MM_memcpy(space->select.sel_info.hslab->diminfo.low_bounds, space->select.sel_info.hslab->span_lst->low_bounds, sizeof(hsize_t) * space->extent.rank);
-        H5MM_memcpy(space->select.sel_info.hslab->diminfo.high_bounds, space->select.sel_info.hslab->span_lst->high_bounds, sizeof(hsize_t) * space->extent.rank);
+        H5MM_memcpy(space->select.sel_info.hslab->diminfo.low_bounds,
+                    space->select.sel_info.hslab->span_lst->low_bounds, sizeof(hsize_t) * space->extent.rank);
+        H5MM_memcpy(space->select.sel_info.hslab->diminfo.high_bounds,
+                    space->select.sel_info.hslab->span_lst->high_bounds,
+                    sizeof(hsize_t) * space->extent.rank);
 
         space->select.sel_info.hslab->diminfo_valid = H5S_DIMINFO_VALID_YES;
     } /* end else */
@@ -8959,7 +9015,6 @@ H5S__hyper_rebuild(H5S_t *space)
     FUNC_LEAVE_NOAPI_VOID
 } /* end H5S__hyper_rebuild() */
 
-
 /*--------------------------------------------------------------------------
  NAME
     H5S__hyper_generate_spans
@@ -8981,12 +9036,12 @@ H5S__hyper_rebuild(H5S_t *space)
 static herr_t
 H5S__hyper_generate_spans(H5S_t *space)
 {
-    hsize_t tmp_start[H5S_MAX_RANK];    /* Temporary start information */
-    hsize_t tmp_stride[H5S_MAX_RANK];   /* Temporary stride information */
-    hsize_t tmp_count[H5S_MAX_RANK];    /* Temporary count information */
-    hsize_t tmp_block[H5S_MAX_RANK];    /* Temporary block information */
-    unsigned u;                         /* Local index variable */
-    herr_t ret_value = SUCCEED;         /* Return value */
+    hsize_t  tmp_start[H5S_MAX_RANK];  /* Temporary start information */
+    hsize_t  tmp_stride[H5S_MAX_RANK]; /* Temporary stride information */
+    hsize_t  tmp_count[H5S_MAX_RANK];  /* Temporary count information */
+    hsize_t  tmp_block[H5S_MAX_RANK];  /* Temporary block information */
+    unsigned u;                        /* Local index variable */
+    herr_t   ret_value = SUCCEED;      /* Return value */
 
     FUNC_ENTER_STATIC
 
@@ -8994,31 +9049,30 @@ H5S__hyper_generate_spans(H5S_t *space)
     HDassert(H5S_GET_SELECT_TYPE(space) == H5S_SEL_HYPERSLABS);
 
     /* Get the diminfo */
-    for(u = 0; u < space->extent.rank; u++) {
+    for (u = 0; u < space->extent.rank; u++) {
         /* Check for unlimited dimension and return error */
         /* These should be able to be converted to assertions once everything
          * that calls this function checks for unlimited selections first
          * (especially the new hyperslab API)  -NAF */
-        if(space->select.sel_info.hslab->diminfo.opt[u].count == H5S_UNLIMITED)
+        if (space->select.sel_info.hslab->diminfo.opt[u].count == H5S_UNLIMITED)
             HGOTO_ERROR(H5E_DATASPACE, H5E_UNSUPPORTED, FAIL, "can't generate spans with unlimited count")
-        if(space->select.sel_info.hslab->diminfo.opt[u].block == H5S_UNLIMITED)
+        if (space->select.sel_info.hslab->diminfo.opt[u].block == H5S_UNLIMITED)
             HGOTO_ERROR(H5E_DATASPACE, H5E_UNSUPPORTED, FAIL, "can't generate spans with unlimited block")
 
-        tmp_start[u] = space->select.sel_info.hslab->diminfo.opt[u].start;
+        tmp_start[u]  = space->select.sel_info.hslab->diminfo.opt[u].start;
         tmp_stride[u] = space->select.sel_info.hslab->diminfo.opt[u].stride;
-        tmp_count[u] = space->select.sel_info.hslab->diminfo.opt[u].count;
-        tmp_block[u] = space->select.sel_info.hslab->diminfo.opt[u].block;
+        tmp_count[u]  = space->select.sel_info.hslab->diminfo.opt[u].count;
+        tmp_block[u]  = space->select.sel_info.hslab->diminfo.opt[u].block;
     } /* end for */
 
     /* Build the hyperslab information also */
-    if(H5S__generate_hyperslab(space, H5S_SELECT_SET, tmp_start, tmp_stride, tmp_count, tmp_block) < 0)
+    if (H5S__generate_hyperslab(space, H5S_SELECT_SET, tmp_start, tmp_stride, tmp_count, tmp_block) < 0)
         HGOTO_ERROR(H5E_DATASPACE, H5E_CANTINSERT, FAIL, "can't generate hyperslabs")
 
 done:
     FUNC_LEAVE_NOAPI(ret_value)
 } /* end H5S__hyper_generate_spans() */
 
-
 /*--------------------------------------------------------------------------
  NAME
     H5S__check_spans_overlap
@@ -9038,10 +9092,9 @@ done:
  REVISION LOG
 --------------------------------------------------------------------------*/
 static H5_ATTR_PURE hbool_t
-H5S__check_spans_overlap(const H5S_hyper_span_info_t *spans1,
-    const H5S_hyper_span_info_t *spans2)
+H5S__check_spans_overlap(const H5S_hyper_span_info_t *spans1, const H5S_hyper_span_info_t *spans2)
 {
-    hbool_t ret_value = FALSE;          /* Return value */
+    hbool_t ret_value = FALSE; /* Return value */
 
     FUNC_ENTER_STATIC_NOERR
 
@@ -9050,23 +9103,23 @@ H5S__check_spans_overlap(const H5S_hyper_span_info_t *spans1,
     HDassert(spans2);
 
     /* Use low & high bounds to try to avoid spinning through the span lists */
-    if(H5S_RANGE_OVERLAP(spans1->low_bounds[0], spans1->high_bounds[0],
-                spans2->low_bounds[0], spans2->high_bounds[0])) {
-        H5S_hyper_span_t *span1, *span2;    /* Hyperslab spans */
+    if (H5S_RANGE_OVERLAP(spans1->low_bounds[0], spans1->high_bounds[0], spans2->low_bounds[0],
+                          spans2->high_bounds[0])) {
+        H5S_hyper_span_t *span1, *span2; /* Hyperslab spans */
 
         /* Walk over spans, comparing them for overlap */
         span1 = spans1->head;
         span2 = spans2->head;
-        while(span1 && span2) {
+        while (span1 && span2) {
             /* Check current two spans for overlap */
-            if(H5S_RANGE_OVERLAP(span1->low, span1->high, span2->low, span2->high)) {
+            if (H5S_RANGE_OVERLAP(span1->low, span1->high, span2->low, span2->high)) {
                 /* Check for spans in lowest dimension already */
-                if(span1->down) {
+                if (span1->down) {
                     /* Sanity check */
                     HDassert(span2->down);
 
                     /* Check lower dimensions for overlap */
-                    if(H5S__check_spans_overlap(span1->down, span2->down))
+                    if (H5S__check_spans_overlap(span1->down, span2->down))
                         HGOTO_DONE(TRUE);
                 } /* end if */
                 else
@@ -9074,32 +9127,31 @@ H5S__check_spans_overlap(const H5S_hyper_span_info_t *spans1,
             } /* end if */
 
             /* Advance one of the spans */
-            if(span1->high <= span2->high) {
+            if (span1->high <= span2->high) {
                 /* Advance span1, unless it would be off the list and span2 has more nodes */
-                if(NULL == span1->next && NULL != span2->next)
+                if (NULL == span1->next && NULL != span2->next)
                     span2 = span2->next;
                 else
                     span1 = span1->next;
             } /* end if */
             else {
                 /* Advance span2, unless it would be off the list and span1 has more nodes */
-                if(NULL == span2->next && NULL != span1->next)
+                if (NULL == span2->next && NULL != span1->next)
                     span1 = span1->next;
                 else
                     span2 = span2->next;
             } /* end else */
-        } /* end while */
+        }     /* end while */
 
         /* Make certain we've exhausted our comparisons */
         HDassert((NULL == span1 && (NULL != span2 && NULL == span2->next)) ||
-                ((NULL != span1 && NULL == span1->next) && NULL == span2));
+                 ((NULL != span1 && NULL == span1->next) && NULL == span2));
     } /* end of */
 
 done:
     FUNC_LEAVE_NOAPI(ret_value)
 } /* end H5S__check_spans_overlap() */
 
-
 /*--------------------------------------------------------------------------
  NAME
     H5S__fill_in_new_space
@@ -9130,16 +9182,17 @@ done:
  REVISION LOG
 --------------------------------------------------------------------------*/
 static herr_t
-H5S__fill_in_new_space(H5S_t *space1, H5S_seloper_t op,
-    H5S_hyper_span_info_t *space2_span_lst, hbool_t can_own_span2,
-    hbool_t *span2_owned, hbool_t *updated_spans, H5S_t **result)
+H5S__fill_in_new_space(H5S_t *space1, H5S_seloper_t op, H5S_hyper_span_info_t *space2_span_lst,
+                       hbool_t can_own_span2, hbool_t *span2_owned, hbool_t *updated_spans, H5S_t **result)
 {
-    H5S_hyper_span_info_t *a_not_b = NULL;      /* Span tree for hyperslab spans in old span tree and not in new span tree */
-    H5S_hyper_span_info_t *a_and_b = NULL;      /* Span tree for hyperslab spans in both old and new span trees */
-    H5S_hyper_span_info_t *b_not_a = NULL;      /* Span tree for hyperslab spans in new span tree and not in old span tree */
-    hbool_t overlapped = FALSE;                 /* Whether selections overlap */
+    H5S_hyper_span_info_t *a_not_b =
+        NULL; /* Span tree for hyperslab spans in old span tree and not in new span tree */
+    H5S_hyper_span_info_t *a_and_b = NULL; /* Span tree for hyperslab spans in both old and new span trees */
+    H5S_hyper_span_info_t *b_not_a =
+        NULL; /* Span tree for hyperslab spans in new span tree and not in old span tree */
+    hbool_t overlapped    = FALSE; /* Whether selections overlap */
     hbool_t is_result_new = FALSE;
-    herr_t ret_value = SUCCEED;         /* Return value */
+    herr_t  ret_value     = SUCCEED; /* Return value */
 
     FUNC_ENTER_STATIC
 
@@ -9152,39 +9205,40 @@ H5S__fill_in_new_space(H5S_t *space1, H5S_seloper_t op,
     HDassert(span2_owned);
 
     /* Reset flags to return */
-    *span2_owned = FALSE;
+    *span2_owned   = FALSE;
     *updated_spans = FALSE;
 
     /* The result shares the same info from space1 */
-    if(*result == NULL) {
-        if(NULL == ((*result) = H5S_copy(space1, TRUE, TRUE)))
+    if (*result == NULL) {
+        if (NULL == ((*result) = H5S_copy(space1, TRUE, TRUE)))
             HGOTO_ERROR(H5E_DATASPACE, H5E_CANTINIT, FAIL, "unable to copy dataspace")
         space1->select.sel_info.hslab->span_lst->count--;
         (*result)->select.sel_info.hslab->span_lst = NULL;
-        is_result_new = TRUE;
+        is_result_new                              = TRUE;
     } /* end if */
 
     /* Check both spaces to see if they overlap */
     overlapped = H5S__check_spans_overlap(space1->select.sel_info.hslab->span_lst, space2_span_lst);
 
-    if(!overlapped) {
-        switch(op) {
+    if (!overlapped) {
+        switch (op) {
             case H5S_SELECT_OR:
             case H5S_SELECT_XOR:
                 /* Add the new disjoint spans to the space */
                 /* Copy of space1's spans to *result, and another copy of space2's spans */
-                if(is_result_new)
-                    (*result)->select.sel_info.hslab->span_lst = H5S__hyper_copy_span(space1->select.sel_info.hslab->span_lst, space1->extent.rank);
-                if(!can_own_span2) {
+                if (is_result_new)
+                    (*result)->select.sel_info.hslab->span_lst =
+                        H5S__hyper_copy_span(space1->select.sel_info.hslab->span_lst, space1->extent.rank);
+                if (!can_own_span2) {
                     b_not_a = H5S__hyper_copy_span(space2_span_lst, space1->extent.rank);
-                    if(H5S__hyper_add_disjoint_spans(*result, b_not_a) < 0)
+                    if (H5S__hyper_add_disjoint_spans(*result, b_not_a) < 0)
                         HGOTO_ERROR(H5E_DATASPACE, H5E_CANTINSERT, FAIL, "can't append hyperslabs")
 
                     /* The new_spans are now owned by 'space', so they should not be released */
                     b_not_a = NULL;
                 } /* end if */
                 else {
-                    if(H5S__hyper_add_disjoint_spans(*result, space2_span_lst) < 0)
+                    if (H5S__hyper_add_disjoint_spans(*result, space2_span_lst) < 0)
                         HGOTO_ERROR(H5E_DATASPACE, H5E_CANTINSERT, FAIL, "can't append hyperslabs")
                     *span2_owned = TRUE;
                 } /* end else */
@@ -9195,21 +9249,22 @@ H5S__fill_in_new_space(H5S_t *space1, H5S_seloper_t op,
 
             case H5S_SELECT_AND:
                 /* Convert *result to "none" selection */
-                if(H5S_select_none(*result) < 0)
+                if (H5S_select_none(*result) < 0)
                     HGOTO_ERROR(H5E_DATASPACE, H5E_CANTSELECT, FAIL, "can't convert selection")
                 HGOTO_DONE(SUCCEED);
 
             case H5S_SELECT_NOTB:
                 /* Copy space1's spans to *result */
-                if(is_result_new)
-                    (*result)->select.sel_info.hslab->span_lst = H5S__hyper_copy_span(space1->select.sel_info.hslab->span_lst, space1->extent.rank);
+                if (is_result_new)
+                    (*result)->select.sel_info.hslab->span_lst =
+                        H5S__hyper_copy_span(space1->select.sel_info.hslab->span_lst, space1->extent.rank);
 
                 /* Indicate that the spans changed */
                 *updated_spans = TRUE;
                 break;
 
             case H5S_SELECT_NOTA:
-                if(!is_result_new) {
+                if (!is_result_new) {
                     HDassert(space1 == *result);
 
                     /* Free the current selection */
@@ -9218,11 +9273,12 @@ H5S__fill_in_new_space(H5S_t *space1, H5S_seloper_t op,
                 } /* end if */
 
                 /* Copy space2's spans to *result */
-                if(!can_own_span2)
-                    (*result)->select.sel_info.hslab->span_lst = H5S__hyper_copy_span(space2_span_lst, space1->extent.rank);
+                if (!can_own_span2)
+                    (*result)->select.sel_info.hslab->span_lst =
+                        H5S__hyper_copy_span(space2_span_lst, space1->extent.rank);
                 else {
                     (*result)->select.sel_info.hslab->span_lst = space2_span_lst;
-                    *span2_owned = TRUE;
+                    *span2_owned                               = TRUE;
                 } /* end else */
 
                 /* Reset the number of items in selection */
@@ -9240,12 +9296,12 @@ H5S__fill_in_new_space(H5S_t *space1, H5S_seloper_t op,
             default:
                 HGOTO_ERROR(H5E_ARGS, H5E_UNSUPPORTED, FAIL, "invalid selection operation")
         } /* end switch */
-    } /* end if */
+    }     /* end if */
     else {
-        unsigned selector = 0;                  /* Select which clipping spans to generate */
+        unsigned selector = 0; /* Select which clipping spans to generate */
 
         /* Generate mask for clip operation depending on the op */
-        switch(op) {
+        switch (op) {
             case H5S_SELECT_OR: /* a + b_not_a */
                 selector = H5S_HYPER_COMPUTE_B_NOT_A;
                 break;
@@ -9276,21 +9332,21 @@ H5S__fill_in_new_space(H5S_t *space1, H5S_seloper_t op,
         } /* end switch */
 
         /* Generate lists of spans which overlap and don't overlap */
-        if(H5S__hyper_clip_spans(space1->select.sel_info.hslab->span_lst,
-                space2_span_lst, selector, space1->extent.rank,
-                &a_not_b, &a_and_b, &b_not_a) < 0)
+        if (H5S__hyper_clip_spans(space1->select.sel_info.hslab->span_lst, space2_span_lst, selector,
+                                  space1->extent.rank, &a_not_b, &a_and_b, &b_not_a) < 0)
             HGOTO_ERROR(H5E_DATASPACE, H5E_CANTCLIP, FAIL, "can't clip hyperslab information")
-        switch(op) {
+        switch (op) {
             case H5S_SELECT_OR:
-                if(is_result_new)
-                    (*result)->select.sel_info.hslab->span_lst = H5S__hyper_copy_span(space1->select.sel_info.hslab->span_lst, space1->extent.rank);
+                if (is_result_new)
+                    (*result)->select.sel_info.hslab->span_lst =
+                        H5S__hyper_copy_span(space1->select.sel_info.hslab->span_lst, space1->extent.rank);
                 break;
 
             case H5S_SELECT_AND:
             case H5S_SELECT_XOR:
             case H5S_SELECT_NOTB:
             case H5S_SELECT_NOTA:
-                if(!is_result_new) {
+                if (!is_result_new) {
                     HDassert(space1 == *result);
 
                     /* Free the current selection */
@@ -9313,7 +9369,7 @@ H5S__fill_in_new_space(H5S_t *space1, H5S_seloper_t op,
         } /* end switch */
 
         /* Check if there are any non-overlapped selections */
-        if(a_not_b) {
+        if (a_not_b) {
             /* Other than OR, the span_lst is set to NULL. And in OR,
              *      a_not_b is not needed
              */
@@ -9333,7 +9389,7 @@ H5S__fill_in_new_space(H5S_t *space1, H5S_seloper_t op,
             a_not_b = NULL;
         } /* end if */
 
-        if(a_and_b) {
+        if (a_and_b) {
             /**
              * 1. Other than OR, the span_lst is set to NULL. And in OR,
              *      a_and_b is not needed
@@ -9356,9 +9412,9 @@ H5S__fill_in_new_space(H5S_t *space1, H5S_seloper_t op,
             a_and_b = NULL;
         } /* end if */
 
-        if(b_not_a) {
+        if (b_not_a) {
             /* Merge the b_not_a spans into the result dataspace */
-            if(H5S__hyper_merge_spans(*result, b_not_a) < 0)
+            if (H5S__hyper_merge_spans(*result, b_not_a) < 0)
                 HGOTO_ERROR(H5E_DATASPACE, H5E_CANTINSERT, FAIL, "can't insert hyperslabs")
 
             /* Update the number of elements in current selection */
@@ -9367,10 +9423,10 @@ H5S__fill_in_new_space(H5S_t *space1, H5S_seloper_t op,
             /* Indicate that the spans were updated */
             *updated_spans = TRUE;
         } /* end if */
-    } /* end else for the case the new span overlaps with the old (i.e. space) */
+    }     /* end else for the case the new span overlaps with the old (i.e. space) */
 
     /* Check if the spans weren't updated, and reset selection if so */
-    if(!*updated_spans) {
+    if (!*updated_spans) {
         /* If updated_spans remains FALSE as in this branch, it means the
          *  result has been cleared in XOR / AND / NOTB / NOTA cases, and the
          *  result is a copy of the dataspace in the OR case.
@@ -9379,26 +9435,25 @@ H5S__fill_in_new_space(H5S_t *space1, H5S_seloper_t op,
          *  span trees (i.e. a_not_b, a_and_b, and b_not_a), the
          *  updated_spans must be TRUE.
          */
-        if(H5S_SELECT_OR != op) {
+        if (H5S_SELECT_OR != op) {
             /* Convert *result to "none" selection */
-            if(H5S_select_none(*result) < 0)
+            if (H5S_select_none(*result) < 0)
                 HGOTO_ERROR(H5E_DATASPACE, H5E_CANTSELECT, FAIL, "can't convert selection")
         } /* end else */
-    } /* end if */
+    }     /* end if */
 
 done:
     /* Free resources */
-    if(a_not_b)
+    if (a_not_b)
         H5S__hyper_free_span_info(a_not_b);
-    if(a_and_b)
+    if (a_and_b)
         H5S__hyper_free_span_info(a_and_b);
-    if(b_not_a)
+    if (b_not_a)
         H5S__hyper_free_span_info(b_not_a);
 
     FUNC_LEAVE_NOAPI(ret_value)
 } /* end H5S__fill_in_new_space() */
 
-
 /*-------------------------------------------------------------------------
  * Function:    H5S__generate_hyperlab
  *
@@ -9412,11 +9467,11 @@ done:
  *-------------------------------------------------------------------------
  */
 static herr_t
-H5S__generate_hyperslab(H5S_t *space, H5S_seloper_t op, const hsize_t start[],
-    const hsize_t stride[], const hsize_t count[], const hsize_t block[])
+H5S__generate_hyperslab(H5S_t *space, H5S_seloper_t op, const hsize_t start[], const hsize_t stride[],
+                        const hsize_t count[], const hsize_t block[])
 {
     H5S_hyper_span_info_t *new_spans = NULL;    /* Span tree for new hyperslab */
-    herr_t ret_value = SUCCEED;         /* Return value */
+    herr_t                 ret_value = SUCCEED; /* Return value */
 
     FUNC_ENTER_STATIC
 
@@ -9429,13 +9484,13 @@ H5S__generate_hyperslab(H5S_t *space, H5S_seloper_t op, const hsize_t start[],
     HDassert(block);
 
     /* Generate span tree for new hyperslab information */
-    if(NULL == (new_spans = H5S__hyper_make_spans(space->extent.rank, start, stride, count, block)))
+    if (NULL == (new_spans = H5S__hyper_make_spans(space->extent.rank, start, stride, count, block)))
         HGOTO_ERROR(H5E_DATASPACE, H5E_CANTINSERT, FAIL, "can't create hyperslab information")
 
     /* Generate list of blocks to add/remove based on selection operation */
-    if(op == H5S_SELECT_SET) {
+    if (op == H5S_SELECT_SET) {
         /* Free current selection */
-        if(NULL != space->select.sel_info.hslab->span_lst)
+        if (NULL != space->select.sel_info.hslab->span_lst)
             H5S__hyper_free_span_info(space->select.sel_info.hslab->span_lst);
 
         /* Set the hyperslab selection to the new span tree */
@@ -9449,46 +9504,45 @@ H5S__generate_hyperslab(H5S_t *space, H5S_seloper_t op, const hsize_t start[],
     } /* end if */
     else {
         hbool_t new_spans_owned = FALSE;
-        hbool_t updated_spans = FALSE;
+        hbool_t updated_spans   = FALSE;
 
         /* Generate new spans for space */
-        if(H5S__fill_in_new_space(space, op, new_spans, TRUE, &new_spans_owned, &updated_spans, &space) < 0)
+        if (H5S__fill_in_new_space(space, op, new_spans, TRUE, &new_spans_owned, &updated_spans, &space) < 0)
             HGOTO_ERROR(H5E_DATASPACE, H5E_CANTSELECT, FAIL, "can't generate the specified hyperslab")
 
         /* Check if the spans were updated by H5S__fill_in_new_space */
-        if(updated_spans) {
+        if (updated_spans) {
             H5S_hyper_dim_t new_hyper_diminfo[H5S_MAX_RANK];
-            unsigned u;                         /* Local index variable */
+            unsigned        u; /* Local index variable */
 
             /* Sanity check */
             HDassert(space->select.sel_info.hslab->span_lst->head);
 
             /* Build diminfo struct */
-            for(u = 0; u <space->extent.rank; u++) {
-                new_hyper_diminfo[u].start = start[u];
+            for (u = 0; u < space->extent.rank; u++) {
+                new_hyper_diminfo[u].start  = start[u];
                 new_hyper_diminfo[u].stride = stride[u];
-                new_hyper_diminfo[u].count = count[u];
-                new_hyper_diminfo[u].block = block[u];
+                new_hyper_diminfo[u].count  = count[u];
+                new_hyper_diminfo[u].block  = block[u];
             } /* end for */
 
             /* Update space's dim info */
-            if(H5S__hyper_update_diminfo(space, op, new_hyper_diminfo) < 0)
+            if (H5S__hyper_update_diminfo(space, op, new_hyper_diminfo) < 0)
                 HGOTO_ERROR(H5E_DATASPACE, H5E_CANTCOUNT, FAIL, "can't update hyperslab info")
         } /* end if */
 
         /* Indicate that the new_spans are owned, there's no need to free */
-        if(new_spans_owned)
+        if (new_spans_owned)
             new_spans = NULL;
     } /* end else */
 
 done:
-    if(new_spans)
+    if (new_spans)
         H5S__hyper_free_span_info(new_spans);
 
     FUNC_LEAVE_NOAPI(ret_value)
 } /* end H5S__generate_hyperslab() */
 
-
 /*-------------------------------------------------------------------------
  * Function:    H5S__set_regular_hyperslab
  *
@@ -9502,12 +9556,12 @@ done:
  *-------------------------------------------------------------------------
  */
 herr_t
-H5S__set_regular_hyperslab(H5S_t *space, const hsize_t start[],
-    const hsize_t *app_stride, const hsize_t app_count[], const hsize_t *app_block,
-    const hsize_t *opt_stride, const hsize_t opt_count[], const hsize_t *opt_block)
+H5S__set_regular_hyperslab(H5S_t *space, const hsize_t start[], const hsize_t *app_stride,
+                           const hsize_t app_count[], const hsize_t *app_block, const hsize_t *opt_stride,
+                           const hsize_t opt_count[], const hsize_t *opt_block)
 {
-    unsigned u;                         /* Local index variable */
-    herr_t ret_value = SUCCEED;         /* Return value */
+    unsigned u;                   /* Local index variable */
+    herr_t   ret_value = SUCCEED; /* Return value */
 
     FUNC_ENTER_STATIC
 
@@ -9522,27 +9576,27 @@ H5S__set_regular_hyperslab(H5S_t *space, const hsize_t start[],
     HDassert(opt_block);
 
     /* If we are setting a new selection, remove current selection first */
-    if(H5S_SELECT_RELEASE(space) < 0)
+    if (H5S_SELECT_RELEASE(space) < 0)
         HGOTO_ERROR(H5E_DATASPACE, H5E_CANTDELETE, FAIL, "can't release selection")
 
     /* Allocate space for the hyperslab selection information */
-    if(NULL == (space->select.sel_info.hslab = H5FL_MALLOC(H5S_hyper_sel_t)))
+    if (NULL == (space->select.sel_info.hslab = H5FL_MALLOC(H5S_hyper_sel_t)))
         HGOTO_ERROR(H5E_DATASPACE, H5E_CANTALLOC, FAIL, "can't allocate hyperslab info")
 
     /* Set the diminfo */
-    space->select.num_elem = 1;
+    space->select.num_elem                  = 1;
     space->select.sel_info.hslab->unlim_dim = -1;
-    for(u = 0; u < space->extent.rank; u++) {
+    for (u = 0; u < space->extent.rank; u++) {
         /* Set application and optimized hyperslab info */
-        space->select.sel_info.hslab->diminfo.app[u].start = start[u];
+        space->select.sel_info.hslab->diminfo.app[u].start  = start[u];
         space->select.sel_info.hslab->diminfo.app[u].stride = app_stride[u];
-        space->select.sel_info.hslab->diminfo.app[u].count = app_count[u];
-        space->select.sel_info.hslab->diminfo.app[u].block = app_block[u];
+        space->select.sel_info.hslab->diminfo.app[u].count  = app_count[u];
+        space->select.sel_info.hslab->diminfo.app[u].block  = app_block[u];
 
-        space->select.sel_info.hslab->diminfo.opt[u].start = start[u];
+        space->select.sel_info.hslab->diminfo.opt[u].start  = start[u];
         space->select.sel_info.hslab->diminfo.opt[u].stride = opt_stride[u];
-        space->select.sel_info.hslab->diminfo.opt[u].count = opt_count[u];
-        space->select.sel_info.hslab->diminfo.opt[u].block = opt_block[u];
+        space->select.sel_info.hslab->diminfo.opt[u].count  = opt_count[u];
+        space->select.sel_info.hslab->diminfo.opt[u].block  = opt_block[u];
 
         /* Update # of elements selected */
         space->select.num_elem *= (opt_count[u] * opt_block[u]);
@@ -9551,20 +9605,21 @@ H5S__set_regular_hyperslab(H5S_t *space, const hsize_t start[],
         space->select.sel_info.hslab->diminfo.low_bounds[u] = start[u];
 
         /* Check for unlimited dimension & set high bound */
-        if((app_count[u] == H5S_UNLIMITED) || (app_block[u] == H5S_UNLIMITED)) {
-            space->select.sel_info.hslab->unlim_dim = (int)u;
+        if ((app_count[u] == H5S_UNLIMITED) || (app_block[u] == H5S_UNLIMITED)) {
+            space->select.sel_info.hslab->unlim_dim              = (int)u;
             space->select.sel_info.hslab->diminfo.high_bounds[u] = H5S_UNLIMITED;
         } /* end if */
         else
-            space->select.sel_info.hslab->diminfo.high_bounds[u] = start[u] + opt_stride[u] * (opt_count[u] - 1) + (opt_block[u] - 1);
+            space->select.sel_info.hslab->diminfo.high_bounds[u] =
+                start[u] + opt_stride[u] * (opt_count[u] - 1) + (opt_block[u] - 1);
     } /* end for */
 
     /* Handle unlimited selections */
-    if(space->select.sel_info.hslab->unlim_dim >= 0) {
+    if (space->select.sel_info.hslab->unlim_dim >= 0) {
         /* Calculate num_elem_non_unlim */
         space->select.sel_info.hslab->num_elem_non_unlim = (hsize_t)1;
-        for(u = 0; u < space->extent.rank; u++)
-            if((int)u != space->select.sel_info.hslab->unlim_dim)
+        for (u = 0; u < space->extent.rank; u++)
+            if ((int)u != space->select.sel_info.hslab->unlim_dim)
                 space->select.sel_info.hslab->num_elem_non_unlim *= (opt_count[u] * opt_block[u]);
 
         /* Update num_elem */
@@ -9584,7 +9639,6 @@ done:
     FUNC_LEAVE_NOAPI(ret_value)
 } /* end H5S__set_regular_hyperslab() */
 
-
 /*-------------------------------------------------------------------------
  * Function:    H5S__hyper_regular_and_single_block
  *
@@ -9602,14 +9656,13 @@ done:
  *-------------------------------------------------------------------------
  */
 static herr_t
-H5S__hyper_regular_and_single_block(H5S_t *space, const hsize_t start[],
-    const hsize_t block[])
+H5S__hyper_regular_and_single_block(H5S_t *space, const hsize_t start[], const hsize_t block[])
 {
-    hsize_t select_end, block_end;      /* End of block & selection */
-    hbool_t single_block;       /* Whether the selection is a single block */
-    hbool_t overlap;            /* Whether block & selection overlap */
-    unsigned u;                 /* Local index variable */
-    herr_t ret_value = SUCCEED; /* Return value */
+    hsize_t  select_end, block_end; /* End of block & selection */
+    hbool_t  single_block;          /* Whether the selection is a single block */
+    hbool_t  overlap;               /* Whether block & selection overlap */
+    unsigned u;                     /* Local index variable */
+    herr_t   ret_value = SUCCEED;   /* Return value */
 
     FUNC_ENTER_STATIC
 
@@ -9620,26 +9673,27 @@ H5S__hyper_regular_and_single_block(H5S_t *space, const hsize_t start[],
 
     /* Check for single block selection in dataspace */
     single_block = TRUE;
-    for(u = 0; u < space->extent.rank; u++)
-        if(1 != space->select.sel_info.hslab->diminfo.opt[u].count) {
+    for (u = 0; u < space->extent.rank; u++)
+        if (1 != space->select.sel_info.hslab->diminfo.opt[u].count) {
             single_block = FALSE;
             break;
         } /* end if */
 
     /* Perform different optimizations, based on type of regular selection */
-    if(single_block) {
-        hsize_t new_start[H5S_MAX_RANK];        /* New starting coordinate */
-        hsize_t new_block[H5S_MAX_RANK];        /* New block size */
+    if (single_block) {
+        hsize_t new_start[H5S_MAX_RANK]; /* New starting coordinate */
+        hsize_t new_block[H5S_MAX_RANK]; /* New block size */
 
         /* Check for overlap and compute new start offset & block sizes */
         overlap = TRUE;
-        for(u = 0; u < space->extent.rank; u++) {
+        for (u = 0; u < space->extent.rank; u++) {
             /* Compute the end of the selection & block in this dimension */
             select_end = space->select.sel_info.hslab->diminfo.high_bounds[u];
-            block_end = (start[u] + block[u]) - 1;
+            block_end  = (start[u] + block[u]) - 1;
 
             /* Check for overlap */
-            if(!H5S_RANGE_OVERLAP(space->select.sel_info.hslab->diminfo.opt[u].start, select_end, start[u], block_end)) {
+            if (!H5S_RANGE_OVERLAP(space->select.sel_info.hslab->diminfo.opt[u].start, select_end, start[u],
+                                   block_end)) {
                 overlap = FALSE;
                 break;
             } /* end if */
@@ -9650,125 +9704,122 @@ H5S__hyper_regular_and_single_block(H5S_t *space, const hsize_t start[],
         } /* end for */
 
         /* Check for overlap of selection & block */
-        if(overlap) {
+        if (overlap) {
             /* Set selection to regular hyperslab */
-            if(H5S__set_regular_hyperslab(space, new_start, H5S_hyper_ones_g, H5S_hyper_ones_g, new_block,
-                    H5S_hyper_ones_g, H5S_hyper_ones_g, new_block) < 0)
+            if (H5S__set_regular_hyperslab(space, new_start, H5S_hyper_ones_g, H5S_hyper_ones_g, new_block,
+                                           H5S_hyper_ones_g, H5S_hyper_ones_g, new_block) < 0)
                 HGOTO_ERROR(H5E_DATASPACE, H5E_CANTSET, FAIL, "can't set regular hyperslab selection")
         } /* end if */
         else
             /* Selection & block don't overlap, set to "none" selection */
-            if(H5S_select_none(space) < 0)
-                HGOTO_ERROR(H5E_DATASPACE, H5E_CANTSELECT, FAIL, "can't convert selection")
+            if (H5S_select_none(space) < 0)
+            HGOTO_ERROR(H5E_DATASPACE, H5E_CANTSELECT, FAIL, "can't convert selection")
     } /* end if */
     else {
         hsize_t new_start[H5S_MAX_RANK]; /* New start for hyperslab selection */
         hsize_t new_count[H5S_MAX_RANK]; /* New count for hyperslab selection */
-        hsize_t stride[H5S_MAX_RANK];   /* Stride for hyperslab selection */
+        hsize_t stride[H5S_MAX_RANK];    /* Stride for hyperslab selection */
         hsize_t new_block[H5S_MAX_RANK]; /* New block for hyperslab selection */
-        hbool_t partial_first_span;     /* Whether first span in intersection is partial */
-        hbool_t partial_last_span;      /* Whether last span in intersection is partial */
+        hbool_t partial_first_span;      /* Whether first span in intersection is partial */
+        hbool_t partial_last_span;       /* Whether last span in intersection is partial */
 
         /* Iterate over selection, checking for overlap and computing first / last
          *      span that intersects with the block.
          */
-        overlap = TRUE;
+        overlap            = TRUE;
         partial_first_span = FALSE;
-        partial_last_span = FALSE;
-        for(u = 0; u < space->extent.rank; u++) {
-            hsize_t first_span_start, first_span_end;   /* Start / end of first span */
+        partial_last_span  = FALSE;
+        for (u = 0; u < space->extent.rank; u++) {
+            hsize_t first_span_start, first_span_end; /* Start / end of first span */
             hsize_t last_span_start, last_span_end;   /* Start / end of last span */
-            hsize_t nstride;    /* Number of strides into the selection */
+            hsize_t nstride;                          /* Number of strides into the selection */
 
             /* Compute the end of the selection & block in this dimension */
             select_end = space->select.sel_info.hslab->diminfo.high_bounds[u];
-            block_end = (start[u] + block[u]) - 1;
+            block_end  = (start[u] + block[u]) - 1;
 
             /* Check for overlap */
-            if(!H5S_RANGE_OVERLAP(space->select.sel_info.hslab->diminfo.opt[u].start, select_end, start[u], block_end)) {
+            if (!H5S_RANGE_OVERLAP(space->select.sel_info.hslab->diminfo.opt[u].start, select_end, start[u],
+                                   block_end)) {
                 overlap = FALSE;
                 break;
             } /* end if */
 
             /* Find first span that is before or overlaps with start of block */
-            if(space->select.sel_info.hslab->diminfo.opt[u].start >= start[u]) {
+            if (space->select.sel_info.hslab->diminfo.opt[u].start >= start[u]) {
                 /* Calculate start & end of first span */
                 first_span_start = space->select.sel_info.hslab->diminfo.opt[u].start;
-                first_span_end = (first_span_start +
-                        space->select.sel_info.hslab->diminfo.opt[u].block) - 1;
+                first_span_end = (first_span_start + space->select.sel_info.hslab->diminfo.opt[u].block) - 1;
 
                 /* Check if first span overlaps _end_ of block */
-                if(block_end >= first_span_start && block_end <= first_span_end)
+                if (block_end >= first_span_start && block_end <= first_span_end)
                     partial_first_span = TRUE;
             } /* end if */
             else {
-                hsize_t adj_start;  /* Start coord, adjusted for hyperslab selection parameters */
+                hsize_t adj_start; /* Start coord, adjusted for hyperslab selection parameters */
 
                 /* Adjust start coord for selection's 'start' offset */
                 adj_start = start[u] - space->select.sel_info.hslab->diminfo.opt[u].start;
 
                 /* Compute # of strides into the selection */
-                if(space->select.sel_info.hslab->diminfo.opt[u].count > 1)
+                if (space->select.sel_info.hslab->diminfo.opt[u].count > 1)
                     nstride = adj_start / space->select.sel_info.hslab->diminfo.opt[u].stride;
                 else
                     nstride = 0;
 
                 /* Calculate start & end of first span */
                 first_span_start = space->select.sel_info.hslab->diminfo.opt[u].start +
-                        (nstride * space->select.sel_info.hslab->diminfo.opt[u].stride);
-                first_span_end = (first_span_start +
-                        space->select.sel_info.hslab->diminfo.opt[u].block) - 1;
+                                   (nstride * space->select.sel_info.hslab->diminfo.opt[u].stride);
+                first_span_end = (first_span_start + space->select.sel_info.hslab->diminfo.opt[u].block) - 1;
 
                 /* Check if first span overlaps start of block */
-                if(first_span_start < start[u] && first_span_end >= start[u])
+                if (first_span_start < start[u] && first_span_end >= start[u])
                     partial_first_span = TRUE;
 
                 /* Advance first span to start higher than block's start,
                  *      if it's not partial.
                  */
-                if(first_span_end < start[u]) {
+                if (first_span_end < start[u]) {
                     first_span_start += space->select.sel_info.hslab->diminfo.opt[u].stride;
                     first_span_end += space->select.sel_info.hslab->diminfo.opt[u].stride;
                 } /* end if */
-            } /* end else */
+            }     /* end else */
 
             /* Find last span that is before or overlaps with end of block */
-            if(select_end < block_end) {
+            if (select_end < block_end) {
                 /* Calculate start & end of last span */
-                last_span_start = (select_end -
-                        space->select.sel_info.hslab->diminfo.opt[u].block) + 1;
-                last_span_end = select_end;
+                last_span_start = (select_end - space->select.sel_info.hslab->diminfo.opt[u].block) + 1;
+                last_span_end   = select_end;
 
                 /* Check if last span overlaps _start_ of block */
-                if(start[u] >= last_span_start && start[u] <= last_span_end)
+                if (start[u] >= last_span_start && start[u] <= last_span_end)
                     partial_last_span = TRUE;
             } /* end if */
             else {
-                hsize_t adj_end;    /* End coord, adjusted for hyperslab selection parameters */
+                hsize_t adj_end; /* End coord, adjusted for hyperslab selection parameters */
 
                 /* Adjust end coord for selection's 'start' offset */
                 adj_end = block_end - space->select.sel_info.hslab->diminfo.opt[u].start;
 
                 /* Compute # of strides into the selection */
-                if(space->select.sel_info.hslab->diminfo.opt[u].count > 1)
+                if (space->select.sel_info.hslab->diminfo.opt[u].count > 1)
                     nstride = adj_end / space->select.sel_info.hslab->diminfo.opt[u].stride;
                 else
                     nstride = 0;
 
                 /* Calculate start & end of last span */
                 last_span_start = space->select.sel_info.hslab->diminfo.opt[u].start +
-                        (nstride * space->select.sel_info.hslab->diminfo.opt[u].stride);
-                last_span_end = (last_span_start +
-                        space->select.sel_info.hslab->diminfo.opt[u].block) - 1;
+                                  (nstride * space->select.sel_info.hslab->diminfo.opt[u].stride);
+                last_span_end = (last_span_start + space->select.sel_info.hslab->diminfo.opt[u].block) - 1;
 
                 /* Check if last span overlaps end of block */
-                if(block_end >= last_span_start && block_end <= last_span_end)
+                if (block_end >= last_span_start && block_end <= last_span_end)
                     partial_last_span = TRUE;
             } /* end else */
 
             /* Check if no spans are inside block */
             /* (Can happen when block falls in "gap" between spans) */
-            if(last_span_end < start[u]) {
+            if (last_span_end < start[u]) {
                 overlap = FALSE;
                 break;
             } /* end if */
@@ -9778,9 +9829,10 @@ H5S__hyper_regular_and_single_block(H5S_t *space, const hsize_t start[],
 
             /* Compute new start / count / block values */
             new_start[u] = first_span_start;
-            if(last_span_start != first_span_start)
+            if (last_span_start != first_span_start)
                 new_count[u] = ((last_span_start - first_span_start) /
-                        space->select.sel_info.hslab->diminfo.opt[u].stride) + 1;
+                                space->select.sel_info.hslab->diminfo.opt[u].stride) +
+                               1;
             else
                 new_count[u] = 1;
             new_block[u] = space->select.sel_info.hslab->diminfo.opt[u].block;
@@ -9790,35 +9842,35 @@ H5S__hyper_regular_and_single_block(H5S_t *space, const hsize_t start[],
         } /* end for */
 
         /* Check for overlap of selection & block */
-        if(overlap) {
+        if (overlap) {
             /* Set selection to regular hyperslab */
-            if(H5S__set_regular_hyperslab(space, new_start, stride, new_count, new_block,
-                    stride, new_count, new_block) < 0)
+            if (H5S__set_regular_hyperslab(space, new_start, stride, new_count, new_block, stride, new_count,
+                                           new_block) < 0)
                 HGOTO_ERROR(H5E_DATASPACE, H5E_CANTSET, FAIL, "can't set regular hyperslab selection")
 
             /* If there's a partial first or last span, have to 'AND' against selection */
-            if(partial_first_span || partial_last_span) {
+            if (partial_first_span || partial_last_span) {
                 /* Generate span tree for regular selection */
-                if(H5S__hyper_generate_spans(space) < 0)
+                if (H5S__hyper_generate_spans(space) < 0)
                     HGOTO_ERROR(H5E_DATASPACE, H5E_UNINITIALIZED, FAIL, "dataspace does not have span tree")
 
                 /* 'AND' against block */
-                if(H5S__generate_hyperslab(space, H5S_SELECT_AND, start, H5S_hyper_ones_g, H5S_hyper_ones_g, block) < 0)
+                if (H5S__generate_hyperslab(space, H5S_SELECT_AND, start, H5S_hyper_ones_g, H5S_hyper_ones_g,
+                                            block) < 0)
                     HGOTO_ERROR(H5E_DATASPACE, H5E_CANTINSERT, FAIL, "can't generate hyperslabs")
             } /* end if */
-        } /* end if */
+        }     /* end if */
         else {
             /* Selection & block don't overlap, set to "none" selection */
-            if(H5S_select_none(space) < 0)
+            if (H5S_select_none(space) < 0)
                 HGOTO_ERROR(H5E_DATASPACE, H5E_CANTSELECT, FAIL, "can't convert selection")
         } /* end else */
-    } /* end else */
+    }     /* end else */
 
 done:
     FUNC_LEAVE_NOAPI(ret_value)
 } /* end H5S__hyper_regular_and_single_block() */
 
-
 /*-------------------------------------------------------------------------
  * Function:    H5S_select_hyperslab
  *
@@ -9832,18 +9884,18 @@ done:
  *-------------------------------------------------------------------------
  */
 herr_t
-H5S_select_hyperslab(H5S_t *space, H5S_seloper_t op, const hsize_t start[],
-    const hsize_t *stride, const hsize_t count[], const hsize_t *block)
+H5S_select_hyperslab(H5S_t *space, H5S_seloper_t op, const hsize_t start[], const hsize_t *stride,
+                     const hsize_t count[], const hsize_t *block)
 {
-    hsize_t int_stride[H5S_MAX_RANK];   /* Internal storage for stride information */
-    hsize_t int_count[H5S_MAX_RANK];    /* Internal storage for count information */
-    hsize_t int_block[H5S_MAX_RANK];    /* Internal storage for block information */
-    const hsize_t *opt_stride;      /* Optimized stride information */
-    const hsize_t *opt_count;       /* Optimized count information */
-    const hsize_t *opt_block;       /* Optimized block information */
-    int unlim_dim = -1;             /* Unlimited dimension in selection, of -1 if none */
-    unsigned u;                     /* Local index variable */
-    herr_t ret_value = SUCCEED;     /* Return value */
+    hsize_t        int_stride[H5S_MAX_RANK]; /* Internal storage for stride information */
+    hsize_t        int_count[H5S_MAX_RANK];  /* Internal storage for count information */
+    hsize_t        int_block[H5S_MAX_RANK];  /* Internal storage for block information */
+    const hsize_t *opt_stride;               /* Optimized stride information */
+    const hsize_t *opt_count;                /* Optimized count information */
+    const hsize_t *opt_block;                /* Optimized block information */
+    int            unlim_dim = -1;           /* Unlimited dimension in selection, of -1 if none */
+    unsigned       u;                        /* Local index variable */
+    herr_t         ret_value = SUCCEED;      /* Return value */
 
     FUNC_ENTER_NOAPI(FAIL)
 
@@ -9854,34 +9906,34 @@ H5S_select_hyperslab(H5S_t *space, H5S_seloper_t op, const hsize_t start[],
     HDassert(op > H5S_SELECT_NOOP && op < H5S_SELECT_INVALID);
 
     /* Point to the correct stride values */
-    if(stride == NULL)
+    if (stride == NULL)
         stride = H5S_hyper_ones_g;
 
     /* Point to the correct block values */
-    if(block == NULL)
+    if (block == NULL)
         block = H5S_hyper_ones_g;
 
     /* Check new selection */
-    for(u = 0; u < space->extent.rank; u++) {
+    for (u = 0; u < space->extent.rank; u++) {
         /* Check for overlapping hyperslab blocks in new selection. */
-        if(count[u] > 1 && stride[u] < block[u])
+        if (count[u] > 1 && stride[u] < block[u])
             HGOTO_ERROR(H5E_ARGS, H5E_BADVALUE, FAIL, "hyperslab blocks overlap")
 
         /* Detect zero-sized hyperslabs in new selection */
-        if(count[u] == 0 || block[u] == 0) {
-            switch(op) {
-                case H5S_SELECT_SET:   /* Select "set" operation */
-                case H5S_SELECT_AND:   /* Binary "and" operation for hyperslabs */
-                case H5S_SELECT_NOTA:  /* Binary "B not A" operation for hyperslabs */
+        if (count[u] == 0 || block[u] == 0) {
+            switch (op) {
+                case H5S_SELECT_SET:  /* Select "set" operation */
+                case H5S_SELECT_AND:  /* Binary "and" operation for hyperslabs */
+                case H5S_SELECT_NOTA: /* Binary "B not A" operation for hyperslabs */
                     /* Convert to "none" selection */
-                    if(H5S_select_none(space) < 0)
+                    if (H5S_select_none(space) < 0)
                         HGOTO_ERROR(H5E_DATASPACE, H5E_CANTSELECT, FAIL, "can't convert selection")
                     HGOTO_DONE(SUCCEED);
 
-                case H5S_SELECT_OR:    /* Binary "or" operation for hyperslabs */
-                case H5S_SELECT_XOR:   /* Binary "xor" operation for hyperslabs */
-                case H5S_SELECT_NOTB:  /* Binary "A not B" operation for hyperslabs */
-                    HGOTO_DONE(SUCCEED);        /* Selection stays same */
+                case H5S_SELECT_OR:      /* Binary "or" operation for hyperslabs */
+                case H5S_SELECT_XOR:     /* Binary "xor" operation for hyperslabs */
+                case H5S_SELECT_NOTB:    /* Binary "A not B" operation for hyperslabs */
+                    HGOTO_DONE(SUCCEED); /* Selection stays same */
 
                 case H5S_SELECT_NOOP:
                 case H5S_SELECT_APPEND:
@@ -9890,73 +9942,75 @@ H5S_select_hyperslab(H5S_t *space, H5S_seloper_t op, const hsize_t start[],
                 default:
                     HGOTO_ERROR(H5E_ARGS, H5E_UNSUPPORTED, FAIL, "invalid selection operation")
             } /* end switch */
-        } /* end if */
+        }     /* end if */
 
         /* Check for unlimited dimension */
-        if((count[u] == H5S_UNLIMITED) || (block[u] == H5S_UNLIMITED)) {
-            if(unlim_dim >= 0)
-                HGOTO_ERROR(H5E_DATASPACE, H5E_UNSUPPORTED, FAIL, "cannot have more than one unlimited dimension in selection")
+        if ((count[u] == H5S_UNLIMITED) || (block[u] == H5S_UNLIMITED)) {
+            if (unlim_dim >= 0)
+                HGOTO_ERROR(H5E_DATASPACE, H5E_UNSUPPORTED, FAIL,
+                            "cannot have more than one unlimited dimension in selection")
             else {
-                if(count[u] == block[u]) /* Both are H5S_UNLIMITED */
-                    HGOTO_ERROR(H5E_DATASPACE, H5E_UNSUPPORTED, FAIL, "count and block cannot both be unlimited")
+                if (count[u] == block[u]) /* Both are H5S_UNLIMITED */
+                    HGOTO_ERROR(H5E_DATASPACE, H5E_UNSUPPORTED, FAIL,
+                                "count and block cannot both be unlimited")
                 unlim_dim = (int)u;
             } /* end else */
-        } /* end if */
-    } /* end for */
+        }     /* end if */
+    }         /* end for */
 
     /* Optimize hyperslab parameters to merge contiguous blocks, etc. */
-    if(stride == H5S_hyper_ones_g && block == H5S_hyper_ones_g) {
+    if (stride == H5S_hyper_ones_g && block == H5S_hyper_ones_g) {
         /* Point to existing arrays */
         opt_stride = H5S_hyper_ones_g;
-        opt_count = H5S_hyper_ones_g;
-        opt_block = count;
+        opt_count  = H5S_hyper_ones_g;
+        opt_block  = count;
     } /* end if */
     else {
         /* Point to local arrays */
         opt_stride = int_stride;
-        opt_count = int_count;
-        opt_block = int_block;
-        for(u = 0; u < space->extent.rank; u++) {
+        opt_count  = int_count;
+        opt_block  = int_block;
+        for (u = 0; u < space->extent.rank; u++) {
             /* contiguous hyperslabs have the block size equal to the stride */
-            if((stride[u] == block[u]) && (count[u] != H5S_UNLIMITED)) {
-                int_count[u] = 1;
+            if ((stride[u] == block[u]) && (count[u] != H5S_UNLIMITED)) {
+                int_count[u]  = 1;
                 int_stride[u] = 1;
-                if(block[u] == 1)
+                if (block[u] == 1)
                     int_block[u] = count[u];
                 else
                     int_block[u] = block[u] * count[u];
             } /* end if */
             else {
-                if(count[u] == 1)
+                if (count[u] == 1)
                     int_stride[u] = 1;
                 else {
                     HDassert((stride[u] > block[u]) ||
-                            ((stride[u] == block[u]) && (count[u] == H5S_UNLIMITED)));
+                             ((stride[u] == block[u]) && (count[u] == H5S_UNLIMITED)));
                     int_stride[u] = stride[u];
                 } /* end else */
                 int_count[u] = count[u];
                 int_block[u] = block[u];
             } /* end else */
-        } /* end for */
-    } /* end else */
+        }     /* end for */
+    }         /* end else */
 
     /* Check for operating on unlimited selection */
-    if((H5S_GET_SELECT_TYPE(space) == H5S_SEL_HYPERSLABS)
-            && (space->select.sel_info.hslab->unlim_dim >= 0)
-            && (op != H5S_SELECT_SET)) {
+    if ((H5S_GET_SELECT_TYPE(space) == H5S_SEL_HYPERSLABS) &&
+        (space->select.sel_info.hslab->unlim_dim >= 0) && (op != H5S_SELECT_SET)) {
         /* Check for invalid operation */
-        if(unlim_dim >= 0)
-            HGOTO_ERROR(H5E_DATASPACE, H5E_UNSUPPORTED, FAIL, "cannot modify unlimited selection with another unlimited selection")
-        if(!((op == H5S_SELECT_AND) || (op == H5S_SELECT_NOTA)))
+        if (unlim_dim >= 0)
+            HGOTO_ERROR(H5E_DATASPACE, H5E_UNSUPPORTED, FAIL,
+                        "cannot modify unlimited selection with another unlimited selection")
+        if (!((op == H5S_SELECT_AND) || (op == H5S_SELECT_NOTA)))
             HGOTO_ERROR(H5E_DATASPACE, H5E_UNSUPPORTED, FAIL, "unsupported operation on unlimited selection")
         HDassert(space->select.sel_info.hslab->diminfo_valid);
 
         /* Clip unlimited selection to include new selection */
-        if(H5S_hyper_clip_unlim(space,
-                start[space->select.sel_info.hslab->unlim_dim]
-                    + ((opt_count[space->select.sel_info.hslab->unlim_dim] - (hsize_t)1)
-                        * opt_stride[space->select.sel_info.hslab->unlim_dim])
-                    + opt_block[space->select.sel_info.hslab->unlim_dim]) < 0)
+        if (H5S_hyper_clip_unlim(space,
+                                 start[space->select.sel_info.hslab->unlim_dim] +
+                                     ((opt_count[space->select.sel_info.hslab->unlim_dim] - (hsize_t)1) *
+                                      opt_stride[space->select.sel_info.hslab->unlim_dim]) +
+                                     opt_block[space->select.sel_info.hslab->unlim_dim]) < 0)
             HGOTO_ERROR(H5E_DATASPACE, H5E_CANTCLIP, FAIL, "failed to clip unlimited selection")
 
         /* If an empty space was returned it must be "none" */
@@ -9964,22 +10018,22 @@ H5S_select_hyperslab(H5S_t *space, H5S_seloper_t op, const hsize_t start[],
     } /* end if */
 
     /* Fixup operation for non-hyperslab selections */
-    switch(H5S_GET_SELECT_TYPE(space)) {
-        case H5S_SEL_NONE:   /* No elements selected in dataspace */
-            switch(op) {
-                case H5S_SELECT_SET:   /* Select "set" operation */
+    switch (H5S_GET_SELECT_TYPE(space)) {
+        case H5S_SEL_NONE: /* No elements selected in dataspace */
+            switch (op) {
+                case H5S_SELECT_SET: /* Select "set" operation */
                     /* Change "none" selection to hyperslab selection */
                     break;
 
-                case H5S_SELECT_OR:    /* Binary "or" operation for hyperslabs */
-                case H5S_SELECT_XOR:   /* Binary "xor" operation for hyperslabs */
-                case H5S_SELECT_NOTA:  /* Binary "B not A" operation for hyperslabs */
+                case H5S_SELECT_OR:      /* Binary "or" operation for hyperslabs */
+                case H5S_SELECT_XOR:     /* Binary "xor" operation for hyperslabs */
+                case H5S_SELECT_NOTA:    /* Binary "B not A" operation for hyperslabs */
                     op = H5S_SELECT_SET; /* Maps to "set" operation when applied to "none" selection */
                     break;
 
-                case H5S_SELECT_AND:   /* Binary "and" operation for hyperslabs */
-                case H5S_SELECT_NOTB:  /* Binary "A not B" operation for hyperslabs */
-                    HGOTO_DONE(SUCCEED);        /* Selection stays "none" */
+                case H5S_SELECT_AND:     /* Binary "and" operation for hyperslabs */
+                case H5S_SELECT_NOTB:    /* Binary "A not B" operation for hyperslabs */
+                    HGOTO_DONE(SUCCEED); /* Selection stays "none" */
 
                 case H5S_SELECT_NOOP:
                 case H5S_SELECT_APPEND:
@@ -9990,43 +10044,44 @@ H5S_select_hyperslab(H5S_t *space, H5S_seloper_t op, const hsize_t start[],
             } /* end switch */
             break;
 
-        case H5S_SEL_ALL:    /* All elements selected in dataspace */
-            switch(op) {
-                case H5S_SELECT_SET:   /* Select "set" operation */
+        case H5S_SEL_ALL: /* All elements selected in dataspace */
+            switch (op) {
+                case H5S_SELECT_SET: /* Select "set" operation */
                     /* Change "all" selection to hyperslab selection */
                     break;
 
-                case H5S_SELECT_OR:    /* Binary "or" operation for hyperslabs */
-                    HGOTO_DONE(SUCCEED);        /* Selection stays "all" */
+                case H5S_SELECT_OR:      /* Binary "or" operation for hyperslabs */
+                    HGOTO_DONE(SUCCEED); /* Selection stays "all" */
 
-                case H5S_SELECT_AND:   /* Binary "and" operation for hyperslabs */
+                case H5S_SELECT_AND:     /* Binary "and" operation for hyperslabs */
                     op = H5S_SELECT_SET; /* Maps to "set" operation when applied to "none" selection */
                     break;
 
-                case H5S_SELECT_XOR:   /* Binary "xor" operation for hyperslabs */
-                case H5S_SELECT_NOTB:  /* Binary "A not B" operation for hyperslabs */
+                case H5S_SELECT_XOR:  /* Binary "xor" operation for hyperslabs */
+                case H5S_SELECT_NOTB: /* Binary "A not B" operation for hyperslabs */
                     /* Convert current "all" selection to "real" hyperslab selection */
                     /* Then allow operation to proceed */
                     {
-                        const hsize_t *tmp_start;       /* Temporary start information */
-                        const hsize_t *tmp_stride;      /* Temporary stride information */
-                        const hsize_t *tmp_count;       /* Temporary count information */
-                        const hsize_t *tmp_block;       /* Temporary block information */
+                        const hsize_t *tmp_start;  /* Temporary start information */
+                        const hsize_t *tmp_stride; /* Temporary stride information */
+                        const hsize_t *tmp_count;  /* Temporary count information */
+                        const hsize_t *tmp_block;  /* Temporary block information */
 
                         /* Set up temporary information for the dimensions */
-                        tmp_start = H5S_hyper_zeros_g;
+                        tmp_start  = H5S_hyper_zeros_g;
                         tmp_stride = tmp_count = H5S_hyper_ones_g;
-                        tmp_block = space->extent.size;
+                        tmp_block              = space->extent.size;
 
                         /* Convert to hyperslab selection */
-                        if(H5S_select_hyperslab(space, H5S_SELECT_SET, tmp_start, tmp_stride, tmp_count, tmp_block) < 0)
+                        if (H5S_select_hyperslab(space, H5S_SELECT_SET, tmp_start, tmp_stride, tmp_count,
+                                                 tmp_block) < 0)
                             HGOTO_ERROR(H5E_DATASPACE, H5E_CANTDELETE, FAIL, "can't convert selection")
                     } /* end case */
                     break;
 
-                case H5S_SELECT_NOTA:  /* Binary "B not A" operation for hyperslabs */
+                case H5S_SELECT_NOTA: /* Binary "B not A" operation for hyperslabs */
                     /* Convert to "none" selection */
-                    if(H5S_select_none(space) < 0)
+                    if (H5S_select_none(space) < 0)
                         HGOTO_ERROR(H5E_DATASPACE, H5E_CANTSELECT, FAIL, "can't convert selection")
                     HGOTO_DONE(SUCCEED);
 
@@ -10043,8 +10098,8 @@ H5S_select_hyperslab(H5S_t *space, H5S_seloper_t op, const hsize_t start[],
             /* Hyperslab operation on hyperslab selection, OK */
             break;
 
-        case H5S_SEL_POINTS: /* Can't combine hyperslab operations and point selections currently */
-            if(op == H5S_SELECT_SET)      /* Allow only "set" operation to proceed */
+        case H5S_SEL_POINTS:          /* Can't combine hyperslab operations and point selections currently */
+            if (op == H5S_SELECT_SET) /* Allow only "set" operation to proceed */
                 break;
             /* Else fall through to error */
             H5_ATTR_FALLTHROUGH
@@ -10055,54 +10110,58 @@ H5S_select_hyperslab(H5S_t *space, H5S_seloper_t op, const hsize_t start[],
             HGOTO_ERROR(H5E_ARGS, H5E_UNSUPPORTED, FAIL, "invalid selection operation")
     } /* end switch */
 
-    if(op == H5S_SELECT_SET) {
+    if (op == H5S_SELECT_SET) {
         /* Set selection to regular hyperslab */
-        if(H5S__set_regular_hyperslab(space, start, stride, count, block, opt_stride, opt_count, opt_block) < 0)
+        if (H5S__set_regular_hyperslab(space, start, stride, count, block, opt_stride, opt_count, opt_block) <
+            0)
             HGOTO_ERROR(H5E_DATASPACE, H5E_CANTSET, FAIL, "can't set regular hyperslab selection")
     } /* end if */
-    else if(op >= H5S_SELECT_OR && op <= H5S_SELECT_NOTA) {
-        hbool_t single_block;   /* Whether the selection is a single block */
+    else if (op >= H5S_SELECT_OR && op <= H5S_SELECT_NOTA) {
+        hbool_t single_block; /* Whether the selection is a single block */
 
         /* Sanity check */
         HDassert(H5S_GET_SELECT_TYPE(space) == H5S_SEL_HYPERSLABS);
 
         /* Handle unlimited selections */
-        if(unlim_dim >= 0) {
+        if (unlim_dim >= 0) {
             hsize_t bounds_start[H5S_MAX_RANK];
             hsize_t bounds_end[H5S_MAX_RANK];
             hsize_t tmp_count = opt_count[unlim_dim];
             hsize_t tmp_block = opt_block[unlim_dim];
 
             /* Check for invalid operation */
-            if(space->select.sel_info.hslab->unlim_dim >= 0)
-                HGOTO_ERROR(H5E_DATASPACE, H5E_UNSUPPORTED, FAIL, "cannot modify unlimited selection with another unlimited selection")
-            if(!((op == H5S_SELECT_AND) || (op == H5S_SELECT_NOTB)))
-                HGOTO_ERROR(H5E_DATASPACE, H5E_UNSUPPORTED, FAIL, "unsupported operation with unlimited selection")
+            if (space->select.sel_info.hslab->unlim_dim >= 0)
+                HGOTO_ERROR(H5E_DATASPACE, H5E_UNSUPPORTED, FAIL,
+                            "cannot modify unlimited selection with another unlimited selection")
+            if (!((op == H5S_SELECT_AND) || (op == H5S_SELECT_NOTB)))
+                HGOTO_ERROR(H5E_DATASPACE, H5E_UNSUPPORTED, FAIL,
+                            "unsupported operation with unlimited selection")
 
             /* Get bounds of existing selection */
-            if(H5S__hyper_bounds(space, bounds_start, bounds_end) < 0)
+            if (H5S__hyper_bounds(space, bounds_start, bounds_end) < 0)
                 HGOTO_ERROR(H5E_DATASPACE, H5E_CANTGET, FAIL, "can't get selection bounds")
 
             /* Patch count and block to remove unlimited and include the
              * existing selection.
              */
-            H5S__hyper_get_clip_diminfo(start[unlim_dim], opt_stride[unlim_dim], &tmp_count, &tmp_block, bounds_end[unlim_dim] + (hsize_t)1);
+            H5S__hyper_get_clip_diminfo(start[unlim_dim], opt_stride[unlim_dim], &tmp_count, &tmp_block,
+                                        bounds_end[unlim_dim] + (hsize_t)1);
             HDassert((tmp_count == 1) || (opt_count != H5S_hyper_ones_g));
             HDassert((tmp_block == 1) || (opt_block != H5S_hyper_ones_g));
-            if(opt_count != H5S_hyper_ones_g) {
+            if (opt_count != H5S_hyper_ones_g) {
                 HDassert(opt_count == int_count);
                 int_count[unlim_dim] = tmp_count;
             } /* end if */
-            if(opt_block != H5S_hyper_ones_g) {
+            if (opt_block != H5S_hyper_ones_g) {
                 HDassert(opt_block == int_block);
                 int_block[unlim_dim] = tmp_block;
             } /* end if */
-        } /* end if */
+        }     /* end if */
 
         /* Check for a single block selected */
         single_block = TRUE;
-        for(u = 0; u < space->extent.rank; u++)
-            if(1 != opt_count[u]) {
+        for (u = 0; u < space->extent.rank; u++)
+            if (1 != opt_count[u]) {
                 single_block = FALSE;
                 break;
             } /* end if */
@@ -10110,25 +10169,26 @@ H5S_select_hyperslab(H5S_t *space, H5S_seloper_t op, const hsize_t start[],
         /* Check for single block "AND" operation on a regular hyperslab, which
          *      is used for constructing chunk maps and can be optimized for.
          */
-        if(H5S_SELECT_AND == op && single_block &&
-                space->select.sel_info.hslab->diminfo_valid == H5S_DIMINFO_VALID_YES) {
-            if(H5S__hyper_regular_and_single_block(space, start, opt_block) < 0)
-                HGOTO_ERROR(H5E_DATASPACE, H5E_CANTOPERATE, FAIL, "can't 'AND' single block against regular hyperslab")
+        if (H5S_SELECT_AND == op && single_block &&
+            space->select.sel_info.hslab->diminfo_valid == H5S_DIMINFO_VALID_YES) {
+            if (H5S__hyper_regular_and_single_block(space, start, opt_block) < 0)
+                HGOTO_ERROR(H5E_DATASPACE, H5E_CANTOPERATE, FAIL,
+                            "can't 'AND' single block against regular hyperslab")
         } /* end if */
         else {
             /* Check if there's no hyperslab span information currently */
-            if(NULL == space->select.sel_info.hslab->span_lst)
-                if(H5S__hyper_generate_spans(space) < 0)
+            if (NULL == space->select.sel_info.hslab->span_lst)
+                if (H5S__hyper_generate_spans(space) < 0)
                     HGOTO_ERROR(H5E_DATASPACE, H5E_UNINITIALIZED, FAIL, "dataspace does not have span tree")
 
             /* Set selection type */
             space->select.type = H5S_sel_hyper;
 
             /* Add in the new hyperslab information */
-            if(H5S__generate_hyperslab(space, op, start, opt_stride, opt_count, opt_block) < 0)
+            if (H5S__generate_hyperslab(space, op, start, opt_stride, opt_count, opt_block) < 0)
                 HGOTO_ERROR(H5E_DATASPACE, H5E_CANTINSERT, FAIL, "can't generate hyperslabs")
         } /* end else */
-    } /* end if */
+    }     /* end if */
     else
         HGOTO_ERROR(H5E_ARGS, H5E_UNSUPPORTED, FAIL, "invalid selection operation")
 
@@ -10136,7 +10196,6 @@ done:
     FUNC_LEAVE_NOAPI(ret_value)
 } /* end H5S_select_hyperslab() */
 
-
 /*--------------------------------------------------------------------------
  NAME
     H5Sselect_hyperslab
@@ -10164,8 +10223,8 @@ done:
  REVISION LOG
 --------------------------------------------------------------------------*/
 herr_t
-H5Sselect_hyperslab(hid_t space_id, H5S_seloper_t op, const hsize_t start[],
-    const hsize_t stride[], const hsize_t count[], const hsize_t block[])
+H5Sselect_hyperslab(hid_t space_id, H5S_seloper_t op, const hsize_t start[], const hsize_t stride[],
+                    const hsize_t count[], const hsize_t block[])
 {
     H5S_t *space;               /* Dataspace to modify selection of */
     herr_t ret_value = SUCCEED; /* Return value */
@@ -10174,33 +10233,32 @@ H5Sselect_hyperslab(hid_t space_id, H5S_seloper_t op, const hsize_t start[],
     H5TRACE6("e", "iSs*h*h*h*h", space_id, op, start, stride, count, block);
 
     /* Check args */
-    if(NULL == (space = (H5S_t *)H5I_object_verify(space_id, H5I_DATASPACE)))
+    if (NULL == (space = (H5S_t *)H5I_object_verify(space_id, H5I_DATASPACE)))
         HGOTO_ERROR(H5E_ARGS, H5E_BADTYPE, FAIL, "not a dataspace")
-    if(H5S_SCALAR == H5S_GET_EXTENT_TYPE(space))
+    if (H5S_SCALAR == H5S_GET_EXTENT_TYPE(space))
         HGOTO_ERROR(H5E_ARGS, H5E_BADTYPE, FAIL, "hyperslab doesn't support H5S_SCALAR space")
-    if(H5S_NULL == H5S_GET_EXTENT_TYPE(space))
+    if (H5S_NULL == H5S_GET_EXTENT_TYPE(space))
         HGOTO_ERROR(H5E_ARGS, H5E_BADTYPE, FAIL, "hyperslab doesn't support H5S_NULL space")
-    if(start == NULL || count == NULL)
+    if (start == NULL || count == NULL)
         HGOTO_ERROR(H5E_ARGS, H5E_BADVALUE, FAIL, "hyperslab not specified")
-    if(!(op > H5S_SELECT_NOOP && op < H5S_SELECT_INVALID))
+    if (!(op > H5S_SELECT_NOOP && op < H5S_SELECT_INVALID))
         HGOTO_ERROR(H5E_ARGS, H5E_UNSUPPORTED, FAIL, "invalid selection operation")
-    if(stride != NULL) {
-        unsigned u;             /* Local index variable */
+    if (stride != NULL) {
+        unsigned u; /* Local index variable */
 
         /* Check for 0-sized strides */
-        for(u = 0; u < space->extent.rank; u++)
-            if(stride[u] == 0)
+        for (u = 0; u < space->extent.rank; u++)
+            if (stride[u] == 0)
                 HGOTO_ERROR(H5E_ARGS, H5E_BADVALUE, FAIL, "invalid stride==0 value")
     } /* end if */
 
-    if(H5S_select_hyperslab(space, op, start, stride, count, block) < 0)
+    if (H5S_select_hyperslab(space, op, start, stride, count, block) < 0)
         HGOTO_ERROR(H5E_DATASPACE, H5E_CANTINIT, FAIL, "unable to set hyperslab selection")
 
 done:
     FUNC_LEAVE_API(ret_value)
 } /* end H5Sselect_hyperslab() */
 
-
 /*--------------------------------------------------------------------------
  NAME
     H5S_combine_hyperslab
@@ -10232,12 +10290,11 @@ done:
  REVISION LOG
 --------------------------------------------------------------------------*/
 herr_t
-H5S_combine_hyperslab(H5S_t *old_space, H5S_seloper_t op, const hsize_t start[],
-    const hsize_t *stride, const hsize_t count[], const hsize_t *block,
-    H5S_t **new_space)
+H5S_combine_hyperslab(H5S_t *old_space, H5S_seloper_t op, const hsize_t start[], const hsize_t *stride,
+                      const hsize_t count[], const hsize_t *block, H5S_t **new_space)
 {
-    unsigned u;                     /* Local index variable */
-    herr_t ret_value = SUCCEED;     /* Return value */
+    unsigned u;                   /* Local index variable */
+    herr_t   ret_value = SUCCEED; /* Return value */
 
     FUNC_ENTER_NOAPI(FAIL)
 
@@ -10250,39 +10307,39 @@ H5S_combine_hyperslab(H5S_t *old_space, H5S_seloper_t op, const hsize_t start[],
     HDassert(*new_space == NULL);
 
     /* Point to the correct stride values */
-    if(stride == NULL)
+    if (stride == NULL)
         stride = H5S_hyper_ones_g;
 
     /* Point to the correct block values */
-    if(block == NULL)
+    if (block == NULL)
         block = H5S_hyper_ones_g;
 
     /* Check new selection. */
-    for(u = 0; u < old_space->extent.rank; u++) {
+    for (u = 0; u < old_space->extent.rank; u++) {
         /* Check for overlapping hyperslab blocks in new selection. */
-        if(count[u] > 1 && stride[u] < block[u])
+        if (count[u] > 1 && stride[u] < block[u])
             HGOTO_ERROR(H5E_ARGS, H5E_BADVALUE, FAIL, "hyperslab blocks overlap")
 
         /* Detect zero-sized hyperslabs in new selection */
-        if(count[u] == 0 || block[u] == 0) {
-            switch(op) {
-                case H5S_SELECT_AND:   /* Binary "and" operation for hyperslabs */
-                case H5S_SELECT_NOTA:  /* Binary "B not A" operation for hyperslabs */
+        if (count[u] == 0 || block[u] == 0) {
+            switch (op) {
+                case H5S_SELECT_AND:  /* Binary "and" operation for hyperslabs */
+                case H5S_SELECT_NOTA: /* Binary "B not A" operation for hyperslabs */
                     /* Convert to "none" selection */
                     /* Copy the first dataspace without sharing the list of spans */
-                    if(NULL == ((*new_space) = H5S_copy(old_space, TRUE, TRUE)))
+                    if (NULL == ((*new_space) = H5S_copy(old_space, TRUE, TRUE)))
                         HGOTO_ERROR(H5E_DATASPACE, H5E_CANTINIT, FAIL, "unable to copy dataspace")
-                    if(H5S_select_none((*new_space)) < 0)
+                    if (H5S_select_none((*new_space)) < 0)
                         HGOTO_ERROR(H5E_DATASPACE, H5E_CANTSELECT, FAIL, "can't convert selection")
                     HGOTO_DONE(SUCCEED);
 
-                case H5S_SELECT_OR:    /* Binary "or" operation for hyperslabs */
-                case H5S_SELECT_XOR:   /* Binary "xor" operation for hyperslabs */
-                case H5S_SELECT_NOTB:  /* Binary "A not B" operation for hyperslabs */
+                case H5S_SELECT_OR:   /* Binary "or" operation for hyperslabs */
+                case H5S_SELECT_XOR:  /* Binary "xor" operation for hyperslabs */
+                case H5S_SELECT_NOTB: /* Binary "A not B" operation for hyperslabs */
                     /* Copy the first dataspace with sharing the list of spans */
-                    if(NULL == ((*new_space) = H5S_copy(old_space, FALSE, TRUE)))
+                    if (NULL == ((*new_space) = H5S_copy(old_space, FALSE, TRUE)))
                         HGOTO_ERROR(H5E_DATASPACE, H5E_CANTINIT, FAIL, "unable to copy dataspace")
-                    HGOTO_DONE(SUCCEED);        /* Selection stays same */
+                    HGOTO_DONE(SUCCEED); /* Selection stays same */
 
                 case H5S_SELECT_NOOP:
                 case H5S_SELECT_SET:
@@ -10292,92 +10349,95 @@ H5S_combine_hyperslab(H5S_t *old_space, H5S_seloper_t op, const hsize_t start[],
                 default:
                     HGOTO_ERROR(H5E_ARGS, H5E_UNSUPPORTED, FAIL, "invalid selection operation")
             } /* end switch */
-        } /* end if */
-    } /* end for */
+        }     /* end if */
+    }         /* end for */
 
-    if(H5S_GET_SELECT_TYPE(old_space) == H5S_SEL_HYPERSLABS) {
-        hsize_t *old_low_bounds;                /* Pointer to old space's low & high bounds */
+    if (H5S_GET_SELECT_TYPE(old_space) == H5S_SEL_HYPERSLABS) {
+        hsize_t *old_low_bounds; /* Pointer to old space's low & high bounds */
         hsize_t *old_high_bounds;
-        hsize_t new_low_bounds[H5S_MAX_RANK];   /* New space's low & high bounds */
-        hsize_t new_high_bounds[H5S_MAX_RANK];
-        hbool_t overlapped = FALSE;
+        hsize_t  new_low_bounds[H5S_MAX_RANK]; /* New space's low & high bounds */
+        hsize_t  new_high_bounds[H5S_MAX_RANK];
+        hbool_t  overlapped = FALSE;
 
         /* Set up old space's low & high bounds */
-        if(old_space->select.sel_info.hslab->span_lst) {
-            old_low_bounds = old_space->select.sel_info.hslab->span_lst->low_bounds;
+        if (old_space->select.sel_info.hslab->span_lst) {
+            old_low_bounds  = old_space->select.sel_info.hslab->span_lst->low_bounds;
             old_high_bounds = old_space->select.sel_info.hslab->span_lst->high_bounds;
         } /* end if */
         else {
-            old_low_bounds = old_space->select.sel_info.hslab->diminfo.low_bounds;
+            old_low_bounds  = old_space->select.sel_info.hslab->diminfo.low_bounds;
             old_high_bounds = old_space->select.sel_info.hslab->diminfo.high_bounds;
         } /* end else */
 
         /* Generate bounding box for hyperslab parameters */
-        for(u = 0; u < old_space->extent.rank; u++) {
-            new_low_bounds[u] = start[u];
+        for (u = 0; u < old_space->extent.rank; u++) {
+            new_low_bounds[u]  = start[u];
             new_high_bounds[u] = start[u] + stride[u] * (count[u] - 1) + (block[u] - 1);
         } /* end for */
 
         /* Check bound box of both spaces to see if they overlap */
-        if(H5S_RANGE_OVERLAP(old_low_bounds[0], old_high_bounds[0],
-                new_low_bounds[0], new_high_bounds[0]))
+        if (H5S_RANGE_OVERLAP(old_low_bounds[0], old_high_bounds[0], new_low_bounds[0], new_high_bounds[0]))
             overlapped = TRUE;
 
         /* Non-overlapping situations can be handled in special ways */
-        if(!overlapped) {
+        if (!overlapped) {
             H5S_hyper_span_info_t *new_spans = NULL;
-            H5S_hyper_dim_t new_hyper_diminfo[H5S_MAX_RANK];
+            H5S_hyper_dim_t        new_hyper_diminfo[H5S_MAX_RANK];
 
-            if(NULL == ((*new_space) = H5S_copy(old_space, TRUE, TRUE)))
+            if (NULL == ((*new_space) = H5S_copy(old_space, TRUE, TRUE)))
                 HGOTO_ERROR(H5E_DATASPACE, H5E_CANTCOPY, FAIL, "unable to copy dataspace")
-            if(NULL != (*new_space)->select.sel_info.hslab->span_lst) {
+            if (NULL != (*new_space)->select.sel_info.hslab->span_lst) {
                 old_space->select.sel_info.hslab->span_lst->count--;
                 (*new_space)->select.sel_info.hslab->span_lst = NULL;
             } /* end if */
 
             /* Generate hyperslab info for new space */
-            switch(op) {
+            switch (op) {
                 case H5S_SELECT_OR:
                 case H5S_SELECT_XOR:
                     /* Add the new space to the space */
-                    if(NULL == (new_spans = H5S__hyper_make_spans(old_space->extent.rank, start, stride, count, block)))
+                    if (NULL == (new_spans = H5S__hyper_make_spans(old_space->extent.rank, start, stride,
+                                                                   count, block)))
                         HGOTO_ERROR(H5E_DATASPACE, H5E_CANTINSERT, FAIL, "can't create hyperslab information")
-                    if(NULL != old_space->select.sel_info.hslab->span_lst)
-                        (*new_space)->select.sel_info.hslab->span_lst = H5S__hyper_copy_span(old_space->select.sel_info.hslab->span_lst, old_space->extent.rank);
-                    if(H5S__hyper_add_disjoint_spans(*new_space, new_spans) < 0)
+                    if (NULL != old_space->select.sel_info.hslab->span_lst)
+                        (*new_space)->select.sel_info.hslab->span_lst = H5S__hyper_copy_span(
+                            old_space->select.sel_info.hslab->span_lst, old_space->extent.rank);
+                    if (H5S__hyper_add_disjoint_spans(*new_space, new_spans) < 0)
                         HGOTO_ERROR(H5E_DATASPACE, H5E_CANTINSERT, FAIL, "can't append hyperslabs")
 
                     /* Build diminfo struct */
-                    for(u = 0; u < (*new_space)->extent.rank; u++) {
-                        new_hyper_diminfo[u].start = start[u];
+                    for (u = 0; u < (*new_space)->extent.rank; u++) {
+                        new_hyper_diminfo[u].start  = start[u];
                         new_hyper_diminfo[u].stride = stride[u];
-                        new_hyper_diminfo[u].count = count[u];
-                        new_hyper_diminfo[u].block = block[u];
+                        new_hyper_diminfo[u].count  = count[u];
+                        new_hyper_diminfo[u].block  = block[u];
                     } /* end for */
 
                     /* Update space's dim info */
-                    if(H5S__hyper_update_diminfo(*new_space, op, new_hyper_diminfo) < 0)
+                    if (H5S__hyper_update_diminfo(*new_space, op, new_hyper_diminfo) < 0)
                         HGOTO_ERROR(H5E_DATASPACE, H5E_CANTCOUNT, FAIL, "can't update hyperslab info")
                     break;
 
                 case H5S_SELECT_AND:
-                    if(H5S_select_none((*new_space)) < 0)
+                    if (H5S_select_none((*new_space)) < 0)
                         HGOTO_ERROR(H5E_DATASPACE, H5E_CANTSELECT, FAIL, "can't convert selection")
                     break;
 
                 case H5S_SELECT_NOTB:
-                    if(NULL != old_space->select.sel_info.hslab->span_lst) {
-                        if(NULL == ((*new_space)->select.sel_info.hslab->span_lst = H5S__hyper_copy_span(old_space->select.sel_info.hslab->span_lst, old_space->extent.rank)))
+                    if (NULL != old_space->select.sel_info.hslab->span_lst) {
+                        if (NULL == ((*new_space)->select.sel_info.hslab->span_lst = H5S__hyper_copy_span(
+                                         old_space->select.sel_info.hslab->span_lst, old_space->extent.rank)))
                             HGOTO_ERROR(H5E_DATASPACE, H5E_CANTCOPY, FAIL, "unable to copy dataspace")
                     } /* end if */
                     else {
-                        if(H5S_select_none((*new_space)) < 0)
+                        if (H5S_select_none((*new_space)) < 0)
                             HGOTO_ERROR(H5E_DATASPACE, H5E_CANTSELECT, FAIL, "can't convert selection")
                     } /* end else */
                     break;
 
                 case H5S_SELECT_NOTA:
-                    if(H5S__set_regular_hyperslab(*new_space, start, stride, count, block, stride, count, block) < 0)
+                    if (H5S__set_regular_hyperslab(*new_space, start, stride, count, block, stride, count,
+                                                   block) < 0)
                         HGOTO_ERROR(H5E_DATASPACE, H5E_CANTSET, FAIL, "can't set regular selection")
                     break;
 
@@ -10392,21 +10452,20 @@ H5S_combine_hyperslab(H5S_t *old_space, H5S_seloper_t op, const hsize_t start[],
 
             HGOTO_DONE(SUCCEED);
         } /* end if(!overlapped) */
-    } /* end if the selection of old space is H5S_SEL_HYPERSLABS */
+    }     /* end if the selection of old space is H5S_SEL_HYPERSLABS */
 
     /* Copy the first dataspace with sharing the list of spans */
-    if(NULL == ((*new_space) = H5S_copy(old_space, TRUE, TRUE)))
+    if (NULL == ((*new_space) = H5S_copy(old_space, TRUE, TRUE)))
         HGOTO_ERROR(H5E_DATASPACE, H5E_CANTINIT, FAIL, "unable to copy dataspace")
 
     /* Note: a little overhead in calling the function as some conditions are checked again */
-    if(H5S_select_hyperslab(*new_space, op, start, stride, count, block) < 0)
+    if (H5S_select_hyperslab(*new_space, op, start, stride, count, block) < 0)
         HGOTO_ERROR(H5E_DATASPACE, H5E_CANTINIT, FAIL, "unable to set hyperslab selection")
 
 done:
     FUNC_LEAVE_NOAPI(ret_value)
 } /* end H5S_combine_hyperslab() */
 
-
 /*-------------------------------------------------------------------------
  * Function:    H5S__fill_in_select
  *
@@ -10425,7 +10484,7 @@ H5S__fill_in_select(H5S_t *space1, H5S_seloper_t op, H5S_t *space2, H5S_t **resu
 {
     hbool_t span2_owned;
     hbool_t updated_spans;
-    herr_t ret_value = SUCCEED;         /* Return value */
+    herr_t  ret_value = SUCCEED; /* Return value */
 
     FUNC_ENTER_STATIC
 
@@ -10440,15 +10499,16 @@ H5S__fill_in_select(H5S_t *space1, H5S_seloper_t op, H5S_t *space2, H5S_t **resu
     HDassert(space2->select.sel_info.hslab->span_lst);
 
     /* Note: the offset of space2 is not considered here for bounding box */
-    if(H5S__fill_in_new_space(space1, op, space2->select.sel_info.hslab->span_lst, FALSE, &span2_owned, &updated_spans, result) < 0)
+    if (H5S__fill_in_new_space(space1, op, space2->select.sel_info.hslab->span_lst, FALSE, &span2_owned,
+                               &updated_spans, result) < 0)
         HGOTO_ERROR(H5E_DATASPACE, H5E_CANTSELECT, FAIL, "can't create the specified selection")
 
     /* Update diminfo if space2's diminfo was valid, otherwise just mark it as
      * invalid if the spans were updated */
     HDassert(result);
-    if(updated_spans) {
-        if(space2->select.sel_info.hslab->diminfo_valid == H5S_DIMINFO_VALID_YES) {
-            if(H5S__hyper_update_diminfo(*result, op, space2->select.sel_info.hslab->diminfo.opt) < 0)
+    if (updated_spans) {
+        if (space2->select.sel_info.hslab->diminfo_valid == H5S_DIMINFO_VALID_YES) {
+            if (H5S__hyper_update_diminfo(*result, op, space2->select.sel_info.hslab->diminfo.opt) < 0)
                 HGOTO_ERROR(H5E_DATASPACE, H5E_CANTCOUNT, FAIL, "can't update hyperslab info")
         } /* end if */
         else
@@ -10459,7 +10519,6 @@ done:
     FUNC_LEAVE_NOAPI(ret_value)
 } /* end H5S__fill_in_select() */
 
-
 /*--------------------------------------------------------------------------
  NAME
     H5Scombine_hyperslab
@@ -10490,40 +10549,39 @@ done:
  REVISION LOG
 --------------------------------------------------------------------------*/
 hid_t
-H5Scombine_hyperslab(hid_t space_id, H5S_seloper_t op, const hsize_t start[],
-    const hsize_t stride[], const hsize_t count[], const hsize_t block[])
+H5Scombine_hyperslab(hid_t space_id, H5S_seloper_t op, const hsize_t start[], const hsize_t stride[],
+                     const hsize_t count[], const hsize_t block[])
 {
-    H5S_t   *space;                 /* Dataspace to modify selection of */
-    H5S_t   *new_space = NULL;      /* New dataspace created */
-    hid_t   ret_value;              /* Return value */
+    H5S_t *space;            /* Dataspace to modify selection of */
+    H5S_t *new_space = NULL; /* New dataspace created */
+    hid_t  ret_value;        /* Return value */
 
     FUNC_ENTER_API(H5I_INVALID_HID)
     H5TRACE6("i", "iSs*h*h*h*h", space_id, op, start, stride, count, block);
 
     /* Check args */
-    if(NULL == (space = (H5S_t *)H5I_object_verify(space_id, H5I_DATASPACE)))
+    if (NULL == (space = (H5S_t *)H5I_object_verify(space_id, H5I_DATASPACE)))
         HGOTO_ERROR(H5E_ARGS, H5E_BADTYPE, H5I_INVALID_HID, "not a dataspace")
-    if(start == NULL || count == NULL)
+    if (start == NULL || count == NULL)
         HGOTO_ERROR(H5E_ARGS, H5E_BADVALUE, H5I_INVALID_HID, "hyperslab not specified")
-    if(!(op >= H5S_SELECT_SET && op <= H5S_SELECT_NOTA))
+    if (!(op >= H5S_SELECT_SET && op <= H5S_SELECT_NOTA))
         HGOTO_ERROR(H5E_ARGS, H5E_UNSUPPORTED, H5I_INVALID_HID, "invalid selection operation")
 
     /* Generate new space, with combination of selections */
-    if(H5S_combine_hyperslab(space, op, start, stride, count, block, &new_space) < 0)
+    if (H5S_combine_hyperslab(space, op, start, stride, count, block, &new_space) < 0)
         HGOTO_ERROR(H5E_DATASPACE, H5E_CANTINIT, H5I_INVALID_HID, "unable to set hyperslab selection")
 
     /* Atomize */
-    if((ret_value = H5I_register(H5I_DATASPACE, new_space, TRUE)) < 0)
+    if ((ret_value = H5I_register(H5I_DATASPACE, new_space, TRUE)) < 0)
         HGOTO_ERROR(H5E_ATOM, H5E_CANTREGISTER, H5I_INVALID_HID, "unable to register dataspace atom")
 
 done:
-    if(ret_value < 0 && new_space)
+    if (ret_value < 0 && new_space)
         H5S_close(new_space);
 
     FUNC_LEAVE_API(ret_value)
 } /* end H5Scombine_hyperslab() */
 
-
 /*-------------------------------------------------------------------------
  * Function:    H5S__combine_select
  *
@@ -10539,8 +10597,8 @@ done:
 static H5S_t *
 H5S__combine_select(H5S_t *space1, H5S_seloper_t op, H5S_t *space2)
 {
-    H5S_t *new_space = NULL;    /* New dataspace generated */
-    H5S_t *ret_value = NULL;    /* Return value */
+    H5S_t *new_space = NULL; /* New dataspace generated */
+    H5S_t *ret_value = NULL; /* Return value */
 
     FUNC_ENTER_STATIC
 
@@ -10550,31 +10608,31 @@ H5S__combine_select(H5S_t *space1, H5S_seloper_t op, H5S_t *space2)
     HDassert(op >= H5S_SELECT_OR && op <= H5S_SELECT_NOTA);
 
     /* Check if space1 selections has span trees */
-    if(NULL == space1->select.sel_info.hslab->span_lst)
-        if(H5S__hyper_generate_spans(space1) < 0)
+    if (NULL == space1->select.sel_info.hslab->span_lst)
+        if (H5S__hyper_generate_spans(space1) < 0)
             HGOTO_ERROR(H5E_DATASPACE, H5E_UNINITIALIZED, NULL, "dataspace does not have span tree")
 
-    if(NULL == space2->select.sel_info.hslab->span_lst) {
-        hsize_t tmp_start[H5S_MAX_RANK];
-        hsize_t tmp_stride[H5S_MAX_RANK];
-        hsize_t tmp_count[H5S_MAX_RANK];
-        hsize_t tmp_block[H5S_MAX_RANK];
+    if (NULL == space2->select.sel_info.hslab->span_lst) {
+        hsize_t  tmp_start[H5S_MAX_RANK];
+        hsize_t  tmp_stride[H5S_MAX_RANK];
+        hsize_t  tmp_count[H5S_MAX_RANK];
+        hsize_t  tmp_block[H5S_MAX_RANK];
         unsigned u;
 
-        for(u = 0; u < space2->extent.rank; u++) {
-            tmp_start[u] = space2->select.sel_info.hslab->diminfo.opt[u].start;
+        for (u = 0; u < space2->extent.rank; u++) {
+            tmp_start[u]  = space2->select.sel_info.hslab->diminfo.opt[u].start;
             tmp_stride[u] = space2->select.sel_info.hslab->diminfo.opt[u].stride;
-            tmp_count[u] = space2->select.sel_info.hslab->diminfo.opt[u].count;
-            tmp_block[u] = space2->select.sel_info.hslab->diminfo.opt[u].block;
+            tmp_count[u]  = space2->select.sel_info.hslab->diminfo.opt[u].count;
+            tmp_block[u]  = space2->select.sel_info.hslab->diminfo.opt[u].block;
         } /* end for */
 
         /* Combine hyperslab selection with regular selection directly */
-        if(H5S_combine_hyperslab(space1, op, tmp_start, tmp_stride, tmp_count, tmp_block, &new_space) < 0)
+        if (H5S_combine_hyperslab(space1, op, tmp_start, tmp_stride, tmp_count, tmp_block, &new_space) < 0)
             HGOTO_ERROR(H5E_DATASPACE, H5E_CANTINIT, NULL, "unable to set hyperslab selection")
     } /* end if */
-    else{
+    else {
         /* Combine new_space (a copy of space 1) & space2, with the result in new_space */
-        if(H5S__fill_in_select(space1, op, space2, &new_space) < 0)
+        if (H5S__fill_in_select(space1, op, space2, &new_space) < 0)
             HGOTO_ERROR(H5E_DATASPACE, H5E_CANTCLIP, NULL, "can't clip hyperslab information")
     } /* end else */
 
@@ -10585,13 +10643,12 @@ H5S__combine_select(H5S_t *space1, H5S_seloper_t op, H5S_t *space2)
     ret_value = new_space;
 
 done:
-    if(ret_value == NULL && new_space)
+    if (ret_value == NULL && new_space)
         H5S_close(new_space);
 
     FUNC_LEAVE_NOAPI(ret_value)
 } /* end H5S__combine_select() */
 
-
 /*--------------------------------------------------------------------------
  NAME
     H5Scombine_select
@@ -10617,27 +10674,27 @@ done:
 hid_t
 H5Scombine_select(hid_t space1_id, H5S_seloper_t op, hid_t space2_id)
 {
-    H5S_t    *space1;                /* First Dataspace */
-    H5S_t    *space2;                /* Second Dataspace */
-    H5S_t    *new_space = NULL;      /* New Dataspace */
-    hid_t    ret_value;              /* Return value */
+    H5S_t *space1;           /* First Dataspace */
+    H5S_t *space2;           /* Second Dataspace */
+    H5S_t *new_space = NULL; /* New Dataspace */
+    hid_t  ret_value;        /* Return value */
 
     FUNC_ENTER_API(H5I_INVALID_HID)
     H5TRACE3("i", "iSsi", space1_id, op, space2_id);
 
     /* Check args */
-    if(NULL == (space1 = (H5S_t *)H5I_object_verify(space1_id, H5I_DATASPACE)))
+    if (NULL == (space1 = (H5S_t *)H5I_object_verify(space1_id, H5I_DATASPACE)))
         HGOTO_ERROR(H5E_ARGS, H5E_BADTYPE, H5I_INVALID_HID, "not a dataspace")
-    if(NULL == (space2 = (H5S_t *)H5I_object_verify(space2_id, H5I_DATASPACE)))
+    if (NULL == (space2 = (H5S_t *)H5I_object_verify(space2_id, H5I_DATASPACE)))
         HGOTO_ERROR(H5E_ARGS, H5E_BADTYPE, H5I_INVALID_HID, "not a dataspace")
-    if(!(op >= H5S_SELECT_OR && op <= H5S_SELECT_NOTA))
+    if (!(op >= H5S_SELECT_OR && op <= H5S_SELECT_NOTA))
         HGOTO_ERROR(H5E_ARGS, H5E_UNSUPPORTED, H5I_INVALID_HID, "invalid selection operation")
 
     /* Check that both dataspaces have the same rank */
-    if(space1->extent.rank != space2->extent.rank)
+    if (space1->extent.rank != space2->extent.rank)
         HGOTO_ERROR(H5E_ARGS, H5E_BADVALUE, H5I_INVALID_HID, "dataspaces not same rank")
 
-    /* Note: currently, the offset of each dataspace is ignored */
+        /* Note: currently, the offset of each dataspace is ignored */
 #if 0
     /* Check that both dataspaces have the same offset */
     /* Same note as in H5Smodify_select */
@@ -10648,25 +10705,25 @@ H5Scombine_select(hid_t space1_id, H5S_seloper_t op, hid_t space2_id)
 #endif
 
     /* Check that both dataspaces have hyperslab selections */
-    if(H5S_GET_SELECT_TYPE(space1) != H5S_SEL_HYPERSLABS || H5S_GET_SELECT_TYPE(space2) != H5S_SEL_HYPERSLABS)
+    if (H5S_GET_SELECT_TYPE(space1) != H5S_SEL_HYPERSLABS ||
+        H5S_GET_SELECT_TYPE(space2) != H5S_SEL_HYPERSLABS)
         HGOTO_ERROR(H5E_ARGS, H5E_BADVALUE, H5I_INVALID_HID, "dataspaces don't have hyperslab selections")
 
     /* Go combine the dataspaces */
-    if(NULL == (new_space = H5S__combine_select(space1, op, space2)))
+    if (NULL == (new_space = H5S__combine_select(space1, op, space2)))
         HGOTO_ERROR(H5E_DATASPACE, H5E_CANTINIT, H5I_INVALID_HID, "unable to create hyperslab selection")
 
     /* Atomize */
-    if((ret_value = H5I_register(H5I_DATASPACE, new_space, TRUE)) < 0)
+    if ((ret_value = H5I_register(H5I_DATASPACE, new_space, TRUE)) < 0)
         HGOTO_ERROR(H5E_ATOM, H5E_CANTREGISTER, H5I_INVALID_HID, "unable to register dataspace atom")
 
 done:
-    if(ret_value < 0 && new_space)
+    if (ret_value < 0 && new_space)
         H5S_close(new_space);
 
     FUNC_LEAVE_API(ret_value)
 } /* end H5Scombine_select() */
 
-
 /*-------------------------------------------------------------------------
  * Function:    H5S__modify_select
  *
@@ -10682,7 +10739,7 @@ done:
 herr_t
 H5S__modify_select(H5S_t *space1, H5S_seloper_t op, H5S_t *space2)
 {
-    herr_t      ret_value = SUCCEED;       /* Return value */
+    herr_t ret_value = SUCCEED; /* Return value */
 
     FUNC_ENTER_PACKAGE
 
@@ -10692,41 +10749,40 @@ H5S__modify_select(H5S_t *space1, H5S_seloper_t op, H5S_t *space2)
     HDassert(op >= H5S_SELECT_OR && op <= H5S_SELECT_NOTA);
 
     /* Check that the space selections both have span trees */
-    if(NULL == space1->select.sel_info.hslab->span_lst)
-        if(H5S__hyper_generate_spans(space1) < 0)
+    if (NULL == space1->select.sel_info.hslab->span_lst)
+        if (H5S__hyper_generate_spans(space1) < 0)
             HGOTO_ERROR(H5E_DATASPACE, H5E_UNINITIALIZED, FAIL, "dataspace does not have span tree")
 
     /* Set unlim_dim */
     space1->select.sel_info.hslab->unlim_dim = -1;
 
-    if(NULL == space2->select.sel_info.hslab->span_lst) {
-        hsize_t tmp_start[H5S_MAX_RANK];
-        hsize_t tmp_stride[H5S_MAX_RANK];
-        hsize_t tmp_count[H5S_MAX_RANK];
-        hsize_t tmp_block[H5S_MAX_RANK];
+    if (NULL == space2->select.sel_info.hslab->span_lst) {
+        hsize_t  tmp_start[H5S_MAX_RANK];
+        hsize_t  tmp_stride[H5S_MAX_RANK];
+        hsize_t  tmp_count[H5S_MAX_RANK];
+        hsize_t  tmp_block[H5S_MAX_RANK];
         unsigned u;
 
-        for(u = 0; u < space2->extent.rank; u++) {
-            tmp_start[u] = space2->select.sel_info.hslab->diminfo.opt[u].start;
+        for (u = 0; u < space2->extent.rank; u++) {
+            tmp_start[u]  = space2->select.sel_info.hslab->diminfo.opt[u].start;
             tmp_stride[u] = space2->select.sel_info.hslab->diminfo.opt[u].stride;
-            tmp_count[u] = space2->select.sel_info.hslab->diminfo.opt[u].count;
-            tmp_block[u] = space2->select.sel_info.hslab->diminfo.opt[u].block;
+            tmp_count[u]  = space2->select.sel_info.hslab->diminfo.opt[u].count;
+            tmp_block[u]  = space2->select.sel_info.hslab->diminfo.opt[u].block;
         } /* end for */
 
         /* Call H5S_select_hyperslab directly */
-        if(H5S_select_hyperslab(space1, op, tmp_start, tmp_stride, tmp_count, tmp_block) < 0)
+        if (H5S_select_hyperslab(space1, op, tmp_start, tmp_stride, tmp_count, tmp_block) < 0)
             HGOTO_ERROR(H5E_DATASPACE, H5E_CANTINIT, FAIL, "unable to set hyperslab selection")
     } /* end if */
     else
         /* Combine spans from space1 & spans from space2, with the result in space1 */
-        if(H5S__fill_in_select(space1, op, space2, &space1) < 0)
-            HGOTO_ERROR(H5E_DATASPACE, H5E_CANTCLIP, FAIL, "can't perform operation on two selections")
+        if (H5S__fill_in_select(space1, op, space2, &space1) < 0)
+        HGOTO_ERROR(H5E_DATASPACE, H5E_CANTCLIP, FAIL, "can't perform operation on two selections")
 
 done:
     FUNC_LEAVE_NOAPI(ret_value)
 } /* end H5S__modify_select() */
 
-
 /*--------------------------------------------------------------------------
  NAME
     H5Smodify_select
@@ -10752,43 +10808,43 @@ done:
 herr_t
 H5Smodify_select(hid_t space1_id, H5S_seloper_t op, hid_t space2_id)
 {
-    H5S_t    *space1;                /* First Dataspace */
-    H5S_t    *space2;                /* Second Dataspace */
-    herr_t      ret_value = SUCCEED;    /* Return value */
+    H5S_t *space1;              /* First Dataspace */
+    H5S_t *space2;              /* Second Dataspace */
+    herr_t ret_value = SUCCEED; /* Return value */
 
     FUNC_ENTER_API(FAIL)
     H5TRACE3("e", "iSsi", space1_id, op, space2_id);
 
     /* Check args */
-    if(NULL == (space1 = (H5S_t *)H5I_object_verify(space1_id, H5I_DATASPACE)))
+    if (NULL == (space1 = (H5S_t *)H5I_object_verify(space1_id, H5I_DATASPACE)))
         HGOTO_ERROR(H5E_ARGS, H5E_BADTYPE, FAIL, "not a dataspace")
-    if(NULL == (space2 = (H5S_t *)H5I_object_verify(space2_id, H5I_DATASPACE)))
+    if (NULL == (space2 = (H5S_t *)H5I_object_verify(space2_id, H5I_DATASPACE)))
         HGOTO_ERROR(H5E_ARGS, H5E_BADTYPE, FAIL, "not a dataspace")
-    if(!(op >= H5S_SELECT_OR && op <= H5S_SELECT_NOTA))
+    if (!(op >= H5S_SELECT_OR && op <= H5S_SELECT_NOTA))
         HGOTO_ERROR(H5E_ARGS, H5E_UNSUPPORTED, FAIL, "invalid selection operation")
 
     /* Check that both dataspaces have the same rank */
-    if(space1->extent.rank != space2->extent.rank)
+    if (space1->extent.rank != space2->extent.rank)
         HGOTO_ERROR(H5E_ARGS, H5E_BADVALUE, FAIL, "dataspaces not same rank")
 
-    /* Check that both dataspaces have the same offset */
-    /** Note that this is a tricky part of this function. It's
-     *  possible that two dataspaces have different "offset". If the
-     *  space2 has smaller offset value than that of space1 in a
-     *  dimension, then the span elements of this dimension in
-     *  space2 could have negative "low" and "high" values relative
-     *  to the offset in space1. In other words, if the bounds of
-     *  span elements in space2 are adjusted relative to the offset
-     *  in space1, then every span element's bound is computed as
-     *  "origin_bound+offset2-offset1". Therefore, if offset2 (the
-     *  offset of space2) is smaller, then
-     *  "origin_bound+offset2-offset1" could be negative which is
-     *  not allowed by the bound type declaration as hsize_t!
-     *  As a result, if the op is an OR selection, then the final
-     *  result may contain span elements that have negative bound!
-     *  So right now, the difference in the offset is totally
-     *  ignored!!
-     */
+        /* Check that both dataspaces have the same offset */
+        /** Note that this is a tricky part of this function. It's
+         *  possible that two dataspaces have different "offset". If the
+         *  space2 has smaller offset value than that of space1 in a
+         *  dimension, then the span elements of this dimension in
+         *  space2 could have negative "low" and "high" values relative
+         *  to the offset in space1. In other words, if the bounds of
+         *  span elements in space2 are adjusted relative to the offset
+         *  in space1, then every span element's bound is computed as
+         *  "origin_bound+offset2-offset1". Therefore, if offset2 (the
+         *  offset of space2) is smaller, then
+         *  "origin_bound+offset2-offset1" could be negative which is
+         *  not allowed by the bound type declaration as hsize_t!
+         *  As a result, if the op is an OR selection, then the final
+         *  result may contain span elements that have negative bound!
+         *  So right now, the difference in the offset is totally
+         *  ignored!!
+         */
 #if 0
     for(u=0; u<space1->extent.rank; u++) {
         if(space1->select.offset[u] != space2->select.offset[u])
@@ -10797,18 +10853,18 @@ H5Smodify_select(hid_t space1_id, H5S_seloper_t op, hid_t space2_id)
 #endif
 
     /* Check that both dataspaces have hyperslab selections */
-    if(H5S_GET_SELECT_TYPE(space1) != H5S_SEL_HYPERSLABS || H5S_GET_SELECT_TYPE(space2) != H5S_SEL_HYPERSLABS)
+    if (H5S_GET_SELECT_TYPE(space1) != H5S_SEL_HYPERSLABS ||
+        H5S_GET_SELECT_TYPE(space2) != H5S_SEL_HYPERSLABS)
         HGOTO_ERROR(H5E_ARGS, H5E_BADVALUE, FAIL, "dataspaces don't have hyperslab selections")
 
     /* Go refine the first selection */
-    if(H5S__modify_select(space1, op, space2) < 0)
+    if (H5S__modify_select(space1, op, space2) < 0)
         HGOTO_ERROR(H5E_DATASPACE, H5E_CANTINIT, FAIL, "unable to modify hyperslab selection")
 
 done:
     FUNC_LEAVE_API(ret_value)
 } /* end H5Smodify_select() */
 
-
 /*--------------------------------------------------------------------------
  NAME
     H5S__hyper_proj_int_build_proj
@@ -10831,9 +10887,10 @@ done:
  REVISION LOG
 --------------------------------------------------------------------------*/
 static herr_t
-H5S__hyper_proj_int_build_proj(H5S_hyper_project_intersect_ud_t *udata) {
-    H5S_hyper_span_info_t *copied_span_info = NULL; /* Temporary span info pointer */
-    herr_t ret_value = SUCCEED; /* Return value */
+H5S__hyper_proj_int_build_proj(H5S_hyper_project_intersect_ud_t *udata)
+{
+    H5S_hyper_span_info_t *copied_span_info = NULL;    /* Temporary span info pointer */
+    herr_t                 ret_value        = SUCCEED; /* Return value */
 
     FUNC_ENTER_STATIC
 
@@ -10842,35 +10899,37 @@ H5S__hyper_proj_int_build_proj(H5S_hyper_project_intersect_ud_t *udata) {
     /*
      * Skip over skipped elements
      */
-    if(udata->skip > 0) {
+    if (udata->skip > 0) {
         /* Work upwards, finishing each span tree before moving up */
         HDassert(udata->ds_span[udata->depth]);
         do {
             /* Check for lowest dimension */
-            if(udata->ds_span[udata->depth]->down) {
-                if(udata->ds_low[udata->depth] <= udata->ds_span[udata->depth]->high) {
+            if (udata->ds_span[udata->depth]->down) {
+                if (udata->ds_low[udata->depth] <= udata->ds_span[udata->depth]->high) {
                     /* If we will run out of elements to skip in this span,
                      * advance to the first not fully skipped span and break
                      * out of this loop (start moving downwards) */
-                    if(udata->skip < H5S__hyper_spans_nelem_helper(udata->ds_span[udata->depth]->down, 0, udata->op_gen)
-                            * (udata->ds_span[udata->depth]->high - udata->ds_low[udata->depth] + 1)) {
-                        udata->ds_low[udata->depth] += udata->skip / udata->ds_span[udata->depth]->down->op_info[0].u.nelmts;
+                    if (udata->skip <
+                        H5S__hyper_spans_nelem_helper(udata->ds_span[udata->depth]->down, 0, udata->op_gen) *
+                            (udata->ds_span[udata->depth]->high - udata->ds_low[udata->depth] + 1)) {
+                        udata->ds_low[udata->depth] +=
+                            udata->skip / udata->ds_span[udata->depth]->down->op_info[0].u.nelmts;
                         udata->skip %= udata->ds_span[udata->depth]->down->op_info[0].u.nelmts;
                         break;
                     } /* end if */
 
                     /* Skip over this entire span */
-                    udata->skip -= udata->ds_span[udata->depth]->down->op_info[0].u.nelmts
-                            * (udata->ds_span[udata->depth]->high - udata->ds_low[udata->depth] + 1);
+                    udata->skip -= udata->ds_span[udata->depth]->down->op_info[0].u.nelmts *
+                                   (udata->ds_span[udata->depth]->high - udata->ds_low[udata->depth] + 1);
                 } /* end if */
-            } /* end if */
+            }     /* end if */
             else {
                 HDassert(udata->ds_rank - udata->depth == 1);
 
                 /* If we will run out of elements to skip in this span,
                  * skip the remainder of the skipped elements and break out */
                 HDassert(udata->ds_low[udata->depth] <= udata->ds_span[udata->depth]->high);
-                if(udata->skip < (udata->ds_span[udata->depth]->high - udata->ds_low[udata->depth] + 1)) {
+                if (udata->skip < (udata->ds_span[udata->depth]->high - udata->ds_low[udata->depth] + 1)) {
                     udata->ds_low[udata->depth] += udata->skip;
                     udata->skip = 0;
                     break;
@@ -10882,15 +10941,15 @@ H5S__hyper_proj_int_build_proj(H5S_hyper_project_intersect_ud_t *udata) {
 
             /* Advance to next span */
             udata->ds_span[udata->depth] = udata->ds_span[udata->depth]->next;
-            if(udata->ds_span[udata->depth])
+            if (udata->ds_span[udata->depth])
                 udata->ds_low[udata->depth] = udata->ds_span[udata->depth]->low;
-            else if(udata->depth > 0) {
+            else if (udata->depth > 0) {
                 /* If present, append this span tree to the higher dimension's,
                  * and release ownership of it */
-                if(udata->ps_span_info[udata->depth]) {
-                    if(H5S__hyper_append_span(&udata->ps_span_info[udata->depth - 1],
-                            udata->ds_rank - udata->depth + 1, udata->ds_low[udata->depth - 1],
-                            udata->ds_low[udata->depth - 1],
+                if (udata->ps_span_info[udata->depth]) {
+                    if (H5S__hyper_append_span(
+                            &udata->ps_span_info[udata->depth - 1], udata->ds_rank - udata->depth + 1,
+                            udata->ds_low[udata->depth - 1], udata->ds_low[udata->depth - 1],
                             udata->ps_span_info[udata->depth]) < 0)
                         HGOTO_ERROR(H5E_DATASPACE, H5E_CANTAPPEND, FAIL, "can't allocate hyperslab span")
                     H5S__hyper_free_span_info(udata->ps_span_info[udata->depth]);
@@ -10903,44 +10962,47 @@ H5S__hyper_proj_int_build_proj(H5S_hyper_project_intersect_ud_t *udata) {
                 udata->ds_low[udata->depth]++;
             } /* end if */
             else
-                HGOTO_ERROR(H5E_DATASPACE, H5E_BADVALUE, FAIL, "insufficient elements in destination selection")
-        } while((udata->skip > 0)
-                || (udata->ds_low[udata->depth] > udata->ds_span[udata->depth]->high));
+                HGOTO_ERROR(H5E_DATASPACE, H5E_BADVALUE, FAIL,
+                            "insufficient elements in destination selection")
+        } while ((udata->skip > 0) || (udata->ds_low[udata->depth] > udata->ds_span[udata->depth]->high));
 
         /* Work downwards until skip is 0 */
         HDassert(udata->ds_span[udata->depth]);
-        while(udata->skip > 0) {
+        while (udata->skip > 0) {
             HDassert(udata->ds_span[udata->depth]->down);
             udata->depth++;
             udata->ds_span[udata->depth] = udata->ds_span[udata->depth - 1]->down->head;
-            udata->ds_low[udata->depth] = udata->ds_span[udata->depth]->low;
-            if(udata->ds_span[udata->depth]->down) {
+            udata->ds_low[udata->depth]  = udata->ds_span[udata->depth]->low;
+            if (udata->ds_span[udata->depth]->down) {
                 do {
                     /* If we will run out of elements to skip in this span,
                      * advance to the first not fully skipped span and
                      * continue down */
-                    if(udata->skip < H5S__hyper_spans_nelem_helper(udata->ds_span[udata->depth]->down, 0, udata->op_gen)
-                            * (udata->ds_span[udata->depth]->high - udata->ds_low[udata->depth] + 1)) {
-                        udata->ds_low[udata->depth] += udata->skip / udata->ds_span[udata->depth]->down->op_info[0].u.nelmts;
+                    if (udata->skip <
+                        H5S__hyper_spans_nelem_helper(udata->ds_span[udata->depth]->down, 0, udata->op_gen) *
+                            (udata->ds_span[udata->depth]->high - udata->ds_low[udata->depth] + 1)) {
+                        udata->ds_low[udata->depth] +=
+                            udata->skip / udata->ds_span[udata->depth]->down->op_info[0].u.nelmts;
                         udata->skip %= udata->ds_span[udata->depth]->down->op_info[0].u.nelmts;
                         break;
                     } /* end if */
 
                     /* Skip over this entire span */
-                    udata->skip -= udata->ds_span[udata->depth]->down->op_info[0].u.nelmts
-                            * (udata->ds_span[udata->depth]->high - udata->ds_low[udata->depth] + 1);
+                    udata->skip -= udata->ds_span[udata->depth]->down->op_info[0].u.nelmts *
+                                   (udata->ds_span[udata->depth]->high - udata->ds_low[udata->depth] + 1);
 
                     /* Advance to next span */
                     udata->ds_span[udata->depth] = udata->ds_span[udata->depth]->next;
                     HDassert(udata->ds_span[udata->depth]);
                     udata->ds_low[udata->depth] = udata->ds_span[udata->depth]->low;
-                } while(udata->skip > 0);
+                } while (udata->skip > 0);
             } /* end if */
             else {
                 do {
                     /* If we will run out of elements to skip in this span,
                      * skip the remainder of the skipped elements */
-                    if(udata->skip < (udata->ds_span[udata->depth]->high - udata->ds_low[udata->depth] + 1)) {
+                    if (udata->skip <
+                        (udata->ds_span[udata->depth]->high - udata->ds_low[udata->depth] + 1)) {
                         udata->ds_low[udata->depth] += udata->skip;
                         udata->skip = 0;
                         break;
@@ -10953,10 +11015,10 @@ H5S__hyper_proj_int_build_proj(H5S_hyper_project_intersect_ud_t *udata) {
                     udata->ds_span[udata->depth] = udata->ds_span[udata->depth]->next;
                     HDassert(udata->ds_span[udata->depth]);
                     udata->ds_low[udata->depth] = udata->ds_span[udata->depth]->low;
-                } while(udata->skip > 0);
+                } while (udata->skip > 0);
             } /* end else */
-        } /* end while */
-    } /* end if */
+        }     /* end while */
+    }         /* end if */
 
     /*
      * Add requested number of elements to projected space
@@ -10966,77 +11028,92 @@ H5S__hyper_proj_int_build_proj(H5S_hyper_project_intersect_ud_t *udata) {
     HDassert(udata->ds_span[udata->depth]);
     do {
         /* Check for lowest dimension */
-        if(udata->ds_span[udata->depth]->down) {
-            if(udata->ds_low[udata->depth] <= udata->ds_span[udata->depth]->high) {
+        if (udata->ds_span[udata->depth]->down) {
+            if (udata->ds_low[udata->depth] <= udata->ds_span[udata->depth]->high) {
                 /* If we will run out of elements to add in this span, add
                  * any complete spans, advance to the first not fully added
                  * span, and break out of this loop (start moving downwards)
                  */
-                if(udata->nelem < H5S__hyper_spans_nelem_helper(udata->ds_span[udata->depth]->down, 0, udata->op_gen)
-                        * (udata->ds_span[udata->depth]->high - udata->ds_low[udata->depth] + 1)) {
-                    if(udata->nelem >= udata->ds_span[udata->depth]->down->op_info[0].u.nelmts) {
-                        if(udata->share_selection) {
-                            if(H5S__hyper_append_span(&udata->ps_span_info[udata->depth],
-                                    udata->ds_rank - udata->depth, udata->ds_low[udata->depth],
-                                    udata->ds_low[udata->depth] + (udata->nelem / udata->ds_span[udata->depth]->down->op_info[0].u.nelmts) - 1,
+                if (udata->nelem <
+                    H5S__hyper_spans_nelem_helper(udata->ds_span[udata->depth]->down, 0, udata->op_gen) *
+                        (udata->ds_span[udata->depth]->high - udata->ds_low[udata->depth] + 1)) {
+                    if (udata->nelem >= udata->ds_span[udata->depth]->down->op_info[0].u.nelmts) {
+                        if (udata->share_selection) {
+                            if (H5S__hyper_append_span(
+                                    &udata->ps_span_info[udata->depth], udata->ds_rank - udata->depth,
+                                    udata->ds_low[udata->depth],
+                                    udata->ds_low[udata->depth] +
+                                        (udata->nelem /
+                                         udata->ds_span[udata->depth]->down->op_info[0].u.nelmts) -
+                                        1,
                                     udata->ds_span[udata->depth]->down) < 0)
-                                HGOTO_ERROR(H5E_DATASPACE, H5E_CANTAPPEND, FAIL, "can't allocate hyperslab span")
+                                HGOTO_ERROR(H5E_DATASPACE, H5E_CANTAPPEND, FAIL,
+                                            "can't allocate hyperslab span")
                         } /* end if */
                         else {
                             /* If we're not sharing the destination space's
                              * spans, we must copy it first (then release it
                              * afterwards) */
-                            if(NULL == (copied_span_info = H5S__hyper_copy_span_helper(udata->ds_span[udata->depth]->down, udata->ds_rank - udata->depth, 1, udata->op_gen)))
+                            if (NULL == (copied_span_info = H5S__hyper_copy_span_helper(
+                                             udata->ds_span[udata->depth]->down,
+                                             udata->ds_rank - udata->depth, 1, udata->op_gen)))
                                 HGOTO_ERROR(H5E_DATASPACE, H5E_CANTCOPY, FAIL, "can't copy destination spans")
-                            if(H5S__hyper_append_span(&udata->ps_span_info[udata->depth],
-                                    udata->ds_rank - udata->depth, udata->ds_low[udata->depth],
-                                    udata->ds_low[udata->depth] + (udata->nelem / udata->ds_span[udata->depth]->down->op_info[0].u.nelmts) - 1,
+                            if (H5S__hyper_append_span(
+                                    &udata->ps_span_info[udata->depth], udata->ds_rank - udata->depth,
+                                    udata->ds_low[udata->depth],
+                                    udata->ds_low[udata->depth] +
+                                        (udata->nelem /
+                                         udata->ds_span[udata->depth]->down->op_info[0].u.nelmts) -
+                                        1,
                                     copied_span_info) < 0)
-                                HGOTO_ERROR(H5E_DATASPACE, H5E_CANTAPPEND, FAIL, "can't allocate hyperslab span")
+                                HGOTO_ERROR(H5E_DATASPACE, H5E_CANTAPPEND, FAIL,
+                                            "can't allocate hyperslab span")
                             H5S__hyper_free_span_info(copied_span_info);
                             copied_span_info = NULL;
                         } /* end else */
-                        udata->ds_low[udata->depth] += udata->nelem / udata->ds_span[udata->depth]->down->op_info[0].u.nelmts;
+                        udata->ds_low[udata->depth] +=
+                            udata->nelem / udata->ds_span[udata->depth]->down->op_info[0].u.nelmts;
                         udata->nelem %= udata->ds_span[udata->depth]->down->op_info[0].u.nelmts;
                     } /* end if */
                     break;
                 } /* end if */
 
                 /* Append span tree for entire span */
-                if(udata->share_selection) {
-                    if(H5S__hyper_append_span(&udata->ps_span_info[udata->depth],
-                            udata->ds_rank - udata->depth, udata->ds_low[udata->depth],
-                            udata->ds_span[udata->depth]->high,
-                            udata->ds_span[udata->depth]->down) < 0)
+                if (udata->share_selection) {
+                    if (H5S__hyper_append_span(&udata->ps_span_info[udata->depth],
+                                               udata->ds_rank - udata->depth, udata->ds_low[udata->depth],
+                                               udata->ds_span[udata->depth]->high,
+                                               udata->ds_span[udata->depth]->down) < 0)
                         HGOTO_ERROR(H5E_DATASPACE, H5E_CANTAPPEND, FAIL, "can't allocate hyperslab span")
                 } /* end if */
                 else {
                     /* If we're not sharing the destination space's
                      * spans, we must copy it first (then release it
                      * afterwards) */
-                    if(NULL == (copied_span_info = H5S__hyper_copy_span_helper(udata->ds_span[udata->depth]->down, udata->ds_rank - udata->depth, 1, udata->op_gen)))
+                    if (NULL == (copied_span_info = H5S__hyper_copy_span_helper(
+                                     udata->ds_span[udata->depth]->down, udata->ds_rank - udata->depth, 1,
+                                     udata->op_gen)))
                         HGOTO_ERROR(H5E_DATASPACE, H5E_CANTCOPY, FAIL, "can't copy destination spans")
-                    if(H5S__hyper_append_span(&udata->ps_span_info[udata->depth],
-                            udata->ds_rank - udata->depth, udata->ds_low[udata->depth],
-                            udata->ds_span[udata->depth]->high,
-                            copied_span_info) < 0)
+                    if (H5S__hyper_append_span(&udata->ps_span_info[udata->depth],
+                                               udata->ds_rank - udata->depth, udata->ds_low[udata->depth],
+                                               udata->ds_span[udata->depth]->high, copied_span_info) < 0)
                         HGOTO_ERROR(H5E_DATASPACE, H5E_CANTAPPEND, FAIL, "can't allocate hyperslab span")
                     H5S__hyper_free_span_info(copied_span_info);
                     copied_span_info = NULL;
                 } /* end else */
-                udata->nelem -= udata->ds_span[udata->depth]->down->op_info[0].u.nelmts
-                        * (udata->ds_span[udata->depth]->high - udata->ds_low[udata->depth] + 1);
+                udata->nelem -= udata->ds_span[udata->depth]->down->op_info[0].u.nelmts *
+                                (udata->ds_span[udata->depth]->high - udata->ds_low[udata->depth] + 1);
             } /* end if */
-        } /* end if */
+        }     /* end if */
         else {
             HDassert(udata->ds_rank - udata->depth == 1);
 
             /* If we will run out of elements to add in this span, add the
              * remainder of the elements and break out */
             HDassert(udata->ds_low[udata->depth] <= udata->ds_span[udata->depth]->high);
-            if(udata->nelem < (udata->ds_span[udata->depth]->high - udata->ds_low[udata->depth] + 1)) {
-                if(H5S__hyper_append_span(&udata->ps_span_info[udata->depth], 1,
-                        udata->ds_low[udata->depth], udata->ds_low[udata->depth] + udata->nelem - 1, NULL) < 0)
+            if (udata->nelem < (udata->ds_span[udata->depth]->high - udata->ds_low[udata->depth] + 1)) {
+                if (H5S__hyper_append_span(&udata->ps_span_info[udata->depth], 1, udata->ds_low[udata->depth],
+                                           udata->ds_low[udata->depth] + udata->nelem - 1, NULL) < 0)
                     HGOTO_ERROR(H5E_DATASPACE, H5E_CANTAPPEND, FAIL, "can't allocate hyperslab span")
                 udata->ds_low[udata->depth] += udata->nelem;
                 udata->nelem = 0;
@@ -11044,24 +11121,24 @@ H5S__hyper_proj_int_build_proj(H5S_hyper_project_intersect_ud_t *udata) {
             } /* end if */
 
             /* Append span tree for entire span */
-            if(H5S__hyper_append_span(&udata->ps_span_info[udata->depth], 1,
-                    udata->ds_low[udata->depth], udata->ds_span[udata->depth]->high, NULL) < 0)
-                    HGOTO_ERROR(H5E_DATASPACE, H5E_CANTAPPEND, FAIL, "can't allocate hyperslab span")
+            if (H5S__hyper_append_span(&udata->ps_span_info[udata->depth], 1, udata->ds_low[udata->depth],
+                                       udata->ds_span[udata->depth]->high, NULL) < 0)
+                HGOTO_ERROR(H5E_DATASPACE, H5E_CANTAPPEND, FAIL, "can't allocate hyperslab span")
             udata->nelem -= udata->ds_span[udata->depth]->high - udata->ds_low[udata->depth] + 1;
         } /* end else */
 
         /* Advance to next span */
         udata->ds_span[udata->depth] = udata->ds_span[udata->depth]->next;
-        if(udata->ds_span[udata->depth])
+        if (udata->ds_span[udata->depth])
             udata->ds_low[udata->depth] = udata->ds_span[udata->depth]->low;
-        else if(udata->depth > 0) {
+        else if (udata->depth > 0) {
             /* Append this span tree to the higher dimension's, and release
              * ownership of it */
             HDassert(udata->ps_span_info[udata->depth]);
-            if(H5S__hyper_append_span(&udata->ps_span_info[udata->depth - 1],
-                    udata->ds_rank - udata->depth + 1, udata->ds_low[udata->depth - 1],
-                    udata->ds_low[udata->depth - 1],
-                    udata->ps_span_info[udata->depth]) < 0)
+            if (H5S__hyper_append_span(&udata->ps_span_info[udata->depth - 1],
+                                       udata->ds_rank - udata->depth + 1, udata->ds_low[udata->depth - 1],
+                                       udata->ds_low[udata->depth - 1],
+                                       udata->ps_span_info[udata->depth]) < 0)
                 HGOTO_ERROR(H5E_DATASPACE, H5E_CANTAPPEND, FAIL, "can't allocate hyperslab span")
             H5S__hyper_free_span_info(udata->ps_span_info[udata->depth]);
             udata->ps_span_info[udata->depth] = NULL;
@@ -11074,87 +11151,102 @@ H5S__hyper_proj_int_build_proj(H5S_hyper_project_intersect_ud_t *udata) {
         else {
             /* We have finished the entire destination span tree.  If there are
              * still elements to add, issue an error. */
-            if(udata->nelem > 0)
-                HGOTO_ERROR(H5E_DATASPACE, H5E_BADVALUE, FAIL, "insufficient elements in destination selection")
+            if (udata->nelem > 0)
+                HGOTO_ERROR(H5E_DATASPACE, H5E_BADVALUE, FAIL,
+                            "insufficient elements in destination selection")
             break;
         } /* end else */
-    } while((udata->nelem > 0)
-            || (udata->ds_low[udata->depth] > udata->ds_span[udata->depth]->high));
+    } while ((udata->nelem > 0) || (udata->ds_low[udata->depth] > udata->ds_span[udata->depth]->high));
 
     /* Work downwards until nelem is 0 */
     HDassert(udata->ds_span[udata->depth] || (udata->nelem == 0));
-    while(udata->nelem > 0) {
+    while (udata->nelem > 0) {
         HDassert(udata->ds_span[udata->depth]->down);
         udata->depth++;
         udata->ds_span[udata->depth] = udata->ds_span[udata->depth - 1]->down->head;
-        udata->ds_low[udata->depth] = udata->ds_span[udata->depth]->low;
-        if(udata->ds_span[udata->depth]->down) {
+        udata->ds_low[udata->depth]  = udata->ds_span[udata->depth]->low;
+        if (udata->ds_span[udata->depth]->down) {
             do {
                 /* If we will run out of elements to add in this span, add
                  * any complete spans, advance to the first not fully added
                  * span and continue down
                  */
                 HDassert(udata->ds_low[udata->depth] <= udata->ds_span[udata->depth]->high);
-                if(udata->nelem < H5S__hyper_spans_nelem_helper(udata->ds_span[udata->depth]->down, 0, udata->op_gen)
-                        * (udata->ds_span[udata->depth]->high - udata->ds_low[udata->depth] + 1)) {
-                    if(udata->nelem >= udata->ds_span[udata->depth]->down->op_info[0].u.nelmts) {
-                        if(udata->share_selection) {
-                            if(H5S__hyper_append_span(&udata->ps_span_info[udata->depth],
-                                    udata->ds_rank - udata->depth, udata->ds_low[udata->depth],
-                                    udata->ds_low[udata->depth] + (udata->nelem / udata->ds_span[udata->depth]->down->op_info[0].u.nelmts) - 1,
+                if (udata->nelem <
+                    H5S__hyper_spans_nelem_helper(udata->ds_span[udata->depth]->down, 0, udata->op_gen) *
+                        (udata->ds_span[udata->depth]->high - udata->ds_low[udata->depth] + 1)) {
+                    if (udata->nelem >= udata->ds_span[udata->depth]->down->op_info[0].u.nelmts) {
+                        if (udata->share_selection) {
+                            if (H5S__hyper_append_span(
+                                    &udata->ps_span_info[udata->depth], udata->ds_rank - udata->depth,
+                                    udata->ds_low[udata->depth],
+                                    udata->ds_low[udata->depth] +
+                                        (udata->nelem /
+                                         udata->ds_span[udata->depth]->down->op_info[0].u.nelmts) -
+                                        1,
                                     udata->ds_span[udata->depth]->down) < 0)
-                                HGOTO_ERROR(H5E_DATASPACE, H5E_CANTAPPEND, FAIL, "can't allocate hyperslab span")
+                                HGOTO_ERROR(H5E_DATASPACE, H5E_CANTAPPEND, FAIL,
+                                            "can't allocate hyperslab span")
                         } /* end if */
                         else {
                             /* If we're not sharing the destination space's
                              * spans, we must copy it first (then release it
                              * afterwards) */
-                            if(NULL == (copied_span_info = H5S__hyper_copy_span_helper(udata->ds_span[udata->depth]->down, udata->ds_rank - udata->depth, 1, udata->op_gen)))
+                            if (NULL == (copied_span_info = H5S__hyper_copy_span_helper(
+                                             udata->ds_span[udata->depth]->down,
+                                             udata->ds_rank - udata->depth, 1, udata->op_gen)))
                                 HGOTO_ERROR(H5E_DATASPACE, H5E_CANTCOPY, FAIL, "can't copy destination spans")
-                            if(H5S__hyper_append_span(&udata->ps_span_info[udata->depth],
-                                    udata->ds_rank - udata->depth, udata->ds_low[udata->depth],
-                                    udata->ds_low[udata->depth] + (udata->nelem / udata->ds_span[udata->depth]->down->op_info[0].u.nelmts) - 1,
+                            if (H5S__hyper_append_span(
+                                    &udata->ps_span_info[udata->depth], udata->ds_rank - udata->depth,
+                                    udata->ds_low[udata->depth],
+                                    udata->ds_low[udata->depth] +
+                                        (udata->nelem /
+                                         udata->ds_span[udata->depth]->down->op_info[0].u.nelmts) -
+                                        1,
                                     copied_span_info) < 0)
-                                HGOTO_ERROR(H5E_DATASPACE, H5E_CANTAPPEND, FAIL, "can't allocate hyperslab span")
+                                HGOTO_ERROR(H5E_DATASPACE, H5E_CANTAPPEND, FAIL,
+                                            "can't allocate hyperslab span")
                             H5S__hyper_free_span_info(copied_span_info);
                             copied_span_info = NULL;
                         } /* end else */
-                        udata->ds_low[udata->depth] += udata->nelem / udata->ds_span[udata->depth]->down->op_info[0].u.nelmts;
+                        udata->ds_low[udata->depth] +=
+                            udata->nelem / udata->ds_span[udata->depth]->down->op_info[0].u.nelmts;
                         udata->nelem %= udata->ds_span[udata->depth]->down->op_info[0].u.nelmts;
                     } /* end if */
                     break;
                 } /* end if */
 
                 /* Append span tree for entire span */
-                if(udata->share_selection) {
-                    if(H5S__hyper_append_span(&udata->ps_span_info[udata->depth],
-                            udata->ds_rank - udata->depth, udata->ds_low[udata->depth],
-                            udata->ds_span[udata->depth]->high,
-                            udata->ds_span[udata->depth]->down) < 0)
+                if (udata->share_selection) {
+                    if (H5S__hyper_append_span(&udata->ps_span_info[udata->depth],
+                                               udata->ds_rank - udata->depth, udata->ds_low[udata->depth],
+                                               udata->ds_span[udata->depth]->high,
+                                               udata->ds_span[udata->depth]->down) < 0)
                         HGOTO_ERROR(H5E_DATASPACE, H5E_CANTAPPEND, FAIL, "can't allocate hyperslab span")
                 } /* end if */
                 else {
                     /* If we're not sharing the destination space's
                      * spans, we must copy it first (then release it
                      * afterwards) */
-                    if(NULL == (copied_span_info = H5S__hyper_copy_span_helper(udata->ds_span[udata->depth]->down, udata->ds_rank - udata->depth, 1, udata->op_gen)))
+                    if (NULL == (copied_span_info = H5S__hyper_copy_span_helper(
+                                     udata->ds_span[udata->depth]->down, udata->ds_rank - udata->depth, 1,
+                                     udata->op_gen)))
                         HGOTO_ERROR(H5E_DATASPACE, H5E_CANTCOPY, FAIL, "can't copy destination spans")
-                    if(H5S__hyper_append_span(&udata->ps_span_info[udata->depth],
-                            udata->ds_rank - udata->depth, udata->ds_low[udata->depth],
-                            udata->ds_span[udata->depth]->high,
-                            copied_span_info) < 0)
+                    if (H5S__hyper_append_span(&udata->ps_span_info[udata->depth],
+                                               udata->ds_rank - udata->depth, udata->ds_low[udata->depth],
+                                               udata->ds_span[udata->depth]->high, copied_span_info) < 0)
                         HGOTO_ERROR(H5E_DATASPACE, H5E_CANTAPPEND, FAIL, "can't allocate hyperslab span")
                     H5S__hyper_free_span_info(copied_span_info);
                     copied_span_info = NULL;
                 } /* end else */
-                udata->nelem -= udata->ds_span[udata->depth]->down->op_info[0].u.nelmts
-                        * (udata->ds_span[udata->depth]->high - udata->ds_low[udata->depth] + 1);
+                udata->nelem -= udata->ds_span[udata->depth]->down->op_info[0].u.nelmts *
+                                (udata->ds_span[udata->depth]->high - udata->ds_low[udata->depth] + 1);
 
                 /* Advance to next span */
                 udata->ds_span[udata->depth] = udata->ds_span[udata->depth]->next;
                 HDassert(udata->ds_span[udata->depth]);
                 udata->ds_low[udata->depth] = udata->ds_span[udata->depth]->low;
-            } while(udata->nelem > 0);
+            } while (udata->nelem > 0);
         } /* end if */
         else {
             HDassert(udata->ds_rank - udata->depth == 1);
@@ -11162,9 +11254,10 @@ H5S__hyper_proj_int_build_proj(H5S_hyper_project_intersect_ud_t *udata) {
                 /* If we will run out of elements to add in this span, add
                  * the remainder of the elements and break out */
                 HDassert(udata->ds_low[udata->depth] <= udata->ds_span[udata->depth]->high);
-                if(udata->nelem < (udata->ds_span[udata->depth]->high - udata->ds_low[udata->depth] + 1)) {
-                    if(H5S__hyper_append_span(&udata->ps_span_info[udata->depth], 1,
-                            udata->ds_low[udata->depth], udata->ds_low[udata->depth] + udata->nelem - 1, NULL) < 0)
+                if (udata->nelem < (udata->ds_span[udata->depth]->high - udata->ds_low[udata->depth] + 1)) {
+                    if (H5S__hyper_append_span(&udata->ps_span_info[udata->depth], 1,
+                                               udata->ds_low[udata->depth],
+                                               udata->ds_low[udata->depth] + udata->nelem - 1, NULL) < 0)
                         HGOTO_ERROR(H5E_DATASPACE, H5E_CANTAPPEND, FAIL, "can't allocate hyperslab span")
                     udata->ds_low[udata->depth] += udata->nelem;
                     udata->nelem = 0;
@@ -11172,8 +11265,8 @@ H5S__hyper_proj_int_build_proj(H5S_hyper_project_intersect_ud_t *udata) {
                 } /* end if */
 
                 /* Append span tree for entire span */
-                if(H5S__hyper_append_span(&udata->ps_span_info[udata->depth], 1,
-                        udata->ds_low[udata->depth], udata->ds_span[udata->depth]->high, NULL) < 0)
+                if (H5S__hyper_append_span(&udata->ps_span_info[udata->depth], 1, udata->ds_low[udata->depth],
+                                           udata->ds_span[udata->depth]->high, NULL) < 0)
                     HGOTO_ERROR(H5E_DATASPACE, H5E_CANTAPPEND, FAIL, "can't allocate hyperslab span")
                 udata->nelem -= udata->ds_span[udata->depth]->high - udata->ds_low[udata->depth] + 1;
 
@@ -11181,9 +11274,9 @@ H5S__hyper_proj_int_build_proj(H5S_hyper_project_intersect_ud_t *udata) {
                 udata->ds_span[udata->depth] = udata->ds_span[udata->depth]->next;
                 HDassert(udata->ds_span[udata->depth]);
                 udata->ds_low[udata->depth] = udata->ds_span[udata->depth]->low;
-            } while(udata->nelem > 0);
+            } while (udata->nelem > 0);
         } /* end else */
-    } /* end while */
+    }     /* end while */
 
     HDassert(udata->skip == 0);
     HDassert(udata->nelem == 0);
@@ -11193,7 +11286,7 @@ H5S__hyper_proj_int_build_proj(H5S_hyper_project_intersect_ud_t *udata) {
 
 done:
     /* Cleanup on failure */
-    if(copied_span_info) {
+    if (copied_span_info) {
         HDassert(ret_value < 0);
         H5S__hyper_free_span_info(copied_span_info);
         copied_span_info = NULL;
@@ -11202,7 +11295,6 @@ done:
     FUNC_LEAVE_NOAPI(ret_value)
 } /* end H5S__hyper_proj_int_build_proj() */
 
-
 /*--------------------------------------------------------------------------
  NAME
     H5S__hyper_proj_int_iterate
@@ -11212,8 +11304,8 @@ done:
     herr_t H5S__hyper_proj_int_iterate(ss_span_info,sis_span_info,count,depth,udata)
         const H5S_hyper_span_info_t *ss_span_info; IN: Span tree for source selection
         const H5S_hyper_span_info_t *sis_span_info; IN: Span tree for source intersect selection
-        hsize_t count;          IN: Number of times to compute the intersection of ss_span_info and sis_span_info
-        unsigned depth;         IN: Depth of iteration (in terms of rank)
+        hsize_t count;          IN: Number of times to compute the intersection of ss_span_info and
+sis_span_info unsigned depth;         IN: Depth of iteration (in terms of rank)
         H5S_hyper_project_intersect_ud_t *udata; IN/OUT: Persistent shared data for iteration
  RETURNS
     Non-negative on success/Negative on failure.
@@ -11233,75 +11325,78 @@ done:
 --------------------------------------------------------------------------*/
 static herr_t
 H5S__hyper_proj_int_iterate(const H5S_hyper_span_info_t *ss_span_info,
-    const H5S_hyper_span_info_t *sis_span_info, hsize_t count, unsigned depth,
-    H5S_hyper_project_intersect_ud_t *udata)
+                            const H5S_hyper_span_info_t *sis_span_info, hsize_t count, unsigned depth,
+                            H5S_hyper_project_intersect_ud_t *udata)
 {
-    const H5S_hyper_span_t *ss_span; /* Current span in source space */
-    const H5S_hyper_span_t *sis_span; /* Current span in source intersect space */
-    hsize_t ss_low;             /* Current low bounds of source span */
-    hsize_t sis_low;            /* Current low bounds of source intersect span */
-    hsize_t high;               /* High bounds of current intersection */
-    hsize_t low;                /* Low bounds of current intersection */
-    hsize_t old_skip;           /* Value of udata->skip before main loop */
-    hsize_t old_nelem;          /* Value of udata->nelem before main loop */
-    hbool_t check_intersect;    /* Whether to check for intersecting elements */
-    unsigned u;                 /* Local index variable */
-    herr_t ret_value = SUCCEED; /* Return value */
+    const H5S_hyper_span_t *ss_span;             /* Current span in source space */
+    const H5S_hyper_span_t *sis_span;            /* Current span in source intersect space */
+    hsize_t                 ss_low;              /* Current low bounds of source span */
+    hsize_t                 sis_low;             /* Current low bounds of source intersect span */
+    hsize_t                 high;                /* High bounds of current intersection */
+    hsize_t                 low;                 /* Low bounds of current intersection */
+    hsize_t                 old_skip;            /* Value of udata->skip before main loop */
+    hsize_t                 old_nelem;           /* Value of udata->nelem before main loop */
+    hbool_t                 check_intersect;     /* Whether to check for intersecting elements */
+    unsigned                u;                   /* Local index variable */
+    herr_t                  ret_value = SUCCEED; /* Return value */
 
     FUNC_ENTER_STATIC
 
     /* Check for non-overlapping bounds */
     check_intersect = TRUE;
-    for(u = 0; u < (udata->ss_rank - depth); u++)
-        if(!H5S_RANGE_OVERLAP(ss_span_info->low_bounds[u],
-                ss_span_info->high_bounds[u],
-                sis_span_info->low_bounds[u],
-                sis_span_info->high_bounds[u])) {
+    for (u = 0; u < (udata->ss_rank - depth); u++)
+        if (!H5S_RANGE_OVERLAP(ss_span_info->low_bounds[u], ss_span_info->high_bounds[u],
+                               sis_span_info->low_bounds[u], sis_span_info->high_bounds[u])) {
             check_intersect = FALSE;
             break;
         } /* end if */
 
     /* Only enter main loop if there's something to do */
-    if(check_intersect) {
+    if (check_intersect) {
         /* Set ps_clean_bitmap */
         udata->ps_clean_bitmap |= (((uint32_t)1) << depth);
 
         /* Save old skip and nelem */
-        old_skip = udata->skip;
+        old_skip  = udata->skip;
         old_nelem = udata->nelem;
 
         /* Intersect spaces once per count */
-        for(u = 0; u < count; u++) {
-            ss_span = ss_span_info->head;
+        for (u = 0; u < count; u++) {
+            ss_span  = ss_span_info->head;
             sis_span = sis_span_info->head;
             HDassert(ss_span && sis_span);
-            ss_low = ss_span->low;
+            ss_low  = ss_span->low;
             sis_low = sis_span->low;
 
             /* Main loop */
             do {
                 /* Check if spans overlap */
-                if(H5S_RANGE_OVERLAP(ss_low, ss_span->high,
-                        sis_low, sis_span->high)) {
+                if (H5S_RANGE_OVERLAP(ss_low, ss_span->high, sis_low, sis_span->high)) {
                     high = MIN(ss_span->high, sis_span->high);
-                    if(ss_span->down) {
+                    if (ss_span->down) {
                         /* Add skipped elements if there's a pre-gap */
-                        if(ss_low < sis_low) {
+                        if (ss_low < sis_low) {
                             low = sis_low;
-                            H5S_HYPER_PROJ_INT_ADD_SKIP(udata, H5S__hyper_spans_nelem_helper(ss_span->down, 0, udata->op_gen) * (sis_low - ss_low), FAIL);
+                            H5S_HYPER_PROJ_INT_ADD_SKIP(
+                                udata,
+                                H5S__hyper_spans_nelem_helper(ss_span->down, 0, udata->op_gen) *
+                                    (sis_low - ss_low),
+                                FAIL);
                         } /* end if */
                         else
                             low = ss_low;
 
                         /* Recurse into next dimension down */
-                        if(H5S__hyper_proj_int_iterate(ss_span->down, sis_span->down, high - low + 1, depth + 1, udata) < 0)
-                            HGOTO_ERROR(H5E_DATASPACE, H5E_CANTCOMPARE, FAIL, "can't iterate over source selections")
+                        if (H5S__hyper_proj_int_iterate(ss_span->down, sis_span->down, high - low + 1,
+                                                        depth + 1, udata) < 0)
+                            HGOTO_ERROR(H5E_DATASPACE, H5E_CANTCOMPARE, FAIL,
+                                        "can't iterate over source selections")
                     } /* end if */
                     else {
                         HDassert(depth == udata->ss_rank - 1);
 
                         /* Add skipped elements if there's a pre-gap */
-                        if(ss_low < sis_low) {
+                        if (ss_low < sis_low) {
                             low = sis_low;
                             H5S_HYPER_PROJ_INT_ADD_SKIP(udata, sis_low - ss_low, FAIL);
                         } /* end if */
@@ -11313,87 +11408,99 @@ H5S__hyper_proj_int_iterate(const H5S_hyper_span_info_t *ss_span_info,
                     } /* end else */
 
                     /* Advance spans */
-                    if(ss_span->high == sis_span->high) {
+                    if (ss_span->high == sis_span->high) {
                         /* Advance both spans */
                         ss_span = ss_span->next;
-                        if(ss_span)
+                        if (ss_span)
                             ss_low = ss_span->low;
                         sis_span = sis_span->next;
-                        if(sis_span)
+                        if (sis_span)
                             sis_low = sis_span->low;
                     } /* end if */
-                    else if(ss_span->high == high) {
+                    else if (ss_span->high == high) {
                         /* Advance source span */
                         HDassert(ss_span->high < sis_span->high);
                         sis_low = high + 1;
                         ss_span = ss_span->next;
-                        if(ss_span)
+                        if (ss_span)
                             ss_low = ss_span->low;
                     } /* end if */
                     else {
                         /* Advance source intersect span */
                         HDassert(ss_span->high > sis_span->high);
-                        ss_low = high + 1;
+                        ss_low   = high + 1;
                         sis_span = sis_span->next;
-                        if(sis_span)
+                        if (sis_span)
                             sis_low = sis_span->low;
                     } /* end else */
-                } /* end if */
+                }     /* end if */
                 else {
                     /* Advance spans */
-                    if(ss_span->high < sis_low) {
+                    if (ss_span->high < sis_low) {
                         /* Add skipped elements */
-                        if(ss_span->down)
-                            H5S_HYPER_PROJ_INT_ADD_SKIP(udata, H5S__hyper_spans_nelem_helper(ss_span->down, 0, udata->op_gen) * (ss_span->high - ss_low + 1), FAIL);
+                        if (ss_span->down)
+                            H5S_HYPER_PROJ_INT_ADD_SKIP(
+                                udata,
+                                H5S__hyper_spans_nelem_helper(ss_span->down, 0, udata->op_gen) *
+                                    (ss_span->high - ss_low + 1),
+                                FAIL);
                         else
                             H5S_HYPER_PROJ_INT_ADD_SKIP(udata, ss_span->high - ss_low + 1, FAIL);
 
                         /* Advance source span */
                         ss_span = ss_span->next;
-                        if(ss_span)
+                        if (ss_span)
                             ss_low = ss_span->low;
                     } /* end if */
                     else {
                         /* Advance source intersect span */
                         HDassert(ss_low > sis_span->high);
                         sis_span = sis_span->next;
-                        if(sis_span)
+                        if (sis_span)
                             sis_low = sis_span->low;
                     } /* end else */
-                } /* end else */
-            } while(ss_span && sis_span);
+                }     /* end else */
+            } while (ss_span && sis_span);
 
-            if(ss_span && !((depth == 0) && (u == count - 1))) {
+            if (ss_span && !((depth == 0) && (u == count - 1))) {
                 /* Count remaining elements in ss_span_info */
-                if(ss_span->down) {
-                    H5S_HYPER_PROJ_INT_ADD_SKIP(udata, H5S__hyper_spans_nelem_helper(ss_span->down, 0, udata->op_gen) * (ss_span->high - ss_low + 1), FAIL);
+                if (ss_span->down) {
+                    H5S_HYPER_PROJ_INT_ADD_SKIP(
+                        udata,
+                        H5S__hyper_spans_nelem_helper(ss_span->down, 0, udata->op_gen) *
+                            (ss_span->high - ss_low + 1),
+                        FAIL);
                     ss_span = ss_span->next;
-                    while(ss_span) {
-                        H5S_HYPER_PROJ_INT_ADD_SKIP(udata, H5S__hyper_spans_nelem_helper(ss_span->down, 0, udata->op_gen) * (ss_span->high - ss_span->low + 1), FAIL);
+                    while (ss_span) {
+                        H5S_HYPER_PROJ_INT_ADD_SKIP(
+                            udata,
+                            H5S__hyper_spans_nelem_helper(ss_span->down, 0, udata->op_gen) *
+                                (ss_span->high - ss_span->low + 1),
+                            FAIL);
                         ss_span = ss_span->next;
                     } /* end while */
-                } /* end if */
+                }     /* end if */
                 else {
                     H5S_HYPER_PROJ_INT_ADD_SKIP(udata, ss_span->high - ss_low + 1, FAIL);
                     ss_span = ss_span->next;
-                    while(ss_span) {
+                    while (ss_span) {
                         H5S_HYPER_PROJ_INT_ADD_SKIP(udata, ss_span->high - ss_span->low + 1, FAIL);
                         ss_span = ss_span->next;
                     } /* end while */
-                } /* end else */
-            } /* end if */
+                }     /* end else */
+            }         /* end if */
 
             /* Check if the projected space was not changed since we started the
              * first iteration of the loop, if so we do not need to continue
              * looping and can just copy the result */
-            if(udata->ps_clean_bitmap & (((uint32_t)1) << depth)) {
+            if (udata->ps_clean_bitmap & (((uint32_t)1) << depth)) {
                 HDassert(u == 0);
-                if(udata->skip == old_skip) {
+                if (udata->skip == old_skip) {
                     /* First case: algorithm added only elements */
                     HDassert(udata->nelem >= old_nelem);
                     udata->nelem += (count - 1) * (udata->nelem - old_nelem);
                 } /* end if */
-                else if(udata->nelem == 0) {
+                else if (udata->nelem == 0) {
                     /* Second case: algorithm added only skip.  In this case,
                      * nelem must be 0 since otherwise adding skip would have
                      * triggered a change in the projected space */
@@ -11412,48 +11519,49 @@ H5S__hyper_proj_int_iterate(const H5S_hyper_span_info_t *ss_span_info,
                     HDassert(udata->skip > old_skip);
                     HDassert(old_nelem == 0);
 
-                    skip_add = udata->skip - old_skip;
+                    skip_add  = udata->skip - old_skip;
                     nelem_add = udata->nelem - old_nelem;
-                    for(u = 1; u < count; u++) {
+                    for (u = 1; u < count; u++) {
                         H5S_HYPER_PROJ_INT_ADD_SKIP(udata, skip_add, FAIL);
                         udata->nelem += nelem_add;
                     } /* end for */
-                } /* end else */
+                }     /* end else */
 
                 /* End loop since we already took care of it */
                 break;
             } /* end if */
-        } /* end for */
-    } /* end if */
-    else if(depth > 0)
+        }     /* end for */
+    }         /* end if */
+    else if (depth > 0)
         /* Just count skipped elements */
-        H5S_HYPER_PROJ_INT_ADD_SKIP(udata, H5S__hyper_spans_nelem_helper((H5S_hyper_span_info_t *)ss_span_info, 0, udata->op_gen) * count, FAIL); /* Casting away const OK -NAF */
+        H5S_HYPER_PROJ_INT_ADD_SKIP(
+            udata,
+            H5S__hyper_spans_nelem_helper((H5S_hyper_span_info_t *)ss_span_info, 0, udata->op_gen) * count,
+            FAIL); /* Casting away const OK -NAF */
 
     /* Clean up if we are done */
-    if(depth == 0) {
+    if (depth == 0) {
         /* Add remaining elements */
-        if(udata->nelem > 0)
-            if(H5S__hyper_proj_int_build_proj(udata) < 0)
+        if (udata->nelem > 0)
+            if (H5S__hyper_proj_int_build_proj(udata) < 0)
                 HGOTO_ERROR(H5E_DATASPACE, H5E_CANTAPPEND, FAIL, "can't add elements to projected selection")
 
         /* Append remaining span trees */
-        for(u = udata->ds_rank - 1; u > 0; u--)
-            if(udata->ps_span_info[u]) {
-                if(H5S__hyper_append_span(&udata->ps_span_info[u - 1],
-                        udata->ds_rank - u + 1, udata->ds_low[u - 1],
-                        udata->ds_low[u - 1],
-                        udata->ps_span_info[u]) < 0)
+        for (u = udata->ds_rank - 1; u > 0; u--)
+            if (udata->ps_span_info[u]) {
+                if (H5S__hyper_append_span(&udata->ps_span_info[u - 1], udata->ds_rank - u + 1,
+                                           udata->ds_low[u - 1], udata->ds_low[u - 1],
+                                           udata->ps_span_info[u]) < 0)
                     HGOTO_ERROR(H5E_DATASPACE, H5E_CANTAPPEND, FAIL, "can't allocate hyperslab span")
                 H5S__hyper_free_span_info(udata->ps_span_info[u]);
                 udata->ps_span_info[u] = NULL;
             } /* end if */
-    } /* end if */
+    }         /* end if */
 
 done:
     FUNC_LEAVE_NOAPI(ret_value)
 } /* end H5S__hyper_proj_int_iterate() */
 
-
 /*--------------------------------------------------------------------------
  NAME
     H5S__hyper_project_intersection
@@ -11463,38 +11571,29 @@ done:
     within the selection of dst_space
  USAGE
     herr_t H5S__hyper_project_intersection(src_space,dst_space,src_intersect_space,proj_space,share_selection)
-        H5S_t *src_space;       IN: Selection that is mapped to dst_space, and intersected with src_intersect_space
-        H5S_t *dst_space;       IN: Selection that is mapped to src_space, and which contains the result
-        H5S_t *src_intersect_space; IN: Selection whose intersection with src_space is projected to dst_space to obtain the result
-        H5S_t *proj_space;      OUT: Will contain the result (intersection of src_intersect_space and src_space projected from src_space to dst_space) after the operation
-        hbool_t share_selection; IN: Whether we are allowed to share structures inside dst_space with proj_space
- RETURNS
-    Non-negative on success/Negative on failure.
- DESCRIPTION
-    Projects the intersection of of the selections of src_space and
-    src_intersect_space within the selection of src_space as a selection
-    within the selection of dst_space.  The result is placed in the selection
-    of proj_space.  Note src_space, dst_space, and src_intersect_space do not
-    need to use hyperslab selections, but they cannot use point selections.
-    The result is always a hyperslab or none selection.  Note also that
-    proj_space can share some span trees with dst_space, so proj_space
-    must not be subsequently modified if dst_space must be preserved.
- GLOBAL VARIABLES
- COMMENTS, BUGS, ASSUMPTIONS
- EXAMPLES
- REVISION LOG
+        H5S_t *src_space;       IN: Selection that is mapped to dst_space, and intersected with
+src_intersect_space H5S_t *dst_space;       IN: Selection that is mapped to src_space, and which contains the
+result H5S_t *src_intersect_space; IN: Selection whose intersection with src_space is projected to dst_space
+to obtain the result H5S_t *proj_space;      OUT: Will contain the result (intersection of src_intersect_space
+and src_space projected from src_space to dst_space) after the operation hbool_t share_selection; IN: Whether
+we are allowed to share structures inside dst_space with proj_space RETURNS Non-negative on success/Negative
+on failure. DESCRIPTION Projects the intersection of of the selections of src_space and src_intersect_space
+within the selection of src_space as a selection within the selection of dst_space.  The result is placed in
+the selection of proj_space.  Note src_space, dst_space, and src_intersect_space do not need to use hyperslab
+selections, but they cannot use point selections. The result is always a hyperslab or none selection.  Note
+also that proj_space can share some span trees with dst_space, so proj_space must not be subsequently modified
+if dst_space must be preserved. GLOBAL VARIABLES COMMENTS, BUGS, ASSUMPTIONS EXAMPLES REVISION LOG
 --------------------------------------------------------------------------*/
 herr_t
 H5S__hyper_project_intersection(const H5S_t *src_space, const H5S_t *dst_space,
-    const H5S_t *src_intersect_space, H5S_t *proj_space,
-    hbool_t share_selection)
+                                const H5S_t *src_intersect_space, H5S_t *proj_space, hbool_t share_selection)
 {
-    H5S_hyper_project_intersect_ud_t  udata; /* User data for subroutines */
-    const H5S_hyper_span_info_t *ss_span_info;
-    const H5S_hyper_span_info_t *ds_span_info;
-    H5S_hyper_span_info_t *ss_span_info_buf = NULL;
-    H5S_hyper_span_info_t *ds_span_info_buf = NULL;
-    herr_t              ret_value = SUCCEED; /* Return value */
+    H5S_hyper_project_intersect_ud_t udata; /* User data for subroutines */
+    const H5S_hyper_span_info_t *    ss_span_info;
+    const H5S_hyper_span_info_t *    ds_span_info;
+    H5S_hyper_span_info_t *          ss_span_info_buf = NULL;
+    H5S_hyper_span_info_t *          ds_span_info_buf = NULL;
+    herr_t                           ret_value        = SUCCEED; /* Return value */
 
     FUNC_ENTER_PACKAGE
 
@@ -11513,11 +11612,12 @@ H5S__hyper_project_intersection(const H5S_t *src_space, const H5S_t *dst_space,
     HDassert(H5S_GET_SELECT_TYPE(src_intersect_space) == H5S_SEL_HYPERSLABS);
 
     /* Set up ss_span_info */
-    if(H5S_GET_SELECT_TYPE(src_space) == H5S_SEL_HYPERSLABS) {
+    if (H5S_GET_SELECT_TYPE(src_space) == H5S_SEL_HYPERSLABS) {
         /* Make certain the selection has a span tree */
-        if(NULL == src_space->select.sel_info.hslab->span_lst)
-            if(H5S__hyper_generate_spans((H5S_t *)src_space) < 0)  /* Casting away const OK -NAF */
-                HGOTO_ERROR(H5E_DATASPACE, H5E_UNINITIALIZED, FAIL, "can't construct span tree for source hyperslab selection")
+        if (NULL == src_space->select.sel_info.hslab->span_lst)
+            if (H5S__hyper_generate_spans((H5S_t *)src_space) < 0) /* Casting away const OK -NAF */
+                HGOTO_ERROR(H5E_DATASPACE, H5E_UNINITIALIZED, FAIL,
+                            "can't construct span tree for source hyperslab selection")
 
         /* Simply point to existing span tree */
         ss_span_info = src_space->select.sel_info.hslab->span_lst;
@@ -11526,18 +11626,20 @@ H5S__hyper_project_intersection(const H5S_t *src_space, const H5S_t *dst_space,
         /* Create temporary span tree from all selection */
         HDassert(H5S_GET_SELECT_TYPE(src_space) == H5S_SEL_ALL);
 
-        if(NULL == (ss_span_info_buf = H5S__hyper_make_spans(H5S_GET_EXTENT_NDIMS(src_space),
-                H5S_hyper_zeros_g, H5S_hyper_zeros_g, H5S_hyper_ones_g, src_space->extent.size)))
+        if (NULL == (ss_span_info_buf =
+                         H5S__hyper_make_spans(H5S_GET_EXTENT_NDIMS(src_space), H5S_hyper_zeros_g,
+                                               H5S_hyper_zeros_g, H5S_hyper_ones_g, src_space->extent.size)))
             HGOTO_ERROR(H5E_DATASPACE, H5E_CANTINIT, FAIL, "can't create span tree for ALL source space")
         ss_span_info = ss_span_info_buf;
     } /* end else */
 
     /* Set up ds_span_info */
-    if(H5S_GET_SELECT_TYPE(dst_space) == H5S_SEL_HYPERSLABS) {
+    if (H5S_GET_SELECT_TYPE(dst_space) == H5S_SEL_HYPERSLABS) {
         /* Make certain the selection has a span tree */
-        if(NULL == dst_space->select.sel_info.hslab->span_lst)
-            if(H5S__hyper_generate_spans((H5S_t *)dst_space) < 0)  /* Casting away const OK -NAF */
-                HGOTO_ERROR(H5E_DATASPACE, H5E_UNINITIALIZED, FAIL, "can't construct span tree for dsetination hyperslab selection")
+        if (NULL == dst_space->select.sel_info.hslab->span_lst)
+            if (H5S__hyper_generate_spans((H5S_t *)dst_space) < 0) /* Casting away const OK -NAF */
+                HGOTO_ERROR(H5E_DATASPACE, H5E_UNINITIALIZED, FAIL,
+                            "can't construct span tree for dsetination hyperslab selection")
 
         /* Simply point to existing span tree */
         ds_span_info = dst_space->select.sel_info.hslab->span_lst;
@@ -11546,40 +11648,43 @@ H5S__hyper_project_intersection(const H5S_t *src_space, const H5S_t *dst_space,
         /* Create temporary span tree from all selection */
         HDassert(H5S_GET_SELECT_TYPE(dst_space) == H5S_SEL_ALL);
 
-        if(NULL == (ds_span_info_buf = H5S__hyper_make_spans(H5S_GET_EXTENT_NDIMS(dst_space),
-                H5S_hyper_zeros_g, H5S_hyper_zeros_g, H5S_hyper_ones_g, dst_space->extent.size)))
+        if (NULL == (ds_span_info_buf =
+                         H5S__hyper_make_spans(H5S_GET_EXTENT_NDIMS(dst_space), H5S_hyper_zeros_g,
+                                               H5S_hyper_zeros_g, H5S_hyper_ones_g, dst_space->extent.size)))
             HGOTO_ERROR(H5E_DATASPACE, H5E_CANTINIT, FAIL, "can't create span tree for ALL destination space")
         ds_span_info = ds_span_info_buf;
     } /* end else */
 
     /* Make certain the source intersect selection has a span tree */
-    if(NULL == src_intersect_space->select.sel_info.hslab->span_lst)
-        if(H5S__hyper_generate_spans((H5S_t *)src_intersect_space) < 0)  /* Casting away const OK -NAF */
-            HGOTO_ERROR(H5E_DATASPACE, H5E_UNINITIALIZED, FAIL, "can't construct span tree for source intersect hyperslab selection")
+    if (NULL == src_intersect_space->select.sel_info.hslab->span_lst)
+        if (H5S__hyper_generate_spans((H5S_t *)src_intersect_space) < 0) /* Casting away const OK -NAF */
+            HGOTO_ERROR(H5E_DATASPACE, H5E_UNINITIALIZED, FAIL,
+                        "can't construct span tree for source intersect hyperslab selection")
 
     /* Initialize udata */
     /* We will use op_info[0] for nelem and op_info[1] for copied spans */
     HDmemset(&udata, 0, sizeof(udata));
-    udata.ds_span[0] = ds_span_info->head;
-    udata.ds_low[0] = udata.ds_span[0]->low;
-    udata.ss_rank = H5S_GET_EXTENT_NDIMS(src_space);
-    udata.ds_rank = H5S_GET_EXTENT_NDIMS(dst_space);
-    udata.op_gen = H5S__hyper_get_op_gen();
+    udata.ds_span[0]      = ds_span_info->head;
+    udata.ds_low[0]       = udata.ds_span[0]->low;
+    udata.ss_rank         = H5S_GET_EXTENT_NDIMS(src_space);
+    udata.ds_rank         = H5S_GET_EXTENT_NDIMS(dst_space);
+    udata.op_gen          = H5S__hyper_get_op_gen();
     udata.share_selection = share_selection;
 
     /* Iterate over selections and build projected span tree */
-    if(H5S__hyper_proj_int_iterate(ss_span_info, src_intersect_space->select.sel_info.hslab->span_lst, 1, 0, &udata) < 0)
+    if (H5S__hyper_proj_int_iterate(ss_span_info, src_intersect_space->select.sel_info.hslab->span_lst, 1, 0,
+                                    &udata) < 0)
         HGOTO_ERROR(H5E_DATASPACE, H5E_CANTCOMPARE, FAIL, "selection iteration failed")
 
     /* Remove current selection from proj_space */
-    if(H5S_SELECT_RELEASE(proj_space) < 0)
+    if (H5S_SELECT_RELEASE(proj_space) < 0)
         HGOTO_ERROR(H5E_DATASPACE, H5E_CANTDELETE, FAIL, "can't release selection")
 
     /* Check for elements in projected space */
-    if(udata.ps_span_info[0]) {
+    if (udata.ps_span_info[0]) {
         /* Allocate space for the hyperslab selection information (note this sets
          * diminfo_valid to FALSE, diminfo arrays to 0, and span list to NULL) */
-        if(NULL == (proj_space->select.sel_info.hslab = H5FL_CALLOC(H5S_hyper_sel_t)))
+        if (NULL == (proj_space->select.sel_info.hslab = H5FL_CALLOC(H5S_hyper_sel_t)))
             HGOTO_ERROR(H5E_DATASPACE, H5E_CANTALLOC, FAIL, "can't allocate hyperslab info")
 
         /* Set selection type */
@@ -11590,7 +11695,7 @@ H5S__hyper_project_intersection(const H5S_t *src_space, const H5S_t *dst_space,
 
         /* Set span tree */
         proj_space->select.sel_info.hslab->span_lst = udata.ps_span_info[0];
-        udata.ps_span_info[0] = NULL;
+        udata.ps_span_info[0]                       = NULL;
 
         /* Set the number of elements in current selection */
         proj_space->select.num_elem = H5S__hyper_spans_nelem(proj_space->select.sel_info.hslab->span_lst);
@@ -11602,48 +11707,47 @@ H5S__hyper_project_intersection(const H5S_t *src_space, const H5S_t *dst_space,
     } /* end if */
     else
         /* If we did not add anything to proj_space, select none instead */
-        if(H5S_select_none(proj_space) < 0)
-            HGOTO_ERROR(H5E_DATASPACE, H5E_CANTDELETE, FAIL, "can't convert selection")
+        if (H5S_select_none(proj_space) < 0)
+        HGOTO_ERROR(H5E_DATASPACE, H5E_CANTDELETE, FAIL, "can't convert selection")
 
 done:
     /* Free ss_span_info_buf */
-    if(ss_span_info_buf) {
+    if (ss_span_info_buf) {
         H5S__hyper_free_span_info(ss_span_info_buf);
         ss_span_info_buf = NULL;
     } /* end if */
 
     /* Free ds_span_info_buf */
-    if(ds_span_info_buf) {
+    if (ds_span_info_buf) {
         H5S__hyper_free_span_info(ds_span_info_buf);
         ds_span_info_buf = NULL;
     } /* end if */
 
     /* Cleanup on error */
-    if(ret_value < 0) {
+    if (ret_value < 0) {
         unsigned u;
 
         /* Free span trees */
-        for(u = 0; u < udata.ds_rank; u++)
-            if(udata.ps_span_info[u]) {
+        for (u = 0; u < udata.ds_rank; u++)
+            if (udata.ps_span_info[u]) {
                 H5S__hyper_free_span_info(udata.ps_span_info[u]);
                 udata.ps_span_info[u] = NULL;
             } /* end if */
-    } /* end if */
+    }         /* end if */
 
 #ifndef NDEBUG
     /* Verify there are no more span trees */
     {
         unsigned u;
 
-        for(u = 0; u < H5S_MAX_RANK; u++)
+        for (u = 0; u < H5S_MAX_RANK; u++)
             HDassert(!udata.ps_span_info[u]);
-    } /* end block */
+    }  /* end block */
 #endif /* NDEBUG */
 
     FUNC_LEAVE_NOAPI(ret_value)
 } /* end H5S__hyper_project_intersection() */
 
-
 /*--------------------------------------------------------------------------
  NAME
     H5S__hyper_get_clip_diminfo
@@ -11669,20 +11773,19 @@ done:
  REVISION LOG
 --------------------------------------------------------------------------*/
 static void
-H5S__hyper_get_clip_diminfo(hsize_t start, hsize_t stride, hsize_t *count,
-    hsize_t *block, hsize_t clip_size)
+H5S__hyper_get_clip_diminfo(hsize_t start, hsize_t stride, hsize_t *count, hsize_t *block, hsize_t clip_size)
 {
     FUNC_ENTER_STATIC_NOERR
 
     /* Check for selection outside clip size */
-    if(start >= clip_size) {
-        if(*block == H5S_UNLIMITED)
+    if (start >= clip_size) {
+        if (*block == H5S_UNLIMITED)
             *block = 0;
         else
             *count = 0;
     } /* end if */
     /* Check for single block in unlimited dimension */
-    else if((*block == H5S_UNLIMITED) || (*block == stride)) {
+    else if ((*block == H5S_UNLIMITED) || (*block == stride)) {
         /* Calculate actual block size for this clip size */
         *block = clip_size - start;
         *count = (hsize_t)1;
@@ -11698,7 +11801,6 @@ H5S__hyper_get_clip_diminfo(hsize_t start, hsize_t stride, hsize_t *count,
     FUNC_LEAVE_NOAPI_VOID
 } /* end H5S__hyper_get_clip_diminfo() */
 
-
 /*--------------------------------------------------------------------------
  NAME
     H5S_hyper_clip_unlim
@@ -11723,11 +11825,11 @@ H5S__hyper_get_clip_diminfo(hsize_t start, hsize_t stride, hsize_t *count,
 herr_t
 H5S_hyper_clip_unlim(H5S_t *space, hsize_t clip_size)
 {
-    H5S_hyper_sel_t *hslab = NULL;      /* Convenience pointer to hyperslab info */
-    hsize_t orig_count;                 /* Original count in unlimited dimension */
-    int orig_unlim_dim;                 /* Original unliminted dimension */
-    H5S_hyper_dim_t *diminfo = NULL;    /* Convenience pointer to diminfo.opt in unlimited dimension */
-    herr_t ret_value = SUCCEED;         /* Return value */
+    H5S_hyper_sel_t *hslab = NULL;        /* Convenience pointer to hyperslab info */
+    hsize_t          orig_count;          /* Original count in unlimited dimension */
+    int              orig_unlim_dim;      /* Original unliminted dimension */
+    H5S_hyper_dim_t *diminfo   = NULL;    /* Convenience pointer to diminfo.opt in unlimited dimension */
+    herr_t           ret_value = SUCCEED; /* Return value */
 
     FUNC_ENTER_NOAPI(FAIL)
 
@@ -11754,17 +11856,17 @@ H5S_hyper_clip_unlim(H5S_t *space, hsize_t clip_size)
     space->select.sel_info.hslab->unlim_dim = -1;
 
     /* Check for nothing returned */
-    if((diminfo->block == 0) || (diminfo->count == 0)) {
+    if ((diminfo->block == 0) || (diminfo->count == 0)) {
         /* Convert to "none" selection */
-        if(H5S_select_none(space) < 0)
+        if (H5S_select_none(space) < 0)
             HGOTO_ERROR(H5E_DATASPACE, H5E_CANTDELETE, FAIL, "can't convert selection")
 
         /* Reset the convenience pointers */
-        hslab = NULL;
+        hslab   = NULL;
         diminfo = NULL;
     } /* end if */
     /* Check for single block in unlimited dimension */
-    else if(orig_count == (hsize_t)1) {
+    else if (orig_count == (hsize_t)1) {
         /* Calculate number of elements */
         space->select.num_elem = diminfo->block * hslab->num_elem_non_unlim;
 
@@ -11778,10 +11880,10 @@ H5S_hyper_clip_unlim(H5S_t *space, hsize_t clip_size)
         /* Check if last block is partial.  If superset is set, just keep the
          * last block complete to speed computation. */
         HDassert(clip_size > diminfo->start);
-        if(((diminfo->stride * (diminfo->count - (hsize_t)1)) + diminfo->block)
-                > (clip_size - diminfo->start)) {
-            hsize_t start[H5S_MAX_RANK];
-            hsize_t block[H5S_MAX_RANK];
+        if (((diminfo->stride * (diminfo->count - (hsize_t)1)) + diminfo->block) >
+            (clip_size - diminfo->start)) {
+            hsize_t  start[H5S_MAX_RANK];
+            hsize_t  block[H5S_MAX_RANK];
             unsigned u;
 
             /* Last block is partial, need to construct compound selection */
@@ -11790,22 +11892,23 @@ H5S_hyper_clip_unlim(H5S_t *space, hsize_t clip_size)
 
             /* Set block to clip_size in unlimited dimension, H5S_MAX_SIZE in
              * others so only unlimited dimension is clipped */
-            for(u = 0; u < space->extent.rank; u++)
-                if((int)u == orig_unlim_dim)
+            for (u = 0; u < space->extent.rank; u++)
+                if ((int)u == orig_unlim_dim)
                     block[u] = clip_size;
                 else
                     block[u] = H5S_MAX_SIZE;
 
             /* Generate span tree in selection */
-            if(!hslab->span_lst)
-                if(H5S__hyper_generate_spans(space) < 0)
+            if (!hslab->span_lst)
+                if (H5S__hyper_generate_spans(space) < 0)
                     HGOTO_ERROR(H5E_DATASPACE, H5E_CANTINIT, FAIL, "unable to generate span tree")
 
             /* Indicate that the regular dimensions are no longer valid */
             hslab->diminfo_valid = H5S_DIMINFO_VALID_NO;
 
             /* "And" selection with calculated block to perform clip operation */
-            if(H5S__generate_hyperslab(space, H5S_SELECT_AND, start, H5S_hyper_ones_g, H5S_hyper_ones_g, block) < 0)
+            if (H5S__generate_hyperslab(space, H5S_SELECT_AND, start, H5S_hyper_ones_g, H5S_hyper_ones_g,
+                                        block) < 0)
                 HGOTO_ERROR(H5E_DATASPACE, H5E_CANTINSERT, FAIL, "can't generate hyperslabs")
         } /* end if */
         else
@@ -11814,17 +11917,16 @@ H5S_hyper_clip_unlim(H5S_t *space, hsize_t clip_size)
     } /* end else */
 
     /* Update the upper bound, if the diminfo is valid */
-    if(hslab && (H5S_DIMINFO_VALID_YES == hslab->diminfo_valid))
+    if (hslab && (H5S_DIMINFO_VALID_YES == hslab->diminfo_valid))
         hslab->diminfo.high_bounds[orig_unlim_dim] =
-                hslab->diminfo.opt[orig_unlim_dim].start +
-                hslab->diminfo.opt[orig_unlim_dim].stride * (hslab->diminfo.opt[orig_unlim_dim].count - 1) +
-                (hslab->diminfo.opt[orig_unlim_dim].block - 1);
+            hslab->diminfo.opt[orig_unlim_dim].start +
+            hslab->diminfo.opt[orig_unlim_dim].stride * (hslab->diminfo.opt[orig_unlim_dim].count - 1) +
+            (hslab->diminfo.opt[orig_unlim_dim].block - 1);
 
 done:
     FUNC_LEAVE_NOAPI(ret_value)
 } /* end H5S_hyper_clip_unlim() */
 
-
 /*--------------------------------------------------------------------------
  NAME
     H5S__hyper_get_clip_extent_real
@@ -11853,13 +11955,12 @@ done:
  REVISION LOG
 --------------------------------------------------------------------------*/
 static hsize_t
-H5S__hyper_get_clip_extent_real(const H5S_t *clip_space, hsize_t num_slices,
-    hbool_t incl_trail)
+H5S__hyper_get_clip_extent_real(const H5S_t *clip_space, hsize_t num_slices, hbool_t incl_trail)
 {
     const H5S_hyper_dim_t *diminfo; /* Convenience pointer to opt_unlim_diminfo in unlimited dimension */
-    hsize_t count;
-    hsize_t rem_slices;
-    hsize_t ret_value = 0;      /* Return value */
+    hsize_t                count;
+    hsize_t                rem_slices;
+    hsize_t                ret_value = 0; /* Return value */
 
     FUNC_ENTER_STATIC_NOERR
 
@@ -11870,10 +11971,9 @@ H5S__hyper_get_clip_extent_real(const H5S_t *clip_space, hsize_t num_slices,
 
     diminfo = &clip_space->select.sel_info.hslab->diminfo.opt[clip_space->select.sel_info.hslab->unlim_dim];
 
-    if(num_slices == 0)
+    if (num_slices == 0)
         ret_value = incl_trail ? diminfo->start : 0;
-    else if((diminfo->block == H5S_UNLIMITED)
-            || (diminfo->block == diminfo->stride))
+    else if ((diminfo->block == H5S_UNLIMITED) || (diminfo->block == diminfo->stride))
         /* Unlimited block, just set the extent large enough for the block size
          * to match num_slices */
         ret_value = diminfo->start + num_slices;
@@ -11888,25 +11988,23 @@ H5S__hyper_get_clip_extent_real(const H5S_t *clip_space, hsize_t num_slices,
         /* Calculate slices remaining */
         rem_slices = num_slices - (count * diminfo->block);
 
-        if(rem_slices > 0)
+        if (rem_slices > 0)
             /* Must end extent in middle of partial block (or beginning of empty
              * block if include_trailing_space and rem_slices == 0) */
             ret_value = diminfo->start + (count * diminfo->stride) + rem_slices;
         else {
-            if(incl_trail)
+            if (incl_trail)
                 /* End extent just before first missing block */
                 ret_value = diminfo->start + (count * diminfo->stride);
             else
                 /* End extent at end of last block */
-                ret_value = diminfo->start + ((count - (hsize_t)1)
-                        * diminfo->stride) + diminfo->block;
+                ret_value = diminfo->start + ((count - (hsize_t)1) * diminfo->stride) + diminfo->block;
         } /* end else */
-    } /* end else */
+    }     /* end else */
 
     FUNC_LEAVE_NOAPI(ret_value)
 } /* end H5S__hyper_get_clip_extent_real() */
 
-
 /*--------------------------------------------------------------------------
  NAME
     H5S_hyper_get_clip_extent
@@ -11916,30 +12014,20 @@ H5S__hyper_get_clip_extent_real(const H5S_t *clip_space, hsize_t num_slices,
  USAGE
     hsize_t H5S__hyper_get_clip_extent(clip_space,match_space,incl_trail)
         const H5S_t *clip_space, IN: Space that clip size will be calculated based on
-        const H5S_t *match_space, IN: Space containing the same number of elements as clip_space should after clipping
-        hbool_t incl_trail;     IN: Whether to include trailing unselected space
- RETURNS
-    Calculated clip extent (never fails)
- DESCRIPTION
-    Calculates and returns the extent that clip_space should be clipped to
-    (via H5S_hyper_clip_unlim) in order for it to contain the same number
-    of elements as match_space.  If the clipped selection would end
-    immediately before a section of unselected space (i.e. at the end of a
-    block), then if incl_trail is TRUE, the returned clip extent is
-    selected to include that trailing "blank" space, otherwise it is
-    selected to end at the end before the blank space.
- GLOBAL VARIABLES
- COMMENTS, BUGS, ASSUMPTIONS
-    Note this assumes the offset has been normalized.
- EXAMPLES
- REVISION LOG
+        const H5S_t *match_space, IN: Space containing the same number of elements as clip_space should after
+clipping hbool_t incl_trail;     IN: Whether to include trailing unselected space RETURNS Calculated clip
+extent (never fails) DESCRIPTION Calculates and returns the extent that clip_space should be clipped to (via
+H5S_hyper_clip_unlim) in order for it to contain the same number of elements as match_space.  If the clipped
+selection would end immediately before a section of unselected space (i.e. at the end of a block), then if
+incl_trail is TRUE, the returned clip extent is selected to include that trailing "blank" space, otherwise it
+is selected to end at the end before the blank space. GLOBAL VARIABLES COMMENTS, BUGS, ASSUMPTIONS Note this
+assumes the offset has been normalized. EXAMPLES REVISION LOG
 --------------------------------------------------------------------------*/
 hsize_t
-H5S_hyper_get_clip_extent(const H5S_t *clip_space, const H5S_t *match_space,
-    hbool_t incl_trail)
+H5S_hyper_get_clip_extent(const H5S_t *clip_space, const H5S_t *match_space, hbool_t incl_trail)
 {
-    hsize_t num_slices;         /* Number of slices in unlimited dimension */
-    hsize_t ret_value = 0;      /* Return value */
+    hsize_t num_slices;    /* Number of slices in unlimited dimension */
+    hsize_t ret_value = 0; /* Return value */
 
     FUNC_ENTER_NOAPI(0)
 
@@ -11949,17 +12037,15 @@ H5S_hyper_get_clip_extent(const H5S_t *clip_space, const H5S_t *match_space,
     HDassert(clip_space->select.sel_info.hslab->unlim_dim >= 0);
 
     /* Check for "none" match space */
-    if(match_space->select.type->type == H5S_SEL_NONE)
+    if (match_space->select.type->type == H5S_SEL_NONE)
         num_slices = (hsize_t)0;
     else {
         HDassert(match_space->select.type->type == H5S_SEL_HYPERSLABS);
         HDassert(match_space->select.sel_info.hslab);
 
         /* Calculate number of slices */
-        num_slices = match_space->select.num_elem
-                / clip_space->select.sel_info.hslab->num_elem_non_unlim;
-        HDassert((match_space->select.num_elem
-                % clip_space->select.sel_info.hslab->num_elem_non_unlim) == 0);
+        num_slices = match_space->select.num_elem / clip_space->select.sel_info.hslab->num_elem_non_unlim;
+        HDassert((match_space->select.num_elem % clip_space->select.sel_info.hslab->num_elem_non_unlim) == 0);
     } /* end else */
 
     /* Call "real" get_clip_extent function */
@@ -11969,7 +12055,6 @@ done:
     FUNC_LEAVE_NOAPI(ret_value)
 } /* end H5S_hyper_get_clip_extent() */
 
-
 /*--------------------------------------------------------------------------
  NAME
     H5S_hyper_get_clip_extent_match
@@ -11980,35 +12065,27 @@ done:
  USAGE
     hsize_t H5S__hyper_get_clip_extent_match(clip_space,match_space,match_clip_size,incl_trail)
         const H5S_t *clip_space, IN: Space that clip size will be calculated based on
-        const H5S_t *match_space, IN: Space that, after being clipped to match_clip_size, contains the same number of elements as clip_space should after clipping
-        hsize_t match_clip_size, IN: Extent match_space would be clipped to to match the number of elements in clip_space
-        hbool_t incl_trail;     IN: Whether to include trailing unselected space
- RETURNS
-    Calculated clip extent (never fails)
- DESCRIPTION
-    Calculates and returns the extent that clip_space should be clipped to
-    (via H5S_hyper_clip_unlim) in order for it to contain the same number
-    of elements as match_space would have after being clipped to
-    match_clip_size.  If the clipped selection would end immediately
-    before a section of unselected space (i.e. at the end of a block),
-    then if incl_trail is TRUE, the returned clip extent is selected to
-    include that trailing "blank" space, otherwise it is selected to end
-    at the end before the blank space.
- GLOBAL VARIABLES
- COMMENTS, BUGS, ASSUMPTIONS
-    Note this assumes the offset has been normalized.
- EXAMPLES
- REVISION LOG
+        const H5S_t *match_space, IN: Space that, after being clipped to match_clip_size, contains the same
+number of elements as clip_space should after clipping hsize_t match_clip_size, IN: Extent match_space would
+be clipped to to match the number of elements in clip_space hbool_t incl_trail;     IN: Whether to include
+trailing unselected space RETURNS Calculated clip extent (never fails) DESCRIPTION Calculates and returns the
+extent that clip_space should be clipped to (via H5S_hyper_clip_unlim) in order for it to contain the same
+number of elements as match_space would have after being clipped to match_clip_size.  If the clipped selection
+would end immediately before a section of unselected space (i.e. at the end of a block), then if incl_trail is
+TRUE, the returned clip extent is selected to include that trailing "blank" space, otherwise it is selected to
+end at the end before the blank space. GLOBAL VARIABLES COMMENTS, BUGS, ASSUMPTIONS Note this assumes the
+offset has been normalized. EXAMPLES REVISION LOG
 --------------------------------------------------------------------------*/
 hsize_t
-H5S_hyper_get_clip_extent_match(const H5S_t *clip_space,
-    const H5S_t *match_space, hsize_t match_clip_size, hbool_t incl_trail)
+H5S_hyper_get_clip_extent_match(const H5S_t *clip_space, const H5S_t *match_space, hsize_t match_clip_size,
+                                hbool_t incl_trail)
 {
-    const H5S_hyper_dim_t *match_diminfo; /* Convenience pointer to opt_unlim_diminfo in unlimited dimension in match_space */
-    hsize_t count;              /* Temporary count */
-    hsize_t block;              /* Temporary block */
-    hsize_t num_slices;         /* Number of slices in unlimited dimension */
-    hsize_t ret_value = 0;      /* Return value */
+    const H5S_hyper_dim_t
+        *match_diminfo; /* Convenience pointer to opt_unlim_diminfo in unlimited dimension in match_space */
+    hsize_t count;      /* Temporary count */
+    hsize_t block;      /* Temporary block */
+    hsize_t num_slices; /* Number of slices in unlimited dimension */
+    hsize_t ret_value = 0; /* Return value */
 
     FUNC_ENTER_NOAPI(0)
 
@@ -12019,10 +12096,11 @@ H5S_hyper_get_clip_extent_match(const H5S_t *clip_space,
     HDassert(match_space->select.sel_info.hslab);
     HDassert(clip_space->select.sel_info.hslab->unlim_dim >= 0);
     HDassert(match_space->select.sel_info.hslab->unlim_dim >= 0);
-    HDassert(clip_space->select.sel_info.hslab->num_elem_non_unlim
-            == match_space->select.sel_info.hslab->num_elem_non_unlim);
+    HDassert(clip_space->select.sel_info.hslab->num_elem_non_unlim ==
+             match_space->select.sel_info.hslab->num_elem_non_unlim);
 
-    match_diminfo = &match_space->select.sel_info.hslab->diminfo.opt[match_space->select.sel_info.hslab->unlim_dim];
+    match_diminfo =
+        &match_space->select.sel_info.hslab->diminfo.opt[match_space->select.sel_info.hslab->unlim_dim];
 
     /* Get initial count and block */
     count = match_diminfo->count;
@@ -12031,10 +12109,10 @@ H5S_hyper_get_clip_extent_match(const H5S_t *clip_space,
 
     /* Calculate number of slices */
     /* Check for nothing returned */
-    if((block == 0) || (count == 0))
+    if ((block == 0) || (count == 0))
         num_slices = (hsize_t)0;
     /* Check for single block in unlimited dimension */
-    else if(count == (hsize_t)1)
+    else if (count == (hsize_t)1)
         num_slices = block;
     else {
         /* Calculate initial num_slices */
@@ -12042,15 +12120,15 @@ H5S_hyper_get_clip_extent_match(const H5S_t *clip_space,
 
         /* Check for partial last block */
         HDassert(match_clip_size >= match_diminfo->start);
-        if(((match_diminfo->stride * (count - (hsize_t)1)) + block)
-                > (match_clip_size - match_diminfo->start)) {
+        if (((match_diminfo->stride * (count - (hsize_t)1)) + block) >
+            (match_clip_size - match_diminfo->start)) {
             /* Subtract slices missing from last block */
-            HDassert((((match_diminfo->stride * (count - (hsize_t)1)) + block)
-                    - (match_clip_size - match_diminfo->start)) < num_slices);
-            num_slices -= ((match_diminfo->stride * (count - (hsize_t)1))
-                    + block) - (match_clip_size - match_diminfo->start);
+            HDassert((((match_diminfo->stride * (count - (hsize_t)1)) + block) -
+                      (match_clip_size - match_diminfo->start)) < num_slices);
+            num_slices -= ((match_diminfo->stride * (count - (hsize_t)1)) + block) -
+                          (match_clip_size - match_diminfo->start);
         } /* end if */
-    } /* end else */
+    }     /* end else */
 
     /* Call "real" get_clip_extent function */
     ret_value = H5S__hyper_get_clip_extent_real(clip_space, num_slices, incl_trail);
@@ -12059,7 +12137,6 @@ done:
     FUNC_LEAVE_NOAPI(ret_value)
 } /* end H5S_hyper_get_clip_extent_match() */
 
-
 /*--------------------------------------------------------------------------
  NAME
     H5S_hyper_get_unlim_block
@@ -12085,14 +12162,14 @@ done:
 H5S_t *
 H5S_hyper_get_unlim_block(const H5S_t *space, hsize_t block_index)
 {
-    H5S_hyper_sel_t *hslab;     /* Convenience pointer to hyperslab info */
-    H5S_t *space_out = NULL;    /* Dataspace to return */
-    hsize_t start[H5S_MAX_RANK];/* Hyperslab selection info for unlim. selection */
-    hsize_t stride[H5S_MAX_RANK];
-    hsize_t count[H5S_MAX_RANK];
-    hsize_t block[H5S_MAX_RANK];
-    unsigned u;                 /* Local index variable */
-    H5S_t *ret_value = NULL;    /* Return value */
+    H5S_hyper_sel_t *hslab;               /* Convenience pointer to hyperslab info */
+    H5S_t *          space_out = NULL;    /* Dataspace to return */
+    hsize_t          start[H5S_MAX_RANK]; /* Hyperslab selection info for unlim. selection */
+    hsize_t          stride[H5S_MAX_RANK];
+    hsize_t          count[H5S_MAX_RANK];
+    hsize_t          block[H5S_MAX_RANK];
+    unsigned         u;                /* Local index variable */
+    H5S_t *          ret_value = NULL; /* Return value */
 
     FUNC_ENTER_NOAPI(NULL)
 
@@ -12106,10 +12183,9 @@ H5S_hyper_get_unlim_block(const H5S_t *space, hsize_t block_index)
     /* Set start to select block_indexth block in unlimited dimension and set
      * count to 1 in that dimension to only select that block.  Copy all other
      * diminfo parameters. */
-    for(u = 0; u < space->extent.rank; u++) {
-        if((int)u == hslab->unlim_dim){
-            start[u] = hslab->diminfo.opt[u].start + (block_index
-                    * hslab->diminfo.opt[u].stride);
+    for (u = 0; u < space->extent.rank; u++) {
+        if ((int)u == hslab->unlim_dim) {
+            start[u] = hslab->diminfo.opt[u].start + (block_index * hslab->diminfo.opt[u].stride);
             count[u] = (hsize_t)1;
         } /* end if */
         else {
@@ -12117,17 +12193,17 @@ H5S_hyper_get_unlim_block(const H5S_t *space, hsize_t block_index)
             count[u] = hslab->diminfo.opt[u].count;
         } /* end else */
         stride[u] = hslab->diminfo.opt[u].stride;
-        block[u] = hslab->diminfo.opt[u].block;
+        block[u]  = hslab->diminfo.opt[u].block;
     } /* end for */
 
     /* Create output space, copy extent */
-    if(NULL == (space_out = H5S_create(H5S_SIMPLE)))
+    if (NULL == (space_out = H5S_create(H5S_SIMPLE)))
         HGOTO_ERROR(H5E_DATASPACE, H5E_CANTCREATE, NULL, "unable to create output dataspace")
-    if(H5S__extent_copy_real(&space_out->extent, &space->extent, TRUE) < 0)
+    if (H5S__extent_copy_real(&space_out->extent, &space->extent, TRUE) < 0)
         HGOTO_ERROR(H5E_DATASPACE, H5E_CANTCOPY, NULL, "unable to copy destination space extent")
 
     /* Select block as defined by start/stride/count/block computed above */
-    if(H5S_select_hyperslab(space_out, H5S_SELECT_SET, start, stride, count, block) < 0)
+    if (H5S_select_hyperslab(space_out, H5S_SELECT_SET, start, stride, count, block) < 0)
         HGOTO_ERROR(H5E_DATASPACE, H5E_CANTINIT, NULL, "can't select hyperslab")
 
     /* Set return value */
@@ -12135,14 +12211,13 @@ H5S_hyper_get_unlim_block(const H5S_t *space, hsize_t block_index)
 
 done:
     /* Free space on error */
-    if(!ret_value)
-        if(space_out && H5S_close(space_out) < 0)
+    if (!ret_value)
+        if (space_out && H5S_close(space_out) < 0)
             HDONE_ERROR(H5E_DATASPACE, H5E_CANTRELEASE, NULL, "unable to release dataspace")
 
     FUNC_LEAVE_NOAPI(ret_value)
 } /* end H5S_hyper_get_unlim_block */
 
-
 /*--------------------------------------------------------------------------
  NAME
     H5S_hyper_get_first_inc_block
@@ -12168,12 +12243,11 @@ done:
  REVISION LOG
 --------------------------------------------------------------------------*/
 hsize_t
-H5S_hyper_get_first_inc_block(const H5S_t *space, hsize_t clip_size,
-    hbool_t *partial)
+H5S_hyper_get_first_inc_block(const H5S_t *space, hsize_t clip_size, hbool_t *partial)
 {
-    H5S_hyper_sel_t *hslab;     /* Convenience pointer to hyperslab info */
-    H5S_hyper_dim_t *diminfo;   /* Convenience pointer to diminfo in unlimited dimension */
-    hsize_t ret_value = 0;
+    H5S_hyper_sel_t *hslab;   /* Convenience pointer to hyperslab info */
+    H5S_hyper_dim_t *diminfo; /* Convenience pointer to diminfo in unlimited dimension */
+    hsize_t          ret_value = 0;
 
     FUNC_ENTER_NOAPI(0)
 
@@ -12187,30 +12261,28 @@ H5S_hyper_get_first_inc_block(const H5S_t *space, hsize_t clip_size,
     diminfo = &hslab->diminfo.opt[hslab->unlim_dim];
 
     /* Check for selection outside of clip_size */
-    if(diminfo->start >= clip_size) {
+    if (diminfo->start >= clip_size) {
         ret_value = 0;
-        if(partial)
+        if (partial)
             partial = FALSE;
     } /* end if */
     else {
         /* Calculate index of first incomplete block */
-        ret_value = (clip_size - diminfo->start + diminfo->stride
-                - diminfo->block) / diminfo->stride;
+        ret_value = (clip_size - diminfo->start + diminfo->stride - diminfo->block) / diminfo->stride;
 
-        if(partial) {
+        if (partial) {
             /* Check for partial block */
-            if((diminfo->stride * ret_value) < (clip_size - diminfo->start))
+            if ((diminfo->stride * ret_value) < (clip_size - diminfo->start))
                 *partial = TRUE;
             else
                 *partial = FALSE;
         } /* end if */
-    } /* end else */
+    }     /* end else */
 
 done:
     FUNC_LEAVE_NOAPI(ret_value)
 } /* end H5S_hyper_get_first_inc_block */
 
-
 /*--------------------------------------------------------------------------
  NAME
     H5Sis_regular_hyperslab
@@ -12234,16 +12306,16 @@ done:
 htri_t
 H5Sis_regular_hyperslab(hid_t spaceid)
 {
-    H5S_t *space;               /* Dataspace to query */
-    htri_t ret_value;           /* Return value */
+    H5S_t *space;     /* Dataspace to query */
+    htri_t ret_value; /* Return value */
 
     FUNC_ENTER_API(FAIL)
     H5TRACE1("t", "i", spaceid);
 
     /* Check args */
-    if(NULL == (space = (H5S_t *)H5I_object_verify(spaceid, H5I_DATASPACE)))
+    if (NULL == (space = (H5S_t *)H5I_object_verify(spaceid, H5I_DATASPACE)))
         HGOTO_ERROR(H5E_ARGS, H5E_BADTYPE, FAIL, "not a dataspace")
-    if(H5S_GET_SELECT_TYPE(space) != H5S_SEL_HYPERSLABS)
+    if (H5S_GET_SELECT_TYPE(space) != H5S_SEL_HYPERSLABS)
         HGOTO_ERROR(H5E_ARGS, H5E_BADTYPE, FAIL, "not a hyperslab selection")
 
     ret_value = H5S__hyper_is_regular(space);
@@ -12252,7 +12324,6 @@ done:
     FUNC_LEAVE_API(ret_value)
 } /* end H5Sis_regular_hyperslab() */
 
-
 /*--------------------------------------------------------------------------
  NAME
     H5Sget_regular_hyperslab
@@ -12280,39 +12351,37 @@ done:
  REVISION LOG
 --------------------------------------------------------------------------*/
 herr_t
-H5Sget_regular_hyperslab(hid_t spaceid, hsize_t start[], hsize_t stride[],
-    hsize_t count[], hsize_t block[])
+H5Sget_regular_hyperslab(hid_t spaceid, hsize_t start[], hsize_t stride[], hsize_t count[], hsize_t block[])
 {
-    H5S_t *space;               /* Dataspace to query */
-    unsigned u;                 /* Local index variable */
-    herr_t ret_value = SUCCEED; /* Return value */
+    H5S_t *  space;               /* Dataspace to query */
+    unsigned u;                   /* Local index variable */
+    herr_t   ret_value = SUCCEED; /* Return value */
 
     FUNC_ENTER_API(FAIL)
     H5TRACE5("e", "i*h*h*h*h", spaceid, start, stride, count, block);
 
     /* Check args */
-    if(NULL == (space = (H5S_t *)H5I_object_verify(spaceid, H5I_DATASPACE)))
+    if (NULL == (space = (H5S_t *)H5I_object_verify(spaceid, H5I_DATASPACE)))
         HGOTO_ERROR(H5E_ARGS, H5E_BADTYPE, FAIL, "not a dataspace")
-    if(H5S_GET_SELECT_TYPE(space) != H5S_SEL_HYPERSLABS)
+    if (H5S_GET_SELECT_TYPE(space) != H5S_SEL_HYPERSLABS)
         HGOTO_ERROR(H5E_ARGS, H5E_BADTYPE, FAIL, "not a hyperslab selection")
-    if(TRUE != H5S__hyper_is_regular(space))
+    if (TRUE != H5S__hyper_is_regular(space))
         HGOTO_ERROR(H5E_ARGS, H5E_BADTYPE, FAIL, "not a regular hyperslab selection")
 
     /* Retrieve hyperslab parameters */
-    if(start)
-        for(u = 0; u < space->extent.rank; u++)
+    if (start)
+        for (u = 0; u < space->extent.rank; u++)
             start[u] = space->select.sel_info.hslab->diminfo.app[u].start;
-    if(stride)
-        for(u = 0; u < space->extent.rank; u++)
+    if (stride)
+        for (u = 0; u < space->extent.rank; u++)
             stride[u] = space->select.sel_info.hslab->diminfo.app[u].stride;
-    if(count)
-        for(u = 0; u < space->extent.rank; u++)
+    if (count)
+        for (u = 0; u < space->extent.rank; u++)
             count[u] = space->select.sel_info.hslab->diminfo.app[u].count;
-    if(block)
-        for(u = 0; u < space->extent.rank; u++)
+    if (block)
+        for (u = 0; u < space->extent.rank; u++)
             block[u] = space->select.sel_info.hslab->diminfo.app[u].block;
 
 done:
     FUNC_LEAVE_API(ret_value)
 } /* end H5Sget_regular_hyperslab() */
-