Brought H5I, H5Z, and some of H5PL in line with develop/1.12.

11 files changed, 305 insertions, 267 deletions

diff --git a/src/H5I.c b/src/H5I.c
index 6a71566..b7ab6a5 100644
--- a/src/H5I.c
+++ b/src/H5I.c
@@ -46,26 +46,26 @@
 /* Local Macros */
 
 /* Combine a Type number and an atom index into an atom */
-#define H5I_MAKE(g,i)    ((((hid_t)(g) & TYPE_MASK) << ID_BITS) |      \
-                ((hid_t)(i) & ID_MASK))
+#define H5I_MAKE(g,i)       ((((hid_t)(g) & TYPE_MASK) << ID_BITS) |          \
+                             ((hid_t)(i) & ID_MASK))
 
 /* Local typedefs */
 
 /* Atom information structure used */
 typedef struct H5I_id_info_t {
-    hid_t    id;        /* ID for this info                */
-    unsigned    count;        /* ref. count for this atom            */
-    unsigned    app_count;      /* ref. count of application visible atoms  */
-    const void    *obj_ptr;    /* pointer associated with the atom        */
+    hid_t       id;         /* ID for this info                             */
+    unsigned    count;      /* ref. count for this atom                     */
+    unsigned    app_count;  /* ref. count of application visible atoms      */
+    const void  *obj_ptr;   /* pointer associated with the atom             */
 } H5I_id_info_t;
 
 /* ID type structure used */
 typedef struct {
-    const H5I_class_t *cls;     /* Pointer to ID class                      */
-    unsigned    init_count;    /* # of times this type has been initialized*/
-    uint64_t    id_count;    /* Current number of IDs held            */
-    uint64_t    nextid;        /* ID to use for the next atom            */
-    H5SL_t      *ids;           /* Pointer to skip list that stores IDs     */
+    const H5I_class_t *cls; /* Pointer to ID class                          */
+    unsigned    init_count; /* # of times this type has been initialized    */
+    uint64_t    id_count;   /* Current number of IDs held                   */
+    uint64_t    nextid;     /* ID to use for the next atom                  */
+    H5SL_t      *ids;       /* Pointer to skip list that stores IDs         */
 } H5I_id_type_t;
 
 typedef struct {
@@ -102,7 +102,7 @@ static H5I_id_type_t *H5I_id_type_list_g[H5I_MAX_NUM_TYPES];
 /* Starts at 1 instead of 0 because it makes trace output look nicer.  If more */
 /* types (or IDs within a type) are needed, adjust TYPE_BITS in H5Ipkg.h       */
 /* and/or increase size of hid_t */
-static H5I_type_t H5I_next_type = (H5I_type_t) H5I_NTYPES;
+static int H5I_next_type = (int)H5I_NTYPES;
 
 /* Declare a free list to manage the H5I_id_info_t struct */
 H5FL_DEFINE_STATIC(H5I_id_info_t);
@@ -125,7 +125,7 @@ static H5I_id_info_t *H5I__find_id(hid_t id);
 static int H5I__debug_cb(void *_item, void *_key, void *_udata);
 static int H5I__id_dump_cb(void *_item, void *_key, void *_udata);
 
-
+
 /*-------------------------------------------------------------------------
  * Function:    H5I_term_package
  *
@@ -149,16 +149,16 @@ H5I_term_package(void)
 
     if(H5_PKG_INIT_VAR) {
         H5I_id_type_t *type_ptr;        /* Pointer to ID type */
-        H5I_type_t type;                /* Type of ID */
+        int type;                       /* Type of ID */
 
         /* How many types are still being used? */
-        for(type = (H5I_type_t)0; type < H5I_next_type; type++)
+        for(type = 0; type < H5I_next_type; type++)
             if((type_ptr = H5I_id_type_list_g[type]) && type_ptr->ids)
                 n++;
 
         /* If no types are used then clean up */
         if(0 == n) {
-            for(type = (H5I_type_t)0; type < H5I_next_type; type++) {
+            for(type = 0; type < H5I_next_type; type++) {
                 type_ptr = H5I_id_type_list_g[type];
                 if(type_ptr) {
                     HDassert(NULL == type_ptr->ids);
@@ -177,7 +177,7 @@ H5I_term_package(void)
     FUNC_LEAVE_NOAPI(n)
 } /* end H5I_term_package() */
 
-
+
 /*-------------------------------------------------------------------------
  * Function:    H5Iregister_type
  *
@@ -196,7 +196,8 @@ H5I_term_package(void)
  *-------------------------------------------------------------------------
  */
 H5I_type_t
-H5Iregister_type(size_t hash_size, unsigned reserved, H5I_free_t free_func)
+H5Iregister_type(size_t H5_ATTR_DEBUG_API_USED hash_size, unsigned reserved,
+    H5I_free_t free_func)
 {
     H5I_class_t *cls = NULL;            /* New ID class */
     H5I_type_t new_type;                /* New ID type value */
@@ -207,9 +208,9 @@ H5Iregister_type(size_t hash_size, unsigned reserved, H5I_free_t free_func)
 
     /* Generate a new H5I_type_t value */
 
-    /* Increment the number of types*/
+    /* Increment the number of types */
     if(H5I_next_type < H5I_MAX_NUM_TYPES) {
-        new_type = H5I_next_type;
+        new_type = (H5I_type_t)H5I_next_type;
         H5I_next_type++;
     } /* end if */
     else {
@@ -228,7 +229,7 @@ H5Iregister_type(size_t hash_size, unsigned reserved, H5I_free_t free_func)
 
         /* Verify that we found a type to give out */
         if(done == FALSE)
-            HGOTO_ERROR(H5E_RESOURCE, H5E_NOSPACE, H5I_BADID, "Maximum number of ID types exceeded.")
+            HGOTO_ERROR(H5E_ATOM, H5E_NOSPACE, H5I_BADID, "Maximum number of ID types exceeded")
     } /* end else */
 
     /* Allocate new ID class */
@@ -257,7 +258,7 @@ done:
     FUNC_LEAVE_API(ret_value)
 } /* end H5Iregister_type() */
 
-
+
 /*-------------------------------------------------------------------------
  * Function:    H5I_register_type
  *
@@ -272,14 +273,14 @@ done:
 herr_t
 H5I_register_type(const H5I_class_t *cls)
 {
-    H5I_id_type_t *type_ptr = NULL;    /* Ptr to the atomic type*/
+    H5I_id_type_t *type_ptr = NULL;     /* Ptr to the atomic type*/
     herr_t ret_value = SUCCEED;         /* Return value */
 
     FUNC_ENTER_NOAPI(FAIL)
 
     /* Sanity check */
     HDassert(cls);
-    HDassert(cls->type_id > 0 && cls->type_id < H5I_MAX_NUM_TYPES);
+    HDassert(cls->type_id > 0 && (int)cls->type_id < H5I_MAX_NUM_TYPES);
 
     /* Initialize the type */
     if(NULL == H5I_id_type_list_g[cls->type_id]) {
@@ -317,7 +318,7 @@ done:
     FUNC_LEAVE_NOAPI(ret_value)
 } /* end H5I_register_type() */
 
-
+
 /*-------------------------------------------------------------------------
  * Function:    H5Itype_exists
  *
@@ -336,7 +337,10 @@ H5Itype_exists(H5I_type_t type)
     FUNC_ENTER_API(FAIL)
     H5TRACE1("t", "It", type);
 
-    if (type <= H5I_BADID || type >= H5I_next_type)
+    /* Validate parameter */
+    if(H5I_IS_LIB_TYPE(type))
+        HGOTO_ERROR(H5E_ATOM, H5E_BADGROUP, FAIL, "cannot call public function on library type")
+    if (type <= H5I_BADID || (int)type >= H5I_next_type)
         HGOTO_ERROR(H5E_ARGS, H5E_BADRANGE, FAIL, "invalid type number")
 
     if (NULL == H5I_id_type_list_g[type])
@@ -346,7 +350,7 @@ done:
     FUNC_LEAVE_API(ret_value)
 } /* end H5Itype_exists() */
 
-
+
 /*-------------------------------------------------------------------------
  * Function:    H5Inmembers
  *
@@ -378,7 +382,7 @@ H5Inmembers(H5I_type_t type, hsize_t *num_members)
      * the private interface handle it, because the public interface throws
      * an error when the supplied type does not exist.
      */
-    if(type <= H5I_BADID || type >= H5I_next_type)
+    if(type <= H5I_BADID || (int)type >= H5I_next_type)
         HGOTO_ERROR(H5E_ARGS, H5E_BADRANGE, FAIL, "invalid type number")
     if(NULL == H5I_id_type_list_g[type])
         HGOTO_ERROR(H5E_ARGS, H5E_BADRANGE, FAIL, "supplied type does not exist")
@@ -396,7 +400,7 @@ done:
     FUNC_LEAVE_API(ret_value)
 } /* end H5Inmembers() */
 
-
+
 /*-------------------------------------------------------------------------
  * Function:    H5I_nmembers
  *
@@ -407,7 +411,7 @@ done:
  *
  *              Failure:    Negative
  *
- * Programmer:    Robb Matzke
+ * Programmer:  Robb Matzke
  *              Wednesday, March 24, 1999
  *
  *-------------------------------------------------------------------------
@@ -420,7 +424,8 @@ H5I_nmembers(H5I_type_t type)
 
     FUNC_ENTER_NOAPI(FAIL)
 
-    if(type <= H5I_BADID || type >= H5I_next_type)
+    /* Validate parameter */
+    if(type <= H5I_BADID || (int)type >= H5I_next_type)
         HGOTO_ERROR(H5E_ARGS, H5E_BADRANGE, FAIL, "invalid type number")
     if(NULL == (type_ptr = H5I_id_type_list_g[type]) || type_ptr->init_count <= 0)
         HGOTO_DONE(0);
@@ -442,8 +447,8 @@ done:
  *
  * Return:      SUCCEED/FAIL
  *
- * Programmer:    James Laird
- *        Nathaniel Furrer
+ * Programmer:  James Laird
+ *              Nathaniel Furrer
  *              Friday, April 23, 2004
  *
  *-------------------------------------------------------------------------
@@ -465,7 +470,7 @@ done:
     FUNC_LEAVE_API(ret_value)
 } /* end H5Iclear_type() */
 
-
+
 /*-------------------------------------------------------------------------
  * Function:    H5I_clear_type
  *
@@ -474,7 +479,7 @@ done:
  *
  * Return:      SUCCEED/FAIL
  *
- * Programmer:    Robb Matzke
+ * Programmer:  Robb Matzke
  *              Wednesday, March 24, 1999
  *
  *-------------------------------------------------------------------------
@@ -487,7 +492,8 @@ H5I_clear_type(H5I_type_t type, hbool_t force, hbool_t app_ref)
 
     FUNC_ENTER_NOAPI(FAIL)
 
-    if(type <= H5I_BADID || type >= H5I_next_type)
+    /* Validate parameters */
+    if(type <= H5I_BADID || (int)type >= H5I_next_type)
         HGOTO_ERROR(H5E_ARGS, H5E_BADRANGE, FAIL, "invalid type number")
 
     udata.type_ptr = H5I_id_type_list_g[type];
@@ -506,7 +512,7 @@ done:
     FUNC_LEAVE_NOAPI(ret_value)
 } /* end H5I_clear_type() */
 
