Develop clang 13 format (#1933)

* Update format source to clang 13

* More format changes

1 files changed, 119 insertions, 119 deletions

diff --git a/src/H5Dchunk.c b/src/H5Dchunk.c
index 6a89a99..4f628a7 100644
--- a/src/H5Dchunk.c
+++ b/src/H5Dchunk.c
@@ -129,7 +129,7 @@ typedef struct H5D_rdcc_ent_t {
     uint32_t               wr_count;                 /*bytes remaining to be written        */
     H5F_block_t            chunk_block;              /*offset/length of chunk in file        */
     hsize_t                chunk_idx;                /*index of chunk in dataset             */
-    uint8_t *              chunk;                    /*the unfiltered chunk data        */
+    uint8_t               *chunk;                    /*the unfiltered chunk data        */
     unsigned               idx;                      /*index in hash table            */
     struct H5D_rdcc_ent_t *next;                     /*next item in doubly-linked list    */
     struct H5D_rdcc_ent_t *prev;                     /*previous item in doubly-linked list    */
@@ -142,12 +142,12 @@ typedef H5D_rdcc_ent_t *H5D_rdcc_ent_ptr_t; /* For free lists */
 typedef struct H5D_chunk_it_ud1_t {
     H5D_chunk_common_ud_t     common;          /* Common info for B-tree user data (must be first) */
     const H5D_chk_idx_info_t *idx_info;        /* Chunked index info */
-    const H5D_io_info_t *     io_info;         /* I/O info for dataset operation */
-    const hsize_t *           space_dim;       /* New dataset dimensions    */
-    const hbool_t *           shrunk_dim;      /* Dimensions which have been shrunk */
-    H5S_t *                   chunk_space;     /* Dataspace for a chunk */
+    const H5D_io_info_t      *io_info;         /* I/O info for dataset operation */
+    const hsize_t            *space_dim;       /* New dataset dimensions    */
+    const hbool_t            *shrunk_dim;      /* Dimensions which have been shrunk */
+    H5S_t                    *chunk_space;     /* Dataspace for a chunk */
     uint32_t                  elmts_per_chunk; /* Elements in chunk */
-    hsize_t *                 hyper_start;     /* Starting location of hyperslab */
+    hsize_t                  *hyper_start;     /* Starting location of hyperslab */
     H5D_fill_buf_info_t       fb_info;         /* Dataset's fill buffer info */
     hbool_t                   fb_info_init;    /* Whether the fill value buffer has been initialized */
 } H5D_chunk_it_ud1_t;
@@ -165,10 +165,10 @@ typedef struct H5D_chunk_it_ud2_t {
 /* Callback info for iteration to copy data */
 typedef struct H5D_chunk_it_ud3_t {
     H5D_chunk_common_ud_t common;       /* Common info for B-tree user data (must be first) */
-    H5F_t *               file_src;     /* Source file for copy */
-    H5D_chk_idx_info_t *  idx_info_dst; /* Dest. chunk index info object */
-    void *                buf;          /* Buffer to hold chunk data for read/write */
-    void *                bkg;          /* Buffer for background information during type conversion */
+    H5F_t                *file_src;     /* Source file for copy */
+    H5D_chk_idx_info_t   *idx_info_dst; /* Dest. chunk index info object */
+    void                 *buf;          /* Buffer to hold chunk data for read/write */
+    void                 *bkg;          /* Buffer for background information during type conversion */
     size_t                buf_size;     /* Buffer size */
     hbool_t               do_convert;   /* Whether to perform type conversions */
 
@@ -177,17 +177,17 @@ typedef struct H5D_chunk_it_ud3_t {
     hid_t        tid_dst;          /* Datatype ID for destination datatype */
     hid_t        tid_mem;          /* Datatype ID for memory datatype */
     const H5T_t *dt_src;           /* Source datatype */
-    H5T_path_t * tpath_src_mem;    /* Datatype conversion path from source file to memory */
-    H5T_path_t * tpath_mem_dst;    /* Datatype conversion path from memory to dest. file */
-    void *       reclaim_buf;      /* Buffer for reclaiming data */
+    H5T_path_t  *tpath_src_mem;    /* Datatype conversion path from source file to memory */
+    H5T_path_t  *tpath_mem_dst;    /* Datatype conversion path from memory to dest. file */
+    void        *reclaim_buf;      /* Buffer for reclaiming data */
     size_t       reclaim_buf_size; /* Reclaim buffer size */
     uint32_t     nelmts;           /* Number of elements in buffer */
-    H5S_t *      buf_space;        /* Dataspace describing buffer */
+    H5S_t       *buf_space;        /* Dataspace describing buffer */
 
     /* needed for compressed variable-length data */
     const H5O_pline_t *pline;      /* Filter pipeline */
     unsigned           dset_ndims; /* Number of dimensions in dataset */
-    const hsize_t *    dset_dims;  /* Dataset dimensions */
+    const hsize_t     *dset_dims;  /* Dataset dimensions */
 
     /* needed for copy object pointed by refs */
     H5O_copy_t *cpy_info; /* Copy options */
@@ -199,7 +199,7 @@ typedef struct H5D_chunk_it_ud3_t {
 
 /* Callback info for iteration to dump index */
 typedef struct H5D_chunk_it_ud4_t {
-    FILE *    stream;           /* Output stream    */
+    FILE     *stream;           /* Output stream    */
     hbool_t   header_displayed; /* Node's header is displayed? */
     unsigned  ndims;            /* Number of dimensions for chunk/dataset */
     uint32_t *chunk_dim;        /* Chunk dimensions */
@@ -209,13 +209,13 @@ typedef struct H5D_chunk_it_ud4_t {
 typedef struct H5D_chunk_it_ud5_t {
     H5D_chk_idx_info_t *new_idx_info; /* Dest. chunk index info object */
     unsigned            dset_ndims;   /* Number of dimensions in dataset */
-    hsize_t *           dset_dims;    /* Dataset dimensions */
+    hsize_t            *dset_dims;    /* Dataset dimensions */
 } H5D_chunk_it_ud5_t;
 
 /* Callback info for nonexistent readvv operation */
 typedef struct H5D_chunk_readvv_ud_t {
     unsigned char *rbuf; /* Read buffer to initialize */
-    const H5D_t *  dset; /* Dataset to operate on */
+    const H5D_t   *dset; /* Dataset to operate on */
 } H5D_chunk_readvv_ud_t;
 
 /* Typedef for chunk info iterator callback */
@@ -253,7 +253,7 @@ typedef struct H5D_chunk_coll_fill_info_t {
 
 typedef struct H5D_chunk_iter_ud_t {
     H5D_chunk_iter_op_t op;      /* User defined callback */
-    void *              op_data; /* User data for user defined callback */
+    void               *op_data; /* User data for user defined callback */
 } H5D_chunk_iter_ud_t;
 
 /********************/
@@ -310,7 +310,7 @@ static htri_t   H5D__chunk_may_use_select_io(const H5D_io_info_t *io_info);
 static unsigned H5D__chunk_hash_val(const H5D_shared_t *shared, const hsize_t *scaled);
 static herr_t   H5D__chunk_flush_entry(const H5D_t *dset, H5D_rdcc_ent_t *ent, hbool_t reset);
 static herr_t   H5D__chunk_cache_evict(const H5D_t *dset, H5D_rdcc_ent_t *ent, hbool_t flush);
-static void *   H5D__chunk_lock(const H5D_io_info_t *io_info, H5D_chunk_ud_t *udata, hbool_t relax,
+static void    *H5D__chunk_lock(const H5D_io_info_t *io_info, H5D_chunk_ud_t *udata, hbool_t relax,
                                 hbool_t prev_unfilt_chunk);
 static herr_t   H5D__chunk_unlock(const H5D_io_info_t *io_info, const H5D_chunk_ud_t *udata, hbool_t dirty,
                                   void *chunk, uint32_t naccessed);
@@ -507,7 +507,7 @@ herr_t
 H5D__chunk_direct_read(const H5D_t *dset, hsize_t *offset, uint32_t *filters, void *buf)
 {
     const H5O_layout_t *layout = &(dset->shared->layout);      /* Dataset layout */
-    const H5D_rdcc_t *  rdcc   = &(dset->shared->cache.chunk); /* raw data chunk cache */
+    const H5D_rdcc_t   *rdcc   = &(dset->shared->cache.chunk); /* raw data chunk cache */
     H5D_chunk_ud_t      udata;                                 /* User data for querying chunk info */
     hsize_t             scaled[H5S_MAX_RANK];                  /* Scaled coordinates for this chunk */
     herr_t              ret_value = SUCCEED;                   /* Return value */
@@ -602,7 +602,7 @@ herr_t
 H5D__get_chunk_storage_size(H5D_t *dset, const hsize_t *offset, hsize_t *storage_size)
 {
     const H5O_layout_t *layout = &(dset->shared->layout);      /* Dataset layout */
-    const H5D_rdcc_t *  rdcc   = &(dset->shared->cache.chunk); /* raw data chunk cache */
+    const H5D_rdcc_t   *rdcc   = &(dset->shared->cache.chunk); /* raw data chunk cache */
     hsize_t             scaled[H5S_MAX_RANK];                  /* Scaled coordinates for this chunk */
     H5D_chunk_ud_t      udata;                                 /* User data for querying chunk info */
     herr_t              ret_value = SUCCEED;                   /* Return value */
@@ -915,8 +915,8 @@ static herr_t
 H5D__chunk_init(H5F_t *f, const H5D_t *const dset, hid_t dapl_id)
 {
     H5D_chk_idx_info_t idx_info;                            /* Chunked index info */
-    H5D_rdcc_t *       rdcc = &(dset->shared->cache.chunk); /* Convenience pointer to dataset's chunk cache */
-    H5P_genplist_t *   dapl;                                /* Data access property list object pointer */
+    H5D_rdcc_t        *rdcc = &(dset->shared->cache.chunk); /* Convenience pointer to dataset's chunk cache */
+    H5P_genplist_t    *dapl;                                /* Data access property list object pointer */
     H5O_storage_chunk_t *sc        = &(dset->shared->layout.storage.u.chunk);
     herr_t               ret_value = SUCCEED; /* Return value */
 
@@ -1167,8 +1167,8 @@ H5D__chunk_io_init_selections(const H5D_io_info_t *io_info, const H5D_type_info_
 {
     const H5D_t *dataset    = io_info->dset;       /* Local pointer to dataset info */
     const H5T_t *mem_type   = type_info->mem_type; /* Local pointer to memory datatype */
-    H5S_t *      tmp_mspace = NULL;                /* Temporary memory dataspace */
-    H5T_t *      file_type  = NULL;                /* Temporary copy of file datatype for iteration */
+    H5S_t       *tmp_mspace = NULL;                /* Temporary memory dataspace */
+    H5T_t       *file_type  = NULL;                /* Temporary copy of file datatype for iteration */
     hbool_t      iter_init  = FALSE;               /* Selection iteration info has been initialized */
     char         bogus;                            /* "bogus" buffer to pass to selection iterator */
     herr_t       ret_value = SUCCEED;              /* Return value        */
@@ -1373,7 +1373,7 @@ void *
 H5D__chunk_mem_alloc(size_t size, void *pline)
 {
     H5O_pline_t *_pline    = (H5O_pline_t *)pline;
-    void *       ret_value = NULL; /* Return value */
+    void        *ret_value = NULL; /* Return value */
 
     FUNC_ENTER_PACKAGE_NOERR
 
@@ -1608,7 +1608,7 @@ H5D__create_chunk_file_map_all(H5D_chunk_map_t *fm, const H5D_io_info_t
 #endif /* H5_HAVE_PARALLEL */
                                                             *io_info)
 {
-    H5S_t * tmp_fchunk = NULL;       /* Temporary file dataspace */
+    H5S_t  *tmp_fchunk = NULL;       /* Temporary file dataspace */
     hsize_t file_dims[H5S_MAX_RANK]; /* File dataspace dims */
     hsize_t sel_points;              /* Number of elements in file selection */
     hsize_t zeros[H5S_MAX_RANK];     /* All zero vector (for start parameter to setting hyperslab on partial
@@ -1813,7 +1813,7 @@ H5D__create_chunk_file_map_hyper(H5D_chunk_map_t *fm, const H5D_io_info_t
 #endif /* H5_HAVE_PARALLEL */
                                                               *io_info)
 {
-    H5S_t *  tmp_fchunk = NULL;              /* Temporary file dataspace */
+    H5S_t   *tmp_fchunk = NULL;              /* Temporary file dataspace */
     hsize_t  sel_start[H5O_LAYOUT_NDIMS];    /* Offset of low bound of file selection */
     hsize_t  sel_end[H5O_LAYOUT_NDIMS];      /* Offset of high bound of file selection */
     hsize_t  sel_points;                     /* Number of elements in file selection */
@@ -1989,7 +1989,7 @@ static herr_t
 H5D__create_chunk_mem_map_hyper(const H5D_chunk_map_t *fm)
 {
     H5D_chunk_info_t *chunk_info;                   /* Pointer to chunk information */
-    H5SL_node_t *     curr_node;                    /* Current node in skip list */
+    H5SL_node_t      *curr_node;                    /* Current node in skip list */
     hsize_t           file_sel_start[H5S_MAX_RANK]; /* Offset of low bound of file selection */
     hsize_t           file_sel_end[H5S_MAX_RANK];   /* Offset of high bound of file selection */
     hsize_t           mem_sel_start[H5S_MAX_RANK];  /* Offset of low bound of file selection */
@@ -2117,7 +2117,7 @@ static herr_t
 H5D__create_chunk_mem_map_1d(const H5D_chunk_map_t *fm)
 {
     H5D_chunk_info_t *chunk_info;          /* Pointer to chunk information */
-    H5SL_node_t *     curr_node;           /* Current node in skip list */
+    H5SL_node_t      *curr_node;           /* Current node in skip list */
     herr_t            ret_value = SUCCEED; /* Return value */
 
     FUNC_ENTER_PACKAGE
@@ -2198,8 +2198,8 @@ H5D__chunk_file_cb(void H5_ATTR_UNUSED *elem, const H5T_t H5_ATTR_UNUSED *type,
                    const hsize_t *coords, void *_udata)
 {
     H5D_chunk_file_iter_ud_t *udata = (H5D_chunk_file_iter_ud_t *)_udata; /* User data for operation */
-    H5D_chunk_map_t *         fm    = udata->fm;                 /* File<->memory chunk mapping info */
-    H5D_chunk_info_t *        chunk_info;                        /* Chunk information for current chunk */
+    H5D_chunk_map_t          *fm    = udata->fm;                 /* File<->memory chunk mapping info */
+    H5D_chunk_info_t         *chunk_info;                        /* Chunk information for current chunk */
     hsize_t                   coords_in_chunk[H5O_LAYOUT_NDIMS]; /* Coordinates of element in chunk */
     hsize_t                   chunk_index;                       /* Chunk index */
     hsize_t                   scaled[H5S_MAX_RANK];              /* Scaled coordinates for this chunk */
@@ -2314,7 +2314,7 @@ static herr_t
 H5D__chunk_mem_cb(void H5_ATTR_UNUSED *elem, const H5T_t H5_ATTR_UNUSED *type, unsigned ndims,
                   const hsize_t *coords, void *_fm)
 {
-    H5D_chunk_map_t * fm = (H5D_chunk_map_t *)_fm; /* File<->memory chunk mapping info */
+    H5D_chunk_map_t  *fm = (H5D_chunk_map_t *)_fm; /* File<->memory chunk mapping info */
     H5D_chunk_info_t *chunk_info;                  /* Chunk information for current chunk */
     hsize_t           coords_in_mem[H5S_MAX_RANK]; /* Coordinates of element in memory */
     hsize_t           chunk_index;                 /* Chunk index */
@@ -2551,15 +2551,15 @@ static herr_t
 H5D__chunk_read(H5D_io_info_t *io_info, const H5D_type_info_t *type_info, hsize_t H5_ATTR_UNUSED nelmts,
                 H5S_t H5_ATTR_UNUSED *file_space, H5S_t H5_ATTR_UNUSED *mem_space, H5D_chunk_map_t *fm)
 {
-    H5SL_node_t * chunk_node;                  /* Current node in chunk skip list */
+    H5SL_node_t  *chunk_node;                  /* Current node in chunk skip list */
     H5D_io_info_t nonexistent_io_info;         /* "nonexistent" I/O info object */
     uint32_t      src_accessed_bytes  = 0;     /* Total accessed size in a chunk */
     hbool_t       skip_missing_chunks = FALSE; /* Whether to skip missing chunks */
-    H5S_t **      chunk_mem_spaces    = NULL;  /* Array of chunk memory spaces */
-    H5S_t *       chunk_mem_spaces_static[8];  /* Static buffer for chunk_mem_spaces */
-    H5S_t **      chunk_file_spaces = NULL;    /* Array of chunk file spaces */
-    H5S_t *       chunk_file_spaces_static[8]; /* Static buffer for chunk_file_spaces */
-    haddr_t *     chunk_addrs = NULL;          /* Array of chunk addresses */
+    H5S_t       **chunk_mem_spaces    = NULL;  /* Array of chunk memory spaces */
+    H5S_t        *chunk_mem_spaces_static[8];  /* Static buffer for chunk_mem_spaces */
+    H5S_t       **chunk_file_spaces = NULL;    /* Array of chunk file spaces */
+    H5S_t        *chunk_file_spaces_static[8]; /* Static buffer for chunk_file_spaces */
+    haddr_t      *chunk_addrs = NULL;          /* Array of chunk addresses */
     haddr_t       chunk_addrs_static[8];       /* Static buffer for chunk_addrs */
     herr_t        ret_value = SUCCEED;         /*return value        */
 
@@ -2596,7 +2596,7 @@ H5D__chunk_read(H5D_io_info_t *io_info, const H5D_type_info_t *type_info, hsize_
     if (io_info->use_select_io) {
         size_t num_chunks;
         size_t element_sizes[2] = {type_info->dst_type_size, 0};
-        void * bufs[2]          = {io_info->u.rbuf, NULL};
+        void  *bufs[2]          = {io_info->u.rbuf, NULL};
 
         /* Cache number of chunks */
         num_chunks = H5D_CHUNK_GET_NODE_COUNT(fm);
@@ -2733,7 +2733,7 @@ H5D__chunk_read(H5D_io_info_t *io_info, const H5D_type_info_t *type_info, hsize_
             if (H5F_addr_defined(udata.chunk_block.offset) || UINT_MAX != udata.idx_hint ||
                 !skip_missing_chunks) {
                 H5D_io_info_t *chk_io_info;  /* Pointer to I/O info object for this chunk */
-                void *         chunk = NULL; /* Pointer to locked chunk buffer */
+                void          *chunk = NULL; /* Pointer to locked chunk buffer */
 
                 /* Set chunk's [scaled] coordinates */
                 io_info->store->chunk.scaled = chunk_info->scaled;
@@ -2820,18 +2820,18 @@ static herr_t
 H5D__chunk_write(H5D_io_info_t *io_info, const H5D_type_info_t *type_info, hsize_t H5_ATTR_UNUSED nelmts,
                  H5S_t H5_ATTR_UNUSED *file_space, H5S_t H5_ATTR_UNUSED *mem_space, H5D_chunk_map_t *fm)
 {
-    H5SL_node_t * chunk_node;                  /* Current node in chunk skip list */
+    H5SL_node_t  *chunk_node;                  /* Current node in chunk skip list */
     H5D_io_info_t ctg_io_info;                 /* Contiguous I/O info object */
     H5D_storage_t ctg_store;                   /* Chunk storage information as contiguous dataset */
     H5D_io_info_t cpt_io_info;                 /* Compact I/O info object */
     H5D_storage_t cpt_store;                   /* Chunk storage information as compact dataset */
     hbool_t       cpt_dirty;                   /* Temporary placeholder for compact storage "dirty" flag */
     uint32_t      dst_accessed_bytes = 0;      /* Total accessed size in a chunk */
-    H5S_t **      chunk_mem_spaces   = NULL;   /* Array of chunk memory spaces */
-    H5S_t *       chunk_mem_spaces_static[8];  /* Static buffer for chunk_mem_spaces */
-    H5S_t **      chunk_file_spaces = NULL;    /* Array of chunk file spaces */
-    H5S_t *       chunk_file_spaces_static[8]; /* Static buffer for chunk_file_spaces */
-    haddr_t *     chunk_addrs = NULL;          /* Array of chunk addresses */
+    H5S_t       **chunk_mem_spaces   = NULL;   /* Array of chunk memory spaces */
+    H5S_t        *chunk_mem_spaces_static[8];  /* Static buffer for chunk_mem_spaces */
+    H5S_t       **chunk_file_spaces = NULL;    /* Array of chunk file spaces */
+    H5S_t        *chunk_file_spaces_static[8]; /* Static buffer for chunk_file_spaces */
+    haddr_t      *chunk_addrs = NULL;          /* Array of chunk addresses */
     haddr_t       chunk_addrs_static[8];       /* Static buffer for chunk_addrs */
     herr_t        ret_value = SUCCEED;         /* Return value        */
 
@@ -2897,7 +2897,7 @@ H5D__chunk_write(H5D_io_info_t *io_info, const H5D_type_info_t *type_info, hsize
         /* Iterate through nodes in chunk skip list */
         chunk_node = H5D_CHUNK_GET_FIRST_NODE(fm);
         while (chunk_node) {
-            H5D_chunk_info_t * chunk_info; /* Chunk information */
+            H5D_chunk_info_t  *chunk_info; /* Chunk information */
             H5D_chk_idx_info_t idx_info;   /* Chunked index info */
             H5D_chunk_ud_t     udata;      /* Index pass-through    */
             htri_t             cacheable;  /* Whether the chunk is cacheable */
@@ -2926,7 +2926,7 @@ H5D__chunk_write(H5D_io_info_t *io_info, const H5D_type_info_t *type_info, hsize
             if (cacheable) {
                 /* Load the chunk into cache.  But if the whole chunk is written,
                  * simply allocate space instead of load the chunk. */
-                void *  chunk;               /* Pointer to locked chunk buffer */
+                void   *chunk;               /* Pointer to locked chunk buffer */
                 hbool_t entire_chunk = TRUE; /* Whether whole chunk is selected */
 
                 /* Compute # of bytes accessed in chunk */
@@ -3024,10 +3024,10 @@ H5D__chunk_write(H5D_io_info_t *io_info, const H5D_type_info_t *type_info, hsize
         /* Iterate through nodes in chunk skip list */
         chunk_node = H5D_CHUNK_GET_FIRST_NODE(fm);
         while (chunk_node) {
-            H5D_chunk_info_t * chunk_info;  /* Chunk information */
+            H5D_chunk_info_t  *chunk_info;  /* Chunk information */
             H5D_chk_idx_info_t idx_info;    /* Chunked index info */
-            H5D_io_info_t *    chk_io_info; /* Pointer to I/O info object for this chunk */
-            void *             chunk;       /* Pointer to locked chunk buffer */
+            H5D_io_info_t     *chk_io_info; /* Pointer to I/O info object for this chunk */
+            void              *chunk;       /* Pointer to locked chunk buffer */
             H5D_chunk_ud_t     udata;       /* Index pass-through    */
             htri_t             cacheable;   /* Whether the chunk is cacheable */
             hbool_t need_insert = FALSE;    /* Whether the chunk needs to be inserted into the index */
@@ -3168,7 +3168,7 @@ done:
 static herr_t
 H5D__chunk_flush(H5D_t *dset)
 {
-    H5D_rdcc_t *    rdcc = &(dset->shared->cache.chunk);
+    H5D_rdcc_t     *rdcc = &(dset->shared->cache.chunk);
     H5D_rdcc_ent_t *ent, *next;
     unsigned        nerrors   = 0;       /* Count of any errors encountered when flushing chunks */
     herr_t          ret_value = SUCCEED; /* Return value */
@@ -3258,8 +3258,8 @@ static herr_t
 H5D__chunk_dest(H5D_t *dset)
 {
     H5D_chk_idx_info_t   idx_info;                            /* Chunked index info */
-    H5D_rdcc_t *         rdcc = &(dset->shared->cache.chunk); /* Dataset's chunk cache */
-    H5D_rdcc_ent_t *     ent = NULL, *next = NULL;            /* Pointer to current & next cache entries */
+    H5D_rdcc_t          *rdcc = &(dset->shared->cache.chunk); /* Dataset's chunk cache */
+    H5D_rdcc_ent_t      *ent = NULL, *next = NULL;            /* Pointer to current & next cache entries */
     int                  nerrors   = 0;                       /* Accumulated count of errors */
     H5O_storage_chunk_t *sc        = &(dset->shared->layout.storage.u.chunk);
     herr_t               ret_value = SUCCEED; /* Return value */
@@ -3553,7 +3553,7 @@ H5D__chunk_hash_val(const H5D_shared_t *shared, const hsize_t *scaled)
 herr_t
 H5D__chunk_lookup(const H5D_t *dset, const hsize_t *scaled, H5D_chunk_ud_t *udata)
 {
-    H5D_rdcc_ent_t *     ent   = NULL; /* Cache entry */
+    H5D_rdcc_ent_t      *ent   = NULL; /* Cache entry */
     H5O_storage_chunk_t *sc    = &(dset->shared->layout.storage.u.chunk);
     unsigned             idx   = 0;     /* Index of chunk in cache, if present */
     hbool_t              found = FALSE; /* In cache? */
@@ -3708,7 +3708,7 @@ done:
 static herr_t
 H5D__chunk_flush_entry(const H5D_t *dset, H5D_rdcc_ent_t *ent, hbool_t reset)
 {
-    void *               buf                = NULL; /* Temporary buffer        */
+    void                *buf                = NULL; /* Temporary buffer        */
     hbool_t              point_of_no_return = FALSE;
     H5O_storage_chunk_t *sc                 = &(dset->shared->layout.storage.u.chunk);
     herr_t               ret_value          = SUCCEED; /* Return value            */
@@ -3983,8 +3983,8 @@ H5D__chunk_cache_prune(const H5D_t *dset, size_t size)
     size_t            total = rdcc->nbytes_max;
     const int         nmeth = 2;           /* Number of methods */
     int               w[1];                /* Weighting as an interval */
-    H5D_rdcc_ent_t *  p[2], *cur;          /* List pointers */
-    H5D_rdcc_ent_t *  n[2];                /* List next pointers */
+    H5D_rdcc_ent_t   *p[2], *cur;          /* List pointers */
+    H5D_rdcc_ent_t   *n[2];                /* List next pointers */
     int               nerrors   = 0;       /* Accumulated error count during preemptions */
     herr_t            ret_value = SUCCEED; /* Return value */
 
@@ -4104,17 +4104,17 @@ H5D__chunk_lock(const H5D_io_info_t *io_info, H5D_chunk_ud_t *udata, hbool_t rel
     H5O_pline_t *pline =
         &(dset->shared->dcpl_cache
               .pline); /* I/O pipeline info - always equal to the pline passed to H5D__chunk_mem_alloc */
-    H5O_pline_t *       old_pline = pline; /* Old pipeline, i.e. pipeline used to read the chunk */
+    H5O_pline_t        *old_pline = pline; /* Old pipeline, i.e. pipeline used to read the chunk */
     const H5O_layout_t *layout    = &(dset->shared->layout);          /* Dataset layout */
-    const H5O_fill_t *  fill      = &(dset->shared->dcpl_cache.fill); /* Fill value info */
+    const H5O_fill_t   *fill      = &(dset->shared->dcpl_cache.fill); /* Fill value info */
     H5D_fill_buf_info_t fb_info;                                      /* Dataset's fill buffer info */
     hbool_t             fb_info_init = FALSE; /* Whether the fill value buffer has been initialized */
-    H5D_rdcc_t *        rdcc         = &(dset->shared->cache.chunk); /*raw data chunk cache*/
-    H5D_rdcc_ent_t *    ent;                                         /*cache entry        */
+    H5D_rdcc_t         *rdcc         = &(dset->shared->cache.chunk); /*raw data chunk cache*/
+    H5D_rdcc_ent_t     *ent;                                         /*cache entry        */
     size_t              chunk_size;                                  /*size of a chunk    */
     hbool_t             disable_filters = FALSE; /* Whether to disable filters (when adding to cache) */
-    void *              chunk           = NULL;  /*the file chunk    */
-    void *              ret_value       = NULL;  /* Return value         */
+    void               *chunk           = NULL;  /*the file chunk    */
+    void               *ret_value       = NULL;  /* Return value         */
 
     FUNC_ENTER_PACKAGE
 
@@ -4501,7 +4501,7 @@ H5D__chunk_unlock(const H5D_io_info_t *io_info, const H5D_chunk_ud_t *udata, hbo
                   uint32_t naccessed)
 {
     const H5O_layout_t *layout    = &(io_info->dset->shared->layout); /* Dataset layout */
-    const H5D_rdcc_t *  rdcc      = &(io_info->dset->shared->cache.chunk);
+    const H5D_rdcc_t   *rdcc      = &(io_info->dset->shared->cache.chunk);
     herr_t              ret_value = SUCCEED; /* Return value */
 
     FUNC_ENTER_PACKAGE
@@ -4624,8 +4624,8 @@ herr_t
 H5D__chunk_allocated(const H5D_t *dset, hsize_t *nbytes)
 {
     H5D_chk_idx_info_t   idx_info;                            /* Chunked index info */
-    const H5D_rdcc_t *   rdcc = &(dset->shared->cache.chunk); /* Raw data chunk cache */
-    H5D_rdcc_ent_t *     ent;                                 /* Cache entry  */
+    const H5D_rdcc_t    *rdcc = &(dset->shared->cache.chunk); /* Raw data chunk cache */
+    H5D_rdcc_ent_t      *ent;                                 /* Cache entry  */
     hsize_t              chunk_bytes = 0;                     /* Number of bytes allocated for chunks */
     H5O_storage_chunk_t *sc          = &(dset->shared->layout.storage.u.chunk);
     herr_t               ret_value   = SUCCEED; /* Return value */
@@ -4677,7 +4677,7 @@ done:
 herr_t
 H5D__chunk_allocate(const H5D_io_info_t *io_info, hbool_t full_overwrite, const hsize_t old_dim[])
 {
-    const H5D_t *          dset = io_info->dset;                           /* the dataset pointer */
+    const H5D_t           *dset = io_info->dset;                           /* the dataset pointer */
     H5D_chk_idx_info_t     idx_info;                                       /* Chunked index info */
     const H5D_chunk_ops_t *ops = dset->shared->layout.storage.u.chunk.ops; /* Chunk operations */
     hsize_t min_unalloc[H5O_LAYOUT_NDIMS]; /* First chunk in each dimension that is unallocated (in scaled
@@ -4688,14 +4688,14 @@ H5D__chunk_allocate(const H5D_io_info_t *io_info, hbool_t full_overwrite, const
     size_t            orig_chunk_size;          /* Original size of chunk in bytes */
     size_t            chunk_size;               /* Actual size of chunk in bytes, possibly filtered */
     unsigned          filter_mask = 0;          /* Filter mask for chunks that have them */
-    H5O_layout_t *    layout      = &(dset->shared->layout);           /* Dataset layout */
-    H5O_pline_t *     pline       = &(dset->shared->dcpl_cache.pline); /* I/O pipeline info */
+    H5O_layout_t     *layout      = &(dset->shared->layout);           /* Dataset layout */
+    H5O_pline_t      *pline       = &(dset->shared->dcpl_cache.pline); /* I/O pipeline info */
     H5O_pline_t       def_pline   = H5O_CRT_PIPELINE_DEF;              /* Default pipeline */
     const H5O_fill_t *fill        = &(dset->shared->dcpl_cache.fill);  /* Fill value info */
     H5D_fill_value_t  fill_status;                                     /* The fill value status */
     hbool_t           should_fill     = FALSE; /* Whether fill values should be written */
-    void *            unfilt_fill_buf = NULL;  /* Unfiltered fill value buffer */
-    void **           fill_buf        = NULL;  /* Pointer to the fill buffer to use for a chunk */
+    void             *unfilt_fill_buf = NULL;  /* Unfiltered fill value buffer */
+    void            **fill_buf        = NULL;  /* Pointer to the fill buffer to use for a chunk */
 #ifdef H5_HAVE_PARALLEL
     hbool_t blocks_written = FALSE; /* Flag to indicate that chunk was actually written */
     hbool_t using_mpi =
@@ -4704,8 +4704,8 @@ H5D__chunk_allocate(const H5D_io_info_t *io_info, hbool_t full_overwrite, const
 #endif                                          /* H5_HAVE_PARALLEL */
     hbool_t             carry; /* Flag to indicate that chunk increment carrys to higher dimension (sorta) */
     unsigned            space_ndims;                     /* Dataset's space rank */
-    const hsize_t *     space_dim;                       /* Dataset's dataspace dimensions */
-    const uint32_t *    chunk_dim = layout->u.chunk.dim; /* Convenience pointer to chunk dimensions */
+    const hsize_t      *space_dim;                       /* Dataset's dataspace dimensions */
+    const uint32_t     *chunk_dim = layout->u.chunk.dim; /* Convenience pointer to chunk dimensions */
     unsigned            op_dim;                          /* Current operating dimension */
     H5D_fill_buf_info_t fb_info;                         /* Dataset's fill buffer info */
     hbool_t             fb_info_init = FALSE; /* Whether the fill value buffer has been initialized */
@@ -5162,14 +5162,14 @@ H5D__chunk_update_old_edge_chunks(H5D_t *dset, hsize_t old_dim[])
                                                     modified */
     const H5O_layout_t *layout = &(dset->shared->layout); /* Dataset layout */
     hsize_t             chunk_sc[H5O_LAYOUT_NDIMS];       /* Offset of current chunk */
-    const uint32_t *    chunk_dim = layout->u.chunk.dim;  /* Convenience pointer to chunk dimensions */
+    const uint32_t     *chunk_dim = layout->u.chunk.dim;  /* Convenience pointer to chunk dimensions */
     unsigned            space_ndims;                      /* Dataset's space rank */
-    const hsize_t *     space_dim;                        /* Dataset's dataspace dimensions */
+    const hsize_t      *space_dim;                        /* Dataset's dataspace dimensions */
     unsigned            op_dim;                           /* Current operationg dimension */
     H5D_io_info_t       chk_io_info;                      /* Chunked I/O info object */
     H5D_chunk_ud_t      chk_udata;                        /* User data for locking chunk */
     H5D_storage_t       chk_store;                        /* Chunk storage information */
-    void *              chunk;                            /* The file chunk  */
+    void               *chunk;                            /* The file chunk  */
     hbool_t             carry; /* Flag to indicate that chunk increment carrys to higher dimension (sorta) */
     herr_t              ret_value = SUCCEED; /* Return value */
 
@@ -5333,9 +5333,9 @@ H5D__chunk_collective_fill(const H5D_t *dset, H5D_chunk_coll_fill_info_t *chunk_
     size_t           num_blocks;               /* Number of blocks between processes. */
     size_t           leftover_blocks;          /* Number of leftover blocks to handle */
     int              blocks, leftover;         /* converted to int for MPI */
-    MPI_Aint *       chunk_disp_array = NULL;
-    MPI_Aint *       block_disps      = NULL;
-    int *            block_lens       = NULL;
+    MPI_Aint        *chunk_disp_array = NULL;
+    MPI_Aint        *block_disps      = NULL;
+    int             *block_lens       = NULL;
     MPI_Datatype     mem_type = MPI_BYTE, file_type = MPI_BYTE;
     H5FD_mpio_xfer_t prev_xfer_mode;         /* Previous data xfer mode */
     hbool_t          have_xfer_mode = FALSE; /* Whether the previous xffer mode has been retrieved */
@@ -5602,16 +5602,16 @@ static herr_t
 H5D__chunk_prune_fill(H5D_chunk_it_ud1_t *udata, hbool_t new_unfilt_chunk)
 {
     const H5D_io_info_t *io_info         = udata->io_info;          /* Local pointer to I/O info */
-    const H5D_t *        dset            = io_info->dset;           /* Local pointer to the dataset info */
-    const H5O_layout_t * layout          = &(dset->shared->layout); /* Dataset's layout */
+    const H5D_t         *dset            = io_info->dset;           /* Local pointer to the dataset info */
+    const H5O_layout_t  *layout          = &(dset->shared->layout); /* Dataset's layout */
     unsigned             rank            = udata->common.layout->ndims - 1; /* Dataset rank */
-    const hsize_t *      scaled          = udata->common.scaled;            /* Scaled chunk offset */
-    H5S_sel_iter_t *     chunk_iter      = NULL;  /* Memory selection iteration info */
+    const hsize_t       *scaled          = udata->common.scaled;            /* Scaled chunk offset */
+    H5S_sel_iter_t      *chunk_iter      = NULL;  /* Memory selection iteration info */
     hbool_t              chunk_iter_init = FALSE; /* Whether the chunk iterator has been initialized */
     hsize_t              sel_nelmts;              /* Number of elements in selection */
     hsize_t              count[H5O_LAYOUT_NDIMS]; /* Element count of hyperslab */
     size_t               chunk_size;              /*size of a chunk       */
-    void *               chunk;                   /* The file chunk  */
+    void                *chunk;                   /* The file chunk  */
     H5D_chunk_ud_t       chk_udata;               /* User data for locking chunk */
     uint32_t             bytes_accessed;          /* Bytes accessed in chunk */
     unsigned             u;                       /* Local index variable */
@@ -5823,15 +5823,15 @@ H5D__chunk_prune_by_extent(H5D_t *dset, const hsize_t *old_dim)
     H5D_io_info_t       chk_io_info;          /* Chunked I/O info object */
     H5D_storage_t       chk_store;            /* Chunk storage information */
     const H5O_layout_t *layout = &(dset->shared->layout);      /* Dataset's layout */
-    const H5D_rdcc_t *  rdcc   = &(dset->shared->cache.chunk); /*raw data chunk cache */
+    const H5D_rdcc_t   *rdcc   = &(dset->shared->cache.chunk); /*raw data chunk cache */
     unsigned            space_ndims;                           /* Dataset's space rank */
-    const hsize_t *     space_dim;                             /* Current dataspace dimensions */
+    const hsize_t      *space_dim;                             /* Current dataspace dimensions */
     unsigned            op_dim;                                /* Current operating dimension */
     hbool_t             shrunk_dim[H5O_LAYOUT_NDIMS];          /* Dimensions which have shrunk */
     H5D_chunk_it_ud1_t  udata;                                 /* Chunk index iterator user data */
     hbool_t udata_init = FALSE;      /* Whether the chunk index iterator user data has been initialized */
     H5D_chunk_common_ud_t idx_udata; /* User data for index removal routine */
-    H5S_t *               chunk_space = NULL;            /* Dataspace for a chunk */
+    H5S_t                *chunk_space = NULL;            /* Dataspace for a chunk */
     hsize_t               chunk_dim[H5O_LAYOUT_NDIMS];   /* Chunk dimensions */
     hsize_t               scaled[H5O_LAYOUT_NDIMS];      /* Scaled offset of current chunk */
     hsize_t               hyper_start[H5O_LAYOUT_NDIMS]; /* Starting location of hyperslab */
@@ -6185,7 +6185,7 @@ herr_t
 H5D__chunk_addrmap(const H5D_io_info_t *io_info, haddr_t chunk_addr[])
 {
     H5D_chk_idx_info_t   idx_info;             /* Chunked index info */
-    const H5D_t *        dset = io_info->dset; /* Local pointer to dataset info */
+    const H5D_t         *dset = io_info->dset; /* Local pointer to dataset info */
     H5D_chunk_it_ud2_t   udata;                /* User data for iteration callback */
     H5O_storage_chunk_t *sc        = &(dset->shared->layout.storage.u.chunk);
     herr_t               ret_value = SUCCEED; /* Return value */
@@ -6311,7 +6311,7 @@ done:
 herr_t
 H5D__chunk_update_cache(H5D_t *dset)
 {
-    H5D_rdcc_t *    rdcc = &(dset->shared->cache.chunk); /*raw data chunk cache */
+    H5D_rdcc_t     *rdcc = &(dset->shared->cache.chunk); /*raw data chunk cache */
     H5D_rdcc_ent_t *ent, *next;                          /*cache entry  */
     H5D_rdcc_ent_t  tmp_head;                            /* Sentinel entry for temporary entry list */
     H5D_rdcc_ent_t *tmp_tail;                            /* Tail pointer for temporary entry list */
@@ -6430,8 +6430,8 @@ H5D__chunk_copy_cb(const H5D_chunk_rec_t *chunk_rec, void *_udata)
     hbool_t             need_insert = FALSE; /* Whether the chunk needs to be inserted into the index */
 
     /* General information about chunk copy */
-    void *             bkg      = udata->bkg;      /* Background buffer for datatype conversion */
-    void *             buf      = udata->buf;      /* Chunk buffer for I/O & datatype conversions */
+    void              *bkg      = udata->bkg;      /* Background buffer for datatype conversion */
+    void              *buf      = udata->buf;      /* Chunk buffer for I/O & datatype conversions */
     size_t             buf_size = udata->buf_size; /* Size of chunk buffer */
     const H5O_pline_t *pline    = udata->pline;    /* I/O pipeline for applying filters */
 
@@ -6504,7 +6504,7 @@ H5D__chunk_copy_cb(const H5D_chunk_rec_t *chunk_rec, void *_udata)
         H5D_rdcc_ent_t *ent = NULL; /* Cache entry */
         unsigned        idx;        /* Index of chunk in cache, if present */
         unsigned        u;          /* Counter */
-        H5D_shared_t *  shared_fo = (H5D_shared_t *)udata->cpy_info->shared_fo;
+        H5D_shared_t   *shared_fo = (H5D_shared_t *)udata->cpy_info->shared_fo;
 
         /* See if the written chunk is in the chunk cache */
         if (shared_fo && shared_fo->cache.chunk.nslots > 0) {
@@ -6558,11 +6558,11 @@ H5D__chunk_copy_cb(const H5D_chunk_rec_t *chunk_rec, void *_udata)
     if (is_vlen) {
         H5T_path_t *tpath_src_mem    = udata->tpath_src_mem;
         H5T_path_t *tpath_mem_dst    = udata->tpath_mem_dst;
-        H5S_t *     buf_space        = udata->buf_space;
+        H5S_t      *buf_space        = udata->buf_space;
         hid_t       tid_src          = udata->tid_src;
         hid_t       tid_dst          = udata->tid_dst;
         hid_t       tid_mem          = udata->tid_mem;
-        void *      reclaim_buf      = udata->reclaim_buf;
+        void       *reclaim_buf      = udata->reclaim_buf;
         size_t      reclaim_buf_size = udata->reclaim_buf_size;
 
         /* Convert from source file to memory */
@@ -6681,16 +6681,16 @@ H5D__chunk_copy(H5F_t *f_src, H5O_storage_chunk_t *storage_src, H5O_layout_chunk
     hsize_t            max_dims[H5O_LAYOUT_NDIMS];                  /* Curr. size of dataset dimensions */
     H5O_pline_t        _pline;                                      /* Temporary pipeline info */
     const H5O_pline_t *pline;                                       /* Pointer to pipeline info to use */
-    H5T_path_t *       tpath_src_mem = NULL, *tpath_mem_dst = NULL; /* Datatype conversion paths */
+    H5T_path_t        *tpath_src_mem = NULL, *tpath_mem_dst = NULL; /* Datatype conversion paths */
     hid_t              tid_src = -1;                                /* Datatype ID for source datatype */
     hid_t              tid_dst = -1;                                /* Datatype ID for destination datatype */
     hid_t              tid_mem = -1;                                /* Datatype ID for memory datatype */
     size_t             buf_size;                                    /* Size of copy buffer */
     size_t             reclaim_buf_size;                            /* Size of reclaim buffer */
-    void *             buf             = NULL;                      /* Buffer for copying data */
-    void *             bkg             = NULL;    /* Buffer for background during type conversion */
-    void *             reclaim_buf     = NULL;    /* Buffer for reclaiming data */
-    H5S_t *            buf_space       = NULL;    /* Dataspace describing buffer */
+    void              *buf             = NULL;                      /* Buffer for copying data */
+    void              *bkg             = NULL;    /* Buffer for background during type conversion */
+    void              *reclaim_buf     = NULL;    /* Buffer for reclaiming data */
+    H5S_t             *buf_space       = NULL;    /* Dataspace describing buffer */
     hid_t              sid_buf         = -1;      /* ID for buffer dataspace */
     uint32_t           nelmts          = 0;       /* Number of elements in buffer */
     hbool_t            do_convert      = FALSE;   /* Indicate that type conversions should be performed */
@@ -6759,8 +6759,8 @@ H5D__chunk_copy(H5F_t *f_src, H5O_storage_chunk_t *storage_src, H5O_layout_chunk
 
     /* If there's a VLEN source datatype, set up type conversion information */
     if (H5T_detect_class(dt_src, H5T_VLEN, FALSE) > 0) {
-        H5T_t *  dt_dst;      /* Destination datatype */
-        H5T_t *  dt_mem;      /* Memory datatype */
+        H5T_t   *dt_dst;      /* Destination datatype */
+        H5T_t   *dt_mem;      /* Memory datatype */
         size_t   mem_dt_size; /* Memory datatype size */
         size_t   tmp_dt_size; /* Temp. datatype size */
         size_t   max_dt_size; /* Max atatype size */
@@ -6891,7 +6891,7 @@ H5D__chunk_copy(H5F_t *f_src, H5O_storage_chunk_t *storage_src, H5O_layout_chunk
     if (udata.cpy_info->shared_fo) {
         H5D_rdcc_ent_t *ent, *next;
         H5D_chunk_rec_t chunk_rec;
-        H5D_shared_t *  shared_fo = (H5D_shared_t *)udata.cpy_info->shared_fo;
+        H5D_shared_t   *shared_fo = (H5D_shared_t *)udata.cpy_info->shared_fo;
 
         chunk_rec.nbytes      = layout_src->size;
         chunk_rec.filter_mask = 0;
@@ -6955,7 +6955,7 @@ herr_t
 H5D__chunk_bh_info(const H5O_loc_t *loc, H5O_t *oh, H5O_layout_t *layout, hsize_t *index_size)
 {
     H5D_chk_idx_info_t   idx_info;     /* Chunked index info */
-    H5S_t *              space = NULL; /* Dataset's dataspace */
+    H5S_t               *space = NULL; /* Dataset's dataspace */
     H5O_pline_t          pline;        /* I/O pipeline message */
     H5O_storage_chunk_t *sc = &(layout->storage.u.chunk);
     htri_t               exists;                  /* Flag if header message of interest exists */
@@ -7478,7 +7478,7 @@ H5D__chunk_format_convert_cb(const H5D_chunk_rec_t *chunk_rec, void *_udata)
     H5D_chunk_ud_t      insert_udata;                         /* Chunk information to be inserted */
     haddr_t             chunk_addr;                           /* Chunk address */
     size_t              nbytes;                               /* Chunk size */
-    void *              buf       = NULL;                     /* Pointer to buffer of chunk data */
+    void               *buf       = NULL;                     /* Pointer to buffer of chunk data */
     int                 ret_value = H5_ITER_CONT;             /* Return value */
 
     FUNC_ENTER_PACKAGE
@@ -7637,8 +7637,8 @@ herr_t
 H5D__chunk_index_empty(const H5D_t *dset, hbool_t *empty)
 {
     H5D_chk_idx_info_t idx_info;            /* Chunked index info */
-    H5D_rdcc_ent_t *   ent;                 /* Cache entry  */
-    const H5D_rdcc_t * rdcc      = NULL;    /* Raw data chunk cache */
+    H5D_rdcc_ent_t    *ent;                 /* Cache entry  */
+    const H5D_rdcc_t  *rdcc      = NULL;    /* Raw data chunk cache */
     herr_t             ret_value = SUCCEED; /* Return value */
 
     FUNC_ENTER_PACKAGE_TAG(dset->oloc.addr)
@@ -7728,8 +7728,8 @@ H5D__get_num_chunks(const H5D_t *dset, const H5S_t H5_ATTR_UNUSED *space, hsize_
 {
     H5D_chk_idx_info_t idx_info;            /* Chunked index info */
     hsize_t            num_chunks = 0;      /* Number of written chunks */
-    H5D_rdcc_ent_t *   ent;                 /* Cache entry  */
-    const H5D_rdcc_t * rdcc      = NULL;    /* Raw data chunk cache */
+    H5D_rdcc_ent_t    *ent;                 /* Cache entry  */
+    const H5D_rdcc_t  *rdcc      = NULL;    /* Raw data chunk cache */
     herr_t             ret_value = SUCCEED; /* Return value */
 
     FUNC_ENTER_PACKAGE_TAG(dset->oloc.addr)
@@ -7841,8 +7841,8 @@ H5D__get_chunk_info(const H5D_t *dset, const H5S_t H5_ATTR_UNUSED *space, hsize_
 {
     H5D_chk_idx_info_t       idx_info;            /* Chunked index info */
     H5D_chunk_info_iter_ud_t udata;               /* User data for callback */
-    const H5D_rdcc_t *       rdcc = NULL;         /* Raw data chunk cache */
-    H5D_rdcc_ent_t *         ent;                 /* Cache entry index */
+    const H5D_rdcc_t        *rdcc = NULL;         /* Raw data chunk cache */
+    H5D_rdcc_ent_t          *ent;                 /* Cache entry index */
     hsize_t                  ii        = 0;       /* Dimension index */
     herr_t                   ret_value = SUCCEED; /* Return value */
 
@@ -7974,9 +7974,9 @@ herr_t
 H5D__get_chunk_info_by_coord(const H5D_t *dset, const hsize_t *offset, unsigned *filter_mask, haddr_t *addr,
                              hsize_t *size)
 {
-    const H5O_layout_t *     layout = NULL;       /* Dataset layout */
-    const H5D_rdcc_t *       rdcc   = NULL;       /* Raw data chunk cache */
-    H5D_rdcc_ent_t *         ent;                 /* Cache entry index */
+    const H5O_layout_t      *layout = NULL;       /* Dataset layout */
+    const H5D_rdcc_t        *rdcc   = NULL;       /* Raw data chunk cache */
+    H5D_rdcc_ent_t          *ent;                 /* Cache entry index */
     H5D_chk_idx_info_t       idx_info;            /* Chunked index info */
     H5D_chunk_info_iter_ud_t udata;               /* User data for callback */
     herr_t                   ret_value = SUCCEED; /* Return value */
@@ -8094,9 +8094,9 @@ H5D__chunk_iter_cb(const H5D_chunk_rec_t *chunk_rec, void *udata)
 herr_t
 H5D__chunk_iter(H5D_t *dset, H5D_chunk_iter_op_t op, void *op_data)
 {
-    const H5D_rdcc_t * rdcc   = NULL;       /* Raw data chunk cache */
-    H5O_layout_t *     layout = NULL;       /* Dataset layout */
-    H5D_rdcc_ent_t *   ent;                 /* Cache entry index */
+    const H5D_rdcc_t  *rdcc   = NULL;       /* Raw data chunk cache */
+    H5O_layout_t      *layout = NULL;       /* Dataset layout */
+    H5D_rdcc_ent_t    *ent;                 /* Cache entry index */
     H5D_chk_idx_info_t idx_info;            /* Chunked index info */
     herr_t             ret_value = SUCCEED; /* Return value */