-
+
 /*-------------------------------------------------------------------------
  * Function:    H5I__clear_type_cb
  *
@@ -529,6 +535,7 @@ H5I__clear_type_cb(void *_id, void H5_ATTR_UNUSED *key, void *_udata)
 
     FUNC_ENTER_STATIC_NOERR
 
+    /* Sanity checks */
     HDassert(id);
     HDassert(udata);
     HDassert(udata->type_ptr);
@@ -538,8 +545,7 @@ H5I__clear_type_cb(void *_id, void H5_ATTR_UNUSED *key, void *_udata)
      */
     if(udata->force || (id->count - (!udata->app_ref * id->app_count)) <= 1) {
         /* Check for a 'free' function and call it, if it exists */
-        /* (Casting away const OK -QAK) */
-        if(udata->type_ptr->cls->free_func && (udata->type_ptr->cls->free_func)((void *)id->obj_ptr) < 0) {
+        if(udata->type_ptr->cls->free_func && (udata->type_ptr->cls->free_func)((void *)id->obj_ptr) < 0) { /* (Casting away const OK -QAK) */
             if(udata->force) {
 #ifdef H5I_DEBUG
                 if(H5DEBUG(I)) {
@@ -572,7 +578,7 @@ H5I__clear_type_cb(void *_id, void H5_ATTR_UNUSED *key, void *_udata)
     FUNC_LEAVE_NOAPI(ret_value)
 } /* end H5I__clear_type_cb() */
 
-
+
 /*-------------------------------------------------------------------------
  * Function:    H5Idestroy_type
  *
@@ -584,8 +590,8 @@ H5I__clear_type_cb(void *_id, void H5_ATTR_UNUSED *key, void *_udata)
  *
  * Return:      SUCCEED/FAIL
  *
- * Programmer:    Nathaniel Furrer
- *        James Laird
+ * Programmer:  Nathaniel Furrer
+ *              James Laird
  *
  *-------------------------------------------------------------------------
  */
@@ -606,7 +612,7 @@ done:
     FUNC_LEAVE_API(ret_value)
 } /* end H5Idestroy_type() */
 
-
+
 /*-------------------------------------------------------------------------
  * Function:    H5I__destroy_type
  *
@@ -617,8 +623,8 @@ done:
  *
  * Return:      SUCCEED/FAIL
  *
- * Programmer:    Nathaniel Furrer
- *        James Laird
+ * Programmer:  Nathaniel Furrer
+ *              James Laird
  *
  *-------------------------------------------------------------------------
  */
@@ -630,7 +636,8 @@ H5I__destroy_type(H5I_type_t type)
 
     FUNC_ENTER_STATIC
 
-    if(type <= H5I_BADID || type >= H5I_next_type)
+    /* Validate parameter */
+    if(type <= H5I_BADID || (int)type >= H5I_next_type)
         HGOTO_ERROR(H5E_ARGS, H5E_BADRANGE, FAIL, "invalid type number")
 
     type_ptr = H5I_id_type_list_g[type];
@@ -657,7 +664,7 @@ done:
     FUNC_LEAVE_NOAPI(ret_value)
 } /* end H5I__destroy_type() */
 
-
+
 /*-------------------------------------------------------------------------
  * Function:    H5Iregister
  *
@@ -685,7 +692,7 @@ done:
     FUNC_LEAVE_API(ret_value)
 } /* end H5Iregister() */
 
-
+
 /*-------------------------------------------------------------------------
  * Function:    H5I_register
  *
@@ -713,7 +720,7 @@ H5I_register(H5I_type_t type, const void *object, hbool_t app_ref)
     FUNC_ENTER_NOAPI(FAIL)
 
     /* Check arguments */
-    if (type <= H5I_BADID || type >= H5I_next_type)
+    if (type <= H5I_BADID || (int)type >= H5I_next_type)
         HGOTO_ERROR(H5E_ARGS, H5E_BADRANGE, H5I_INVALID_HID, "invalid type number")
     type_ptr = H5I_id_type_list_g[type];
     if ((NULL == type_ptr) || (type_ptr->init_count <= 0))
@@ -744,9 +751,9 @@ done:
     FUNC_LEAVE_NOAPI(ret_value)
 } /* end H5I_register() */
 
-
+
 /*-------------------------------------------------------------------------
- * Function:    H5I_register_with_id
+ * Function:    H5I_register_using_existing_id
  *
  * Purpose:     Registers an OBJECT in a TYPE with the supplied ID for it.
  *              This routine will check to ensure the supplied ID is not already
@@ -755,12 +762,16 @@ done:
  *              registered (thus, it is possible to register one object under
  *              multiple IDs).
  *
+ * NOTE:        Intended for use in refresh calls, where we have to close
+ *              and re-open the underlying data, then hook the object back
+ *              up to the original ID.
+ *
  * Return:      SUCCEED/FAIL
  *
  *-------------------------------------------------------------------------
  */
 herr_t
-H5I_register_with_id(H5I_type_t type, const void *object, hbool_t app_ref, hid_t id)
+H5I_register_using_existing_id(H5I_type_t type, void *object, hbool_t app_ref, hid_t existing_id)
 {
     H5I_id_type_t  *type_ptr;               /* ptr to the type                  */
     H5I_id_info_t  *id_ptr;                 /* ptr to the new ID information    */
@@ -772,11 +783,11 @@ H5I_register_with_id(H5I_type_t type, const void *object, hbool_t app_ref, hid_t
     HDassert(object);
 
     /* Make sure ID is not already in use */
-    if(NULL != (id_ptr = H5I__find_id(id)))
+    if(NULL != (id_ptr = H5I__find_id(existing_id)))
         HGOTO_ERROR(H5E_ATOM, H5E_BADRANGE, FAIL, "ID already in use")
 
     /* Make sure type number is valid */
-    if(type <= H5I_BADID || type >= H5I_next_type)
+    if(type <= H5I_BADID || (int)type >= H5I_next_type)
         HGOTO_ERROR(H5E_ARGS, H5E_BADRANGE, FAIL, "invalid type number")
 
     /* Get type pointer from list of types */
@@ -786,7 +797,7 @@ H5I_register_with_id(H5I_type_t type, const void *object, hbool_t app_ref, hid_t
         HGOTO_ERROR(H5E_ATOM, H5E_BADGROUP, FAIL, "invalid type")
 
     /* Make sure requested ID belongs to object's type */
-    if(H5I_TYPE(id) != type)
+    if(H5I_TYPE(existing_id) != type)
         HGOTO_ERROR(H5E_ATOM, H5E_BADRANGE, FAIL, "invalid type for provided ID")
 
     /* Allocate new structure to house this ID */
@@ -794,7 +805,7 @@ H5I_register_with_id(H5I_type_t type, const void *object, hbool_t app_ref, hid_t
         HGOTO_ERROR(H5E_ATOM, H5E_NOSPACE, FAIL, "memory allocation failed")
 
     /* Create the struct & insert requested ID */
-    id_ptr->id          = id;
+    id_ptr->id          = existing_id;
     id_ptr->count       = 1; /* initial reference count*/
     id_ptr->app_count   = !!app_ref;
     id_ptr->obj_ptr     = object;
@@ -806,9 +817,9 @@ H5I_register_with_id(H5I_type_t type, const void *object, hbool_t app_ref, hid_t
 
 done:
     FUNC_LEAVE_NOAPI(ret_value)
-} /* end H5I_register_with_id() */
-
+} /* end H5I_register_using_existing_id() */
 
+
 /*-------------------------------------------------------------------------
  * Function:    H5I_subst
  *
@@ -818,8 +829,8 @@ done:
  *                          with the specified ID.
  *              Failure:    NULL
  *
- * Programmer:    Quincey Koziol
- *        Saturday, February 27, 2010
+ * Programmer:  Quincey Koziol
+ *              Saturday, February 27, 2010
  *
  *-------------------------------------------------------------------------
  */
@@ -827,7 +838,7 @@ void *
 H5I_subst(hid_t id, const void *new_object)
 {
     H5I_id_info_t *id_ptr;      /* Pointer to the atom */
-    void *ret_value = NULL;    /* Return value */
+    void *ret_value = NULL;     /* Return value */
 
     FUNC_ENTER_NOAPI(NULL)
 
@@ -836,8 +847,7 @@ H5I_subst(hid_t id, const void *new_object)
         HGOTO_ERROR(H5E_ATOM, H5E_NOTFOUND, NULL, "can't get ID ref count")
 
     /* Get the old object pointer to return */
-    /* (Casting away const OK -QAK) */
-    ret_value = (void *)id_ptr->obj_ptr;
+    ret_value = (void *)id_ptr->obj_ptr;        /* (Casting away const OK -QAK) */
 
     /* Set the new object pointer for the ID */
     id_ptr->obj_ptr = new_object;
@@ -846,7 +856,7 @@ done:
     FUNC_LEAVE_NOAPI(ret_value)
 } /* end H5I_subst() */
 
-
+
 /*-------------------------------------------------------------------------
  * Function:    H5I_object
  *
@@ -862,7 +872,7 @@ done:
 void *
 H5I_object(hid_t id)
 {
-    H5I_id_info_t    *id_ptr;            /* Pointer to the new atom  */
+    H5I_id_info_t   *id_ptr;            /* Pointer to the new atom  */
     void            *ret_value = NULL;  /* Return value             */
 
     FUNC_ENTER_NOAPI_NOERR
@@ -876,7 +886,7 @@ H5I_object(hid_t id)
     FUNC_LEAVE_NOAPI(ret_value)
 } /* end H5I_object() */
 
-
+
 /*-------------------------------------------------------------------------
  * Function:    H5Iobject_verify
  *
@@ -898,10 +908,10 @@ H5Iobject_verify(hid_t id, H5I_type_t id_type)
     FUNC_ENTER_API(NULL)
     H5TRACE2("*x", "iIt", id, id_type);
 
+    /* Validate parameters */
     if(H5I_IS_LIB_TYPE(id_type))
         HGOTO_ERROR(H5E_ATOM, H5E_BADGROUP, NULL, "cannot call public function on library type")
-
-    if(id_type < 1 || id_type >= H5I_next_type)
+    if(id_type < 1 || (int)id_type >= H5I_next_type)
         HGOTO_ERROR(H5E_ATOM, H5E_BADGROUP, NULL, "identifier has invalid type")
 
     ret_value = H5I_object_verify(id, id_type);
@@ -910,7 +920,7 @@ done:
     FUNC_LEAVE_API(ret_value)
 } /* end H5Iobject_verify() */
 
-
+
 /*-------------------------------------------------------------------------
  * Function:    H5I_object_verify
  *
@@ -921,8 +931,8 @@ done:
  *                          specified ID.
  *              Failure:    NULL
  *
- * Programmer:    Quincey Koziol
- *        Wednesday, July 31, 2002
+ * Programmer:  Quincey Koziol
+ *              Wednesday, July 31, 2002
  *
  *-------------------------------------------------------------------------
  */
@@ -934,7 +944,7 @@ H5I_object_verify(hid_t id, H5I_type_t id_type)
 
     FUNC_ENTER_NOAPI_NOERR
 
-    HDassert(id_type >= 1 && id_type < H5I_next_type);
+    HDassert(id_type >= 1 && (int)id_type < H5I_next_type);
 
     /* Verify that the type of the ID is correct & lookup the ID */
     if(id_type == H5I_TYPE(id) && NULL != (id_ptr = H5I__find_id(id))) {
@@ -945,7 +955,7 @@ H5I_object_verify(hid_t id, H5I_type_t id_type)
     FUNC_LEAVE_NOAPI(ret_value)
 } /* H5I_object_verify() */
 
-
+
 /*-------------------------------------------------------------------------
  * Function:    H5I_get_type
  *
@@ -959,8 +969,8 @@ H5I_object_verify(hid_t id, H5I_type_t id_type)
  *                          ID types).
  *              Failure:    H5I_BADID
  *
- * Programmer:    Robb Matzke
- *        Friday, February 19, 1999
+ * Programmer:  Robb Matzke
+ *              Friday, February 19, 1999
  *
  *-------------------------------------------------------------------------
  */
@@ -974,12 +984,12 @@ H5I_get_type(hid_t id)
     if(id > 0)
         ret_value = H5I_TYPE(id);
 
-    HDassert(ret_value >= H5I_BADID && ret_value < H5I_next_type);
+    HDassert(ret_value >= H5I_BADID && (int)ret_value < H5I_next_type);
 
     FUNC_LEAVE_NOAPI(ret_value)
 } /* end H5I_get_type() */
 
-
+
 /*-------------------------------------------------------------------------
  * Function:    H5Iget_type
  *
@@ -1005,8 +1015,8 @@ H5Iget_type(hid_t id)
 
     ret_value = H5I_get_type(id);
 
-    if(ret_value <= H5I_BADID || ret_value >= H5I_next_type || NULL == H5I_object(id))
-    HGOTO_DONE(H5I_BADID);
+    if(ret_value <= H5I_BADID || (int)ret_value >= H5I_next_type || NULL == H5I_object(id))
+        HGOTO_DONE(H5I_BADID);
 
 done:
     FUNC_LEAVE_API(ret_value)
@@ -1025,8 +1035,8 @@ done:
  *                          calling H5I_object().
  *              Failure:    NULL
  *
- * Programmer:    James Laird
- *        Nathaniel Furrer
+ * Programmer:  James Laird
+ *              Nathaniel Furrer
  *
  *-------------------------------------------------------------------------
  */
@@ -1048,7 +1058,7 @@ done:
     FUNC_LEAVE_API(ret_value)
 } /* end H5Iremove_verify() */
 
-
+
 /*-------------------------------------------------------------------------
  * Function:    H5I__remove_verify
  *
@@ -1060,12 +1070,12 @@ done:
  *                          calling H5I_object().
  *              Failure:    NULL
  *
- * Programmer:    James Laird
- *        Nat Furrer
+ * Programmer:  James Laird
+ *              Nat Furrer
  *
  *-------------------------------------------------------------------------
  */
-void *
+static void *
 H5I__remove_verify(hid_t id, H5I_type_t id_type)
 {
     void * ret_value = NULL;    /*return value            */
@@ -1081,7 +1091,7 @@ H5I__remove_verify(hid_t id, H5I_type_t id_type)
     FUNC_LEAVE_NOAPI(ret_value)
 } /* end H5I__remove_verify() */
 
-
+
 /*-------------------------------------------------------------------------
  * Function:    H5I__remove_common
  *
@@ -1112,8 +1122,7 @@ H5I__remove_common(H5I_id_type_t *type_ptr, hid_t id)
     if(NULL == (curr_id = (H5I_id_info_t *)H5SL_remove(type_ptr->ids, &id)))
         HGOTO_ERROR(H5E_ATOM, H5E_CANTDELETE, NULL, "can't remove ID node from skip list")
 
-    /* (Casting away const OK -QAK) */
-    ret_value = (void *)curr_id->obj_ptr;
+    ret_value = (void *)curr_id->obj_ptr;       /* (Casting away const OK -QAK) */
     curr_id = H5FL_FREE(H5I_id_info_t, curr_id);
 
     /* Decrement the number of IDs in the type */
@@ -1123,7 +1132,7 @@ done:
     FUNC_LEAVE_NOAPI(ret_value)
 } /* end H5I__remove_common() */
 
-
+
 /*-------------------------------------------------------------------------
  * Function:    H5I_remove
  *
@@ -1134,7 +1143,7 @@ done:
  *                          calling H5I_object().
  *              Failure:    NULL
  *
- * Programmer:    Unknown
+ * Programmer:  Unknown
  *
  *-------------------------------------------------------------------------
  */
@@ -1149,7 +1158,7 @@ H5I_remove(hid_t id)
 
     /* Check arguments */
     type = H5I_TYPE(id);
-    if(type <= H5I_BADID || type >= H5I_next_type)
+    if(type <= H5I_BADID || (int)type >= H5I_next_type)
         HGOTO_ERROR(H5E_ARGS, H5E_BADRANGE, NULL, "invalid type number")
     type_ptr = H5I_id_type_list_g[type];
     if(type_ptr == NULL || type_ptr->init_count <= 0)
@@ -1163,7 +1172,7 @@ done:
     FUNC_LEAVE_NOAPI(ret_value)
 } /* end H5I_remove() */
 
-
+
 /*-------------------------------------------------------------------------
  * Function:    H5Idec_ref
  *
@@ -1199,7 +1208,7 @@ done:
     FUNC_LEAVE_API(ret_value)
 } /* end H5Idec_ref() */
 
-
+
 /*-------------------------------------------------------------------------
  * Function:    H5I_dec_ref
  *
@@ -1269,7 +1278,7 @@ done:
     FUNC_LEAVE_NOAPI(ret_value)
 } /* end H5I_dec_ref() */
 
-
+
 /*-------------------------------------------------------------------------
  * Function:    H5I_dec_app_ref
  *
@@ -1317,7 +1326,7 @@ done:
     FUNC_LEAVE_NOAPI(ret_value)
 } /* end H5I_dec_app_ref() */
 
-
+
 /*-------------------------------------------------------------------------
  * Function:    H5I_dec_app_ref_always_close
  *
@@ -1359,7 +1368,7 @@ done:
     FUNC_LEAVE_NOAPI(ret_value)
 } /* end H5I_dec_app_ref_always_close() */
 
-
+
 /*-------------------------------------------------------------------------
  * Function:    H5Iinc_ref
  *
@@ -1390,7 +1399,7 @@ done:
     FUNC_LEAVE_API(ret_value)
 } /* end H5Iinc_ref() */
 
-
+
 /*-------------------------------------------------------------------------
  * Function:    H5I_inc_ref
  *
@@ -1428,7 +1437,7 @@ done:
     FUNC_LEAVE_NOAPI(ret_value)
 } /* end H5I_inc_ref() */
 
-
+
 /*-------------------------------------------------------------------------
  * Function:    H5Iget_ref
  *
@@ -1459,7 +1468,7 @@ done:
     FUNC_LEAVE_API(ret_value)
 } /* end H5Iget_ref() */
 
-
+
 /*-------------------------------------------------------------------------
  * Function:    H5I_get_ref
  *
@@ -1492,7 +1501,7 @@ done:
     FUNC_LEAVE_NOAPI(ret_value)
 } /* end H5I_get_ref() */
 
-
+
 /*-------------------------------------------------------------------------
  * Function:    H5Iinc_type_ref
  *
@@ -1512,9 +1521,8 @@ H5Iinc_type_ref(H5I_type_t type)
     H5TRACE1("Is", "It", type);
 
     /* Check arguments */
-    if (type <= 0 || type >= H5I_next_type)
+    if (type <= 0 || (int)type >= H5I_next_type)
         HGOTO_ERROR(H5E_ATOM, H5E_BADATOM, (-1), "invalid ID type")
-
     if (H5I_IS_LIB_TYPE(type))
         HGOTO_ERROR(H5E_ATOM, H5E_BADGROUP, (-1), "cannot call public function on library type")
 
@@ -1526,7 +1534,7 @@ done:
     FUNC_LEAVE_API(ret_value)
 } /* end H5Iinc_ref() */
 
-
+
 /*-------------------------------------------------------------------------
  * Function:    H5I__inc_type_ref
  *
@@ -1546,7 +1554,7 @@ H5I__inc_type_ref(H5I_type_t type)
     FUNC_ENTER_STATIC
 
     /* Sanity check */
-    HDassert(type > 0 && type < H5I_next_type);
+    HDassert(type > 0 && (int)type < H5I_next_type);
 
     /* Check arguments */
     type_ptr = H5I_id_type_list_g[type];
@@ -1560,14 +1568,14 @@ done:
     FUNC_LEAVE_NOAPI(ret_value)
 } /* end H5I__inc_type_ref() */
 
-
+
 /*-------------------------------------------------------------------------
  * Function:    H5Idec_type_ref
  *
  * Purpose:     Decrements the reference count on an entire type of IDs.
  *              If the type reference count becomes zero then the type is
  *              destroyed along with all atoms in that type regardless of
- *              their reference counts.     Destroying IDs involves calling
+ *              their reference counts.  Destroying IDs involves calling
  *              the free-func for each ID's object and then adding the ID
  *              struct to the ID free list.  Public interface to
  *              H5I_dec_type_ref.
@@ -1602,14 +1610,14 @@ done:
     FUNC_LEAVE_API(ret_value)
 } /* end H5Idec_type_ref() */
 
-
+
 /*-------------------------------------------------------------------------
  * Function:    H5I_dec_type_ref
  *
  * Purpose:     Decrements the reference count on an entire type of IDs.
  *              If the type reference count becomes zero then the type is
  *              destroyed along with all atoms in that type regardless of
- *              their reference counts.     Destroying IDs involves calling
+ *              their reference counts.  Destroying IDs involves calling
  *              the free-func for each ID's object and then adding the ID
  *              struct to the ID free list.
  *              Returns the number of references to the type on success; a
@@ -1630,7 +1638,7 @@ H5I_dec_type_ref(H5I_type_t type)
 
     FUNC_ENTER_NOAPI((-1))
 
-    if (type <= H5I_BADID || type >= H5I_next_type)
+    if (type <= H5I_BADID || (int)type >= H5I_next_type)
         HGOTO_ERROR(H5E_ARGS, H5E_BADRANGE, (-1), "invalid type number")
 
     type_ptr = H5I_id_type_list_g[type];
@@ -1655,7 +1663,7 @@ done:
     FUNC_LEAVE_NOAPI(ret_value)
 } /* end H5I_dec_type_ref() */
 
-
+
 /*-------------------------------------------------------------------------
  * Function:    H5Iget_type_ref
  *
@@ -1675,9 +1683,8 @@ H5Iget_type_ref(H5I_type_t type)
     H5TRACE1("Is", "It", type);
 
     /* Check arguments */
-    if (type <= 0 || type >= H5I_next_type)
+    if (type <= 0 || (int)type >= H5I_next_type)
         HGOTO_ERROR(H5E_ATOM, H5E_BADATOM, (-1), "invalid ID type")
-
     if (H5I_IS_LIB_TYPE(type))
         HGOTO_ERROR(H5E_ATOM, H5E_BADGROUP, (-1), "cannot call public function on library type")
 
@@ -1689,7 +1696,7 @@ done:
     FUNC_LEAVE_API(ret_value)
 } /* end H5Iget_ref() */
 
-
+
 /*-------------------------------------------------------------------------
  * Function:    H5I__get_type_ref
  *
@@ -1724,7 +1731,7 @@ done:
     FUNC_LEAVE_NOAPI(ret_value)
 } /* end H5I__get_type_ref() */
 
-
+
 /*-------------------------------------------------------------------------
  * Function:    H5Iis_valid
  *
@@ -1754,7 +1761,7 @@ done:
     FUNC_LEAVE_API(ret_value)
 } /* end H5Iis_valid() */
 
-
+
 /*-------------------------------------------------------------------------
  * Function:    H5I__search_cb
  *
@@ -1780,7 +1787,7 @@ H5I__search_cb(void *obj, hid_t id, void *_udata)
 
     /* Set the return value based on the callback's return value */
     if(cb_ret_val > 0) {
-        ret_value = H5_ITER_STOP;    /* terminate iteration early */
+        ret_value = H5_ITER_STOP;   /* terminate iteration early */
         udata->ret_obj = obj;       /* also set out parameter */
     }
     else if(cb_ret_val < 0)
@@ -1789,7 +1796,7 @@ H5I__search_cb(void *obj, hid_t id, void *_udata)
     FUNC_LEAVE_NOAPI(ret_value)
 } /* end H5I__search_cb() */
 
-
+
 /*-------------------------------------------------------------------------
  * Function:    H5Isearch
  *
@@ -1873,7 +1880,7 @@ H5I__iterate_cb(void *_item, void H5_ATTR_UNUSED *_key, void *_udata)
 
         /* Set the return value based on the callback's return value */
         if(cb_ret_val > 0)
-            ret_value = H5_ITER_STOP;    /* terminate iteration early */
+            ret_value = H5_ITER_STOP;   /* terminate iteration early */
         else if(cb_ret_val < 0)
             ret_value = H5_ITER_ERROR;  /* indicate failure (which terminates iteration) */
     }
@@ -1881,7 +1888,7 @@ H5I__iterate_cb(void *_item, void H5_ATTR_UNUSED *_key, void *_udata)
     FUNC_LEAVE_NOAPI(ret_value)
 } /* end H5I__iterate_cb() */
 
-
+
 /*-------------------------------------------------------------------------
  * Function:    H5I_iterate
  *
@@ -1955,9 +1962,9 @@ done:
 static H5I_id_info_t *
 H5I__find_id(hid_t id)
 {
-    H5I_type_t        type;            /*ID's type        */
-    H5I_id_type_t    *type_ptr;        /*ptr to the type    */
-    H5I_id_info_t    *ret_value = NULL;    /* Return value */
+    H5I_type_t        type;                 /*ID's type         */
+    H5I_id_type_t    *type_ptr;             /*ptr to the type   */
+    H5I_id_info_t    *ret_value = NULL;     /* Return value     */
 
     FUNC_ENTER_STATIC_NOERR
 
@@ -2024,8 +2031,8 @@ done:
 /*-------------------------------------------------------------------------
  * Function:    H5Iget_file_id
  *
- * Purpose:     The public version of H5I_get_file_id(), obtains the file
- *              ID given an object ID.  User has to close this ID.
+ * Purpose:     Obtains the file ID given an object ID.  The user has to
+ *              close this ID.
  *
  * Return:      Success:    The file ID associated with the object
  *
@@ -2036,10 +2043,10 @@ done:
 hid_t
 H5Iget_file_id(hid_t obj_id)
 {
-    H5I_type_t      type;                           /* ID type */
-    hid_t           ret_value   = H5I_INVALID_HID;  /* Return value */
+    H5I_type_t  type;                           /* ID type */
+    hid_t       ret_value   = H5I_INVALID_HID;  /* Return value */
 
-    FUNC_ENTER_API(FAIL)
+    FUNC_ENTER_API(H5I_INVALID_HID)
     H5TRACE1("i", "i", obj_id);
 
     /* Get object type */
@@ -2128,17 +2135,17 @@ H5I__id_dump_cb(void *_item, void H5_ATTR_UNUSED *_key, void *_udata)
     switch (type) {
         case H5I_GROUP:
         {
-            path = H5G_nameof((H5G_t*)item->obj_ptr);
+            path = H5G_nameof((const H5G_t *)item->obj_ptr);
             break;
         }
         case H5I_DATASET:
         {
-            path = H5D_nameof((H5D_t*)item->obj_ptr);
+            path = H5D_nameof((const H5D_t *)item->obj_ptr);
             break;
         }
         case H5I_DATATYPE:
         {
-            path = H5T_nameof((H5T_t*)item->obj_ptr);
+            path = H5T_nameof((const H5T_t *)item->obj_ptr);
             break;
         }
         case H5I_UNINIT:
diff --git a/src/H5Iprivate.h b/src/H5Iprivate.h
index 25a0572..579d21c 100644
--- a/src/H5Iprivate.h
+++ b/src/H5Iprivate.h
@@ -66,14 +66,7 @@ typedef struct H5I_class_t {
 H5_DLL herr_t H5I_register_type(const H5I_class_t *cls);
 H5_DLL int64_t H5I_nmembers(H5I_type_t type);
 H5_DLL herr_t H5I_clear_type(H5I_type_t type, hbool_t force, hbool_t app_ref);
-H5_DLL hid_t H5I_register(H5I_type_t type, const void *object, hbool_t app_ref);
-H5_DLL herr_t H5I_register_with_id(H5I_type_t type, const void *object, hbool_t app_ref, hid_t id);
-H5_DLL void *H5I_subst(hid_t id, const void *new_object);
-H5_DLL void *H5I_object(hid_t id);
-H5_DLL void *H5I_object_verify(hid_t id, H5I_type_t id_type);
 H5_DLL H5I_type_t H5I_get_type(hid_t id);
-H5_DLL hid_t H5I_get_file_id(hid_t obj_id, H5I_type_t id_type);
-H5_DLL void *H5I_remove(hid_t id);
 H5_DLL herr_t H5I_iterate(H5I_type_t type, H5I_search_func_t func, void *udata, hbool_t app_ref);
 H5_DLL int H5I_get_ref(hid_t id, hbool_t app_ref);
 H5_DLL int H5I_inc_ref(hid_t id, hbool_t app_ref);
@@ -81,6 +74,17 @@ H5_DLL int H5I_dec_ref(hid_t id);
 H5_DLL int H5I_dec_app_ref(hid_t id);
 H5_DLL int H5I_dec_app_ref_always_close(hid_t id);
 H5_DLL int H5I_dec_type_ref(H5I_type_t type);
+H5_DLL hid_t H5I_get_file_id(hid_t obj_id, H5I_type_t id_type);
+
+/* Functions that manipulate objects */
+H5_DLL void *H5I_object(hid_t id);
+H5_DLL void *H5I_object_verify(hid_t id, H5I_type_t id_type);
+H5_DLL void *H5I_remove(hid_t id);
+H5_DLL void *H5I_subst(hid_t id, const void *new_object);
+
+/* ID registration functions */
+H5_DLL hid_t H5I_register(H5I_type_t type, const void *object, hbool_t app_ref);
+H5_DLL herr_t H5I_register_using_existing_id(H5I_type_t type, void *object, hbool_t app_ref, hid_t existing_id);
 
 /* Debugging functions */
 H5_DLL herr_t H5I_dump_ids_for_type(H5I_type_t type);
diff --git a/src/H5Ipublic.h b/src/H5Ipublic.h
index c737bbe..7acca3a 100644
--- a/src/H5Ipublic.h
+++ b/src/H5Ipublic.h
@@ -30,8 +30,8 @@
  * When adding types here, add a section to the 'misc19' test in test/tmisc.c
  * to verify that the H5I{inc|dec|get}_ref() routines work correctly with it.
  *
- * NOTE: H5I_REFERENCE is not used by the library and has been deprecated
- *       with a tentative removal version of 1.12.0. (DER, July 2017)
+ * NOTE: H5I_REFERENCE is not used by the library and was removed
+ *       in HDF5 1.12.0.
  */
 typedef enum H5I_type_t {
     H5I_UNINIT      = (-2),     /* uninitialized type                           */
@@ -66,7 +66,7 @@ typedef int64_t hid_t;
  * can be removed from the ID type. If the function returns negative
  * (failure) then the object will remain in the ID type.
  */
-typedef herr_t (*H5I_free_t)(void*);
+typedef herr_t (*H5I_free_t)(void *);
 
 /* Type of the function to compare objects & keys */
 typedef int (*H5I_search_func_t)(void *obj, hid_t id, void *key);
diff --git a/src/H5Oflush.c b/src/H5Oflush.c
index d8c9530..eeb3040 100644
--- a/src/H5Oflush.c
+++ b/src/H5Oflush.c
@@ -79,7 +79,7 @@ H5Oflush(hid_t obj_id)
 
     /* Set up collective metadata if appropriate */
     if(H5CX_set_loc(obj_id) < 0)
-        HGOTO_ERROR(H5E_DATATYPE, H5E_CANTSET, FAIL, "can't set access property list info")
+        HGOTO_ERROR(H5E_OHDR, H5E_CANTSET, FAIL, "can't set access property list info")
 
     /* Call internal routine */
     if(H5O__flush(obj_id) < 0)
@@ -116,11 +116,11 @@ H5O_flush_common(H5O_loc_t *oloc, hid_t obj_id)
 
     /* Flush metadata based on tag value of the object */
     if(H5F_flush_tagged_metadata(oloc->file, tag) < 0)
-        HGOTO_ERROR(H5E_FILE, H5E_CANTFLUSH, FAIL, "unable to flush tagged metadata")
+        HGOTO_ERROR(H5E_OHDR, H5E_CANTFLUSH, FAIL, "unable to flush tagged metadata")
 
     /* Check to invoke callback */
     if(H5F_object_flush_cb(oloc->file, obj_id) < 0)
-	HGOTO_ERROR(H5E_OHDR, H5E_CANTFLUSH, FAIL, "unable to do object flush callback")
+        HGOTO_ERROR(H5E_OHDR, H5E_CANTFLUSH, FAIL, "unable to do object flush callback")
 
 done:
     FUNC_LEAVE_NOAPI(ret_value)
@@ -219,9 +219,9 @@ done:
 /*-------------------------------------------------------------------------
  * Function:    H5Orefresh
  *
- * Purpose:    Refreshes all buffers associated with an object.
+ * Purpose:     Refreshes all buffers associated with an object.
  *
- * Return:    Non-negative on success, negative on failure
+ * Return:      Non-negative on success, negative on failure
  *
  * Programmer:  Mike McGreevy
  *              July 28, 2010
@@ -231,9 +231,9 @@ done:
 herr_t
 H5Orefresh(hid_t oid)
 {
-    H5O_loc_t *oloc;            /* object location */
-    herr_t ret_value = SUCCEED; /* return value */
-    
+    H5O_loc_t          *oloc;                   /* Object location  */
+    herr_t              ret_value   = SUCCEED;  /* Return value     */
+
     FUNC_ENTER_API(FAIL)
     H5TRACE1("e", "i", oid);
 
@@ -243,7 +243,7 @@ H5Orefresh(hid_t oid)
 
     /* Set up collective metadata if appropriate */
     if(H5CX_set_loc(oid) < 0)
-        HGOTO_ERROR(H5E_DATATYPE, H5E_CANTSET, FAIL, "can't set access property list info")
+        HGOTO_ERROR(H5E_OHDR, H5E_CANTSET, FAIL, "can't set access property list info")
 
     /* Call internal routine */
     if(H5O_refresh_metadata(oid, *oloc) < 0)
@@ -260,11 +260,11 @@ done:
  * Purpose:     Refreshes all buffers associated with an object.
  *
  * Note:	This is based on the original H5O_refresh_metadata() but
- *	        is split into 2 routines.  
+ *	        is split into 2 routines.
  *	        This is done so that H5Fstart_swmr_write() can use these
- *	        2 routines to refresh opened objects.  This may be 
+ *	        2 routines to refresh opened objects.  This may be
  *	        restored back to the original code when H5Fstart_swmr_write()
- *	        uses a different approach to handle issues with opened objects.	
+ *	        uses a different approach to handle issues with opened objects.
  *	 	H5Fstart_swmr_write() no longer calls the 1st routine.	(12/24/15)
  *
  * Return:    	Non-negative on success, negative on failure
@@ -343,7 +343,7 @@ H5O__refresh_metadata_close(hid_t oid, H5O_loc_t oloc, H5G_loc_t *obj_loc)
     herr_t ret_value = SUCCEED; /* Return value */
 
     FUNC_ENTER_STATIC
-    
+
     /* Make deep local copy of object's location information */
     if(obj_loc) {
         H5G_loc_t tmp_loc;
@@ -352,35 +352,35 @@ H5O__refresh_metadata_close(hid_t oid, H5O_loc_t oloc, H5G_loc_t *obj_loc)
         H5G_loc_copy(obj_loc, &tmp_loc, H5_COPY_DEEP);
     } /* end if */
 
-    /* Get object's type */
+    /* Handle close for multiple dataset opens */
     if(H5I_get_type(oid) == H5I_DATASET)
-	if(H5D_mult_refresh_close(oid) < 0)
-	    HGOTO_ERROR(H5E_DATASET, H5E_CANTOPENOBJ, FAIL, "unable to prepare refresh for dataset")
+        if(H5D_mult_refresh_close(oid) < 0)
+            HGOTO_ERROR(H5E_OHDR, H5E_CANTOPENOBJ, FAIL, "unable to prepare refresh for dataset")
 
     /* Retrieve tag for object */
     if(H5O__oh_tag(&oloc, &tag) < 0)
-        HGOTO_ERROR(H5E_DATASET, H5E_CANTFLUSH, FAIL, "unable to get object header address")
+        HGOTO_ERROR(H5E_OHDR, H5E_CANTFLUSH, FAIL, "unable to get object header address")
 
     /* Get cork status of the object with tag */
     if(H5AC_cork(oloc.file, tag, H5AC__GET_CORKED, &corked) < 0)
-        HGOTO_ERROR(H5E_ATOM, H5E_SYSTEM, FAIL, "unable to retrieve an object's cork status")
+        HGOTO_ERROR(H5E_OHDR, H5E_SYSTEM, FAIL, "unable to retrieve an object's cork status")
 
     /* Close the object */
     if(H5I_dec_ref(oid) < 0)
-        HGOTO_ERROR(H5E_DATASET, H5E_CANTINIT, FAIL, "unable to close object")
+        HGOTO_ERROR(H5E_OHDR, H5E_CANTINIT, FAIL, "unable to close object")
 
     /* Flush metadata based on tag value of the object */
     if(H5F_flush_tagged_metadata(oloc.file, tag) < 0)
-        HGOTO_ERROR(H5E_FILE, H5E_CANTFLUSH, FAIL, "unable to flush tagged metadata")
+        HGOTO_ERROR(H5E_OHDR, H5E_CANTFLUSH, FAIL, "unable to flush tagged metadata")
 
     /* Evict the object's tagged metadata */
     if(H5F_evict_tagged_metadata(oloc.file, tag) < 0)
-        HGOTO_ERROR(H5E_FILE, H5E_CANTFLUSH, FAIL, "unable to evict metadata")
+        HGOTO_ERROR(H5E_OHDR, H5E_CANTFLUSH, FAIL, "unable to evict metadata")
 
     /* Re-cork object with tag */
     if(corked)
-	if(H5AC_cork(oloc.file, tag, H5AC__SET_CORK, &corked) < 0)
-	    HGOTO_ERROR(H5E_ATOM, H5E_SYSTEM, FAIL, "unable to cork the object")
+        if(H5AC_cork(oloc.file, tag, H5AC__SET_CORK, &corked) < 0)
+            HGOTO_ERROR(H5E_OHDR, H5E_SYSTEM, FAIL, "unable to cork the object")
 
 done:
     FUNC_LEAVE_NOAPI(ret_value);
@@ -404,12 +404,15 @@ done:
 herr_t
 H5O_refresh_metadata_reopen(hid_t oid, H5G_loc_t *obj_loc, hbool_t start_swmr)
 {
-    void *object = NULL;        /* Dataset for this operation */
+    void *object = NULL;        /* Object for this operation */
     H5I_type_t type;            /* Type of object for the ID */
     herr_t ret_value = SUCCEED; /* Return value */
 
     FUNC_ENTER_NOAPI(FAIL)
 
+    /* Sanity check */
+    HDassert(obj_loc);
+
     /* Get object's type */
     type = H5I_get_type(oid);
 
@@ -417,13 +420,13 @@ H5O_refresh_metadata_reopen(hid_t oid, H5G_loc_t *obj_loc, hbool_t start_swmr)
         case H5I_GROUP:
             /* Re-open the group */
             if(NULL == (object = H5G_open(obj_loc)))
-                HGOTO_ERROR(H5E_SYM, H5E_CANTOPENOBJ, FAIL, "unable to open group")
+                HGOTO_ERROR(H5E_OHDR, H5E_CANTOPENOBJ, FAIL, "unable to open group")
             break;
 
         case H5I_DATATYPE:
             /* Re-open the named datatype */
             if(NULL == (object = H5T_open(obj_loc)))
-                HGOTO_ERROR(H5E_DATATYPE, H5E_CANTOPENOBJ, FAIL, "unable to open named datatype")
+                HGOTO_ERROR(H5E_OHDR, H5E_CANTOPENOBJ, FAIL, "unable to open named datatype")
             break;
 
         case H5I_DATASET:
@@ -432,7 +435,7 @@ H5O_refresh_metadata_reopen(hid_t oid, H5G_loc_t *obj_loc, hbool_t start_swmr)
                 HGOTO_ERROR(H5E_DATASET, H5E_CANTOPENOBJ, FAIL, "unable to open dataset")
             if(!start_swmr) /* No need to handle multiple opens when H5Fstart_swmr_write() */
                 if(H5D_mult_refresh_reopen((H5D_t *)object) < 0)
-                    HGOTO_ERROR(H5E_DATASET, H5E_CANTOPENOBJ, FAIL, "unable to finish refresh for dataset")
+                    HGOTO_ERROR(H5E_OHDR, H5E_CANTOPENOBJ, FAIL, "unable to finish refresh for dataset")
             break;
 
         case H5I_UNINIT:
@@ -449,13 +452,13 @@ H5O_refresh_metadata_reopen(hid_t oid, H5G_loc_t *obj_loc, hbool_t start_swmr)
         case H5I_ERROR_STACK:
         case H5I_NTYPES:
         default:
-            HGOTO_ERROR(H5E_ARGS, H5E_BADTYPE, FAIL, "not a valid file object ID (dataset, group, or datatype)")
+            HGOTO_ERROR(H5E_OHDR, H5E_BADTYPE, FAIL, "not a valid file object ID (dataset, group, or datatype)")
         break;
     } /* end switch */
 
     /* Re-register ID for the object */
-    if((H5I_register_with_id(type, object, TRUE, oid)) < 0)
-        HGOTO_ERROR(H5E_ATOM, H5E_CANTREGISTER, FAIL, "unable to re-register object atom")
+    if((H5I_register_using_existing_id(type, object, TRUE, oid)) < 0)
+        HGOTO_ERROR(H5E_OHDR, H5E_CANTREGISTER, FAIL, "unable to re-register object atom")
 
 done:
     FUNC_LEAVE_NOAPI(ret_value);
diff --git a/src/H5PL.c b/src/H5PL.c
index 8f6ec36..a79dd20 100644
--- a/src/H5PL.c
+++ b/src/H5PL.c
@@ -209,13 +209,13 @@ done:
  *-------------------------------------------------------------------------
  */
 herr_t
-H5PLreplace(const char *search_path, unsigned int index)
+H5PLreplace(const char *search_path, unsigned int idx)
 {
     unsigned    num_paths;              /* Current number of stored paths */
     herr_t      ret_value = SUCCEED;    /* Return value */
 
     FUNC_ENTER_API(FAIL)
-    H5TRACE2("e", "*sIu", search_path, index);
+    H5TRACE2("e", "*sIu", search_path, idx);
 
     /* Check args */
     if (NULL == search_path)
@@ -227,11 +227,11 @@ H5PLreplace(const char *search_path, unsigned int index)
     num_paths = H5PL__get_num_paths();
     if (0 == num_paths)
         HGOTO_ERROR(H5E_ARGS, H5E_BADRANGE, FAIL, "path table is empty")
-    else if (index >= num_paths)
+    else if (idx >= num_paths)
         HGOTO_ERROR(H5E_ARGS, H5E_BADRANGE, FAIL, "index path out of bounds for table - can't be more than %u", (num_paths - 1))
 
     /* Insert the search path into the path table */
-    if (H5PL__replace_path(search_path, index) < 0)
+    if (H5PL__replace_path(search_path, idx) < 0)
         HGOTO_ERROR(H5E_PLUGIN, H5E_CANTINSERT, FAIL, "unable to replace search path")
 
 done:
@@ -251,13 +251,13 @@ done:
  *-------------------------------------------------------------------------
  */
 herr_t
-H5PLinsert(const char *search_path, unsigned int index)
+H5PLinsert(const char *search_path, unsigned int idx)
 {
     unsigned    num_paths;              /* Current number of stored paths */
     herr_t      ret_value = SUCCEED;    /* Return value */
 
     FUNC_ENTER_API(FAIL)
-    H5TRACE2("e", "*sIu", search_path, index);
+    H5TRACE2("e", "*sIu", search_path, idx);
 
     /* Check args */
     if (NULL == search_path)
@@ -267,11 +267,11 @@ H5PLinsert(const char *search_path, unsigned int index)
 
     /* Check index */
     num_paths = H5PL__get_num_paths();
-    if ((0 != num_paths) && (index >= num_paths))
+    if ((0 != num_paths) && (idx >= num_paths))
         HGOTO_ERROR(H5E_ARGS, H5E_BADRANGE, FAIL, "index path out of bounds for table - can't be more than %u", (num_paths - 1))
 
     /* Insert the search path into the path table */
-    if (H5PL__insert_path(search_path, index) < 0)
+    if (H5PL__insert_path(search_path, idx) < 0)
         HGOTO_ERROR(H5E_PLUGIN, H5E_CANTINSERT, FAIL, "unable to insert search path")
 
 done:
@@ -293,23 +293,23 @@ done:
  *-------------------------------------------------------------------------
  */
 herr_t
-H5PLremove(unsigned int index)
+H5PLremove(unsigned int idx)
 {
     unsigned    num_paths;              /* Current number of stored paths */
     herr_t      ret_value = SUCCEED;    /* Return value */
 
     FUNC_ENTER_API(FAIL)
-    H5TRACE1("e", "Iu", index);
+    H5TRACE1("e", "Iu", idx);
 
     /* Check index */
     num_paths = H5PL__get_num_paths();
     if (0 == num_paths)
         HGOTO_ERROR(H5E_ARGS, H5E_BADRANGE, FAIL, "path table is empty")
-    else if (index >= num_paths)
+    else if (idx >= num_paths)
         HGOTO_ERROR(H5E_ARGS, H5E_BADRANGE, FAIL, "index path out of bounds for table - can't be more than %u", (num_paths - 1))
 
     /* Delete the search path from the path table */
-    if (H5PL__remove_path(index) < 0)
+    if (H5PL__remove_path(idx) < 0)
         HGOTO_ERROR(H5E_PLUGIN, H5E_CANTDELETE, FAIL, "unable to remove search path")
 
 done:
@@ -342,7 +342,7 @@ done:
  *-------------------------------------------------------------------------
  */
 ssize_t
-H5PLget(unsigned int index, char *path_buf, size_t buf_size)
+H5PLget(unsigned int idx, char *path_buf, size_t buf_size)
 {
     unsigned    num_paths;              /* Current number of stored paths */
     const char *path = NULL;            /* path from table */
@@ -350,13 +350,13 @@ H5PLget(unsigned int index, char *path_buf, size_t buf_size)
     ssize_t     ret_value = 0;          /* Return value */
 
     FUNC_ENTER_API(FAIL)
-    H5TRACE3("Zs", "Iu*sz", index, path_buf, buf_size);
+    H5TRACE3("Zs", "Iu*sz", idx, path_buf, buf_size);
 
     /* Check index */
     num_paths = H5PL__get_num_paths();
     if (0 == num_paths)
         HGOTO_ERROR(H5E_ARGS, H5E_BADRANGE, FAIL, "path table is empty")
-    else if (index >= num_paths)
+    else if (idx >= num_paths)
         HGOTO_ERROR(H5E_ARGS, H5E_BADRANGE, FAIL, "index path out of bounds for table - can't be more than %u", (num_paths - 1))
 
     /* Check if the search table is empty */
@@ -364,7 +364,7 @@ H5PLget(unsigned int index, char *path_buf, size_t buf_size)
         HGOTO_ERROR(H5E_PLUGIN, H5E_NOSPACE, (-1), "plugin search path table is empty")
 
     /* Get the path at the specified index and its length */
-    if (NULL == (path = H5PL__get_path(index)))
+    if (NULL == (path = H5PL__get_path(idx)))
         HGOTO_ERROR(H5E_PLUGIN, H5E_BADVALUE, (-1), "no path stored at that index")
     path_len = HDstrlen(path);
 
diff --git a/src/H5PLint.c b/src/H5PLint.c
index 8b649d2..4aa04e1 100644
--- a/src/H5PLint.c
+++ b/src/H5PLint.c
@@ -300,8 +300,7 @@ done:
  *       get_plugin_info function pointer, but early (4.4.7, at least) gcc
  *       only allows diagnostic pragmas to be toggled outside of functions.
  */
-#pragma GCC diagnostic push
-#pragma GCC diagnostic ignored "-Wpedantic"
+H5_GCC_DIAG_OFF(pedantic)
 herr_t
 H5PL__open(const char *path, H5PL_type_t type, H5PL_key_t key, hbool_t *success, const void **plugin_info)
 {
@@ -329,7 +328,7 @@ H5PL__open(const char *path, H5PL_type_t type, H5PL_key_t key, hbool_t *success,
     }
 
     /* Return a handle for the function H5PLget_plugin_info in the dynamic library.
-     * The plugin library is suppose to define this function.
+     * The plugin library is supposed to define this function.
      */
     if (NULL == (get_plugin_info = (H5PL_get_plugin_info_t)H5PL_GET_LIB_FUNC(handle, "H5PLget_plugin_info")))
         HGOTO_DONE(SUCCEED)
@@ -370,7 +369,7 @@ done:
 
     FUNC_LEAVE_NOAPI(ret_value)
 } /* end H5PL__open() */
-#pragma GCC diagnostic pop
+H5_GCC_DIAG_ON(pedantic)
 
 
 /*-------------------------------------------------------------------------
diff --git a/src/H5Z.c b/src/H5Z.c
index e418f7e..93d7df9 100644
--- a/src/H5Z.c
+++ b/src/H5Z.c
@@ -43,10 +43,10 @@ typedef struct H5Z_stats_t {
 #endif /* H5Z_DEBUG */
 
 typedef struct H5Z_object_t {
-    H5Z_filter_t filter_id;     /* ID of the filter we're looking for */
-    htri_t      found;          /* Whether we find an object using the filter */
+    H5Z_filter_t    filter_id;      /* ID of the filter we're looking for */
+    htri_t          found;          /* Whether we find an object using the filter */
 #ifdef H5_HAVE_PARALLEL
-    hbool_t     sanity_checked; /* Whether the sanity check for collectively calling H5Zunregister has been done */
+    hbool_t         sanity_checked; /* Whether the sanity check for collectively calling H5Zunregister has been done */
 #endif /* H5_HAVE_PARALLEL */
 } H5Z_object_t;
 
@@ -215,8 +215,10 @@ herr_t
 H5Zregister(const void *cls)
 {
     const H5Z_class2_t  *cls_real = (const H5Z_class2_t *) cls; /* "Real" class pointer */
-    H5Z_class2_t        cls_new;                  /* Translated class struct */
     herr_t              ret_value = SUCCEED;      /* Return value */
+#ifndef H5_NO_DEPRECATED_SYMBOLS
+    H5Z_class2_t        cls_new;    /* Translated class struct */
+#endif
 
     FUNC_ENTER_API(FAIL)
     H5TRACE1("e", "*x", cls);
@@ -339,12 +341,12 @@ done:
 
 
 /*-------------------------------------------------------------------------
- * Function: H5Zunregister
+ * Function:    H5Zunregister
  *
- * Purpose:  This function unregisters a filter.
+ * Purpose:     This function unregisters a filter.
  *
- * Return:   Non-negative on success
- *           Negative on failure
+ * Return:      Non-negative on success
+ *              Negative on failure
  *-------------------------------------------------------------------------
  */
 herr_t
@@ -371,13 +373,13 @@ done:
 
 
 /*-------------------------------------------------------------------------
- * Function: H5Z__unregister
+ * Function:    H5Z__unregister
  *
- * Purpose:  Same as the public version except this one allows filters
- *           to be unset for predefined method numbers <H5Z_FILTER_RESERVED
+ * Purpose:     Same as the public version except this one allows filters
+ *               to be unset for predefined method numbers <H5Z_FILTER_RESERVED
  *
- * Return:   Non-negative on success
- *           Negative on failure
+ * Return:      Non-negative on success
+ *              Negative on failure
  *-------------------------------------------------------------------------
  */
 herr_t
@@ -401,10 +403,10 @@ H5Z__unregister(H5Z_filter_t filter_id)
         HGOTO_ERROR(H5E_PLINE, H5E_NOTFOUND, FAIL, "filter is not registered")
 
     /* Initialize the structure object for iteration */
-    object.filter_id = filter_id;
-    object.found = FALSE;
+    object.filter_id        = filter_id;
+    object.found            = FALSE;
 #ifdef H5_HAVE_PARALLEL
-    object.sanity_checked = FALSE;
+    object.sanity_checked   = FALSE;
 #endif /* H5_HAVE_PARALLEL */
 
     /* Iterate through all opened datasets, returns a failure if any of them uses the filter */
@@ -439,12 +441,14 @@ done:
 
 
 /*-------------------------------------------------------------------------
- * Function: H5Z__check_unregister
+ * Function:    H5Z__check_unregister
+ *
+ * Purpose:     Check if an object uses the filter to be unregistered.
  *
- * Purpose: Check if an object uses the filter to be unregistered.
+ * Return:      TRUE if the object uses the filter
+ *              FALSE if not
+ *              NEGATIVE on error
  *
- * Return:  TRUE if the object uses the filter.
- *          FALSE if not, NEGATIVE on error.
  *-------------------------------------------------------------------------
  */
 static htri_t
@@ -469,15 +473,17 @@ done:
 
 
 /*-------------------------------------------------------------------------
- * Function: H5Z__check_unregister_group_cb
+ * Function:    H5Z__check_unregister_group_cb
+ *
+ * Purpose:     The callback function for H5Z__unregister. It iterates
+ *              through all opened objects.  If the object is a dataset
+ *              or a group and it uses the filter to be unregistered, the
+ *              function returns TRUE.
  *
- * Purpose:  The callback function for H5Z__unregister. It iterates
- *           through all opened objects.  If the object is a dataset
- *           or a group and it uses the filter to be unregistered, the
- *           function returns TRUE.
+ * Return:      TRUE if the object uses the filter
+ *              FALSE if not
+ *              NEGATIVE on error
  *
- * Return:   TRUE if the object uses the filter.
- *           FALSE otherwise.
  *-------------------------------------------------------------------------
  */
 static int
@@ -506,7 +512,7 @@ H5Z__check_unregister_group_cb(void *obj_ptr, hid_t H5_ATTR_UNUSED obj_id, void
     if (filter_in_pline) {
         object->found = TRUE;
         ret_value = TRUE;
-    } /* end if */
+    }
 
 done:
     if (ocpl_id > 0)
@@ -518,15 +524,17 @@ done:
 
 
 /*-------------------------------------------------------------------------
- * Function: H5Z__check_unregister_dset_cb
+ * Function:    H5Z__check_unregister_dset_cb
  *
- * Purpose: The callback function for H5Z__unregister. It iterates
- *          through all opened objects.  If the object is a dataset
- *          or a group and it uses the filter to be unregistered, the
- *          function returns TRUE.
+ * Purpose:     The callback function for H5Z__unregister. It iterates
+ *              through all opened objects.  If the object is a dataset
+ *              or a group and it uses the filter to be unregistered, the
+ *              function returns TRUE.
+ *
+ * Return:      TRUE if the object uses the filter
+ *              FALSE if not
+ *              NEGATIVE on error
  *
- * Return:  TRUE if the object uses the filter.
- *          FALSE otherwise.
  *-------------------------------------------------------------------------
  */
 static int
@@ -555,7 +563,7 @@ H5Z__check_unregister_dset_cb(void *obj_ptr, hid_t H5_ATTR_UNUSED obj_id, void *
     if (filter_in_pline) {
         object->found = TRUE;
         ret_value = TRUE;
-    } /* end if */
+    }
 
 done:
     if (ocpl_id > 0)
@@ -567,27 +575,30 @@ done:
 
 
 /*-------------------------------------------------------------------------
- * Function: H5Z__flush_file_cb
+ * Function:    H5Z__flush_file_cb
  *
- * Purpose:  The callback function for H5Z__unregister. It iterates
- *           through all opened files and flush them.
+ * Purpose:     The callback function for H5Z__unregister. It iterates
+ *              through all opened files and flush them.
  *
- * Return:   FALSE if finishes flushing and moves on
- *           FAIL if there is an error
+ * Return:      NON-NEGATIVE if finishes flushing and moves on
+ *              NEGATIVE if there is an error
  *-------------------------------------------------------------------------
  */
 static int
-H5Z__flush_file_cb(void *obj_ptr, hid_t H5_ATTR_UNUSED obj_id, void *key)
+H5Z__flush_file_cb(void *obj_ptr, hid_t H5_ATTR_UNUSED obj_id,
+    void *key H5_ATTR_PARALLEL_USED)
 {
-    H5F_t *f = (H5F_t *)obj_ptr;        /* File object for operations */
-    H5Z_object_t    *object = (H5Z_object_t *)key;
-    int    ret_value = FALSE;    /* Return value */
+    H5F_t          *f           = (H5F_t *)obj_ptr;     /* File object for operations */
+#ifdef H5_HAVE_PARALLEL
+    H5Z_object_t   *object      = (H5Z_object_t *)key;
+#endif /* H5_HAVE_PARALLEL */
+    int             ret_value   = FALSE;                /* Return value */
 
     FUNC_ENTER_STATIC
 
     /* Sanity checks */
-    HDassert(f);
-    HDassert(object);
+    HDassert(obj_ptr);
+    HDassert(key);
 
     /* Do a global flush if the file is opened for write */
     if(H5F_ACC_RDWR & H5F_INTENT(f)) {
@@ -693,7 +704,7 @@ H5Z_filter_avail(H5Z_filter_t id)
         if (H5Z_register(filter_info) < 0)
             HGOTO_ERROR(H5E_PLINE, H5E_CANTINIT, FAIL, "unable to register loaded filter")
         HGOTO_DONE(TRUE)
-    }
+    } /* end if */
 
 done:
     FUNC_LEAVE_NOAPI(ret_value)
@@ -817,11 +828,11 @@ H5Z_prepare_prelude_callback_dcpl(hid_t dcpl_id, hid_t type_id, H5Z_prelude_type
 
         /* Get dataset creation property list object */
         if (NULL == (dc_plist = (H5P_genplist_t *)H5I_object(dcpl_id)))
-            HGOTO_ERROR (H5E_ARGS, H5E_BADTYPE, FAIL, "can't get dataset creation property list")
+            HGOTO_ERROR(H5E_ARGS, H5E_BADTYPE, FAIL, "can't get dataset creation property list")
 
         /* Peek at the layout information */
         if (H5P_peek(dc_plist, H5D_CRT_LAYOUT_NAME, dcpl_layout) < 0)
-            HGOTO_ERROR (H5E_PLIST, H5E_CANTGET, FAIL, "can't retrieve layout")
+            HGOTO_ERROR(H5E_PLIST, H5E_CANTGET, FAIL, "can't retrieve layout")
 
         /* Check if the dataset is chunked */
         if (H5D_CHUNKED == dcpl_layout->type) {
@@ -829,7 +840,7 @@ H5Z_prepare_prelude_callback_dcpl(hid_t dcpl_id, hid_t type_id, H5Z_prelude_type
 
             /* Get I/O pipeline information */
             if (H5P_peek(dc_plist, H5O_CRT_PIPELINE_NAME, &dcpl_pline) < 0)
-                HGOTO_ERROR (H5E_PLIST, H5E_CANTGET, FAIL, "can't retrieve pipeline filter")
+                HGOTO_ERROR(H5E_PLIST, H5E_CANTGET, FAIL, "can't retrieve pipeline filter")
 
             /* Check if the chunks have filters */
             if (dcpl_pline.nused > 0) {
@@ -846,12 +857,12 @@ H5Z_prepare_prelude_callback_dcpl(hid_t dcpl_id, hid_t type_id, H5Z_prelude_type
                 /* Get ID for dataspace to pass to filter routines */
                 if ((space_id = H5I_register(H5I_DATASPACE, space, FALSE)) < 0) {
                     (void)H5S_close(space);
-                    HGOTO_ERROR (H5E_ATOM, H5E_CANTREGISTER, FAIL, "unable to register dataspace ID")
+                    HGOTO_ERROR(H5E_ATOM, H5E_CANTREGISTER, FAIL, "unable to register dataspace ID")
                 }
 
                 /* Make the callbacks */
                 if (H5Z_prelude_callback(&dcpl_pline, dcpl_id, type_id, space_id, prelude_type) < 0)
-                    HGOTO_ERROR (H5E_PLINE, H5E_CANAPPLY, FAIL, "unable to apply filter")
+                    HGOTO_ERROR(H5E_PLINE, H5E_CANAPPLY, FAIL, "unable to apply filter")
             }
         }
     }
@@ -1519,13 +1530,13 @@ H5Z_delete(H5O_pline_t *pline, H5Z_filter_t filter)
 
     /* if the pipeline has no filters, just return */
     if (pline->nused == 0)
-        HGOTO_DONE (SUCCEED)
+        HGOTO_DONE(SUCCEED)
 
     /* Delete all filters */
     if (H5Z_FILTER_ALL == filter) {
         if (H5O_msg_reset(H5O_PLINE_ID, pline) < 0)
             HGOTO_ERROR(H5E_PLINE, H5E_CANTFREE, FAIL, "can't release pipeline info")
-    } /* end if */
+    }
     /* Delete filter */
     else {
         size_t  idx;             /* Index of filter in pipeline */
@@ -1568,7 +1579,7 @@ H5Z_delete(H5O_pline_t *pline, H5Z_filter_t filter)
         pline->nused--;
 
         /* Reset information for previous last filter in pipeline */
-        HDmemset (&pline->filter[pline->nused], 0, sizeof(H5Z_filter_info_t));
+        HDmemset(&pline->filter[pline->nused], 0, sizeof(H5Z_filter_info_t));
     } /* end else */
 
 done:
@@ -1596,7 +1607,7 @@ H5Zget_filter_info(H5Z_filter_t filter, unsigned int *filter_config_flags)
 
     /* Get the filter info */
     if (H5Z_get_filter_info(filter, filter_config_flags) < 0)
-        HGOTO_ERROR (H5E_PLINE, H5E_CANTGET, FAIL, "Filter info not retrieved")
+        HGOTO_ERROR(H5E_PLINE, H5E_CANTGET, FAIL, "Filter info not retrieved")
 
 done:
     FUNC_LEAVE_API(ret_value)
diff --git a/src/H5Zdeflate.c b/src/H5Zdeflate.c
index 34fdfec..6d7b87e 100644
--- a/src/H5Zdeflate.c
+++ b/src/H5Zdeflate.c
@@ -26,7 +26,7 @@
 
 #ifdef H5_HAVE_FILTER_DEFLATE
 
-#if defined(H5_HAVE_ZLIB_H) && !defined(H5_ZLIB_HEADER) 
+#if defined(H5_HAVE_ZLIB_H) && !defined(H5_ZLIB_HEADER)
 # define H5_ZLIB_HEADER "zlib.h"
 #endif
 #if defined(H5_ZLIB_HEADER)
diff --git a/src/H5Znbit.c b/src/H5Znbit.c
index 2f79725..8c0e876 100644
--- a/src/H5Znbit.c
+++ b/src/H5Znbit.c
@@ -751,7 +751,7 @@ H5Z_set_parms_compound(const H5T_t *type, unsigned *cd_values_index,
                     H5_CHECK_OVERFLOW(dtype_member_offset, size_t, unsigned);
                     H5_CHECK_OVERFLOW(dtype_next_member_offset, size_t, unsigned);
                     cd_values[(*cd_values_index)++] = (unsigned)dtype_next_member_offset - (unsigned)dtype_member_offset;
-                } 
+                }
                 break;
 
             case H5T_TIME:
diff --git a/src/H5Zscaleoffset.c b/src/H5Zscaleoffset.c
index d3e8fc0..7bdc283 100644
--- a/src/H5Zscaleoffset.c
+++ b/src/H5Zscaleoffset.c
@@ -482,23 +482,23 @@ H5Z_class2_t H5Z_SCALEOFFSET[1] = {{
    if(sizeof(type) == sizeof(int))                                                    \
       for(i = 0; i < d_nelmts; i++) {                                                 \
          if(abs_fun(buf[i] - filval) < pow_fun(10.0f, (type)-D_val))                  \
-            *(int *)&buf[i] = (int)(((unsigned int)1 << *minbits) - 1);               \
+            *(int *)((void *)&buf[i]) = (int)(((unsigned int)1 << *minbits) - 1);               \
          else                                                                         \
-            *(int *)&buf[i] = (int)lround_fun(buf[i] * pow_fun(10.0f, (type)D_val) - min * pow_fun(10.0f, (type)D_val));  \
+            *(int *)((void *)&buf[i]) = (int)lround_fun(buf[i] * pow_fun(10.0f, (type)D_val) - min * pow_fun(10.0f, (type)D_val));  \
       }                                                                               \
    else if(sizeof(type) == sizeof(long))                                              \
       for(i = 0; i < d_nelmts; i++) {                                                 \
          if(abs_fun(buf[i] - filval) < pow_fun(10.0f, (type)-D_val))                  \
-            *(long *)&buf[i] = (long)(((unsigned long)1 << *minbits) - 1);            \
+            *(long *)((void *)&buf[i]) = (long)(((unsigned long)1 << *minbits) - 1);            \
          else                                                                         \
-            *(long *)&buf[i] = lround_fun(buf[i] * pow_fun(10.0f, (type)D_val) - min * pow_fun(10.0f, (type)D_val)); \
+            *(long *)((void *)&buf[i]) = lround_fun(buf[i] * pow_fun(10.0f, (type)D_val) - min * pow_fun(10.0f, (type)D_val)); \
       }                                                                               \
    else if(sizeof(type) == sizeof(long long))                                         \
       for(i = 0; i < d_nelmts; i++) {                                                 \
          if(abs_fun(buf[i] - filval) < pow_fun(10.0f, (type)-D_val))                  \
-            *(long long *)&buf[i] = (long long)(((unsigned long long)1 << *minbits) - 1); \
+            *(long long *)((void *)&buf[i]) = (long long)(((unsigned long long)1 << *minbits) - 1); \
          else                                                                         \
-            *(long long *)&buf[i] = llround_fun(buf[i] * pow_fun(10.0f, (type)D_val) - min * pow_fun(10.0f, (type)D_val)); \
+            *(long long *)((void *)&buf[i]) = llround_fun(buf[i] * pow_fun(10.0f, (type)D_val) - min * pow_fun(10.0f, (type)D_val)); \
       }                                                                               \
    else                                                                               \
       HGOTO_ERROR(H5E_PLINE, H5E_BADTYPE, FAIL, "cannot find matched integer dataype") \
@@ -509,13 +509,13 @@ H5Z_class2_t H5Z_SCALEOFFSET[1] = {{
 {                                                                                     \
    if(sizeof(type) == sizeof(int))                                                    \
       for(i = 0; i < d_nelmts; i++)                                                   \
-         *(int *)&buf[i] = (int)lround_fun(buf[i] * pow_fun(10.0f, (type)D_val) - min * pow_fun(10.0f, (type)D_val));     \
+         *(int *)((void *)&buf[i]) = (int)lround_fun(buf[i] * pow_fun(10.0f, (type)D_val) - min * pow_fun(10.0f, (type)D_val));     \
    else if(sizeof(type) == sizeof(long))                                              \
       for(i = 0; i < d_nelmts; i++)                                                   \
-         *(long *)&buf[i] = lround_fun(buf[i] * pow_fun(10.0f, (type)D_val) - min * pow_fun(10.0f, (type)D_val));    \
+         *(long *)((void *)&buf[i]) = lround_fun(buf[i] * pow_fun(10.0f, (type)D_val) - min * pow_fun(10.0f, (type)D_val));    \
    else if(sizeof(type) == sizeof(long long))                                         \
       for(i = 0; i < d_nelmts; i++)                                                   \
-         *(long long *)&buf[i] = llround_fun(buf[i] * pow_fun(10.0f, (type)D_val) - min * pow_fun(10.0f, (type)D_val)); \
+         *(long long *)((void *)&buf[i]) = llround_fun(buf[i] * pow_fun(10.0f, (type)D_val) - min * pow_fun(10.0f, (type)D_val)); \
    else                                                                               \
       HGOTO_ERROR(H5E_PLINE, H5E_BADTYPE, FAIL, "cannot find matched integer dataype") \
 }
@@ -619,16 +619,16 @@ H5Z_class2_t H5Z_SCALEOFFSET[1] = {{
 {                                                                                         \
    if(sizeof(type) == sizeof(int))                                                          \
       for(i = 0; i < d_nelmts; i++)                                                       \
-         buf[i] = (type)((*(int *)&buf[i] == (int)(((unsigned int)1 << minbits) - 1)) ?   \
-                  filval : (type)(*(int *)&buf[i]) / pow_fun(10.0f, (type)D_val) + min);        \
+         buf[i] = (type)((*(int *)((void *)&buf[i]) == (int)(((unsigned int)1 << minbits) - 1)) ?   \
+                  filval : (type)(*(int *)((void *)&buf[i])) / pow_fun(10.0f, (type)D_val) + min);        \
    else if(sizeof(type) == sizeof(long))                                                    \
       for(i = 0; i < d_nelmts; i++)                                                       \
-         buf[i] = (type)((*(long *)&buf[i] == (long)(((unsigned long)1 << minbits) - 1)) ? \
-                  filval : (type)(*(long *)&buf[i]) / pow_fun(10.0f, (type)D_val) + min);       \
+         buf[i] = (type)((*(long *)((void *)&buf[i]) == (long)(((unsigned long)1 << minbits) - 1)) ? \
+                  filval : (type)(*(long *)((void *)&buf[i])) / pow_fun(10.0f, (type)D_val) + min);       \
    else if(sizeof(type) == sizeof(long long))                                               \
       for(i = 0; i < d_nelmts; i++)                                                       \
-         buf[i] = (type)((*(long long *)&buf[i] == (long long)(((unsigned long long)1 << minbits) - 1)) ? \
-                  filval : (type)(*(long long *)&buf[i]) / pow_fun(10.0f, (type)D_val) + min);  \
+         buf[i] = (type)((*(long long *)((void *)&buf[i]) == (long long)(((unsigned long long)1 << minbits) - 1)) ? \
+                  filval : (type)(*(long long *)((void *)&buf[i])) / pow_fun(10.0f, (type)D_val) + min);  \
    else                                                                                   \
       HGOTO_ERROR(H5E_PLINE, H5E_BADTYPE, FAIL, "cannot find matched integer dataype")    \
 }
@@ -638,13 +638,13 @@ H5Z_class2_t H5Z_SCALEOFFSET[1] = {{
 {                                                                                      \
    if(sizeof(type)==sizeof(int))                                                       \
       for(i = 0; i < d_nelmts; i++)                                                    \
-         buf[i] = ((type)(*(int *)&buf[i]) / pow_fun(10.0f, (type)D_val) + min);       \
+         buf[i] = ((type)(*(int *)((void *)&buf[i])) / pow_fun(10.0f, (type)D_val) + min);       \
    else if(sizeof(type)==sizeof(long))                                                 \
       for(i = 0; i < d_nelmts; i++)                                                    \
-         buf[i] = ((type)(*(long *)&buf[i]) / pow_fun(10.0f, (type)D_val) + min);      \
+         buf[i] = ((type)(*(long *)((void *)&buf[i])) / pow_fun(10.0f, (type)D_val) + min);      \
    else if(sizeof(type)==sizeof(long long))                                            \
       for(i = 0; i < d_nelmts; i++)                                                    \
-         buf[i] = ((type)(*(long long *)&buf[i]) / pow_fun(10.0f, (type)D_val) + min); \
+         buf[i] = ((type)(*(long long *)((void *)&buf[i])) / pow_fun(10.0f, (type)D_val) + min); \
    else                                                                                \
       HGOTO_ERROR(H5E_PLINE, H5E_BADTYPE, FAIL, "cannot find matched integer dataype") \
 }
diff --git a/src/H5Zshuffle.c b/src/H5Zshuffle.c
index e70ef33..b1d0722 100644
--- a/src/H5Zshuffle.c
+++ b/src/H5Zshuffle.c
@@ -185,18 +185,25 @@ H5Z_filter_shuffle(unsigned flags, size_t cd_nelmts, const unsigned cd_values[],
                         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:
                             DUFF_GUTS
+                            H5_ATTR_FALLTHROUGH
                     case 1:
                             DUFF_GUTS
                       } while (--duffs_index > 0);
@@ -243,18 +250,25 @@ H5Z_filter_shuffle(unsigned flags, size_t cd_nelmts, const unsigned cd_values[],
                         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:
                             DUFF_GUTS
+                            H5_ATTR_FALLTHROUGH
                     case 1:
                             DUFF_GUTS
                       } while (--duffs_index > 0);