Merge CMake and tools changes from develop

29 files changed, 919 insertions, 903 deletions

diff --git a/tools/src/CMakeLists.txt b/tools/src/CMakeLists.txt
index 757c9cd..8c3e361 100644
--- a/tools/src/CMakeLists.txt
+++ b/tools/src/CMakeLists.txt
@@ -1,4 +1,4 @@
-cmake_minimum_required (VERSION 3.10)
+cmake_minimum_required (VERSION 3.12)
 project (HDF5_TOOLS_SRC C)
 
 #-- Add the h5diff and test executables
diff --git a/tools/src/h5copy/CMakeLists.txt b/tools/src/h5copy/CMakeLists.txt
index 85233ef..29888f2 100644
--- a/tools/src/h5copy/CMakeLists.txt
+++ b/tools/src/h5copy/CMakeLists.txt
@@ -1,4 +1,4 @@
-cmake_minimum_required (VERSION 3.10)
+cmake_minimum_required (VERSION 3.12)
 project (HDF5_TOOLS_SRC_H5COPY C)
 
 # --------------------------------------------------------------------
diff --git a/tools/src/h5copy/h5copy.c b/tools/src/h5copy/h5copy.c
index 9490cd9..e1370e2 100644
--- a/tools/src/h5copy/h5copy.c
+++ b/tools/src/h5copy/h5copy.c
@@ -207,13 +207,12 @@ static int parse_flag(const char* s_flag, unsigned *flag)
 int
 main (int argc, const char *argv[])
 {
-    int            ret_value = 0; /*no need to LEAVE() on ERROR: HERR_INIT(int, SUCCEED) */
     H5E_auto2_t         func;
     H5E_auto2_t         tools_func;
     void               *edata;
     void               *tools_edata;
-    hid_t        fid_src = -1;
-    hid_t        fid_dst = -1;
+    hid_t        fid_src = H5I_INVALID_HID;
+    hid_t        fid_dst = H5I_INVALID_HID;
     unsigned     flag = 0;
     unsigned     verbose = 0;
     unsigned     parents = 0;
@@ -222,6 +221,7 @@ main (int argc, const char *argv[])
     int          opt;
     int          li_ret;
     h5tool_link_info_t linkinfo;
+    int          ret_value = 0;
 
     h5tools_setprogname(PROGRAMNAME);
     h5tools_setstatus(EXIT_SUCCESS);
@@ -394,19 +394,19 @@ main (int argc, const char *argv[])
     *-------------------------------------------------------------------------*/
 
     /* create property to pass copy options */
-    if ( (ocpl_id = H5Pcreate(H5P_OBJECT_COPY)) < 0)
-        HGOTO_ERROR(EXIT_FAILURE, H5E_tools_min_id_g, "H5Pcreate failed");
+    if ((ocpl_id = H5Pcreate(H5P_OBJECT_COPY)) < 0)
+        H5TOOLS_GOTO_ERROR(EXIT_FAILURE, "H5Pcreate failed");
 
     /* set options for object copy */
     if (flag) {
         if ( H5Pset_copy_object(ocpl_id, flag) < 0)
-            HGOTO_ERROR(EXIT_FAILURE, H5E_tools_min_id_g, "H5Pset_copy_object failed");
+            H5TOOLS_GOTO_ERROR(EXIT_FAILURE, "H5Pset_copy_object failed");
     }
 
     /* Create link creation property list */
     if((lcpl_id = H5Pcreate(H5P_LINK_CREATE)) < 0) {
         error_msg("Could not create link creation property list\n");
-        HGOTO_ERROR(EXIT_FAILURE, H5E_tools_min_id_g, "H5Pcreate failed");
+        H5TOOLS_GOTO_ERROR(EXIT_FAILURE, "H5Pcreate failed");
     } /* end if */
 
     /* Check for creating intermediate groups */
@@ -414,7 +414,7 @@ main (int argc, const char *argv[])
         /* Set the intermediate group creation property */
         if(H5Pset_create_intermediate_group(lcpl_id, 1) < 0) {
             error_msg("Could not set property for creating parent groups\n");
-            HGOTO_ERROR(EXIT_FAILURE, H5E_tools_min_id_g, "H5Pset_create_intermediate_group failed");
+            H5TOOLS_GOTO_ERROR(EXIT_FAILURE, "H5Pset_create_intermediate_group failed");
         } /* end if */
 
         /* Display some output if requested */
@@ -438,7 +438,7 @@ main (int argc, const char *argv[])
                 if (H5Lexists(fid_dst, str_ptr, H5P_DEFAULT) <= 0) {
                     error_msg("group <%s> doesn't exist. Use -p to create parent groups.\n", str_ptr);
                     HDfree(str_ptr);
-                    HGOTO_ERROR(EXIT_FAILURE, H5E_tools_min_id_g, "H5Lexists failed");
+                    H5TOOLS_GOTO_ERROR(EXIT_FAILURE, "H5Lexists failed");
                 }
                 HDfree(str_ptr);
             }
@@ -458,7 +458,7 @@ main (int argc, const char *argv[])
         if(H5Lcopy(fid_src, oname_src,
                    fid_dst, oname_dst,
                    H5P_DEFAULT, H5P_DEFAULT) < 0)
-            HGOTO_ERROR(EXIT_FAILURE, H5E_tools_min_id_g, "H5Lcopy failed");
+            H5TOOLS_GOTO_ERROR(EXIT_FAILURE, "H5Lcopy failed");
     }
     else {
         /* valid link */
@@ -468,7 +468,7 @@ main (int argc, const char *argv[])
                   oname_dst,        /* Name of the destination object  */
                   ocpl_id,          /* Object copy property list */
                   lcpl_id)<0)       /* Link creation property list */
-            HGOTO_ERROR(EXIT_FAILURE, H5E_tools_min_id_g, "H5Ocopy failed");
+            H5TOOLS_GOTO_ERROR(EXIT_FAILURE, "H5Ocopy failed");
     }
 
     /* free link info path */
@@ -477,15 +477,15 @@ main (int argc, const char *argv[])
 
     /* close propertis */
     if(H5Pclose(ocpl_id)<0)
-        HGOTO_ERROR(EXIT_FAILURE, H5E_tools_min_id_g, "H5Pclose failed");
+        H5TOOLS_GOTO_ERROR(EXIT_FAILURE, "H5Pclose failed");
     if(H5Pclose(lcpl_id)<0)
-        HGOTO_ERROR(EXIT_FAILURE, H5E_tools_min_id_g, "H5Pclose failed");
+        H5TOOLS_GOTO_ERROR(EXIT_FAILURE, "H5Pclose failed");
 
     /* close files */
     if (H5Fclose(fid_src)<0)
-        HGOTO_ERROR(EXIT_FAILURE, H5E_tools_min_id_g, "H5Fclose failed");
+        H5TOOLS_GOTO_ERROR(EXIT_FAILURE, "H5Fclose failed");
     if (H5Fclose(fid_dst)<0)
-        HGOTO_ERROR(EXIT_FAILURE, H5E_tools_min_id_g, "H5Fclose failed");
+        H5TOOLS_GOTO_ERROR(EXIT_FAILURE, "H5Fclose failed");
 
     leave(EXIT_SUCCESS);
 
diff --git a/tools/src/h5diff/CMakeLists.txt b/tools/src/h5diff/CMakeLists.txt
index 96ed6ad..93e99cf 100644
--- a/tools/src/h5diff/CMakeLists.txt
+++ b/tools/src/h5diff/CMakeLists.txt
@@ -1,4 +1,4 @@
-cmake_minimum_required (VERSION 3.10)
+cmake_minimum_required (VERSION 3.12)
 project (HDF5_TOOLS_SRC_H5DIFF C)
 
 # --------------------------------------------------------------------
@@ -10,6 +10,7 @@ if (NOT ONLY_SHARED_LIBS)
       ${HDF5_TOOLS_SRC_H5DIFF_SOURCE_DIR}/h5diff_main.c
   )
   target_include_directories (h5diff PRIVATE "${HDF5_TOOLS_DIR}/lib;${HDF5_SRC_DIR};${HDF5_BINARY_DIR};$<$<BOOL:${HDF5_ENABLE_PARALLEL}>:${MPI_C_INCLUDE_DIRS}>")
+  #target_compile_definitions (h5diff PRIVATE H5_TOOLS_DEBUG)
   TARGET_C_PROPERTIES (h5diff STATIC)
   target_link_libraries (h5diff PRIVATE ${HDF5_TOOLS_LIB_TARGET} ${HDF5_LIB_TARGET})
   set_target_properties (h5diff PROPERTIES FOLDER tools)
@@ -23,6 +24,7 @@ if (BUILD_SHARED_LIBS)
       ${HDF5_TOOLS_SRC_H5DIFF_SOURCE_DIR}/h5diff_main.c
   )
   target_include_directories (h5diff-shared PRIVATE "${HDF5_TOOLS_DIR}/lib;${HDF5_SRC_DIR};${HDF5_BINARY_DIR};$<$<BOOL:${HDF5_ENABLE_PARALLEL}>:${MPI_C_INCLUDE_DIRS}>")
+  #target_compile_definitions (h5diff-shared PRIVATE H5_TOOLS_DEBUG)
   TARGET_C_PROPERTIES (h5diff-shared SHARED)
   target_link_libraries (h5diff-shared PRIVATE ${HDF5_TOOLS_LIBSH_TARGET} ${HDF5_LIBSH_TARGET})
   set_target_properties (h5diff-shared PROPERTIES FOLDER tools)
diff --git a/tools/src/h5diff/h5diff_common.c b/tools/src/h5diff/h5diff_common.c
index 362e3f2..e05a8e3 100644
--- a/tools/src/h5diff/h5diff_common.c
+++ b/tools/src/h5diff/h5diff_common.c
@@ -302,30 +302,29 @@ void parse_command_line(int argc,
  *
  *-------------------------------------------------------------------------
  */
+void print_info(diff_opt_t* opts)
+{
+    if (opts->m_quiet || opts->err_stat)
+        return;
+
+    if (opts->cmn_objs == 0) {
+        HDprintf("No common objects found. Files are not comparable.\n");
+        if (!opts->m_verbose)
+            HDprintf("Use -v for a list of objects.\n");
+    }
 
- void  print_info(diff_opt_t* opts)
- {
-     if (opts->m_quiet || opts->err_stat)
-         return;
-
-     if (opts->cmn_objs == 0) {
-         HDprintf("No common objects found. Files are not comparable.\n");
-         if (!opts->m_verbose)
-             HDprintf("Use -v for a list of objects.\n");
-     }
-
-     if (opts->not_cmp == 1) {
-         if (opts->m_list_not_cmp == 0) {
-             HDprintf("--------------------------------\n");
-             HDprintf("Some objects are not comparable\n");
-             HDprintf("--------------------------------\n");
-             if (opts->m_verbose)
-                 HDprintf("Use -c for a list of objects without details of differences.\n");
-             else
-                 HDprintf("Use -c for a list of objects.\n");
-         }
-     }
- }
+    if (opts->not_cmp == 1) {
+        if (opts->m_list_not_cmp == 0) {
+            HDprintf("--------------------------------\n");
+            HDprintf("Some objects are not comparable\n");
+            HDprintf("--------------------------------\n");
+            if (opts->m_verbose)
+                HDprintf("Use -c for a list of objects without details of differences.\n");
+            else
+                HDprintf("Use -c for a list of objects.\n");
+        }
+    }
+}
 
 /*-------------------------------------------------------------------------
  * Function: check_n_input
diff --git a/tools/src/h5diff/ph5diff_main.c b/tools/src/h5diff/ph5diff_main.c
index 5ba5fb3..c473c8b 100644
--- a/tools/src/h5diff/ph5diff_main.c
+++ b/tools/src/h5diff/ph5diff_main.c
@@ -166,7 +166,7 @@ ph5diff_worker(int nID)
         {
             struct diff_mpi_args args;
             struct diffs_found  diffs;
-            int i;
+            unsigned i;
 
             /* Make certain we've received the filenames and opened the files already */
             if(file1_id < 0 || file2_id < 0)
diff --git a/tools/src/h5dump/CMakeLists.txt b/tools/src/h5dump/CMakeLists.txt
index 383b04e..104d9b0 100644
--- a/tools/src/h5dump/CMakeLists.txt
+++ b/tools/src/h5dump/CMakeLists.txt
@@ -1,4 +1,4 @@
-cmake_minimum_required (VERSION 3.10)
+cmake_minimum_required (VERSION 3.12)
 project (HDF5_TOOLS_SRC_H5DUMP C)
 
 # --------------------------------------------------------------------
@@ -13,6 +13,7 @@ if (NOT ONLY_SHARED_LIBS)
   target_include_directories (h5dump PRIVATE "${HDF5_TOOLS_DIR}/lib;${HDF5_SRC_DIR};${HDF5_BINARY_DIR};$<$<BOOL:${HDF5_ENABLE_PARALLEL}>:${MPI_C_INCLUDE_DIRS}>")
   TARGET_C_PROPERTIES (h5dump STATIC)
   target_link_libraries (h5dump PRIVATE ${HDF5_TOOLS_LIB_TARGET} ${HDF5_LIB_TARGET})
+  #target_compile_definitions(h5dump PRIVATE H5_TOOLS_DEBUG)
   set_target_properties (h5dump PROPERTIES FOLDER tools)
   set_global_variable (HDF5_UTILS_TO_EXPORT "${HDF5_UTILS_TO_EXPORT};h5dump")
 
@@ -28,6 +29,7 @@ if (BUILD_SHARED_LIBS)
   target_include_directories (h5dump-shared PRIVATE "${HDF5_TOOLS_DIR}/lib;${HDF5_SRC_DIR};${HDF5_BINARY_DIR};$<$<BOOL:${HDF5_ENABLE_PARALLEL}>:${MPI_C_INCLUDE_DIRS}>")
   TARGET_C_PROPERTIES (h5dump-shared SHARED)
   target_link_libraries (h5dump-shared PRIVATE ${HDF5_TOOLS_LIBSH_TARGET} ${HDF5_LIBSH_TARGET})
+  #target_compile_definitions(h5dump-shared PRIVATE H5_TOOLS_DEBUG)
   set_target_properties (h5dump-shared PROPERTIES FOLDER tools)
   set_global_variable (HDF5_UTILS_TO_EXPORT "${HDF5_UTILS_TO_EXPORT};h5dump-shared")
 
diff --git a/tools/src/h5dump/h5dump.c b/tools/src/h5dump/h5dump.c
index 19ed013..731fcd7 100644
--- a/tools/src/h5dump/h5dump.c
+++ b/tools/src/h5dump/h5dump.c
@@ -634,8 +634,7 @@ parse_hsize_list(const char *h_list, subset_d *d)
 /*-------------------------------------------------------------------------
  * Function:    parse_subset_params
  *
- * Purpose:     Parse the so-called "terse" syntax for specifying subsetting
- *              parameters.
+ * Purpose:     Parse the so-called "terse" syntax for specifying subsetting parameters.
  *
  * Return:      Success:    struct subset_t object
  *              Failure:    NULL
@@ -1394,8 +1393,8 @@ error:
 int
 main(int argc, const char *argv[])
 {
-    hid_t               fid = -1;
-    hid_t               gid = -1;
+    hid_t               fid = H5I_INVALID_HID;
+    hid_t               gid = H5I_INVALID_HID;
     hid_t               fapl_id = H5P_DEFAULT;
     H5E_auto2_t         func;
     H5E_auto2_t         tools_func;
@@ -1704,6 +1703,8 @@ main(int argc, const char *argv[])
 
     /* To Do:  clean up XML table */
 
+    H5Eset_auto2(H5E_DEFAULT, func, edata);
+
     leave(h5tools_getstatus());
 
 done:
diff --git a/tools/src/h5dump/h5dump_ddl.c b/tools/src/h5dump/h5dump_ddl.c
index 4fb8398..64ccfe0 100644
--- a/tools/src/h5dump/h5dump_ddl.c
+++ b/tools/src/h5dump/h5dump_ddl.c
@@ -41,11 +41,6 @@ static int      dump_extlink(hid_t group, const char *linkname, const char *objn
  *              atomic datatype or committed/transient datatype.
  *
  * Return:      void
- *
- * Programmer:  Ruey-Hsia Li
- *
- * Modifications:
- *
  *-------------------------------------------------------------------------
  */
 void
@@ -70,11 +65,6 @@ dump_datatype(hid_t type)
  *              array, or others.
  *
  * Return:      void
- *
- * Programmer:  Ruey-Hsia Li
- *
- * Modifications:
- *
  *-------------------------------------------------------------------------
  */
 void
@@ -97,14 +87,7 @@ dump_dataspace(hid_t space)
  * Purpose:     attribute function callback called by H5Aiterate2, displays the attribute
  *
  * Return:      Success:        SUCCEED
- *
  *              Failure:        FAIL
- *
- * Programmer:  Ruey-Hsia Li
- *
- * Modifications: Pedro Vicente, October 4, 2007
- *  Added H5A_info_t parameter to conform with H5Aiterate2
- *
  *-------------------------------------------------------------------------
  */
 herr_t
@@ -120,6 +103,8 @@ dump_attr_cb(hid_t oid, const char *attr_name, const H5A_info_t H5_ATTR_UNUSED *
     HDmemset(&ctx, 0, sizeof(ctx));
     ctx.indent_level = dump_indent / COL;
     ctx.cur_column = dump_indent;
+    ctx.display_index = display_ai;
+    ctx.display_char = display_char;
 
     attr_id = H5Aopen(oid, attr_name, H5P_DEFAULT);
     oid_output = display_oid;
@@ -144,7 +129,7 @@ dump_attr_cb(hid_t oid, const char *attr_name, const H5A_info_t H5_ATTR_UNUSED *
     outputformat = &string_dataformat;
 
     h5dump_type_table = type_table;
-    h5tools_dump_attribute(rawoutstream, outputformat, &ctx, attr_name, attr_id, display_ai, display_char);
+    h5tools_dump_attribute(rawoutstream, outputformat, &ctx, attr_name, attr_id);
     h5dump_type_table = NULL;
 
     if(attr_id < 0) {
@@ -163,18 +148,7 @@ dump_attr_cb(hid_t oid, const char *attr_name, const H5A_info_t H5_ATTR_UNUSED *
  *                displays everything in the specified object
  *
  * Return:      Success:        SUCCEED
- *
  *              Failure:        FAIL
- *
- * Programmer:  Ruey-Hsia Li
- *
- * Modifications:
- *  RMcG, November 2000
- *   Added XML support. Also, optionally checks the op_data argument
- *
- * PVN, May 2008
- *   Dump external links
- *
  *-------------------------------------------------------------------------
  */
 static herr_t
@@ -183,12 +157,12 @@ dump_all_cb(hid_t group, const char *name, const H5L_info_t *linfo, void H5_ATTR
     hid_t       obj;
     hid_t       dapl_id = H5P_DEFAULT;  /* dataset access property list ID */
     herr_t      ret = SUCCEED;
-    char       *obj_path = NULL;    /* Full path of object */
-    h5tools_str_t buffer;          /* string into which to render   */
-    h5tools_context_t ctx;            /* print context  */
+    char       *obj_path = NULL;        /* Full path of object */
+    h5tools_str_t     buffer;           /* string into which to render   */
+    h5tools_context_t ctx;              /* print context  */
     h5tool_format_t  *outputformat = &h5tools_dataformat;
     h5tool_format_t   string_dataformat;
-    hsize_t     curr_pos = 0;        /* total data element position   */
+    hsize_t           curr_pos = 0;     /* total data element position   */
 
     /* setup */
     HDmemset(&buffer, 0, sizeof(h5tools_str_t));
@@ -583,7 +557,6 @@ done:
  * Purpose:     Iterate and display attributes within the specified group
  *
  * Return:      void
- *
  *-------------------------------------------------------------------------
  */
 void
@@ -613,7 +586,6 @@ attr_iteration(hid_t gid, unsigned attr_crt_order_flags)
  * Purpose:     Iterate and display links within the specified group
  *
  * Return:      void
- *
  *-------------------------------------------------------------------------
  */
 void
@@ -634,15 +606,6 @@ link_iteration(hid_t gid, unsigned crt_order_flags)
  * Purpose:     Dump named datatype
  *
  * Return:      void
- *
- * Programmer:  Ruey-Hsia Li
- *
- * Modifications:
- *  Pedro Vicente, March 27, 2006
- *   added display of attributes
- *  Pedro Vicente, October 4, 2007, added parameters to H5Aiterate2() to allow for
- *   other iteration orders
- *
  *-------------------------------------------------------------------------
  */
 void
@@ -650,10 +613,10 @@ dump_named_datatype(hid_t tid, const char *name)
 {
     H5O_info_t        oinfo;
     unsigned          attr_crt_order_flags;
-    hid_t             tcpl_id = -1;  /* datatype creation property list ID */
-    hsize_t           curr_pos = 0;        /* total data element position   */
+    hid_t             tcpl_id = H5I_INVALID_HID;    /* datatype creation property list ID */
+    hsize_t           curr_pos = 0;    /* total data element position   */
     h5tools_str_t     buffer;          /* string into which to render   */
-    h5tools_context_t ctx;            /* print context  */
+    h5tools_context_t ctx;             /* print context  */
     h5tool_format_t  *outputformat = &h5tools_dataformat;
     h5tool_format_t   string_dataformat;
 
@@ -770,16 +733,6 @@ done:
  * Purpose:     Dump everything within the specified group
  *
  * Return:      void
- *
- * Programmer:  Ruey-Hsia Li
- *
- * Modifications:
- *
- * Call to dump_all_cb -- add parameter to select everything.
- *
- * Pedro Vicente, October 1, 2007
- *  handle several iteration orders for attributes and groups
- *
  *-------------------------------------------------------------------------
  */
 void
@@ -792,11 +745,11 @@ dump_group(hid_t gid, const char *name)
     unsigned    crt_order_flags;
     unsigned    attr_crt_order_flags;
     char        type_name[1024];
-    h5tools_str_t buffer;          /* string into which to render   */
-    h5tools_context_t ctx;            /* print context  */
+    h5tools_str_t     buffer;          /* string into which to render   */
+    h5tools_context_t ctx;             /* print context  */
     h5tool_format_t  *outputformat = &h5tools_dataformat;
     h5tool_format_t   string_dataformat;
-    hsize_t     curr_pos = 0;        /* total data element position   */
+    hsize_t           curr_pos = 0;    /* total data element position   */
 
     if ((gcpl_id = H5Gget_create_plist(gid)) < 0) {
         error_msg("error in getting group creation property list ID\n");
@@ -934,14 +887,6 @@ dump_group(hid_t gid, const char *name)
  * Purpose:     Dump the specified data set
  *
  * Return:      void
- *
- * Programmer:  Ruey-Hsia Li
- *
- * Modifications:
- *  Pedro Vicente, 2004, added dataset creation property list display
- *  Pedro Vicente, October 4, 2007, added parameters to H5Aiterate2() to allow for
- *   other  iteration orders
- *
  *-------------------------------------------------------------------------
  */
 void
@@ -950,11 +895,11 @@ dump_dataset(hid_t did, const char *name, struct subset_t *sset)
     h5tools_context_t ctx;            /* print context  */
     h5tool_format_t  *outputformat = &h5tools_dataformat;
     h5tool_format_t   string_dataformat;
-    hid_t       type, space;
-    unsigned    attr_crt_order_flags;
-    hid_t       dcpl_id;  /* dataset creation property list ID */
-    h5tools_str_t buffer;          /* string into which to render   */
-    hsize_t       curr_pos = 0;        /* total data element position   */
+    hid_t         type, space;
+    unsigned      attr_crt_order_flags;
+    hid_t         dcpl_id;           /* dataset creation property list ID */
+    h5tools_str_t buffer;            /* string into which to render   */
+    hsize_t       curr_pos = 0;      /* total data element position   */
 
     HDmemset(&ctx, 0, sizeof(ctx));
     ctx.indent_level = dump_indent / COL;
@@ -1026,6 +971,9 @@ dump_dataset(hid_t did, const char *name, struct subset_t *sset)
     }
     H5Pclose(dcpl_id);
 
+    ctx.sset = sset;
+    ctx.display_index = display_ai;
+    ctx.display_char = display_char;
     if(display_data) {
         unsigned  data_loop = 1;
         unsigned  u;
@@ -1069,7 +1017,7 @@ dump_dataset(hid_t did, const char *name, struct subset_t *sset)
             case H5T_VLEN:
             case H5T_ARRAY:
                 {
-                    h5tools_dump_data(rawoutstream, outputformat, &ctx, did, TRUE, sset, display_ai, display_char);
+                    h5tools_dump_data(rawoutstream, outputformat, &ctx, did, TRUE);
                 }
                 break;
 
@@ -1112,13 +1060,6 @@ dump_dataset(hid_t did, const char *name, struct subset_t *sset)
  * Purpose:     Dump attribute or dataset data
  *
  * Return:      void
- *
- * Programmer:  Ruey-Hsia Li
- *
- * Modifications: pvn, print the matrix indices
- *  Albert Cheng, 2004/11/18
- *  Add --string printing for attributes too.
- *
  *-------------------------------------------------------------------------
  */
 void
@@ -1149,10 +1090,13 @@ dump_data(hid_t obj_id, int obj_data, struct subset_t *sset, int display_index)
     HDmemset(&ctx, 0, sizeof(ctx));
     ctx.indent_level = dump_indent / COL;
     ctx.cur_column = dump_indent;
+    ctx.sset = sset;
+    ctx.display_index = display_index;
+    ctx.display_char = display_char;
 
     if(obj_data == DATASET_DATA)
         print_dataset = TRUE;
-    h5tools_dump_data(rawoutstream, outputformat, &ctx, obj_id, print_dataset, sset, display_index, display_char);
+    h5tools_dump_data(rawoutstream, outputformat, &ctx, obj_id, print_dataset);
 }
 
 
@@ -1162,11 +1106,6 @@ dump_data(hid_t obj_id, int obj_data, struct subset_t *sset, int display_index)
  * Purpose:     prints file creation property list information
  *
  * Return:      void
- *
- * Programmer:  pvn
- *
- * Modifications:
- *
  *-------------------------------------------------------------------------
  */
 void
@@ -1177,9 +1116,9 @@ dump_fcpl(hid_t fid)
     size_t   off_size;  /* size of offsets in the file */
     size_t   len_size;  /* size of lengths in the file */
     H5F_fspace_strategy_t  fs_strategy;  /* file space strategy */
-    hbool_t fs_persist;     /* Persisting free-space or not */
-    hsize_t fs_threshold;       /* free-space section threshold */
-    hsize_t fsp_size;        /* file space page size */
+    hbool_t  fs_persist;    /* Persisting free-space or not */
+    hsize_t  fs_threshold;  /* free-space section threshold */
+    hsize_t  fsp_size;      /* file space page size */
     H5F_info2_t finfo;      /* file information */
 #ifdef SHOW_FILE_DRIVER
     hid_t    fapl;      /* file access property list ID */
@@ -1260,13 +1199,17 @@ dump_fcpl(hid_t fid)
     indentation(dump_indent + COL);
     if(fs_strategy == H5F_FSPACE_STRATEGY_FSM_AGGR) {
         PRINTSTREAM(rawoutstream, "%s %s\n", "FILE_SPACE_STRATEGY", "H5F_FSPACE_STRATEGY_FSM_AGGR");
-    } else if(fs_strategy == H5F_FSPACE_STRATEGY_PAGE) {
+    }
+    else if(fs_strategy == H5F_FSPACE_STRATEGY_PAGE) {
         PRINTSTREAM(rawoutstream, "%s %s\n", "FILE_SPACE_STRATEGY", "H5F_FSPACE_STRATEGY_PAGE");
-    } else if(fs_strategy == H5F_FSPACE_STRATEGY_AGGR) {
+    }
+    else if(fs_strategy == H5F_FSPACE_STRATEGY_AGGR) {
         PRINTSTREAM(rawoutstream, "%s %s\n", "FILE_SPACE_STRATEGY", "H5F_FSPACE_STRATEGY_AGGR");
-    } else if(fs_strategy == H5F_FSPACE_STRATEGY_NONE) {
+    }
+    else if(fs_strategy == H5F_FSPACE_STRATEGY_NONE) {
         PRINTSTREAM(rawoutstream, "%s %s\n", "FILE_SPACE_STRATEGY", "H5F_FSPACE_STRATEGY_NONE");
-    } else
+    }
+    else
         PRINTSTREAM(rawoutstream, "%s %s\n", "FILE_SPACE_STRATEGY", "Unknown strategy");
     indentation(dump_indent + COL);
     PRINTSTREAM(rawoutstream, "%s %s\n","FREE_SPACE_PERSIST", fs_persist ? "TRUE" : "FALSE");
@@ -1295,11 +1238,6 @@ dump_fcpl(hid_t fid)
  * Purpose:     prints all objects
  *
  * Return:      void
- *
- * Programmer:  pvn
- *
- * Modifications:
- *
  *-------------------------------------------------------------------------
  */
 void
@@ -1470,13 +1408,12 @@ lnk_search(const char *path, const H5L_info_t *li, void *_op_data)
  * Purpose:     Handle objects from the command.
  *
  * Return:      void
- *
  *-------------------------------------------------------------------------
  */
 void
 handle_paths(hid_t fid, const char *path_name, void H5_ATTR_UNUSED * data, int H5_ATTR_UNUSED pe, const char H5_ATTR_UNUSED *display_name)
 {
-    hid_t  gid = -1;
+    hid_t  gid = H5I_INVALID_HID;
 
     if((gid = H5Gopen2(fid, "/", H5P_DEFAULT)) < 0) {
         error_msg("unable to open root group\n");
@@ -1525,30 +1462,21 @@ handle_paths(hid_t fid, const char *path_name, void H5_ATTR_UNUSED * data, int H
  * Purpose:     Handle the attributes from the command.
  *
  * Return:      void
- *
- * Programmer:  Bill Wendling
- *              Tuesday, 9. January 2001
- *
- * Modifications:
- *
- * PVN, May 2008
- *   add an extra parameter PE, to allow printing/not printing of error messages
- *
  *-------------------------------------------------------------------------
  */
 void
-handle_attributes(hid_t fid, const char *attr, void H5_ATTR_UNUSED * data, int H5_ATTR_UNUSED pe, const char H5_ATTR_UNUSED *display_name)
+handle_attributes(hid_t fid, const char *attr, void H5_ATTR_UNUSED *data, int H5_ATTR_UNUSED pe, const char H5_ATTR_UNUSED *display_name)
 {
-    hid_t  oid          = -1;
-    hid_t  attr_id      = -1;
+    hid_t  oid          = H5I_INVALID_HID;
+    hid_t  attr_id      = H5I_INVALID_HID;
     char *obj_name      = NULL;
     char *attr_name     = NULL;
     int j;
-    h5tools_str_t buffer;          /* string into which to render   */
-    h5tools_context_t ctx;            /* print context  */
+    h5tools_str_t     buffer;          /* string into which to render   */
+    h5tools_context_t ctx;             /* print context  */
     h5tool_format_t  *outputformat = &h5tools_dataformat;
     h5tool_format_t   string_dataformat;
-    hsize_t     curr_pos = 0;        /* total data element position   */
+    hsize_t           curr_pos = 0;    /* total data element position   */
 
     j = (int)HDstrlen(attr) - 1;
     obj_name = (char *)HDmalloc((size_t)j + 2);
@@ -1574,6 +1502,8 @@ handle_attributes(hid_t fid, const char *attr, void H5_ATTR_UNUSED * data, int H
     HDmemset(&ctx, 0, sizeof(ctx));
     ctx.indent_level = dump_indent / COL;
     ctx.cur_column = dump_indent;
+    ctx.display_index = display_ai;
+    ctx.display_char = display_char;
 
     string_dataformat = *outputformat;
 
@@ -1633,7 +1563,7 @@ handle_attributes(hid_t fid, const char *attr, void H5_ATTR_UNUSED * data, int H
     attr_data_output = display_attr_data;
 
     h5dump_type_table = type_table;
-    h5tools_dump_attribute(rawoutstream, outputformat, &ctx, attr_name, attr_id, display_ai, display_char);
+    h5tools_dump_attribute(rawoutstream, outputformat, &ctx, attr_name, attr_id);
     h5dump_type_table = NULL;
 
     if(attr_id < 0) {
@@ -1671,19 +1601,6 @@ error:
  * Purpose:     Handle the datasets from the command.
  *
  * Return:      void
- *
- * Programmer:  Bill Wendling
- *              Tuesday, 9. January 2001
- *
- * Modifications:
- *  Pedro Vicente, Tuesday, January 15, 2008
- *  check for block overlap\
- *
- *  Pedro Vicente, May 8, 2008
- *   added a flag PE that prints/not prints error messages
- *   added for cases of external links not found, to avoid printing of
- *    objects not found, since external links are dumped on a trial error basis
- *
  *-------------------------------------------------------------------------
  */
 void
@@ -1844,18 +1761,6 @@ handle_datasets(hid_t fid, const char *dset, void *data, int pe, const char *dis
  * Purpose:     Handle the groups from the command.
  *
  * Return:      void
- *
- * Programmer:  Bill Wendling
- *              Tuesday, 9. January 2001
- *
- * Modifications: Pedro Vicente, September 26, 2007
- *  handle creation order
- *
- * Pedro Vicente, May 8, 2008
- *   added a flag PE that prints/not prints error messages
- *   added for cases of external links not found, to avoid printing of
- *    objects not found, since external links are dumped on a trial error basis
- *
  *-------------------------------------------------------------------------
  */
 void
@@ -1900,12 +1805,6 @@ handle_groups(hid_t fid, const char *group, void H5_ATTR_UNUSED *data, int pe, c
  * Purpose:     Handle soft or UD links from the command.
  *
  * Return:      void
- *
- * Programmer:  Bill Wendling
- *              Tuesday, 9. January 2001
- *
- * Modifications:
- *
  *-------------------------------------------------------------------------
  */
 void
@@ -1986,17 +1885,6 @@ handle_links(hid_t fid, const char *links, void H5_ATTR_UNUSED * data, int H5_AT
  * Purpose:     Handle the datatypes from the command.
  *
  * Return:      void
- *
- * Programmer:  Bill Wendling
- *              Tuesday, 9. January 2001
- *
- * Modifications:
- *
- *  Pedro Vicente, May 8, 2008
- *   added a flag PE that prints/not prints error messages
- *   added for cases of external links not found, to avoid printing of
- *    objects not found, since external links are dumped on a trial error basis
- *
  *-------------------------------------------------------------------------
  */
 void
@@ -2061,19 +1949,10 @@ handle_datatypes(hid_t fid, const char *type, void H5_ATTR_UNUSED * data, int pe
 /*-------------------------------------------------------------------------
  * Function:    dump_extlink
  *
- * made by: PVN
- *
  * Purpose:     Dump an external link
- *  Since external links are soft links, they are dumped on a trial error
- *   basis, attempting to dump as a dataset, as a group and as a named datatype
- *   Error messages are supressed
- *
- * Modifications:
- *      Neil Fortner
- *      13 October 2008
- *      Function basically rewritten.  No longer directly opens the target file,
- *      now initializes a new set of tables for the external file.  No longer
- *      dumps on a trial and error basis, but errors are still suppressed.
+ *      Function does not directly open the target file,
+ *      it initializes a new set of tables for the external file.
+ *      Errors are suppressed.
  *
  *-------------------------------------------------------------------------
  */
diff --git a/tools/src/h5dump/h5dump_xml.c b/tools/src/h5dump/h5dump_xml.c
index fdbdd40..ae8b9c7 100644
--- a/tools/src/h5dump/h5dump_xml.c
+++ b/tools/src/h5dump/h5dump_xml.c
@@ -1777,22 +1777,15 @@ xml_dump_dataspace(hid_t space)
  *              the h5tools library.
  *
  * Return:      void
- *
- * Programmer:  REMcG
  *-------------------------------------------------------------------------
  */
 void
-xml_dump_data(hid_t obj_id, int obj_data, struct subset_t H5_ATTR_UNUSED * sset, int H5_ATTR_UNUSED pindex)
+xml_dump_data(hid_t obj_id, int obj_data, struct subset_t H5_ATTR_UNUSED *sset, int H5_ATTR_UNUSED pindex)
 {
-    hid_t               space = -1;
-    hid_t               type = -1;
-    hid_t               p_type = -1;
-    hsize_t             size[64];
-    hsize_t             nelmts = 1;
-    int                 ndims;
-    int                 i;
+    hid_t               space = H5I_INVALID_HID;
+    hid_t               type = H5I_INVALID_HID;
+    hid_t               p_type = H5I_INVALID_HID;
     int                 status = -1;
-    void               *buf = NULL;
     hsize_t             curr_pos = 0;        /* total data element position   */
     h5tools_str_t       buffer;              /* string into which to render   */
     h5tools_context_t   ctx;                 /* print context  */
@@ -1861,7 +1854,7 @@ xml_dump_data(hid_t obj_id, int obj_data, struct subset_t H5_ATTR_UNUSED * sset,
             datactx.need_prefix = TRUE;
             datactx.indent_level = ctx.indent_level;
             datactx.cur_column = ctx.cur_column;
-            status = h5tools_dump_dset(rawoutstream, outputformat, &datactx, obj_id, NULL);
+            status = h5tools_dump_dset(rawoutstream, outputformat, &datactx, obj_id);
         }
     }
     else {
@@ -1881,47 +1874,17 @@ xml_dump_data(hid_t obj_id, int obj_data, struct subset_t H5_ATTR_UNUSED * sset,
             status = xml_print_strs(obj_id, ATTRIBUTE_DATA);
         }
         else {  /* all other data */
-            /* VL data special information */
-            unsigned int vl_data = 0; /* contains VL datatypes */
-
-            p_type = H5Tget_native_type(type, H5T_DIR_DEFAULT);
-
-            /* Check if we have VL data in the dataset's datatype */
-            if (h5tools_detect_vlen(p_type) == TRUE)
-                vl_data = TRUE;
-
-            H5Tclose(type);
-
             space = H5Aget_space(obj_id);
             if(space == H5S_NULL || space == H5S_NO_CLASS) {
                 status = SUCCEED;
             }
             else {
-                ndims = H5Sget_simple_extent_dims(space, size, NULL);
-
-                for (i = 0; i < ndims; i++)
-                    nelmts *= size[i];
-
-                if((buf = HDmalloc((size_t)(nelmts * MAX(H5Tget_size(type), H5Tget_size(p_type))))) == NULL)  {
-                    error_msg("unable to allocate buffer\n");
-                    h5tools_setstatus(EXIT_FAILURE);
-                    status = FAIL;
-                }
-                else {
-                    if (H5Aread(obj_id, p_type, buf) >= 0) {
-                        h5tools_context_t datactx;
-                        HDmemset(&datactx, 0, sizeof(datactx));
-                        datactx.need_prefix = TRUE;
-                        datactx.indent_level = ctx.indent_level;
-                        datactx.cur_column = ctx.cur_column;
-                        status = h5tools_dump_mem(rawoutstream, outputformat, &datactx, obj_id, p_type, space, buf);
-                    }
-                    /* Reclaim any VL memory, if necessary */
-                    if (vl_data)
-                        H5Dvlen_reclaim(p_type, space, H5P_DEFAULT, buf);
-
-                    HDfree(buf);
-                }
+                h5tools_context_t datactx;
+                HDmemset(&datactx, 0, sizeof(datactx));
+                datactx.need_prefix = TRUE;
+                datactx.indent_level = ctx.indent_level;
+                datactx.cur_column = ctx.cur_column;
+                status = h5tools_dump_mem(rawoutstream, outputformat, &datactx, obj_id);
             }
             H5Tclose(p_type);
             H5Sclose(space);
@@ -1981,9 +1944,9 @@ herr_t
 xml_dump_attr(hid_t attr, const char *attr_name, const H5A_info_t H5_ATTR_UNUSED *info,
     void H5_ATTR_UNUSED * op_data)
 {
-    hid_t             attr_id = -1;
-    hid_t             type = -1;
-    hid_t             space = -1;
+    hid_t             attr_id = H5I_INVALID_HID;
+    hid_t             type = H5I_INVALID_HID;
+    hid_t             space = H5I_INVALID_HID;
     H5S_class_t       space_type;
     hsize_t           curr_pos = 0;        /* total data element position   */
     h5tools_str_t     buffer;              /* string into which to render   */
@@ -2818,8 +2781,8 @@ static int
 xml_print_refs(hid_t did, int source)
 {
     herr_t            e;
-    hid_t             type    = -1;
-    hid_t             space   = -1;
+    hid_t             type    = H5I_INVALID_HID;
+    hid_t             space   = H5I_INVALID_HID;
     hssize_t          ssiz    = -1;
     hsize_t           i;
     size_t            tsiz;
@@ -2967,8 +2930,8 @@ static int
 xml_print_strs(hid_t did, int source)
 {
     herr_t            e;
-    hid_t             type    = -1;
-    hid_t             space   = -1;
+    hid_t             type    = H5I_INVALID_HID;
+    hid_t             space   = H5I_INVALID_HID;
     hssize_t          ssiz    = -1;
     htri_t            is_vlstr = FALSE;
     size_t            tsiz    = 0;
@@ -3578,12 +3541,10 @@ xml_dump_fill_value(hid_t dcpl, hid_t type)
  * Purpose:     Dump a description of an HDF5 dataset in XML.
  *
  * Return:      void
- *
- * Programmer:  REMcG
  *-------------------------------------------------------------------------
  */
 void
-xml_dump_dataset(hid_t did, const char *name, struct subset_t H5_ATTR_UNUSED * sset)
+xml_dump_dataset(hid_t did, const char *name, struct subset_t H5_ATTR_UNUSED *sset)
 {
     hid_t               type;
     hid_t               space;
@@ -4154,7 +4115,7 @@ xml_print_enum(hid_t type)
     unsigned char      *value = NULL;   /*value array                    */
     unsigned            nmembs;         /*number of members              */
     hid_t               super;          /*enum base integer type         */
-    hid_t               native = -1;    /*native integer datatype        */
+    hid_t               native = H5I_INVALID_HID;    /*native integer datatype        */
     size_t              dst_size;       /*destination value type size    */
     unsigned            i;              /*miscellaneous counters         */
     size_t              j;
diff --git a/tools/src/h5format_convert/CMakeLists.txt b/tools/src/h5format_convert/CMakeLists.txt
index 540be8c..70c07ee 100644
--- a/tools/src/h5format_convert/CMakeLists.txt
+++ b/tools/src/h5format_convert/CMakeLists.txt
@@ -1,4 +1,4 @@
-cmake_minimum_required (VERSION 3.10)
+cmake_minimum_required (VERSION 3.12)
 project (HDF5_TOOLS_SRC_H5FC C)
 
 # --------------------------------------------------------------------
diff --git a/tools/src/h5import/CMakeLists.txt b/tools/src/h5import/CMakeLists.txt
index dd7921d..a52467e 100644
--- a/tools/src/h5import/CMakeLists.txt
+++ b/tools/src/h5import/CMakeLists.txt
@@ -1,4 +1,4 @@
-cmake_minimum_required (VERSION 3.10)
+cmake_minimum_required (VERSION 3.12)
 project (HDF5_TOOLS_SRC_H5IMPORT C)
 
 # --------------------------------------------------------------------
diff --git a/tools/src/h5import/h5import.c b/tools/src/h5import/h5import.c
index 81f9a32..f87f371 100644
--- a/tools/src/h5import/h5import.c
+++ b/tools/src/h5import/h5import.c
@@ -1428,7 +1428,7 @@ static int processConfigurationFile(char *infile, struct Input *in)
     /* Initialize machine endian */
     volatile uint32_t ibyte=0x01234567;
     /* 0 for big endian, 1 for little endian. */
-    if ((*((uint8_t*)(&ibyte))) == 0x67) {
+    if ((*((volatile uint8_t*)(&ibyte))) == 0x67) {
         if ((kindex = OutputByteOrderStrToInt("LE")) == -1) {
             (void) HDfprintf(stderr, "%s", err11e);
             return (-1);
@@ -4725,15 +4725,15 @@ uint32_t swap_uint32(uint32_t val)
 
 int32_t swap_int32(int32_t val)
 {
-    val = ((val << 8) & 0xFF00FF00) | ((val >> 8) & 0xFF00FF);
+    val = (int32_t)(((uint32_t)(val << 8) & 0xFF00FF00) | ((val >> 8) & 0xFF00FF));
     return (val << 16) | ((val >> 16) & 0xFFFF);
 }
 
 int64_t swap_int64(int64_t val)
 {
-    val = ((val << 8) & 0xFF00FF00FF00FF00ULL) | ((val >> 8) & 0x00FF00FF00FF00FFULL);
-    val = ((val << 16) & 0xFFFF0000FFFF0000ULL) | ((val >> 16) & 0x0000FFFF0000FFFFULL);
-    return (val << 32) | ((val >> 32) & 0xFFFFFFFFULL);
+    val = (int64_t)(((uint64_t)(val << 8) & 0xFF00FF00FF00FF00ULL) | ((uint64_t)(val >> 8) & 0x00FF00FF00FF00FFULL));
+    val = (int64_t)(((uint64_t)(val << 16) & 0xFFFF0000FFFF0000ULL) | ((uint64_t)(val >> 16) & 0x0000FFFF0000FFFFULL));
+    return (int64_t)((uint64_t)(val << 32) | ((uint64_t)(val >> 32) & 0xFFFFFFFFULL));
 }
 
 uint64_t swap_uint64(uint64_t val)
diff --git a/tools/src/h5jam/CMakeLists.txt b/tools/src/h5jam/CMakeLists.txt
index f430417..69d4c4d 100644
--- a/tools/src/h5jam/CMakeLists.txt
+++ b/tools/src/h5jam/CMakeLists.txt
@@ -1,4 +1,4 @@
-cmake_minimum_required (VERSION 3.10)
+cmake_minimum_required (VERSION 3.12)
 project (HDF5_TOOLS_SRC_H5JAM C)
 
 # --------------------------------------------------------------------
diff --git a/tools/src/h5ls/CMakeLists.txt b/tools/src/h5ls/CMakeLists.txt
index f2470fb..7be33b5 100644
--- a/tools/src/h5ls/CMakeLists.txt
+++ b/tools/src/h5ls/CMakeLists.txt
@@ -1,4 +1,4 @@
-cmake_minimum_required (VERSION 3.10)
+cmake_minimum_required (VERSION 3.12)
 project (HDF5_TOOLS_SRC_H5LS C)
 
 #-----------------------------------------------------------------------------
@@ -7,6 +7,7 @@ project (HDF5_TOOLS_SRC_H5LS C)
 if (NOT ONLY_SHARED_LIBS)
   add_executable (h5ls ${HDF5_TOOLS_SRC_H5LS_SOURCE_DIR}/h5ls.c)
   target_include_directories (h5ls PRIVATE "${HDF5_TOOLS_DIR}/lib;${HDF5_SRC_DIR};${HDF5_BINARY_DIR};$<$<BOOL:${HDF5_ENABLE_PARALLEL}>:${MPI_C_INCLUDE_DIRS}>")
+  #target_compile_definitions(h5ls PRIVATE H5_TOOLS_DEBUG)
   TARGET_C_PROPERTIES (h5ls STATIC)
   target_link_libraries (h5ls PRIVATE ${HDF5_TOOLS_LIB_TARGET} ${HDF5_LIB_TARGET})
   set_target_properties (h5ls PROPERTIES FOLDER tools)
@@ -18,6 +19,7 @@ endif ()
 if (BUILD_SHARED_LIBS)
   add_executable (h5ls-shared ${HDF5_TOOLS_SRC_H5LS_SOURCE_DIR}/h5ls.c)
   target_include_directories (h5ls-shared PRIVATE "${HDF5_TOOLS_DIR}/lib;${HDF5_SRC_DIR};${HDF5_BINARY_DIR};$<$<BOOL:${HDF5_ENABLE_PARALLEL}>:${MPI_C_INCLUDE_DIRS}>")
+  #target_compile_definitions(h5ls-shared PRIVATE H5_TOOLS_DEBUG)
   TARGET_C_PROPERTIES (h5ls-shared SHARED)
   target_link_libraries (h5ls-shared PRIVATE ${HDF5_TOOLS_LIBSH_TARGET} ${HDF5_LIBSH_TARGET})
   set_target_properties (h5ls-shared PROPERTIES FOLDER tools)
diff --git a/tools/src/h5ls/h5ls.c b/tools/src/h5ls/h5ls.c
index 3b0001d..eafa592 100644
--- a/tools/src/h5ls/h5ls.c
+++ b/tools/src/h5ls/h5ls.c
@@ -91,7 +91,7 @@ static h5tool_format_t         ls_dataformat = {
         "", /*line_suf */
         "", /*line_sep */
         1, /*line_multi_new */
-        "", /*line_indent */
+        "   ", /*line_indent */
 
         0, /*skip_first */
 
@@ -132,7 +132,6 @@ static hbool_t  no_dangling_link_g = FALSE; /* treat dangling link is error */
 static hbool_t  follow_elink_g = FALSE;   /* follow external links */
 static hbool_t  grp_literal_g = FALSE;    /* list group, not contents */
 static hbool_t  hexdump_g = FALSE;        /* show data as raw hexadecimal */
-static hbool_t  show_errors_g = FALSE;    /* print HDF5 error messages */
 static hbool_t  simple_output_g = FALSE;  /* make output more machine-readable */
 static hbool_t  show_file_name_g = FALSE; /* show file name for full names */
 static hbool_t  no_line_wrap_g = FALSE;   /* show data content without line wrap */
@@ -193,7 +192,7 @@ usage (void)
     PRINTVALSTREAM(rawoutstream, "   --no-dangling-links\n");
     PRINTVALSTREAM(rawoutstream, "                   Must be used with --follow-symlinks option;\n");
     PRINTVALSTREAM(rawoutstream, "                   otherwise, h5ls shows error message and returns an exit\n");
-    PRINTVALSTREAM(rawoutstream, "                   code of 1. \n");
+    PRINTVALSTREAM(rawoutstream, "                   code of 1.\n");
     PRINTVALSTREAM(rawoutstream, "                   Check for any symbolic links (soft links or external links)\n");
     PRINTVALSTREAM(rawoutstream, "                   that do not resolve to an existing object (dataset, group,\n");
     PRINTVALSTREAM(rawoutstream, "                   or named datatype).\n");
@@ -883,7 +882,7 @@ print_enum_type(h5tools_str_t *buffer, hid_t type, int ind)
     if (nmembs > 0) {
         char        **name;         /* member names */
         unsigned char *value;       /* value array */
-        hid_t       native = -1;    /* native integer data type */
+        hid_t       native = H5I_INVALID_HID;    /* native integer data type */
         size_t      dst_size;       /* destination value type size */
         unsigned    i;              /* miscellaneous counters */
 
@@ -918,6 +917,7 @@ print_enum_type(h5tools_str_t *buffer, hid_t type, int ind)
                     H5free_memory(name[i]);
                 HDfree(name);
                 HDfree(value);
+                H5Tclose(super);
 
                 return FALSE;
             }
@@ -1285,6 +1285,58 @@ print_type(h5tools_str_t *buffer, hid_t type, int ind)
     h5tools_str_append(buffer,"%lu-byte class-%u unknown", (unsigned long)H5Tget_size(type), (unsigned)data_class);
 }
 
+/*
+ *
+ */
+static void
+dump_reference(FILE *stream, const h5tool_format_t *info, h5tools_context_t *ctx, hid_t container, void *ref_buf, int ndims)
+{
+    hid_t               f_type = H5I_INVALID_HID;
+    size_t              nsize;
+    hsize_t             elmt_counter = 0;  /*counts the # elements printed. */
+    size_t              ncols = 80;        /* available output width        */
+    int                 i;
+    hsize_t             curr_pos = 0;      /* total data element position   */
+    h5tools_str_t       buffer;            /* string into which to render   */
+    h5tools_context_t   datactx;           /* print context  */
+    unsigned char *mem = (unsigned char*) ref_buf;
+
+    H5TOOLS_START_DEBUG("");
+
+    f_type = H5Dget_type(container);
+    nsize = H5Tget_size(f_type);
+    datactx = *ctx;  /* print context  */
+    /* Assume entire data space to be printed */
+    if (datactx.ndims > 0)
+        for (i = 0; (unsigned)i < datactx.ndims; i++)
+            datactx.p_min_idx[i] = 0;
+    datactx.need_prefix = TRUE;
+
+    HDmemset(&buffer, 0, sizeof(h5tools_str_t));
+    for(i = 0; i < ndims; i++, datactx.cur_elmt++, elmt_counter++) {
+        void* memref = mem + i * nsize;
+
+        H5TOOLS_DEBUG("reference loop:%d with curr_pos=%ld", i, curr_pos);
+
+        datactx.need_prefix = TRUE;
+        h5tools_str_reset(&buffer);
+        h5tools_str_sprint(&buffer, info, container, f_type, memref, &datactx);
+        h5tools_render_element(stream, info, &datactx, &buffer, &curr_pos, (size_t)ncols, (hsize_t)i, (hsize_t)ndims);
+
+        datactx.indent_level++;
+        h5tools_dump_dset(stream, info, &datactx, container);
+        datactx.indent_level--;
+
+        H5TOOLS_DEBUG("finished reference loop:%d",i);
+    } /* end for(i = 0; i < ndims; i++, ctx->cur_elmt++, elmt_counter++) */
+
+    h5tools_str_close(&buffer);
+    H5Tclose(f_type);
+
+    PRINTVALSTREAM(stream, "\n");
+
+    H5TOOLS_ENDDEBUG("");
+}
 
 /*-------------------------------------------------------------------------
  * Function:    dump_dataset_values
@@ -1297,6 +1349,11 @@ print_type(h5tools_str_t *buffer, hid_t type, int ind)
 static void
 dump_dataset_values(hid_t dset)
 {
+    hid_t               f_type = H5I_INVALID_HID;
+    hid_t               space = H5I_INVALID_HID;
+    hsize_t             total_size[H5S_MAX_RANK];
+    int                 ndims;
+    size_t              i;
     char                string_prefix[64];
     static char         fmt_double[16];
     static char         fmt_float[16];
@@ -1306,16 +1363,18 @@ dump_dataset_values(hid_t dset)
     h5tool_format_t     outputformat;
     h5tool_format_t    *info = &ls_dataformat;
 
-    hid_t  f_type = H5Dget_type(dset);
-    size_t  size = H5Tget_size(f_type);
+    H5TOOLS_START_DEBUG("");
+
+    f_type = H5Dget_type(dset);
+    space = H5Dget_space(dset);
 
     HDmemset(&ctx, 0, sizeof(ctx));
     HDmemset(&buffer, 0, sizeof(h5tools_str_t));
 
     outputformat = *info;
     outputformat.line_1st  = NULL;
+    outputformat.idx_fmt = "";
     if (simple_output_g) {
-        outputformat.idx_fmt = "";
         outputformat.line_per_line = 1;
         outputformat.line_multi_new = 0;
         outputformat.line_pre  = "        ";
@@ -1345,9 +1404,10 @@ dump_dataset_values(hid_t dset)
         else {
             outputformat.line_ncols = (unsigned)width_g;
         }
-        if (label_g) outputformat.cmpd_name = "%s=";
+        if (label_g)
+            outputformat.cmpd_name = "%s=";
         outputformat.line_pre  = "        %s ";
-        outputformat.line_cont = "        %s  ";
+        outputformat.line_cont = "        %s ";
         outputformat.str_repeat = 8;
 
         outputformat.arr_pre = NULL;
@@ -1375,7 +1435,7 @@ dump_dataset_values(hid_t dset)
          * command line switch was given. */
         outputformat.raw = TRUE;
     }
-    else if (string_g && 1 == size && H5T_INTEGER == H5Tget_class(f_type)) {
+    else if (string_g && H5Tget_size(f_type) == 1 && (H5Tget_class(f_type) == H5T_INTEGER)) {
         /* Print 1-byte integer data as an ASCI character string instead of
          * integers if the `-s' or `--string' command-line option was given. */
         outputformat.ascii = TRUE;
@@ -1387,29 +1447,174 @@ dump_dataset_values(hid_t dset)
     }
     info = &outputformat;
 
-    ctx.indent_level = 2;
+    ctx.indent_level = 1;
     ctx.cur_column = (size_t)curr_pos;
     /* Print all the values. */
     h5tools_str_reset(&buffer);
     h5tools_str_append(&buffer, "    Data:\n");
+
     h5tools_render_element(rawoutstream, info, &ctx, &buffer, &curr_pos, (size_t)info->line_ncols, (hsize_t)0, (hsize_t)0);
+
     ctx.need_prefix = TRUE;
     ctx.cur_column = (size_t)curr_pos;
-    if (h5tools_dump_dset(rawoutstream, info, &ctx, dset, NULL) < 0) {
+    if (h5tools_dump_dset(rawoutstream, info, &ctx, dset) < 0) {
         h5tools_str_reset(&buffer);
         h5tools_str_append(&buffer, "        Unable to print data.");
         h5tools_render_element(rawoutstream, info, &ctx, &buffer, &curr_pos, (size_t)info->line_ncols, (hsize_t)0, (hsize_t)0);
     }
-
+done:
+    H5Sclose(space);
     H5Tclose(f_type);
 
     h5tools_str_close(&buffer);
 
     PRINTVALSTREAM(rawoutstream, "\n");
+
+    H5TOOLS_ENDDEBUG("");
 }
 
 
 /*-------------------------------------------------------------------------
+ * Function:    dump_attribute_values
+ *
+ * Purpose:     Prints all values of a attribute.
+ *
+ * Return:      void
+ *-------------------------------------------------------------------------
+ */
+static void
+dump_attribute_values(hid_t attr)
+{
+    hid_t               f_type = H5I_INVALID_HID;
+    hid_t               space = H5I_INVALID_HID;
+    hsize_t             total_size[H5S_MAX_RANK];
+    int                 ndims;
+    size_t              i;
+    char                string_prefix[64];
+    static char         fmt_double[16];
+    static char         fmt_float[16];
+    hsize_t             curr_pos = 0;    /* total data element position   */
+    h5tools_str_t       buffer;          /* string into which to render   */
+    h5tools_context_t   ctx;             /* print context  */
+    h5tool_format_t     outputformat;
+    h5tool_format_t    *info = &ls_dataformat;
+
+    H5TOOLS_START_DEBUG("");
+
+    f_type = H5Aget_type(attr);
+    space = H5Aget_space(attr);
+
+    HDmemset(&ctx, 0, sizeof(ctx));
+    HDmemset(&buffer, 0, sizeof(h5tools_str_t));
+
+    outputformat = *info;
+    outputformat.line_1st  = NULL;
+    outputformat.idx_fmt = "";
+    if (simple_output_g) {
+        outputformat.line_per_line = 1;
+        outputformat.line_multi_new = 0;
+        outputformat.line_pre  = "        ";
+        outputformat.line_cont = "        ";
+
+        outputformat.arr_pre = "";
+        outputformat.arr_suf = "";
+        outputformat.arr_sep = " ";
+
+        if (!label_g) {
+            outputformat.cmpd_pre = "";
+            outputformat.cmpd_suf = "";
+        }
+        outputformat.cmpd_sep = " ";
+
+        if (label_g)
+            outputformat.cmpd_name = "%s=";
+
+        outputformat.elmt_suf1 = " ";
+        outputformat.str_locale = ESCAPE_HTML;
+
+    }
+    else {
+        if (no_line_wrap_g) {
+            outputformat.line_per_line = 1;
+        }
+        else {
+            outputformat.line_ncols = (unsigned)width_g;
+        }
+        if (label_g)
+            outputformat.cmpd_name = "%s=";
+        outputformat.line_pre  = "        %s ";
+        outputformat.line_cont = "        %s  ";
+        outputformat.str_repeat = 8;
+
+        outputformat.arr_pre = NULL;
+        outputformat.arr_suf = NULL;
+        outputformat.arr_sep = NULL;
+
+        outputformat.cmpd_pre = NULL;
+        outputformat.cmpd_suf = NULL;
+        outputformat.cmpd_sep = NULL;
+
+        outputformat.vlen_sep = NULL;
+        outputformat.vlen_pre = NULL;
+        outputformat.vlen_suf = NULL;
+        outputformat.vlen_end = NULL;
+    }
+    outputformat.arr_linebreak = 0;
+    /* Floating point types should display full precision */
+    HDsnprintf(fmt_float, sizeof(fmt_float), "%%1.%dg", FLT_DIG);
+    outputformat.fmt_float = fmt_float;
+    HDsnprintf(fmt_double, sizeof(fmt_double), "%%1.%dg", DBL_DIG);
+    outputformat.fmt_double = fmt_double;
+
+    if (hexdump_g) {
+        /* Print all data in hexadecimal format if the `-x' or `--hexdump'
+         * command line switch was given. */
+        outputformat.raw = TRUE;
+    }
+    else if (string_g && H5Tget_size(f_type) == 1 && (H5Tget_class(f_type) == H5T_INTEGER)) {
+        /* Print 1-byte integer data as an ASCI character string instead of
+         * integers if the `-s' or `--string' command-line option was given. */
+        outputformat.ascii = TRUE;
+        outputformat.elmt_suf1 = "";
+        outputformat.elmt_suf2 = "";
+        HDsnprintf(string_prefix, sizeof(string_prefix), "%s\"", outputformat.line_pre);
+        outputformat.line_pre = string_prefix;
+        outputformat.line_suf = "\"";
+    }
+    info = &outputformat;
+
+    ctx.indent_level = 2;
+    ctx.cur_column = (size_t)curr_pos;
+
+    /* Print all the values. */
+    h5tools_str_reset(&buffer);
+    h5tools_str_append(&buffer, "        Data:\n");
+
+    h5tools_render_element(rawoutstream, info, &ctx, &buffer, &curr_pos, (size_t)info->line_ncols, (hsize_t)0, (hsize_t)0);
+
+    ctx.need_prefix = TRUE;
+    ctx.cur_column = (size_t)curr_pos;
+    H5TOOLS_DEBUG("Attribute data read");
+    ctx.indent_level++;
+    if (h5tools_dump_mem(rawoutstream, info, &ctx, attr) < 0) {
+        h5tools_str_reset(&buffer);
+        h5tools_str_append(&buffer, "        Unable to print data.");
+        h5tools_render_element(rawoutstream, info, &ctx, &buffer, &curr_pos, (size_t)info->line_ncols, (hsize_t)0, (hsize_t)0);
+    }
+    ctx.indent_level--;
+    H5TOOLS_DEBUG("Attribute data read complete");
+done:
+    H5Sclose(space);
+    H5Tclose(f_type);
+
+    h5tools_str_close(&buffer);
+
+    PRINTVALSTREAM(rawoutstream, "\n");
+
+    H5TOOLS_ENDDEBUG("");
+}
+
+/*-------------------------------------------------------------------------
  * Function:    list_attr
  *
  * Purpose:     Prints information about attributes.
@@ -1425,36 +1630,38 @@ list_attr(hid_t obj, const char *attr_name, const H5A_info_t H5_ATTR_UNUSED *ain
     hid_t               attr = H5I_INVALID_HID;
     hid_t               space = H5I_INVALID_HID;
     hid_t               type = H5I_INVALID_HID;
-    hid_t               p_type = H5I_INVALID_HID;
     hsize_t             size[H5S_MAX_RANK];
     hsize_t             nelmts = 1;
-    hsize_t             temp_need;
-    size_t              need;
     int                 ndims;
     int                 i;
-    void               *buf;
     H5S_class_t         space_type;
     hsize_t             curr_pos = 0;        /* total data element position   */
     h5tools_str_t       buffer;          /* string into which to render   */
     h5tools_context_t   ctx;             /* print context  */
     h5tool_format_t    *info = &ls_dataformat;
-    h5tool_format_t     outputformat;
+
+    H5TOOLS_START_DEBUG("");
 
     HDmemset(&ctx, 0, sizeof(ctx));
     HDmemset(&buffer, 0, sizeof(h5tools_str_t));
 
+    ctx.indent_level = 2;
+    ctx.cur_column = (size_t)curr_pos;
+
     h5tools_str_reset(&buffer);
     h5tools_str_append(&buffer, "    Attribute: ");
 
     print_string(&buffer, attr_name, TRUE);
 
-    if ((attr = H5Aopen(obj, attr_name, H5P_DEFAULT))) {
+    H5TOOLS_DEBUG("Attribute name:%s", attr_name);
+    if ((attr = H5Aopen(obj, attr_name, H5P_DEFAULT)) >= 0) {
         space = H5Aget_space(attr);
         type = H5Aget_type(attr);
 
         /* Data space */
         ndims = H5Sget_simple_extent_dims(space, size, NULL);
         space_type = H5Sget_simple_extent_type(space);
+        H5TOOLS_DEBUG("Attribute ndims:%d", ndims);
         switch(space_type) {
             case H5S_SCALAR:
                 /* scalar dataspace */
@@ -1489,100 +1696,25 @@ list_attr(hid_t obj, const char *attr_name, const H5A_info_t H5_ATTR_UNUSED *ain
 
         /* Data type */
         h5tools_str_reset(&buffer);
-        h5tools_str_append(&buffer, "        Type:      ");
+        h5tools_str_append(&buffer, "        %-10s ", "Type:");
         print_type(&buffer, type, 15);
         h5tools_str_append(&buffer, "\n");
         h5tools_render_element(rawoutstream, info, &ctx, &buffer, &curr_pos, (size_t)info->line_ncols, (hsize_t)0, (hsize_t)0);
 
-        /* Data */
-        outputformat = *info;
-
-        if (nelmts < 5) {
-            outputformat.idx_fmt = "";
-            outputformat.line_1st  = "        Data:  ";
-            outputformat.line_pre  = "               ";
-            outputformat.line_cont = "                ";
-            outputformat.str_repeat = 8;
-
-        }
-        else {
-            h5tools_str_reset(&buffer);
-            h5tools_str_append(&buffer, "        Data:\n");
-            h5tools_render_element(rawoutstream, info, &ctx, &buffer, &curr_pos, (size_t)info->line_ncols, (hsize_t)0, (hsize_t)0);
-            outputformat.line_1st  = NULL;
-            outputformat.line_pre  = "            %s ";
-            outputformat.line_cont = "            %s  ";
-            outputformat.str_repeat = 8;
-        }
-
-        outputformat.line_ncols = (unsigned)width_g;
-        if (label_g)
-            outputformat.cmpd_name = "%s=";
-        if (string_g && 1 == H5Tget_size(type) && H5T_INTEGER == H5Tget_class(type)) {
-            outputformat.ascii = TRUE;
-            outputformat.elmt_suf1 = "";
-            outputformat.elmt_suf2 = "";
-            outputformat.line_pre = "            %s \"";
-            outputformat.line_suf = "\"";
-        } /* end if */
-
-
-        outputformat.arr_pre = NULL;
-        outputformat.arr_suf = NULL;
-        outputformat.arr_sep = NULL;
-
-        outputformat.cmpd_pre = NULL;
-        outputformat.cmpd_suf = NULL;
-        outputformat.cmpd_sep = NULL;
-
-        outputformat.vlen_sep = NULL;
-        outputformat.vlen_pre = NULL;
-        outputformat.vlen_suf = NULL;
-        outputformat.vlen_end = NULL;
-
-        info = &outputformat;
-
-        if (space_type != H5S_NULL && space_type != H5S_NO_CLASS) {
-            if (hexdump_g)
-                p_type = H5Tcopy(type);
-            else
-                p_type = H5Tget_native_type(type, H5T_DIR_DEFAULT);
-
-            if (p_type >= 0) {
-                /* VL data special information */
-                unsigned int        vl_data = 0; /* contains VL datatypes */
-
-                /* Check if we have VL data in the dataset's datatype */
-                if (h5tools_detect_vlen(p_type) == TRUE)
-                    vl_data = TRUE;
-
-                temp_need = nelmts * MAX(H5Tget_size(type), H5Tget_size(p_type));
-                need = (size_t)temp_need;
-                if((buf = HDmalloc(need)) != NULL) {
-                    if(H5Aread(attr, p_type, buf) >= 0) {
-                        ctx.need_prefix = TRUE;
-                        ctx.indent_level = 2;
-                        ctx.cur_column = (size_t)curr_pos;
-                        h5tools_dump_mem(rawoutstream, info, &ctx, attr, p_type, space, buf);
-                    }
-
-                    /* Reclaim any VL memory, if necessary */
-                    if (vl_data)
-                        H5Dvlen_reclaim(p_type, space, H5P_DEFAULT, buf);
-
-                    HDfree(buf);
-                }
-                H5Tclose(p_type);
-            } /* end if */
-        }
-
         H5Sclose(space);
         H5Tclose(type);
+
+        h5tools_str_close(&buffer);
+
+        if (data_g)
+            dump_attribute_values(attr);
         H5Aclose(attr);
     }
-    h5tools_str_close(&buffer);
-
-    PRINTVALSTREAM(rawoutstream, "\n");
+    else {
+        H5TOOLS_DEBUG("Attribute open failed");
+        h5tools_str_close(&buffer);
+    }
+    H5TOOLS_ENDDEBUG("");
 
     return 0;
 }
@@ -1796,7 +1928,7 @@ dataset_list2(hid_t dset, const char H5_ATTR_UNUSED *name)
             break;
 
         case H5T_REFERENCE:
-            if (H5Tequal(type, H5T_STD_REF_DSETREG)) {
+            if (H5Tequal(dset, H5T_STD_REF_DSETREG)) {
                 h5tools_str_append(&buffer, "information not available");
             }
             break;
@@ -1835,8 +1967,10 @@ dataset_list2(hid_t dset, const char H5_ATTR_UNUSED *name)
                 h5tools_str_append(&buffer, "}\n");
             } /* end for */
         } /* end if */
+        h5tools_render_element(rawoutstream, info, &ctx, &buffer, &curr_pos, (size_t)info->line_ncols, (hsize_t)0, (hsize_t)0);
 
         /* Print data type */
+        h5tools_str_reset(&buffer);
         h5tools_str_append(&buffer, "    %-10s ", "Type:");
         print_type(&buffer, type, 15);
         h5tools_str_append(&buffer, "\n");
@@ -1915,11 +2049,14 @@ list_obj(const char *name, const H5O_info_t *oinfo, const char *first_seen, void
     h5tools_context_t   ctx;             /* print context  */
     h5tool_format_t    *info = &ls_dataformat;
 
+    H5TOOLS_START_DEBUG("");
+
     HDmemset(&ctx, 0, sizeof(ctx));
     HDmemset(&buffer, 0, sizeof(h5tools_str_t));
 
     h5tools_str_reset(&buffer);
 
+    H5TOOLS_DEBUG("Object name:%s", name);
     /* Print the link's name, either full name or base name */
     if (!iter->symlink_target)
         print_obj_name(&buffer, iter, name, "");
@@ -1951,6 +2088,7 @@ list_obj(const char *name, const H5O_info_t *oinfo, const char *first_seen, void
         /* Open the object.  Not all objects can be opened.  If this is the case
          * then return right away.
          */
+        H5TOOLS_DEBUG("Open object name=%s", name);
         if (obj_type >= 0 && (obj = H5Oopen(iter->fid, name, H5P_DEFAULT)) < 0) {
             h5tools_str_reset(&buffer);
             h5tools_str_append(&buffer, " *ERROR*\n");
@@ -1959,6 +2097,7 @@ list_obj(const char *name, const H5O_info_t *oinfo, const char *first_seen, void
         } /* end if */
 
         /* List the first line of information for the object. */
+        H5TOOLS_DEBUG("Object type:%d", obj_type);
         if (obj_type >= 0 && dispatch_g[obj_type].list1)
             (dispatch_g[obj_type].list1)(obj);
         if (!iter->symlink_target || (verbose_g > 0)) {
@@ -1975,6 +2114,7 @@ list_obj(const char *name, const H5O_info_t *oinfo, const char *first_seen, void
             ssize_t cmt_bufsize = -1;
 
             /* Display attributes */
+            H5TOOLS_DEBUG("Display attributes");
             if (obj_type >= 0)
                 H5Aiterate2(obj, H5_INDEX_NAME, H5_ITER_INC, NULL, list_attr, NULL);
 
@@ -2042,6 +2182,8 @@ done:
     }
     h5tools_str_close(&buffer);
 
+    H5TOOLS_ENDDEBUG("");
+
     return 0;
 } /* end list_obj() */
 
@@ -2435,7 +2577,7 @@ leave(int ret)
 int
 main(int argc, const char *argv[])
 {
-    hid_t       file = H5I_INVALID_HID;
+    hid_t       file_id = H5I_INVALID_HID;
     char       *fname = NULL, *oname = NULL, *x;
     const char *s = NULL;
     char       *rest;
@@ -2445,6 +2587,10 @@ main(int argc, const char *argv[])
     const char *preferred_driver = NULL;
     int         err_exit = 0;
     hid_t       fapl_id = H5P_DEFAULT;
+    H5E_auto2_t         func;
+    H5E_auto2_t         tools_func;
+    void               *edata;
+    void               *tools_edata;
 
 #ifdef H5_HAVE_ROS3_VFD
     /* default "anonymous" s3 configuration */
@@ -2472,9 +2618,17 @@ main(int argc, const char *argv[])
     h5tools_setprogname(PROGRAMNAME);
     h5tools_setstatus(EXIT_SUCCESS);
 
+    /* Disable error reporting */
+    H5Eget_auto2(H5E_DEFAULT, &func, &edata);
+    H5Eset_auto2(H5E_DEFAULT, NULL, NULL);
+
     /* Initialize h5tools lib */
     h5tools_init();
 
+    /* Disable tools error reporting */
+    H5Eget_auto2(H5tools_ERR_STACK_g, &tools_func, &tools_edata);
+    H5Eset_auto2(H5tools_ERR_STACK_g, NULL, NULL);
+
     /* Build object display table */
     DISPATCH(H5O_TYPE_GROUP, "Group", NULL, NULL);
     DISPATCH(H5O_TYPE_DATASET, "Dataset", dataset_list1, dataset_list2);
@@ -2501,11 +2655,11 @@ main(int argc, const char *argv[])
             data_g = TRUE;
         }
         else if (!HDstrcmp(argv[argno], "--enable-error-stack")) {
-            show_errors_g = TRUE;
+            enable_error_stack = 1;
         /* deprecated --errors */
         }
         else if (!HDstrcmp(argv[argno], "--errors")) {
-            show_errors_g = TRUE;
+            enable_error_stack = 1;
         }
         else if (!HDstrcmp(argv[argno], "--follow-symlinks")) {
             follow_symlink_g = TRUE;
@@ -2754,7 +2908,7 @@ main(int argc, const char *argv[])
 
                     /* deprecated -e */
                     case 'e': /* --errors */
-                        show_errors_g = TRUE;
+                        enable_error_stack = 1;
                         break;
 
                     case 'E': /* --external */
@@ -2862,10 +3016,10 @@ main(int argc, const char *argv[])
         }
     } /* preferred_driver defined */
 
-    /* Turn off HDF5's automatic error printing unless you're debugging h5ls */
-    if(!show_errors_g)
-        H5Eset_auto2(H5E_DEFAULT, NULL, NULL);
-
+    if (enable_error_stack > 0) {
+        H5Eset_auto2(H5E_DEFAULT, func, edata);
+        H5Eset_auto2(H5tools_ERR_STACK_g, tools_func, tools_edata);
+    }
 
     /* Each remaining argument is an hdf5 file followed by an optional slash
      * and object name.
@@ -2888,17 +3042,17 @@ main(int argc, const char *argv[])
 
         fname = HDstrdup(argv[argno++]);
         oname = NULL;
-        file = -1;
+        file_id = H5I_INVALID_HID;
 
         while (fname && *fname) {
             if (fapl_id != H5P_DEFAULT) {
-                file = H5Fopen(fname, H5F_ACC_RDONLY, fapl_id);
+                file_id = H5Fopen(fname, H5F_ACC_RDONLY, fapl_id);
             }
             else {
-                file = h5tools_fopen(fname, H5F_ACC_RDONLY, H5P_DEFAULT, preferred_driver, drivername, sizeof drivername);
+                file_id = h5tools_fopen(fname, H5F_ACC_RDONLY, H5P_DEFAULT, preferred_driver, drivername, sizeof drivername);
             }
 
-            if (file >= 0) {
+            if (file_id >= 0) {
                 if (verbose_g)
                     PRINTSTREAM(rawoutstream, "Opened \"%s\" with %s driver.\n", fname, drivername);
                 break; /*success*/
@@ -2914,7 +3068,7 @@ main(int argc, const char *argv[])
             *oname = '\0';
         } /* end while */
 
-        if (file < 0) {
+        if (file_id < 0) {
             HDfprintf(rawerrorstream, "%s: unable to open file\n", argv[argno-1]);
             HDfree(fname);
             err_exit = 1;
@@ -2929,6 +3083,7 @@ main(int argc, const char *argv[])
             x = oname;
             if (NULL == (oname = HDstrdup(oname))) {
                 HDfprintf(rawerrorstream, "memory allocation failed\n");
+                H5Eset_auto2(H5E_DEFAULT, func, edata);
                 leave(EXIT_FAILURE);
             }
             *x = '\0';
@@ -2948,8 +3103,8 @@ main(int argc, const char *argv[])
 
         /* Remember the file information for later */
         iter.fname = fname;
-        iter.fid = file;
-        iter.gid = -1;
+        iter.fid = file_id;
+        iter.gid = H5I_INVALID_HID;
         iter.symlink_target = FALSE;
         iter.symlink_list = &symlink_list;
         iter.symlink_list->dangle_link = FALSE;
@@ -2961,7 +3116,7 @@ main(int argc, const char *argv[])
         /* Check for root group as object name */
         if (HDstrcmp(oname, root_name)) {
             /* Check the type of link given */
-            if (H5Lget_info(file, oname, &li, H5P_DEFAULT) < 0) {
+            if (H5Lget_info(file_id, oname, &li, H5P_DEFAULT) < 0) {
                 hsize_t             curr_pos = 0;        /* total data element position   */
                 h5tools_str_t       buffer;          /* string into which to render   */
                 h5tools_context_t   ctx;             /* print context  */
@@ -2973,6 +3128,7 @@ main(int argc, const char *argv[])
                 h5tools_str_reset(&buffer);
                 print_obj_name(&buffer, &iter, oname, "**NOT FOUND**");
                 h5tools_render_element(rawoutstream, info, &ctx, &buffer, &curr_pos, (size_t)info->line_ncols, (hsize_t)0, (hsize_t)0);
+                H5Eset_auto2(H5E_DEFAULT, func, edata);
                 leave(EXIT_FAILURE);
             } /* end if */
         } /* end if */
@@ -2981,16 +3137,18 @@ main(int argc, const char *argv[])
 
         /* Open the object and display it's information */
         if (li.type == H5L_TYPE_HARD) {
-            if (visit_obj(file, oname, &iter) < 0)
+            if (visit_obj(file_id, oname, &iter) < 0) {
+                H5Eset_auto2(H5E_DEFAULT, func, edata);
                 leave(EXIT_FAILURE);
+            }
         } /* end if(li.type == H5L_TYPE_HARD) */
         else {
             /* Specified name is not for object -- list that link */
-            /* Use file ID for root group ID */
-            iter.gid = file;
+            /* Use file_id ID for root group ID */
+            iter.gid = file_id;
             list_lnk(oname, &li, &iter);
         }
-        H5Fclose(file);
+        H5Fclose(file_id);
         HDfree(fname);
         if (x)
             HDfree(oname);
@@ -3011,10 +3169,12 @@ main(int argc, const char *argv[])
     if (fapl_id != H5P_DEFAULT) {
         if (0 < H5Pclose(fapl_id)) {
             HDfprintf(rawerrorstream, "Error: Unable to set close fapl entry\n\n");
+            H5Eset_auto2(H5E_DEFAULT, func, edata);
             leave(EXIT_FAILURE);
         }
     }
 
+    H5Eset_auto2(H5E_DEFAULT, func, edata);
     if (err_exit)
         leave(EXIT_FAILURE);
     else
diff --git a/tools/src/h5repack/CMakeLists.txt b/tools/src/h5repack/CMakeLists.txt
index 4a1430e..967e8d7 100644
--- a/tools/src/h5repack/CMakeLists.txt
+++ b/tools/src/h5repack/CMakeLists.txt
@@ -1,4 +1,4 @@
-cmake_minimum_required (VERSION 3.10)
+cmake_minimum_required (VERSION 3.12)
 project (HDF5_TOOLS_SRC_H5REPACK C)
 
 # --------------------------------------------------------------------
diff --git a/tools/src/h5repack/h5repack.c b/tools/src/h5repack/h5repack.c
index 0183cbf..d17d465 100644
--- a/tools/src/h5repack/h5repack.c
+++ b/tools/src/h5repack/h5repack.c
@@ -225,10 +225,10 @@ copy_named_datatype(hid_t type_in, hid_t fidout, named_dt_t **named_dt_head_p, t
     named_dt_t *dt = *named_dt_head_p; /* Stack pointer */
     named_dt_t *dt_ret = NULL;         /* Datatype to return */
     H5O_info_t  oinfo;                 /* Object info of input dtype */
-    hid_t       ret_value = -1;        /* The identifier of the named dtype in the out file */
+    hid_t       ret_value = H5I_INVALID_HID;
 
     if (H5Oget_info2(type_in, &oinfo, H5O_INFO_BASIC) < 0)
-        HGOTO_ERROR(FAIL, H5E_tools_min_id_g, "H5Oget_info failed");
+        H5TOOLS_GOTO_ERROR(H5I_INVALID_HID, "H5Oget_info failed");
 
     if (*named_dt_head_p) {
         /* Stack already exists, search for the datatype */
@@ -244,13 +244,13 @@ copy_named_datatype(hid_t type_in, hid_t fidout, named_dt_t **named_dt_head_p, t
             if (travt->objs[i].type == H5TRAV_TYPE_NAMED_DATATYPE) {
                 /* Push onto the stack */
                 if (NULL == (dt = (named_dt_t *)HDmalloc(sizeof(named_dt_t))))
-                    HGOTO_ERROR(FAIL, H5E_tools_min_id_g, "buffer allocation failed failed");
+                    H5TOOLS_GOTO_ERROR(H5I_INVALID_HID, "buffer allocation failed failed");
                 dt->next = *named_dt_head_p;
                 *named_dt_head_p = dt;
 
                 /* Update the address and id */
                 dt->addr_in = travt->objs[i].objno;
-                dt->id_out = -1;
+                dt->id_out = H5I_INVALID_HID;
 
                 /* Check if this type is the one requested */
                 if (oinfo.addr == dt->addr_in) {
@@ -266,13 +266,13 @@ copy_named_datatype(hid_t type_in, hid_t fidout, named_dt_t **named_dt_head_p, t
     if (!dt_ret) {
         /* Push the new datatype onto the stack */
         if (NULL == (dt_ret = (named_dt_t *)HDmalloc(sizeof(named_dt_t))))
-            HGOTO_ERROR(FAIL, H5E_tools_min_id_g, "buffer allocation failed failed");
+            H5TOOLS_GOTO_ERROR(H5I_INVALID_HID, "buffer allocation failed failed");
         dt_ret->next = *named_dt_head_p;
         *named_dt_head_p = dt_ret;
 
         /* Update the address and id */
         dt_ret->addr_in = oinfo.addr;
-        dt_ret->id_out = -1;
+        dt_ret->id_out = H5I_INVALID_HID;
     } /* end if requested datatype not found */
 
     /* If the requested datatype does not yet exist in the output file, copy it
@@ -284,9 +284,9 @@ copy_named_datatype(hid_t type_in, hid_t fidout, named_dt_t **named_dt_head_p, t
         else
             dt_ret->id_out = H5Tcopy(type_in);
         if (dt_ret->id_out < 0)
-            HGOTO_ERROR(FAIL, H5E_tools_min_id_g, "H5Tget_native_type-H5Tcopy failed");
+            H5TOOLS_GOTO_ERROR(H5I_INVALID_HID, "H5Tget_native_type-H5Tcopy failed");
         if (H5Tcommit_anon(fidout, dt_ret->id_out, H5P_DEFAULT, H5P_DEFAULT) < 0)
-            HGOTO_ERROR(FAIL, H5E_tools_min_id_g, "H5Tcommit_anon failed");
+            H5TOOLS_GOTO_ERROR(H5I_INVALID_HID, "H5Tcommit_anon failed");
     } /* end if named datatype not yet in output file */
 
     /* Set return value */
@@ -296,7 +296,7 @@ copy_named_datatype(hid_t type_in, hid_t fidout, named_dt_t **named_dt_head_p, t
      * to close it. (TODO: fix scope envy)
      */
     if (H5Iinc_ref(ret_value) < 0)
-        HGOTO_ERROR(FAIL, H5E_tools_min_id_g, "H5Iinc_ref failed");
+        H5TOOLS_GOTO_ERROR(H5I_INVALID_HID, "H5Iinc_ref failed");
 
 done:
     return ret_value;
@@ -312,12 +312,12 @@ int
 named_datatype_free(named_dt_t **named_dt_head_p, int ignore_err)
 {
     named_dt_t *dt = *named_dt_head_p;
-    int         ret_value = -1;
+    int ret_value = -1;
 
     while (dt) {
         /* Pop the datatype off the stack and free it */
         if (H5Tclose(dt->id_out) < 0 && !ignore_err)
-            HGOTO_ERROR(FAIL, H5E_tools_min_id_g, "H5Tclose failed");
+            H5TOOLS_GOTO_ERROR((-1), "H5Tclose failed");
         dt = dt->next;
         HDfree(*named_dt_head_p);
         *named_dt_head_p = dt;
@@ -343,12 +343,11 @@ done:
 int
 copy_attr(hid_t loc_in, hid_t loc_out, named_dt_t **named_dt_head_p, trav_table_t *travt, pack_opt_t *options)
 {
-    int         ret_value = 0;
-    hid_t       attr_id = -1;  /* attr ID */
-    hid_t       attr_out = -1; /* attr ID */
-    hid_t       space_id = -1; /* space ID */
-    hid_t       ftype_id = -1; /* file type ID */
-    hid_t       wtype_id = -1; /* read/write type ID */
+    hid_t       attr_id = H5I_INVALID_HID;  /* attr ID */
+    hid_t       attr_out = H5I_INVALID_HID; /* attr ID */
+    hid_t       space_id = H5I_INVALID_HID; /* space ID */
+    hid_t       ftype_id = H5I_INVALID_HID; /* file type ID */
+    hid_t       wtype_id = H5I_INVALID_HID; /* read/write type ID */
     size_t      msize;         /* size of type */
     void       *buf = NULL;    /* data buffer */
     hsize_t     nelmts;        /* number of elements in dataset */
@@ -361,9 +360,10 @@ copy_attr(hid_t loc_in, hid_t loc_out, named_dt_t **named_dt_head_p, trav_table_
     unsigned    u;
     hbool_t     is_ref = 0;
     H5T_class_t type_class = -1;
+    int         ret_value = 0;
 
     if (H5Oget_info2(loc_in, &oinfo, H5O_INFO_NUM_ATTRS) < 0)
-        HGOTO_ERROR(FAIL, H5E_tools_min_id_g, "H5Oget_info failed");
+        H5TOOLS_GOTO_ERROR((-1), "H5Oget_info failed");
 
     /*-------------------------------------------------------------------------
      * copy all attributes
@@ -372,33 +372,33 @@ copy_attr(hid_t loc_in, hid_t loc_out, named_dt_t **named_dt_head_p, trav_table_
     for (u = 0; u < (unsigned) oinfo.num_attrs; u++) {
         /* open attribute */
         if ((attr_id = H5Aopen_by_idx(loc_in, ".", H5_INDEX_CRT_ORDER, H5_ITER_INC, (hsize_t) u, H5P_DEFAULT, H5P_DEFAULT)) < 0)
-            HGOTO_ERROR(FAIL, H5E_tools_min_id_g, "H5Aopen_by_idx failed");
+            H5TOOLS_GOTO_ERROR((-1), "H5Aopen_by_idx failed");
 
         if (H5Aget_name(attr_id, (size_t) 255, name) < 0)
-            HGOTO_ERROR(FAIL, H5E_tools_min_id_g, "H5Pclose failed");
+            H5TOOLS_GOTO_ERROR((-1), "H5Pclose failed");
 
         /* get the file datatype  */
         if ((ftype_id = H5Aget_type(attr_id)) < 0)
-            HGOTO_ERROR(FAIL, H5E_tools_min_id_g, "H5Aget_type failed");
+            H5TOOLS_GOTO_ERROR((-1), "H5Aget_type failed");
 
         /* Check if the datatype is committed */
         if ((is_named = H5Tcommitted(ftype_id)) < 0)
-            HGOTO_ERROR(FAIL, H5E_tools_min_id_g, "H5Tcommitted failed");
+            H5TOOLS_GOTO_ERROR((-1), "H5Tcommitted failed");
         if (is_named && travt) {
-            hid_t fidout = -1;
+            hid_t fidout = H5I_INVALID_HID;
 
             /* Create out file id */
             if ((fidout = H5Iget_file_id(loc_out)) < 0)
-                HGOTO_ERROR(FAIL, H5E_tools_min_id_g, "H5Iget_file_id failed");
+                H5TOOLS_GOTO_ERROR((-1), "H5Iget_file_id failed");
 
             /* Copy named dt */
             if ((wtype_id = copy_named_datatype(ftype_id, fidout, named_dt_head_p, travt, options)) < 0) {
                 H5Fclose(fidout);
-                HGOTO_ERROR(FAIL, H5E_tools_min_id_g, "copy_named_datatype failed");
+                H5TOOLS_GOTO_ERROR((-1), "copy_named_datatype failed");
             }
 
             if (H5Fclose(fidout) < 0)
-                HGOTO_ERROR(FAIL, H5E_tools_min_id_g, "H5Fclose failed");
+                H5TOOLS_GOTO_ERROR((-1), "H5Fclose failed");
         } /* end if datatype is committed and we have a traversal table */
         else {
             if (options->use_native == 1)
@@ -409,18 +409,18 @@ copy_attr(hid_t loc_in, hid_t loc_out, named_dt_t **named_dt_head_p, trav_table_
 
         /* get the dataspace handle  */
         if ((space_id = H5Aget_space(attr_id)) < 0)
-            HGOTO_ERROR(FAIL, H5E_tools_min_id_g, "H5Aget_space failed");
+            H5TOOLS_GOTO_ERROR((-1), "H5Aget_space failed");
 
         /* get dimensions  */
         if ((rank = H5Sget_simple_extent_dims(space_id, dims, NULL)) < 0)
-            HGOTO_ERROR(FAIL, H5E_tools_min_id_g, "H5Sget_simple_extent_dims failed");
+            H5TOOLS_GOTO_ERROR((-1), "H5Sget_simple_extent_dims failed");
 
         nelmts = 1;
         for (j = 0; j < rank; j++)
             nelmts *= dims[j];
 
         if ((msize = H5Tget_size(wtype_id)) == 0)
-            HGOTO_ERROR(FAIL, H5E_tools_min_id_g, "H5Tget_size failed");
+            H5TOOLS_GOTO_ERROR((-1), "H5Tget_size failed");
 
         /*---------------------------------------------------------------------
          * object references are a special case. We cannot just copy the
@@ -432,12 +432,12 @@ copy_attr(hid_t loc_in, hid_t loc_out, named_dt_t **named_dt_head_p, trav_table_
         type_class = H5Tget_class(wtype_id);
         is_ref = (type_class == H5T_REFERENCE);
         if (type_class == H5T_VLEN || type_class == H5T_ARRAY) {
-            hid_t base_type = -1;
+            hid_t base_type = H5I_INVALID_HID;
 
             base_type = H5Tget_super(ftype_id);
             is_ref = (is_ref || (H5Tget_class(base_type) == H5T_REFERENCE));
             if (H5Tclose(base_type) < 0)
-                H5TOOLS_INFO(H5E_tools_min_id_g, "H5Tclose base_type failed");
+                H5TOOLS_ERROR((-1), "H5Tclose base_type failed");
         } /* end if type_class is variable length or array */
 
         if (type_class == H5T_COMPOUND) {
@@ -447,7 +447,7 @@ copy_attr(hid_t loc_in, hid_t loc_out, named_dt_t **named_dt_head_p, trav_table_
                 hid_t mtid = H5Tget_member_type(wtype_id, (unsigned)j);
                 H5T_class_t mtclass = H5Tget_class(mtid);
                 if (H5Tclose(mtid) < 0)
-                    H5TOOLS_INFO(H5E_tools_min_id_g, "H5Tclose mtid failed");
+                    H5TOOLS_ERROR((-1), "H5Tclose mtid failed");
 
                 if (mtclass == H5T_REFERENCE) {
                     is_ref = 1;
@@ -464,10 +464,10 @@ copy_attr(hid_t loc_in, hid_t loc_out, named_dt_t **named_dt_head_p, trav_table_
 
             buf = (void *)HDmalloc((size_t)(nelmts * msize));
             if (buf == NULL) {
-                HGOTO_ERROR(FAIL, H5E_tools_min_id_g, "HDmalloc failed");
+                H5TOOLS_GOTO_ERROR((-1), "HDmalloc failed");
             } /* end if */
             if (H5Aread(attr_id, wtype_id, buf) < 0)
-                HGOTO_ERROR(FAIL, H5E_tools_min_id_g, "H5Aread failed");
+                H5TOOLS_GOTO_ERROR((-1), "H5Aread failed");
 
             /*-----------------------------------------------------------------
              * copy
@@ -475,13 +475,13 @@ copy_attr(hid_t loc_in, hid_t loc_out, named_dt_t **named_dt_head_p, trav_table_
              */
 
             if ((attr_out = H5Acreate2(loc_out, name, wtype_id, space_id, H5P_DEFAULT, H5P_DEFAULT)) < 0)
-                HGOTO_ERROR(FAIL, H5E_tools_min_id_g, "H5Acreate2 failed on ,%s>", name);
+                H5TOOLS_GOTO_ERROR((-1), "H5Acreate2 failed on ,%s>", name);
             if (H5Awrite(attr_out, wtype_id, buf) < 0)
-                HGOTO_ERROR(FAIL, H5E_tools_min_id_g, "H5Awrite failed");
+                H5TOOLS_GOTO_ERROR((-1), "H5Awrite failed");
 
             /*close*/
             if (H5Aclose(attr_out) < 0)
-                HGOTO_ERROR(FAIL, H5E_tools_min_id_g, "H5Aclose failed");
+                H5TOOLS_GOTO_ERROR((-1), "H5Aclose failed");
 
             /* Check if we have VL data and string in the attribute's  datatype that must
              * be reclaimed */
@@ -499,17 +499,17 @@ copy_attr(hid_t loc_in, hid_t loc_out, named_dt_t **named_dt_head_p, trav_table_
          *---------------------------------------------------------------------
          */
         if (H5Sclose(space_id) < 0)
-            HGOTO_ERROR(FAIL, H5E_tools_min_id_g, "H5Sclose failed");
-        space_id = -1;
+            H5TOOLS_GOTO_ERROR((-1), "H5Sclose failed");
+        space_id = H5I_INVALID_HID;
         if (H5Tclose(wtype_id) < 0)
-            HGOTO_ERROR(FAIL, H5E_tools_min_id_g, "H5Tclose failed");
-        wtype_id = -1;
+            H5TOOLS_GOTO_ERROR((-1), "H5Tclose failed");
+        wtype_id = H5I_INVALID_HID;
         if (H5Tclose(ftype_id) < 0)
-            HGOTO_ERROR(FAIL, H5E_tools_min_id_g, "H5Tclose failed");
-        ftype_id = -1;
+            H5TOOLS_GOTO_ERROR((-1), "H5Tclose failed");
+        ftype_id = H5I_INVALID_HID;
         if (H5Aclose(attr_id) < 0)
-            HGOTO_ERROR(FAIL, H5E_tools_min_id_g, "H5Aclose failed");
-        attr_id = -1;
+            H5TOOLS_GOTO_ERROR((-1), "H5Aclose failed");
+        attr_id = H5I_INVALID_HID;
     } /* for u (each attribute) */
 
 done:
@@ -544,10 +544,10 @@ done:
 static int
 check_options(pack_opt_t *options)
 {
-    int          ret_value = 0; /*no need to LEAVE() on ERROR: HERR_INIT(int, SUCCEED) */
     unsigned int i;
     int          k, j, has_cp = 0, has_ck = 0;
     char         slayout[30];
+    int          ret_value = 0;
 
     /*-------------------------------------------------------------------------
      * Objects to layout
@@ -571,10 +571,11 @@ check_options(pack_opt_t *options)
                 break;
             case H5D_LAYOUT_ERROR:
             case H5D_NLAYOUTS:
-                HGOTO_ERROR(FAIL, H5E_tools_min_id_g, "invalid layout");
+                H5TOOLS_GOTO_ERROR((-1), "invalid layout");
+                break;
             default:
                 strcpy(slayout, "invalid layout\n");
-                HGOTO_DONE(FAIL);
+                H5TOOLS_GOTO_DONE((-1));
             }
             HDprintf(" Apply %s layout to all", slayout);
             if (H5D_CHUNKED == options->layout_g) {
@@ -609,7 +610,7 @@ check_options(pack_opt_t *options)
     } /* end for each object in options */
 
     if (options->all_layout == 1 && has_ck)
-        HGOTO_ERROR(FAIL, H5E_tools_min_id_g, "invalid chunking input: 'all' option is present with other objects");
+        H5TOOLS_GOTO_ERROR((-1), "invalid chunking input: 'all' option is present with other objects");
 
     /*-------------------------------------------------------------------------
      * Objects to filter
@@ -667,7 +668,7 @@ check_options(pack_opt_t *options)
     } /* end for each object in options table */
 
     if (options->all_filter == 1 && has_cp)
-        HGOTO_ERROR(FAIL, H5E_tools_min_id_g, "invalid compression input: 'all' option is present with other objects");
+        H5TOOLS_GOTO_ERROR((-1), "invalid compression input: 'all' option is present with other objects");
 
     /*-------------------------------------------------------------------------
      * Check options for the latest format
@@ -675,14 +676,14 @@ check_options(pack_opt_t *options)
      */
 
     if (options->grp_compact < 0)
-        HGOTO_ERROR(FAIL, H5E_tools_min_id_g, "invalid maximum number of links to store as header messages");
+        H5TOOLS_GOTO_ERROR((-1), "invalid maximum number of links to store as header messages");
     if (options->grp_indexed < 0)
-        HGOTO_ERROR(FAIL, H5E_tools_min_id_g, "invalid minimum number of links to store in the indexed format");
+        H5TOOLS_GOTO_ERROR((-1), "invalid minimum number of links to store in the indexed format");
     if (options->grp_indexed > options->grp_compact)
-        HGOTO_ERROR(FAIL, H5E_tools_min_id_g, "minimum indexed size is greater than the maximum compact size");
+        H5TOOLS_GOTO_ERROR((-1), "minimum indexed size is greater than the maximum compact size");
     for (i = 0; i < 8; i++)
         if (options->msg_size[i] < 0)
-            HGOTO_ERROR(FAIL, H5E_tools_min_id_g, "invalid shared message size");
+            H5TOOLS_GOTO_ERROR((-1), "invalid shared message size");
 
     /*------------------------------------------------------------------------
      * Verify new user userblock options; file name must be present
@@ -696,7 +697,7 @@ check_options(pack_opt_t *options)
     }
 
     if (options->ublock_filename == NULL && options->ublock_size != 0)
-        HGOTO_ERROR(FAIL, H5E_tools_min_id_g, "file name missing for user block", options->ublock_filename);
+        H5TOOLS_GOTO_ERROR((-1), "file name missing for user block", options->ublock_filename);
 
     /*------------------------------------------------------------------------
      * Verify alignment options; threshold is zero default but alignment not
@@ -704,7 +705,7 @@ check_options(pack_opt_t *options)
      */
 
     if (options->alignment == 0 && options->threshold != 0)
-        HGOTO_ERROR(FAIL, H5E_tools_min_id_g, "alignment for H5Pset_alignment missing");
+        H5TOOLS_GOTO_ERROR((-1), "alignment for H5Pset_alignment missing");
 
 done:
     return ret_value;
@@ -722,24 +723,24 @@ done:
 static int
 check_objects(const char* fname, pack_opt_t *options)
 {
-    hid_t         fid = -1;
-    hid_t         did = -1;
-    hid_t         sid = -1;
+    hid_t         fid = H5I_INVALID_HID;
+    hid_t         did = H5I_INVALID_HID;
+    hid_t         sid = H5I_INVALID_HID;
     unsigned int  i;
-    int  ifil;
+    int           ifil;
     trav_table_t *travt = NULL;
-    int           ret_value = 0; /*no need to LEAVE() on ERROR: HERR_INIT(int, SUCCEED) */
+    int           ret_value = 0;
 
     /* nothing to do */
     if (options->op_tbl->nelems == 0)
-        HGOTO_DONE(0);
+        H5TOOLS_GOTO_DONE(0);
 
     /*-------------------------------------------------------------------------
      * open the file
      *-------------------------------------------------------------------------
      */
     if ((fid = h5tools_fopen(fname, H5F_ACC_RDONLY, H5P_DEFAULT, NULL, NULL, 0)) < 0)
-        HGOTO_ERROR(FAIL, H5E_tools_min_id_g, "h5tools_fopen failed <%s>: %s", fname, H5FOPENERROR);
+        H5TOOLS_GOTO_ERROR((-1), "h5tools_fopen failed <%s>: %s", fname, H5FOPENERROR);
 
     /*-------------------------------------------------------------------------
      * get the list of objects in the file
@@ -753,7 +754,7 @@ check_objects(const char* fname, pack_opt_t *options)
 
     /* get the list of objects in the file */
     if (h5trav_gettable(fid, travt) < 0)
-        HGOTO_ERROR(FAIL, H5E_tools_min_id_g, "h5trav_gettable failed");
+        H5TOOLS_GOTO_ERROR((-1), "h5trav_gettable failed");
 
     /*-------------------------------------------------------------------------
      * compare with user supplied list
@@ -772,14 +773,14 @@ check_objects(const char* fname, pack_opt_t *options)
 
         /* the input object names are present in the file and are valid */
         if (h5trav_getindext(name, travt) < 0)
-            HGOTO_ERROR(FAIL, H5E_tools_min_id_g, "%s Could not find <%s> in file <%s>. Exiting...\n",
+            H5TOOLS_GOTO_ERROR((-1), "%s Could not find <%s> in file <%s>. Exiting...\n",
                     (options->verbose ? "\n" : ""), name, fname);
         if (options->verbose)
             HDprintf("...Found\n");
 
         for (ifil = 0; ifil < obj.nfilters; ifil++) {
             if (obj.filter[ifil].filtn < 0)
-                HGOTO_ERROR(FAIL, H5E_tools_min_id_g, "invalid filter");
+                H5TOOLS_GOTO_ERROR((-1), "invalid filter");
             /* check for extra filter conditions */
             switch (obj.filter[ifil].filtn) {
             /* chunk size must be smaller than pixels per block */
@@ -798,25 +799,25 @@ check_objects(const char* fname, pack_opt_t *options)
                     }
                     else {
                         if ((did = H5Dopen2(fid, name, H5P_DEFAULT)) < 0)
-                            HGOTO_ERROR(FAIL, H5E_tools_min_id_g, "H5Dopen2 failed");
+                            H5TOOLS_GOTO_ERROR((-1), "H5Dopen2 failed");
                         if ((sid = H5Dget_space(did)) < 0)
-                            HGOTO_ERROR(FAIL, H5E_tools_min_id_g, "H5Dget_space failed");
+                            H5TOOLS_GOTO_ERROR((-1), "H5Dget_space failed");
                         if ((rank = H5Sget_simple_extent_ndims(sid)) < 0)
-                            HGOTO_ERROR(FAIL, H5E_tools_min_id_g, "H5Sget_simple_extent_ndims failed");
+                            H5TOOLS_GOTO_ERROR((-1), "H5Sget_simple_extent_ndims failed");
                         HDmemset(dims, 0, sizeof dims);
                         if (H5Sget_simple_extent_dims(sid, dims, NULL) < 0)
-                            HGOTO_ERROR(FAIL, H5E_tools_min_id_g, "H5Sget_simple_extent_dims failed");
+                            H5TOOLS_GOTO_ERROR((-1), "H5Sget_simple_extent_dims failed");
                         for (j = 0; j < rank; j++)
                             csize *= dims[j];
                         if (H5Sclose(sid) < 0)
-                            HGOTO_ERROR(FAIL, H5E_tools_min_id_g, "H5Sclose failed");
+                            H5TOOLS_GOTO_ERROR((-1), "H5Sclose failed");
                         if (H5Dclose(did) < 0)
-                            HGOTO_ERROR(FAIL, H5E_tools_min_id_g, "H5Dclose failed");
+                            H5TOOLS_GOTO_ERROR((-1), "H5Dclose failed");
                     }
 
                     if (csize < ppb) {
                         HDprintf(" <warning: SZIP settings, chunk size is smaller than pixels per block>\n");
-                        HGOTO_DONE(0);
+                        H5TOOLS_GOTO_DONE(0);
                     }
                 } /* end case SZIP */
                 break;
diff --git a/tools/src/h5repack/h5repack_copy.c b/tools/src/h5repack/h5repack_copy.c
index f6409e3..b85a63f 100644
--- a/tools/src/h5repack/h5repack_copy.c
+++ b/tools/src/h5repack/h5repack_copy.c
@@ -61,12 +61,11 @@ static void print_user_block(const char *filename, hid_t fid);
 int
 copy_objects(const char* fnamein, const char* fnameout, pack_opt_t *options)
 {
-    int           ret_value = 0;
-    hid_t         fidin = -1;
-    hid_t         fidout = -1;
-    hid_t         fcpl_in = -1;  /* file creation property list ID for input file */
-    hid_t         grp_in = -1;   /* group ID */
-    hid_t         gcpl_in = -1;  /* group creation property list */
+    hid_t         fidin = H5I_INVALID_HID;
+    hid_t         fidout = H5I_INVALID_HID;
+    hid_t         fcpl_in = H5I_INVALID_HID;  /* file creation property list ID for input file */
+    hid_t         grp_in = H5I_INVALID_HID;   /* group ID */
+    hid_t         gcpl_in = H5I_INVALID_HID;  /* group creation property list */
     hid_t         fcpl = H5P_DEFAULT;     /* file creation property list ID */
     hid_t         fapl = H5P_DEFAULT;     /* file access property list ID */
     trav_table_t *travt = NULL;
@@ -80,65 +79,66 @@ copy_objects(const char* fnamein, const char* fnameout, pack_opt_t *options)
     hsize_t       in_threshold;           /* Free-space section threshold from input file */
     hsize_t       in_pagesize;            /* File space page size from input file */
     unsigned      crt_order_flags;        /* group creation order flag */
+    int           ret_value = 0;
 
     /*-------------------------------------------------------------------------
      * open input file
      *-------------------------------------------------------------------------
      */
     if ((fidin = h5tools_fopen(fnamein, H5F_ACC_RDONLY, H5P_DEFAULT, NULL, NULL, (size_t) 0)) < 0)
-        HGOTO_ERROR(FAIL, H5E_tools_min_id_g, "h5tools_fopen failed <%s>: %s", fnamein, H5FOPENERROR);
+        H5TOOLS_GOTO_ERROR((-1), "h5tools_fopen failed <%s>: %s", fnamein, H5FOPENERROR);
 
     /* get user block size and file space strategy/persist/threshold */
     {
         if ((fcpl_in = H5Fget_create_plist(fidin)) < 0)
-            HGOTO_ERROR(FAIL, H5E_tools_min_id_g, "H5Fget_create_plist failed to retrieve file creation property list");
+            H5TOOLS_GOTO_ERROR((-1), "H5Fget_create_plist failed to retrieve file creation property list");
 
         if (H5Pget_userblock(fcpl_in, &ub_size) < 0)
-            HGOTO_ERROR(FAIL, H5E_tools_min_id_g, "H5Pget_userblock failed to retrieve userblock size");
+            H5TOOLS_GOTO_ERROR((-1), "H5Pget_userblock failed to retrieve userblock size");
 
         /* If the -S option is not set, get "strategy" from the input file */
         if(H5Pget_file_space_strategy(fcpl_in, &in_strategy, &in_persist, &in_threshold) < 0)
-            HGOTO_ERROR(FAIL, H5E_tools_min_id_g, "H5Pget_file_space_strategy failed to retrieve file space strategy");
+            H5TOOLS_GOTO_ERROR((-1), "H5Pget_file_space_strategy failed to retrieve file space strategy");
 
         /* If the -G option is not set, get "pagesize" from the input file */
         if(H5Pget_file_space_page_size(fcpl_in, &in_pagesize) < 0)
-            HGOTO_ERROR(FAIL, H5E_tools_min_id_g, "H5Pget_file_space_page_size failed to retrieve file space threshold");
+            H5TOOLS_GOTO_ERROR((-1), "H5Pget_file_space_page_size failed to retrieve file space threshold");
 
         /* open root group */
         if ((grp_in = H5Gopen2(fidin, "/", H5P_DEFAULT)) < 0)
-            HGOTO_ERROR(FAIL, H5E_tools_min_id_g, "H5Gopen2 failed");
+            H5TOOLS_GOTO_ERROR((-1), "H5Gopen2 failed");
 
         /* get root group creation property list */
         if ((gcpl_in = H5Gget_create_plist(grp_in)) < 0)
-            HGOTO_ERROR(FAIL, H5E_tools_min_id_g, "H5Gget_create_plist failed");
+            H5TOOLS_GOTO_ERROR((-1), "H5Gget_create_plist failed");
 
         /* query and set the group creation properties */
         if (H5Pget_link_creation_order(gcpl_in, &crt_order_flags) < 0)
-            HGOTO_ERROR(FAIL, H5E_tools_min_id_g, "H5Pget_link_creation_order failed");
+            H5TOOLS_GOTO_ERROR((-1), "H5Pget_link_creation_order failed");
 
         if (H5Pclose(fcpl_in) < 0)
-            HGOTO_ERROR(FAIL, H5E_tools_min_id_g, "H5Pclose failed to close property list");
+            H5TOOLS_GOTO_ERROR((-1), "H5Pclose failed to close property list");
     }
 
     if(options->latest)
         options->low_bound = options->high_bound = H5F_LIBVER_LATEST;
     /* Create file access property list */
     if((fapl = H5Pcreate(H5P_FILE_ACCESS)) < 0)
-        HGOTO_ERROR(FAIL, H5E_tools_min_id_g, "H5Pcreate failed to create file access property list");
+        H5TOOLS_GOTO_ERROR((-1), "H5Pcreate failed to create file access property list");
 
     /* It can be default, latest or other settings by users */
     if(H5Pset_libver_bounds(fapl, options->low_bound, options->high_bound) < 0)
-        HGOTO_ERROR(FAIL, H5E_tools_min_id_g, "H5Pset_libver_bounds failed to set format version bounds");
+        H5TOOLS_GOTO_ERROR((-1), "H5Pset_libver_bounds failed to set format version bounds");
 
     /* Check if we need to create a non-default file creation property list */
     if (options->low_bound >= H5F_LIBVER_V18 || ub_size > 0) {
         /* Create file creation property list */
         if ((fcpl = H5Pcreate(H5P_FILE_CREATE)) < 0)
-            HGOTO_ERROR(FAIL, H5E_tools_min_id_g, "H5Pcreate failed to create a file creation property list");
+            H5TOOLS_GOTO_ERROR((-1), "H5Pcreate failed to create a file creation property list");
 
         if (ub_size > 0)
             if (H5Pset_userblock(fcpl, ub_size) < 0)
-                HGOTO_ERROR(FAIL, H5E_tools_min_id_g, "H5Pset_userblock failed to set non-default userblock size");
+                H5TOOLS_GOTO_ERROR((-1), "H5Pset_userblock failed to set non-default userblock size");
 
         if (options->low_bound >= H5F_LIBVER_V18) {
             unsigned i = 0, nindex = 0, mesg_type_flags[5], min_mesg_sizes[5];
@@ -146,7 +146,7 @@ copy_objects(const char* fnamein, const char* fnameout, pack_opt_t *options)
             /* Adjust group creation parameters for root group */
             /* (So that it is created in "dense storage" form) */
             if (H5Pset_link_phase_change(fcpl, (unsigned) options->grp_compact, (unsigned) options->grp_indexed) < 0)
-                HGOTO_ERROR(FAIL, H5E_tools_min_id_g, "H5Pset_link_phase_change failed to adjust group creation parameters for root group");
+                H5TOOLS_GOTO_ERROR((-1), "H5Pset_link_phase_change failed to adjust group creation parameters for root group");
 
             for (i = 0; i < 5; i++) {
                 if (options->msg_size[i] > 0) {
@@ -182,12 +182,12 @@ copy_objects(const char* fnamein, const char* fnameout, pack_opt_t *options)
 
             if (nindex > 0) {
                 if (H5Pset_shared_mesg_nindexes(fcpl, nindex) < 0)
-                    HGOTO_ERROR(FAIL, H5E_tools_min_id_g, "H5Pset_shared_mesg_nindexes failed to set the number of shared object header message indexes");
+                    H5TOOLS_GOTO_ERROR((-1), "H5Pset_shared_mesg_nindexes failed to set the number of shared object header message indexes");
 
                 /* msg_size[0]=dataspace, 1=datatype, 2=file value, 3=filter pipleline, 4=attribute */
                 for (i = 0; i < (nindex - 1); i++)
                     if (H5Pset_shared_mesg_index(fcpl, i, mesg_type_flags[i], min_mesg_sizes[i]) < 0)
-                        HGOTO_ERROR(FAIL, H5E_tools_min_id_g, "H5Pset_shared_mesg_index failed to configure the specified shared object header message index");
+                        H5TOOLS_GOTO_ERROR((-1), "H5Pset_shared_mesg_index failed to configure the specified shared object header message index");
             } /* if (nindex>0) */
 
         } /* end if */
@@ -205,11 +205,11 @@ print_user_block(fnamein, fidin);
         if (fcpl == H5P_DEFAULT)
             /* create a file creation property list */
             if ((fcpl = H5Pcreate(H5P_FILE_CREATE)) < 0)
-                HGOTO_ERROR(FAIL, H5E_tools_min_id_g, "H5Pcreate failed to create a file creation property list");
+                H5TOOLS_GOTO_ERROR((-1), "H5Pcreate failed to create a file creation property list");
 
         /* set user block size */
         if (H5Pset_userblock(fcpl, options->ublock_size) < 0)
-            HGOTO_ERROR(FAIL, H5E_tools_min_id_g, "H5Pset_userblock failed to set userblock size");
+            H5TOOLS_GOTO_ERROR((-1), "H5Pset_userblock failed to set userblock size");
     }
 
     /*-------------------------------------------------------------------------
@@ -221,10 +221,10 @@ print_user_block(fnamein, fidin);
         if (fapl == H5P_DEFAULT)
             /* create a file access property list */
             if ((fapl = H5Pcreate(H5P_FILE_ACCESS)) < 0)
-                HGOTO_ERROR(FAIL, H5E_tools_min_id_g, "H5Pcreate failed to create file access property list");
+                H5TOOLS_GOTO_ERROR((-1), "H5Pcreate failed to create file access property list");
 
         if (H5Pset_alignment(fapl, options->threshold, options->alignment) < 0)
-            HGOTO_ERROR(FAIL, H5E_tools_min_id_g, "H5Pset_alignment failed to set alignment");
+            H5TOOLS_GOTO_ERROR((-1), "H5Pset_alignment failed to set alignment");
     }
 
     /*-------------------------------------------------------------------------
@@ -236,10 +236,10 @@ print_user_block(fnamein, fidin);
         if (fapl == H5P_DEFAULT)
             /* create a file access property list */
             if ((fapl = H5Pcreate(H5P_FILE_ACCESS)) < 0)
-                HGOTO_ERROR(FAIL, H5E_tools_min_id_g, "H5Pcreate failed to create file access property list");
+                H5TOOLS_GOTO_ERROR((-1), "H5Pcreate failed to create file access property list");
 
         if (H5Pset_meta_block_size(fapl, options->meta_block_size) < 0)
-            HGOTO_ERROR(FAIL, H5E_tools_min_id_g, "H5Pset_meta_block_size failed to set metadata block size");
+            H5TOOLS_GOTO_ERROR((-1), "H5Pset_meta_block_size failed to set metadata block size");
     }
 
     /*-------------------------------------------------------------------------
@@ -251,10 +251,10 @@ print_user_block(fnamein, fidin);
     if (fcpl == H5P_DEFAULT)
         /* create a file creation property list */
         if ((fcpl = H5Pcreate(H5P_FILE_CREATE)) < 0)
-            HGOTO_ERROR(FAIL, H5E_tools_min_id_g, "H5Pcreate failed to create a file creation property list");
+            H5TOOLS_GOTO_ERROR((-1), "H5Pcreate failed to create a file creation property list");
 
     if(H5Pset_link_creation_order(fcpl, crt_order_flags ) < 0)
-        HGOTO_ERROR(FAIL, H5E_tools_min_id_g, "H5Pset_link_creation_order failed");
+        H5TOOLS_GOTO_ERROR((-1), "H5Pset_link_creation_order failed");
 
     /* Set file space info to those from input file */
     set_strategy = in_strategy;
@@ -279,7 +279,7 @@ print_user_block(fnamein, fidin);
 
     /* Set file space information as specified */
     if(H5Pset_file_space_strategy(fcpl, set_strategy, set_persist, set_threshold) < 0)
-        HGOTO_ERROR(FAIL, H5E_tools_min_id_g, "H5Pset_file_space_strategy failed to set file space strategy");
+        H5TOOLS_GOTO_ERROR((-1), "H5Pset_file_space_strategy failed to set file space strategy");
 
     if(options->fs_pagesize == -1) /* A "0" file space page size is specified by user */
         set_pagesize = (hsize_t)0;
@@ -288,7 +288,7 @@ print_user_block(fnamein, fidin);
 
     if(set_pagesize != FS_PAGESIZE_DEF) /* Set non-default file space page size as specified */
         if(H5Pset_file_space_page_size(fcpl, set_pagesize) < 0)
-            HGOTO_ERROR(FAIL, H5E_tools_min_id_g, "H5Pset_file_space_page_size failed to set file space page size");
+            H5TOOLS_GOTO_ERROR((-1), "H5Pset_file_space_page_size failed to set file space page size");
 
     /*-------------------------------------------------------------------------
      * create the output file
@@ -298,7 +298,7 @@ print_user_block(fnamein, fidin);
         HDprintf("Making new file ...\n");
 
     if ((fidout = H5Fcreate(fnameout, H5F_ACC_TRUNC, fcpl, fapl)) < 0)
-        HGOTO_ERROR(FAIL, H5E_tools_min_id_g, "H5Fcreate could not create file <%s>:", fnameout);
+        H5TOOLS_GOTO_ERROR((-1), "H5Fcreate could not create file <%s>:", fnameout);
 
     /*-------------------------------------------------------------------------
      * write a new user block if requested
@@ -306,7 +306,7 @@ print_user_block(fnamein, fidin);
      */
     if (options->ublock_size > 0)
         if (copy_user_block(options->ublock_filename, fnameout, options->ublock_size) < 0)
-            HGOTO_ERROR(FAIL, H5E_tools_min_id_g, "Could not copy user block. Exiting...");
+            H5TOOLS_GOTO_ERROR((-1), "Could not copy user block. Exiting...");
 
     /*-------------------------------------------------------------------------
      * get list of objects
@@ -321,14 +321,14 @@ print_user_block(fnamein, fidin);
     if (travt) {
         /* get the list of objects in the file */
         if (h5trav_gettable(fidin, travt) < 0)
-            HGOTO_ERROR(FAIL, H5E_tools_min_id_g, "h5trav_gettable failed");
+            H5TOOLS_GOTO_ERROR((-1), "h5trav_gettable failed");
 
         /*-------------------------------------------------------------------------
         * do the copy
         *-------------------------------------------------------------------------
         */
         if (do_copy_objects(fidin, fidout, travt, options) < 0)
-            HGOTO_ERROR(FAIL, H5E_tools_min_id_g, "do_copy_objects from <%s> could not copy data to <%s>", fnamein, fnameout);
+            H5TOOLS_GOTO_ERROR((-1), "do_copy_objects from <%s> could not copy data to <%s>", fnamein, fnameout);
 
         /*-------------------------------------------------------------------------
         * do the copy of referenced objects
@@ -336,7 +336,7 @@ print_user_block(fnamein, fidin);
         *-------------------------------------------------------------------------
         */
         if (do_copy_refobjs(fidin, fidout, travt, options) < 0)
-            HGOTO_ERROR(FAIL, H5E_tools_min_id_g, "do_copy_refobjs from <%s> could not copy data to <%s>", fnamein, fnameout);
+            H5TOOLS_GOTO_ERROR((-1), "do_copy_refobjs from <%s> could not copy data to <%s>", fnamein, fnameout);
     }
 
     /*-------------------------------------------------------------------------
@@ -346,7 +346,7 @@ print_user_block(fnamein, fidin);
 
     if (ub_size > 0 && options->ublock_size == 0)
         if (copy_user_block(fnamein, fnameout, ub_size) < 0)
-            HGOTO_ERROR(FAIL, H5E_tools_min_id_g, "Could not copy user block. Exiting...");
+            H5TOOLS_GOTO_ERROR((-1), "Could not copy user block. Exiting...");
 
 done:
     H5E_BEGIN_TRY {
@@ -402,7 +402,6 @@ int
 get_hyperslab(hid_t dcpl_id, int rank_dset, hsize_t dims_dset[],
         size_t size_datum, hsize_t dims_hslab[], hsize_t * hslab_nbytes_p)
 {
-    int     ret_value = 0;
     int     k;
     H5D_layout_t dset_layout;
     int     rank_chunk;
@@ -413,6 +412,7 @@ get_hyperslab(hid_t dcpl_id, int rank_dset, hsize_t dims_dset[],
     hsize_t chunk_dims_map[H5S_MAX_RANK]; /* mapped chunk dimentions */
     hsize_t hs_dims_map[H5S_MAX_RANK];    /* mapped hyperslab dimentions */
     hsize_t hslab_nbytes;                 /* size of hyperslab in byte */
+    int     ret_value = 0;
 
     /* init to set as size of a data element */
     hslab_nbytes = size_datum;
@@ -425,7 +425,7 @@ get_hyperslab(hid_t dcpl_id, int rank_dset, hsize_t dims_dset[],
         /* get chunk dims */
         rank_chunk = H5Pget_chunk(dcpl_id, rank_dset, dims_chunk);
         if (rank_chunk < 0)
-            HGOTO_ERROR(FAIL, H5E_tools_min_id_g, "H5Pget_chunk failed");
+            H5TOOLS_GOTO_ERROR((-1), "H5Pget_chunk failed");
 
         for (k = rank_dset; k > 0; --k)
             size_chunk *= dims_chunk[k - 1];
@@ -487,7 +487,7 @@ get_hyperslab(hid_t dcpl_id, int rank_dset, hsize_t dims_dset[],
                 hslab_nbytes *= dims_hslab[k - 1];
 
                 if (hslab_nbytes <= 0)
-                    HGOTO_ERROR(FAIL, H5E_tools_min_id_g, "calculate total size for the hyperslab failed");
+                    H5TOOLS_GOTO_ERROR((-1), "calculate total size for the hyperslab failed");
             }
         }
     }
@@ -511,7 +511,7 @@ get_hyperslab(hid_t dcpl_id, int rank_dset, hsize_t dims_dset[],
             hslab_nbytes *= dims_hslab[k - 1];
 
             if (hslab_nbytes <= 0)
-                HGOTO_ERROR(FAIL, H5E_tools_min_id_g, "calculate total size for the hyperslab failed");
+                H5TOOLS_GOTO_ERROR((-1), "calculate total size for the hyperslab failed");
         }
     }
 
@@ -580,20 +580,19 @@ int
 do_copy_objects(hid_t fidin, hid_t fidout, trav_table_t *travt,
         pack_opt_t *options) /* repack options */
 {
-    int   ret_value = 0;
-    hid_t grp_in = -1;   /* group ID */
-    hid_t grp_out = -1;  /* group ID */
-    hid_t dset_in = -1;  /* read dataset ID */
-    hid_t dset_out = -1; /* write dataset ID */
-    hid_t gcpl_in = -1;  /* group creation property list */
-    hid_t gcpl_out = -1; /* group creation property list */
-    hid_t type_in = -1;  /* named type ID */
-    hid_t type_out = -1; /* named type ID */
-    hid_t dcpl_in = -1;  /* dataset creation property list ID */
-    hid_t dcpl_out = -1; /* dataset creation property list ID */
-    hid_t f_space_id = -1; /* file space ID */
-    hid_t ftype_id = -1; /* file type ID */
-    hid_t wtype_id = -1; /* read/write type ID */
+    hid_t grp_in = H5I_INVALID_HID;   /* group ID */
+    hid_t grp_out = H5I_INVALID_HID;  /* group ID */
+    hid_t dset_in = H5I_INVALID_HID;  /* read dataset ID */
+    hid_t dset_out = H5I_INVALID_HID; /* write dataset ID */
+    hid_t gcpl_in = H5I_INVALID_HID;  /* group creation property list */
+    hid_t gcpl_out = H5I_INVALID_HID; /* group creation property list */
+    hid_t type_in = H5I_INVALID_HID;  /* named type ID */
+    hid_t type_out = H5I_INVALID_HID; /* named type ID */
+    hid_t dcpl_in = H5I_INVALID_HID;  /* dataset creation property list ID */
+    hid_t dcpl_out = H5I_INVALID_HID; /* dataset creation property list ID */
+    hid_t f_space_id = H5I_INVALID_HID; /* file space ID */
+    hid_t ftype_id = H5I_INVALID_HID; /* file type ID */
+    hid_t wtype_id = H5I_INVALID_HID; /* read/write type ID */
     named_dt_t *named_dt_head = NULL; /* Pointer to the stack of named datatypes copied */
     size_t msize;        /* size of type */
     hsize_t nelmts;      /* number of elements in dataset */
@@ -617,6 +616,7 @@ do_copy_objects(hid_t fidin, hid_t fidout, trav_table_t *travt,
     htri_t is_named;
     hbool_t limit_maxdims;
     hsize_t size_dset;
+    int ret_value = 0;
 
     /*-------------------------------------------------------------------------
      * copy the supplied object list
@@ -649,22 +649,22 @@ do_copy_objects(hid_t fidin, hid_t fidout, trav_table_t *travt,
 
                 /* open input group */
                 if ((grp_in = H5Gopen2(fidin, travt->objs[i].name, H5P_DEFAULT)) < 0)
-                    HGOTO_ERROR(FAIL, H5E_tools_min_id_g, "H5Gopen2 failed");
+                    H5TOOLS_GOTO_ERROR((-1), "H5Gopen2 failed");
 
                 /* get input group creation property list */
                 if ((gcpl_in = H5Gget_create_plist(grp_in)) < 0)
-                    HGOTO_ERROR(FAIL, H5E_tools_min_id_g, "H5Gget_create_plist failed");
+                    H5TOOLS_GOTO_ERROR((-1), "H5Gget_create_plist failed");
 
                 /* query and set the group creation properties */
                 if (H5Pget_link_creation_order(gcpl_in, &crt_order_flags) < 0)
-                    HGOTO_ERROR(FAIL, H5E_tools_min_id_g, "H5Pget_link_creation_order failed");
+                    H5TOOLS_GOTO_ERROR((-1), "H5Pget_link_creation_order failed");
 
                 /* set up group creation property list */
                 if ((gcpl_out = H5Pcreate(H5P_GROUP_CREATE)) < 0)
-                    HGOTO_ERROR(FAIL, H5E_tools_min_id_g, "H5Pcreate failed");
+                    H5TOOLS_GOTO_ERROR((-1), "H5Pcreate failed");
 
                 if (H5Pset_link_creation_order(gcpl_out, crt_order_flags) < 0)
-                    HGOTO_ERROR(FAIL, H5E_tools_min_id_g, "H5Pset_link_creation_order failed");
+                    H5TOOLS_GOTO_ERROR((-1), "H5Pset_link_creation_order failed");
 
                 /*-------------------------------------------------------------------------
                  * the root is a special case, we get an ID for the root group
@@ -673,15 +673,15 @@ do_copy_objects(hid_t fidin, hid_t fidout, trav_table_t *travt,
                  */
                 if (HDstrcmp(travt->objs[i].name, "/") == 0) {
                     if ((grp_out = H5Gopen2(fidout, "/", H5P_DEFAULT)) < 0)
-                        HGOTO_ERROR(FAIL, H5E_tools_min_id_g, "H5Gopen2 failed");
+                        H5TOOLS_GOTO_ERROR((-1), "H5Gopen2 failed");
                 }
                 else {
                     if (options->grp_compact > 0 || options->grp_indexed > 0)
                         if (H5Pset_link_phase_change(gcpl_out, (unsigned) options->grp_compact, (unsigned) options->grp_indexed) < 0)
-                            HGOTO_ERROR(FAIL, H5E_tools_min_id_g, "H5Pset_link_phase_change failed");
+                            H5TOOLS_GOTO_ERROR((-1), "H5Pset_link_phase_change failed");
 
                     if ((grp_out = H5Gcreate2(fidout, travt->objs[i].name, H5P_DEFAULT, gcpl_out, H5P_DEFAULT)) < 0)
-                        HGOTO_ERROR(FAIL, H5E_tools_min_id_g, "H5Gcreate2 failed");
+                        H5TOOLS_GOTO_ERROR((-1), "H5Gcreate2 failed");
                 }
 
                 /*-------------------------------------------------------------------------
@@ -689,16 +689,16 @@ do_copy_objects(hid_t fidin, hid_t fidout, trav_table_t *travt,
                  *-------------------------------------------------------------------------
                  */
                 if (copy_attr(grp_in, grp_out, &named_dt_head, travt, options) < 0)
-                    HGOTO_ERROR(FAIL, H5E_tools_min_id_g, "copy_attr failed");
+                    H5TOOLS_GOTO_ERROR((-1), "copy_attr failed");
 
                 if (H5Pclose(gcpl_out) < 0)
-                    HGOTO_ERROR(FAIL, H5E_tools_min_id_g, "H5Pclose failed");
+                    H5TOOLS_GOTO_ERROR((-1), "H5Pclose failed");
                 if (H5Pclose(gcpl_in) < 0)
-                    HGOTO_ERROR(FAIL, H5E_tools_min_id_g, "H5Pclose failed");
+                    H5TOOLS_GOTO_ERROR((-1), "H5Pclose failed");
                 if (H5Gclose(grp_out) < 0)
-                    HGOTO_ERROR(FAIL, H5E_tools_min_id_g, "H5Gclose failed");
+                    H5TOOLS_GOTO_ERROR((-1), "H5Gclose failed");
                 if (H5Gclose(grp_in) < 0)
-                    HGOTO_ERROR(FAIL, H5E_tools_min_id_g, "H5Gclose failed");
+                    H5TOOLS_GOTO_ERROR((-1), "H5Gclose failed");
 
                 break;
 
@@ -740,23 +740,23 @@ do_copy_objects(hid_t fidin, hid_t fidout, trav_table_t *travt,
 
                 /* early detection of references */
                 if ((dset_in = H5Dopen2(fidin, travt->objs[i].name, H5P_DEFAULT)) < 0)
-                    HGOTO_ERROR(FAIL, H5E_tools_min_id_g, "H5Dopen2 failed");
+                    H5TOOLS_GOTO_ERROR((-1), "H5Dopen2 failed");
                 if ((ftype_id = H5Dget_type(dset_in)) < 0)
-                    HGOTO_ERROR(FAIL, H5E_tools_min_id_g, "H5Dget_type failed");
+                    H5TOOLS_GOTO_ERROR((-1), "H5Dget_type failed");
                 if (H5T_REFERENCE == H5Tget_class(ftype_id))
                     is_ref = 1;
 
                 /* Check if the datatype is committed */
                 if ((is_named = H5Tcommitted(ftype_id)) < 0)
-                    HGOTO_ERROR(FAIL, H5E_tools_min_id_g, "H5Tcommitted failed");
+                    H5TOOLS_GOTO_ERROR((-1), "H5Tcommitted failed");
                 if (is_named)
                     if ((wtype_id = copy_named_datatype(ftype_id, fidout, &named_dt_head, travt, options)) < 0)
-                        HGOTO_ERROR(FAIL, H5E_tools_min_id_g, "copy_named_datatype failed");
+                        H5TOOLS_GOTO_ERROR((-1), "copy_named_datatype failed");
 
                 if (H5Tclose(ftype_id) < 0)
-                    HGOTO_ERROR(FAIL, H5E_tools_min_id_g, "H5Tclose failed");
+                    H5TOOLS_GOTO_ERROR((-1), "H5Tclose failed");
                 if (H5Dclose(dset_in) < 0)
-                    HGOTO_ERROR(FAIL, H5E_tools_min_id_g, "H5Dclose failed");
+                    H5TOOLS_GOTO_ERROR((-1), "H5Dclose failed");
 
                 /*-------------------------------------------------------------------------
                  * check if we should use H5Ocopy or not
@@ -770,20 +770,20 @@ do_copy_objects(hid_t fidin, hid_t fidout, trav_table_t *travt,
                     int j;
 
                     if ((dset_in = H5Dopen2(fidin, travt->objs[i].name, H5P_DEFAULT)) < 0)
-                        HGOTO_ERROR(FAIL, H5E_tools_min_id_g, "H5Dopen2 failed");
+                        H5TOOLS_GOTO_ERROR((-1), "H5Dopen2 failed");
                     if ((f_space_id = H5Dget_space(dset_in)) < 0)
-                        HGOTO_ERROR(FAIL, H5E_tools_min_id_g, "H5Dget_space failed");
+                        H5TOOLS_GOTO_ERROR((-1), "H5Dget_space failed");
                     if ((ftype_id = H5Dget_type(dset_in)) < 0)
-                        HGOTO_ERROR(FAIL, H5E_tools_min_id_g, "H5Dget_type failed");
+                        H5TOOLS_GOTO_ERROR((-1), "H5Dget_type failed");
                     if ((dcpl_in = H5Dget_create_plist(dset_in)) < 0)
-                        HGOTO_ERROR(FAIL, H5E_tools_min_id_g, "H5Dget_create_plist failed");
+                        H5TOOLS_GOTO_ERROR((-1), "H5Dget_create_plist failed");
                     if ((rank = H5Sget_simple_extent_ndims(f_space_id)) < 0)
-                        HGOTO_ERROR(FAIL, H5E_tools_min_id_g, "H5Sget_simple_extent_ndims failed");
+                        H5TOOLS_GOTO_ERROR((-1), "H5Sget_simple_extent_ndims failed");
                     HDmemset(dims, 0, sizeof dims);
                     if (H5Sget_simple_extent_dims(f_space_id, dims, NULL) < 0)
-                        HGOTO_ERROR(FAIL, H5E_tools_min_id_g, "H5Sget_simple_extent_dims failed");
+                        H5TOOLS_GOTO_ERROR((-1), "H5Sget_simple_extent_dims failed");
                     if (H5Dget_space_status(dset_in, &space_status) < 0)
-                        HGOTO_ERROR(FAIL, H5E_tools_min_id_g, "H5Dget_space_status failed");
+                        H5TOOLS_GOTO_ERROR((-1), "H5Dget_space_status failed");
 
                     /* If the input dataset has external storage, it must be contiguous.
                      * Accordingly, there would be no filter or chunk properties to preserve,
@@ -792,10 +792,10 @@ do_copy_objects(hid_t fidin, hid_t fidout, trav_table_t *travt,
                      */
                     if (H5Pget_external_count(dcpl_in)) {
                         if ((dcpl_out = H5Pcreate(H5P_DATASET_CREATE)) < 0)
-                            HGOTO_ERROR(FAIL, H5E_tools_min_id_g, "H5Pcreate failed");
+                            H5TOOLS_GOTO_ERROR((-1), "H5Pcreate failed");
                     }
                     else if ((dcpl_out = H5Pcopy(dcpl_in)) < 0) {
-                        HGOTO_ERROR(FAIL, H5E_tools_min_id_g, "H5Pcopy failed");
+                        H5TOOLS_GOTO_ERROR((-1), "H5Pcopy failed");
                     }
 
                     nelmts = 1;
@@ -811,7 +811,7 @@ do_copy_objects(hid_t fidin, hid_t fidout, trav_table_t *travt,
                     }
 
                     if ((msize = H5Tget_size(wtype_id)) == 0)
-                        HGOTO_ERROR(FAIL, H5E_tools_min_id_g, "H5Tget_size failed");
+                        H5TOOLS_GOTO_ERROR((-1), "H5Tget_size failed");
 
                     /* size of current dset */
                     size_dset = nelmts * msize;
@@ -848,7 +848,7 @@ do_copy_objects(hid_t fidin, hid_t fidout, trav_table_t *travt,
                             /* apply the filter */
                             if (apply_s)
                                 if (apply_filters(travt->objs[i].name, rank, dims, msize, dcpl_out, options, &has_filter) < 0)
-                                    HGOTO_ERROR(FAIL, H5E_tools_min_id_g, "apply_filters failed");
+                                    H5TOOLS_GOTO_ERROR((-1), "apply_filters failed");
 
                             /* only if layout change requested for entire file or
                              * individual obj */
@@ -888,13 +888,13 @@ do_copy_objects(hid_t fidin, hid_t fidout, trav_table_t *travt,
                              *-------------------------------------------------------------------------
                              */
                             dset_out = H5Dcreate2(fidout, travt->objs[i].name, wtype_id, f_space_id, H5P_DEFAULT, dcpl_out, H5P_DEFAULT);
-                            if (dset_out == FAIL) {
-                                H5Epush2(H5tools_ERR_STACK_g, __FILE__, FUNC, __LINE__, H5tools_ERR_CLS_g, H5E_tools_g, H5E_tools_min_id_g, "H5Dcreate2 failed");
+                            if (dset_out == H5I_INVALID_HID) {
+                                H5TOOLS_INFO("H5Dcreate2 failed");
                                 if (options->verbose)
                                     HDprintf(" warning: could not create dataset <%s>. Applying original settings\n", travt->objs[i].name);
 
                                 if ((dset_out = H5Dcreate2(fidout, travt->objs[i].name, wtype_id, f_space_id, H5P_DEFAULT, dcpl_in, H5P_DEFAULT)) < 0)
-                                    HGOTO_ERROR(FAIL, H5E_tools_min_id_g, "H5Dcreate2 failed");
+                                    H5TOOLS_GOTO_ERROR((-1), "H5Dcreate2 failed");
                                 apply_f = 0;
                             } /* end if retry dataset create */
 
@@ -911,15 +911,15 @@ do_copy_objects(hid_t fidin, hid_t fidout, trav_table_t *travt,
 
                                 if (buf != NULL) {
                                     if(H5Dread(dset_in, wtype_id, H5S_ALL, H5S_ALL, H5P_DEFAULT, buf) < 0)
-                                        HGOTO_ERROR(FAIL, H5E_tools_min_id_g, "H5Dread failed");
+                                        H5TOOLS_GOTO_ERROR((-1), "H5Dread failed");
                                     if(H5Dwrite(dset_out, wtype_id, H5S_ALL, H5S_ALL, H5P_DEFAULT, buf) < 0)
-                                        HGOTO_ERROR(FAIL, H5E_tools_min_id_g, "H5Dwrite failed");
+                                        H5TOOLS_GOTO_ERROR((-1), "H5Dwrite failed");
 
                                     /* Check if we have VL data in the dataset's
                                      * datatype that must be reclaimed */
                                     if (TRUE == H5Tdetect_class(wtype_id, H5T_VLEN))
                                         if (H5Dvlen_reclaim(wtype_id, f_space_id, H5P_DEFAULT, buf) < 0)
-                                            HGOTO_ERROR(FAIL, H5E_tools_min_id_g, "H5Dvlen_reclaim failed");
+                                            H5TOOLS_GOTO_ERROR((-1), "H5Dvlen_reclaim failed");
 
                                     if (buf != NULL) { /* TODO: is buf potentially released by H5Dvlen_reclaim()? */
                                         HDfree(buf);
@@ -946,7 +946,7 @@ do_copy_objects(hid_t fidin, hid_t fidout, trav_table_t *travt,
                                     hsize_t zero[8]; /*vector of zeros */
                                     int k;
                                     H5D_layout_t dset_layout;
-                                    hid_t dcpl_tmp = -1; /* dataset creation property list ID */
+                                    hid_t dcpl_tmp = H5I_INVALID_HID; /* dataset creation property list ID */
 
                                     /* check if we have VL data in the dataset's datatype */
                                     if (H5Tdetect_class(wtype_id, H5T_VLEN) == TRUE)
@@ -965,11 +965,11 @@ do_copy_objects(hid_t fidin, hid_t fidout, trav_table_t *travt,
 
                                     /* get hyperslab dims and size in byte */
                                     if (get_hyperslab(dcpl_tmp, rank, dims, p_type_nbytes, hslab_dims, &hslab_nbytes) < 0)
-                                        HGOTO_ERROR(FAIL, H5E_tools_min_id_g, "get_hyperslab failed");
+                                        H5TOOLS_GOTO_ERROR((-1), "get_hyperslab failed");
 
                                     hslab_buf = HDmalloc((size_t)hslab_nbytes);
                                     if (hslab_buf == NULL)
-                                        HGOTO_ERROR(FAIL, H5E_tools_min_id_g, "can't allocate space for hyperslab");
+                                        H5TOOLS_GOTO_ERROR((-1), "can't allocate space for hyperslab");
 
                                     hslab_nelmts = hslab_nbytes / p_type_nbytes;
                                     hslab_space = H5Screate_simple(1, &hslab_nelmts, NULL);
@@ -993,9 +993,9 @@ do_copy_objects(hid_t fidin, hid_t fidout, trav_table_t *travt,
                                             }
 
                                             if (H5Sselect_hyperslab(f_space_id, H5S_SELECT_SET, hs_sel_offset, NULL, hs_sel_count, NULL) < 0)
-                                                HGOTO_ERROR(FAIL, H5E_tools_min_id_g, "H5Sselect_hyperslab failed");
+                                                H5TOOLS_GOTO_ERROR((-1), "H5Sselect_hyperslab failed");
                                             if (H5Sselect_hyperslab(hslab_space, H5S_SELECT_SET, zero, NULL, &hs_select_nelmts, NULL) < 0)
-                                                HGOTO_ERROR(FAIL, H5E_tools_min_id_g, "H5Sselect_hyperslab failed");
+                                                H5TOOLS_GOTO_ERROR((-1), "H5Sselect_hyperslab failed");
                                         } /* end if rank > 0 */
                                         else {
                                             H5Sselect_all(f_space_id);
@@ -1004,9 +1004,9 @@ do_copy_objects(hid_t fidin, hid_t fidout, trav_table_t *travt,
                                         } /* end (else) rank  == 0 */
 
                                         if(H5Dread(dset_in, wtype_id, hslab_space, f_space_id, H5P_DEFAULT, hslab_buf) < 0)
-                                            HGOTO_ERROR(FAIL, H5E_tools_min_id_g, "H5Dread failed");
+                                            H5TOOLS_GOTO_ERROR((-1), "H5Dread failed");
                                         if(H5Dwrite(dset_out, wtype_id,  hslab_space, f_space_id, H5P_DEFAULT, hslab_buf) < 0)
-                                            HGOTO_ERROR(FAIL, H5E_tools_min_id_g, "H5Dwrite failed");
+                                            H5TOOLS_GOTO_ERROR((-1), "H5Dwrite failed");
 
                                         /* reclaim any VL memory, if necessary */
                                         if (vl_data)
@@ -1066,10 +1066,10 @@ do_copy_objects(hid_t fidin, hid_t fidout, trav_table_t *travt,
                              *-------------------------------------------------------------------------
                              */
                             if (copy_attr(dset_in, dset_out, &named_dt_head, travt, options) < 0)
-                                HGOTO_ERROR(FAIL, H5E_tools_min_id_g, "copy_attr failed");
+                                H5TOOLS_GOTO_ERROR((-1), "copy_attr failed");
 
                             if (H5Dclose(dset_out) < 0)
-                                HGOTO_ERROR(FAIL, H5E_tools_min_id_g, "H5Dclose failed");
+                                H5TOOLS_GOTO_ERROR((-1), "H5Dclose failed");
                         } /* end if not a reference */
                     } /* end if h5tools_canreadf (filter availability check) */
 
@@ -1078,32 +1078,32 @@ do_copy_objects(hid_t fidin, hid_t fidout, trav_table_t *travt,
                      *-------------------------------------------------------------------------
                      */
                     if (H5Tclose(ftype_id) < 0)
-                        HGOTO_ERROR(FAIL, H5E_tools_min_id_g, "H5Tclose failed");
+                        H5TOOLS_GOTO_ERROR((-1), "H5Tclose failed");
                     if (H5Tclose(wtype_id) < 0)
-                        HGOTO_ERROR(FAIL, H5E_tools_min_id_g, "H5Tclose failed");
+                        H5TOOLS_GOTO_ERROR((-1), "H5Tclose failed");
                     if (H5Pclose(dcpl_in) < 0)
-                        HGOTO_ERROR(FAIL, H5E_tools_min_id_g, "H5Pclose failed");
+                        H5TOOLS_GOTO_ERROR((-1), "H5Pclose failed");
                     if (H5Pclose(dcpl_out) < 0)
-                        HGOTO_ERROR(FAIL, H5E_tools_min_id_g, "H5Pclose failed");
+                        H5TOOLS_GOTO_ERROR((-1), "H5Pclose failed");
                     if (H5Sclose(f_space_id) < 0)
-                        HGOTO_ERROR(FAIL, H5E_tools_min_id_g, "H5Sclose failed");
+                        H5TOOLS_GOTO_ERROR((-1), "H5Sclose failed");
                     if (H5Dclose(dset_in) < 0)
-                        HGOTO_ERROR(FAIL, H5E_tools_min_id_g, "H5Dclose failed");
+                        H5TOOLS_GOTO_ERROR((-1), "H5Dclose failed");
                 }
                 /*-------------------------------------------------------------------------
                  * We do not have request for filter/chunking; use H5Ocopy instead
                  *-------------------------------------------------------------------------
                  */
                 else {
-                    hid_t pid = -1;
+                    hid_t pid = H5I_INVALID_HID;
 
                     /* create property to pass copy options */
                     if ((pid = H5Pcreate(H5P_OBJECT_COPY)) < 0)
-                        HGOTO_ERROR(FAIL, H5E_tools_min_id_g, "H5Pcreate failed");
+                        H5TOOLS_GOTO_ERROR((-1), "H5Pcreate failed");
 
                     /* set options for object copy */
                     if (H5Pset_copy_object(pid, H5O_COPY_WITHOUT_ATTR_FLAG) < 0)
-                        HGOTO_ERROR(FAIL, H5E_tools_min_id_g, "H5Pset_copy_object failed");
+                        H5TOOLS_GOTO_ERROR((-1), "H5Pset_copy_object failed");
 
                     if (H5Ocopy(fidin, /* Source file or group identifier */
                             travt->objs[i].name, /* Name of the source object to be copied */
@@ -1111,25 +1111,25 @@ do_copy_objects(hid_t fidin, hid_t fidout, trav_table_t *travt,
                             travt->objs[i].name, /* Name of the destination object  */
                             pid, /* Properties which apply to the copy   */
                             H5P_DEFAULT) < 0) /* Properties which apply to the new hard link */
-                        HGOTO_ERROR(FAIL, H5E_tools_min_id_g, "H5Ocopy failed");
+                        H5TOOLS_GOTO_ERROR((-1), "H5Ocopy failed");
 
                     if (H5Pclose(pid) < 0)
-                        HGOTO_ERROR(FAIL, H5E_tools_min_id_g, "H5Pclose failed");
+                        H5TOOLS_GOTO_ERROR((-1), "H5Pclose failed");
 
                     /*-------------------------------------------------------------------------
                      * Copy attrs manually
                      *-------------------------------------------------------------------------
                      */
                     if ((dset_in = H5Dopen2(fidin, travt->objs[i].name, H5P_DEFAULT)) < 0)
-                        HGOTO_ERROR(FAIL, H5E_tools_min_id_g, "H5Dopen2 failed");
+                        H5TOOLS_GOTO_ERROR((-1), "H5Dopen2 failed");
                     if ((dset_out = H5Dopen2(fidout, travt->objs[i].name, H5P_DEFAULT)) < 0)
-                        HGOTO_ERROR(FAIL, H5E_tools_min_id_g, "H5Dopen2 failed");
+                        H5TOOLS_GOTO_ERROR((-1), "H5Dopen2 failed");
                     if (copy_attr(dset_in, dset_out, &named_dt_head, travt, options) < 0)
-                        HGOTO_ERROR(FAIL, H5E_tools_min_id_g, "copy_attr failed");
+                        H5TOOLS_GOTO_ERROR((-1), "copy_attr failed");
                     if (H5Dclose(dset_in) < 0)
-                        HGOTO_ERROR(FAIL, H5E_tools_min_id_g, "H5Dclose failed");
+                        H5TOOLS_GOTO_ERROR((-1), "H5Dclose failed");
                     if (H5Dclose(dset_out) < 0)
-                        HGOTO_ERROR(FAIL, H5E_tools_min_id_g, "H5Dclose failed");
+                        H5TOOLS_GOTO_ERROR((-1), "H5Dclose failed");
 
                     if (options->verbose)
                         HDprintf(FORMAT_OBJ, "dset", travt->objs[i].name);
@@ -1146,28 +1146,28 @@ do_copy_objects(hid_t fidin, hid_t fidout, trav_table_t *travt,
                     HDprintf(FORMAT_OBJ, "type", travt->objs[i].name);
 
                 if ((type_in = H5Topen2(fidin, travt->objs[i].name, H5P_DEFAULT)) < 0)
-                    HGOTO_ERROR(FAIL, H5E_tools_min_id_g, "H5Topen2 failed");
+                    H5TOOLS_GOTO_ERROR((-1), "H5Topen2 failed");
 
                 /* Copy the datatype anonymously */
                 if ((type_out = copy_named_datatype(type_in, fidout, &named_dt_head, travt, options)) < 0)
-                    HGOTO_ERROR(FAIL, H5E_tools_min_id_g, "copy_named_datatype failed");
+                    H5TOOLS_GOTO_ERROR((-1), "copy_named_datatype failed");
 
                 /* Link in to group structure */
                 if (H5Lcreate_hard(type_out, ".", fidout, travt->objs[i].name, H5P_DEFAULT, H5P_DEFAULT) < 0)
-                    HGOTO_ERROR(FAIL, H5E_tools_min_id_g, "H5Lcreate_hard failed");
+                    H5TOOLS_GOTO_ERROR((-1), "H5Lcreate_hard failed");
 
                 /*-------------------------------------------------------------------------
                  * copy attrs
                  *-------------------------------------------------------------------------
                  */
                 if (copy_attr(type_in, type_out, &named_dt_head, travt, options) < 0)
-                    HGOTO_ERROR(FAIL, H5E_tools_min_id_g, "copy_attr failed");
+                    H5TOOLS_GOTO_ERROR((-1), "copy_attr failed");
 
                 if (H5Tclose(type_in) < 0)
-                    HGOTO_ERROR(FAIL, H5E_tools_min_id_g, "H5Tclose failed");
+                    H5TOOLS_GOTO_ERROR((-1), "H5Tclose failed");
                 if (H5Tclose(type_out) < 0)
-                    HGOTO_ERROR(FAIL, H5E_tools_min_id_g, "H5Tclose failed");
-                type_out = -1; /* named datatypes stack, named_dt_head, manages allocation */
+                    H5TOOLS_GOTO_ERROR((-1), "H5Tclose failed");
+                type_out = H5I_INVALID_HID; /* named datatypes stack, named_dt_head, manages allocation */
 
                 break;
 
@@ -1185,14 +1185,14 @@ do_copy_objects(hid_t fidin, hid_t fidout, trav_table_t *travt,
                     HDprintf(FORMAT_OBJ, "link", travt->objs[i].name);
 
                 if (H5Lcopy(fidin, travt->objs[i].name, fidout, travt->objs[i].name, H5P_DEFAULT, H5P_DEFAULT) < 0)
-                    HGOTO_ERROR(FAIL, H5E_tools_min_id_g, "H5Lcopy failed");
+                    H5TOOLS_GOTO_ERROR((-1), "H5Lcopy failed");
 
                 if (options->verbose)
                     HDprintf(FORMAT_OBJ, "link", travt->objs[i].name);
                 break;
 
             default:
-                HGOTO_ERROR(FAIL, H5E_tools_min_id_g, "Object type not found");
+                H5TOOLS_GOTO_ERROR((-1), "Object type not found");
             } /* switch */
         } /* end for each object to traverse */
     } /* end if there are objects */
@@ -1203,7 +1203,7 @@ done:
      * because of reference counting */
     if (0 == ret_value && named_dt_head != NULL) {
         if (named_datatype_free(&named_dt_head, 0) < 0)
-            H5TOOLS_INFO(H5E_tools_min_id_g, "named_datatype_free failed");
+            H5TOOLS_ERROR((-1), "named_datatype_free failed");
     }
     else
         H5E_BEGIN_TRY {
@@ -1354,16 +1354,16 @@ print_dataset_info(hid_t dcpl_id, char *objname, double ratio, int pr)
 static int
 copy_user_block(const char *infile, const char *outfile, hsize_t size)
 {
-    int ret_value = 0;
     int infid = -1, outfid = -1; /* File descriptors */
+    int ret_value = 0;
 
     /* User block must be any power of 2 equal to 512 or greater (512, 1024, 2048, etc.) */
 
     /* Open files */
     if ((infid = HDopen(infile, O_RDONLY)) < 0)
-        HGOTO_ERROR(FAIL, H5E_tools_min_id_g, "HDopen failed input file <%s>", infile);
+        H5TOOLS_GOTO_ERROR((-1), "HDopen failed input file <%s>", infile);
     if ((outfid = HDopen(outfile, O_WRONLY)) < 0)
-        HGOTO_ERROR(FAIL, H5E_tools_min_id_g, "HDopen failed output file <%s>", outfile);
+        H5TOOLS_GOTO_ERROR((-1), "HDopen failed output file <%s>", outfile);
 
     /* Copy the userblock from the input file to the output file */
     while (size > 0) {
@@ -1377,7 +1377,7 @@ copy_user_block(const char *infile, const char *outfile, hsize_t size)
         else
             nread = HDread(infid, rbuf, (size_t)size);
         if (nread < 0)
-            HGOTO_ERROR(FAIL, H5E_tools_min_id_g, "HDread failed to read userblock");
+            H5TOOLS_GOTO_ERROR((-1), "HDread failed to read userblock");
 
         /* Write buffer to destination file */
         /* (compensating for interrupted writes & checking for errors, etc.) */
@@ -1390,7 +1390,7 @@ copy_user_block(const char *infile, const char *outfile, hsize_t size)
                 nwritten = HDwrite(outfid, wbuf, (size_t)nbytes);
             } while (-1 == nwritten && EINTR == errno);
             if (-1 == nwritten)  /* error */
-                HGOTO_ERROR(FAIL, H5E_tools_min_id_g, "HDwrite failed");
+                H5TOOLS_GOTO_ERROR((-1), "HDwrite failed");
             HDassert(nwritten > 0);
             HDassert(nwritten <= nbytes);
 
@@ -1426,29 +1426,29 @@ static
 void
 print_user_block(const char *filename, hid_t fid)
 {
-    int     ret_value = 0;
     int     fh = -1;   /* file handle */
     hsize_t ub_size;   /* user block size */
     hsize_t size;      /* size read */
-    hid_t   fcpl = -1; /* file creation property list ID for HDF5 file */
+    hid_t   fcpl = H5I_INVALID_HID; /* file creation property list ID for HDF5 file */
     int     i;
+    int     ret_value = 0;
 
     /* get user block size */
     if ((fcpl = H5Fget_create_plist(fid)) < 0) {
-        HGOTO_ERROR(H5E_tools_g, H5E_tools_min_id_g, "H5Fget_create_plist failed to retrieve file creation property list");
+        H5TOOLS_GOTO_ERROR((-1), "H5Fget_create_plist failed to retrieve file creation property list");
     }
 
     if (H5Pget_userblock(fcpl, &ub_size) < 0) {
-        HGOTO_ERROR(H5E_tools_g, H5E_tools_min_id_g, "H5Pget_userblock failed to retrieve userblock size");
+        H5TOOLS_GOTO_ERROR((-1), "H5Pget_userblock failed to retrieve userblock size");
     }
 
     if (H5Pclose(fcpl) < 0) {
-        HGOTO_ERROR(H5E_tools_g, H5E_tools_min_id_g, "H5Pclose failed to close property list");
+        H5TOOLS_GOTO_ERROR((-1), "H5Pclose failed to close property list");
     }
 
     /* open file */
     if ((fh = HDopen(filename, O_RDONLY)) < 0) {
-        HGOTO_ERROR(H5E_tools_g, H5E_tools_min_id_g, "HDopen failed to open file <%s>", filename);
+        H5TOOLS_GOTO_ERROR((-1), "HDopen failed to open file <%s>", filename);
     }
 
     size = ub_size;
@@ -1472,7 +1472,7 @@ print_user_block(const char *filename, hid_t fid)
         HDprintf("\n");
 
         if (nread < 0) {
-            HGOTO_ERROR(H5E_tools_g, H5E_tools_min_id_g, "nread < 0");
+            H5TOOLS_GOTO_ERROR((-1), "nread < 0");
         }
 
         /* update size of userblock left to transfer */
diff --git a/tools/src/h5repack/h5repack_filters.c b/tools/src/h5repack/h5repack_filters.c
index 7e32def..d1179fb 100644
--- a/tools/src/h5repack/h5repack_filters.c
+++ b/tools/src/h5repack/h5repack_filters.c
@@ -36,35 +36,35 @@ static int aux_copy_obj(hid_t dcpl_id, /* dataset creation property list */
         const char* name,              /* object name from traverse list */
         pack_info_t *objout /*OUT*/)   /* info about object to filter */
 {
-    int          ret_value = 0;  /*no need to LEAVE() on ERROR: HERR_INIT(int, SUCCEED) */
     int          nfilters;       /* number of filters in DCPL */
     char         f_objname[256]; /* filter objname */
     H5D_layout_t layout;
     int          rank;           /* rank of dataset */
     hsize_t      chsize[64];     /* chunk size in elements */
-    int i;
-    unsigned u;
+    int          i;
+    unsigned     u;
+    int          ret_value = 0;
 
     /* get information about input filters */
     if ((nfilters = H5Pget_nfilters(dcpl_id)) < 0)
-        HGOTO_ERROR(FAIL, H5E_tools_min_id_g, "H5Pget_nfilters failed");
+        H5TOOLS_GOTO_ERROR((-1), "H5Pget_nfilters failed");
     /* copy filter_info_t structure */
     for (i = 0; i < nfilters; i++) {
         if ((objout->filter[i].filtn = H5Pget_filter2(dcpl_id, (unsigned) i, &objout->filter[i].filt_flag, &objout->filter[i].cd_nelmts,
                 objout->filter[i].cd_values, sizeof(f_objname), f_objname, NULL)) < 0)
-            HGOTO_ERROR(FAIL, H5E_tools_min_id_g, "H5Pget_filter2 failed");
+            H5TOOLS_GOTO_ERROR((-1), "H5Pget_filter2 failed");
     }
 
     objout->nfilters = nfilters;
     HDstrcpy(objout->path, name);
 
     if ((layout = H5Pget_layout(dcpl_id)) < 0)
-        HGOTO_ERROR(FAIL, H5E_tools_min_id_g, "H5Pget_layout failed");
+        H5TOOLS_GOTO_ERROR((-1), "H5Pget_layout failed");
     objout->layout = layout;
 
     if (layout == H5D_CHUNKED) {
         if ((rank = H5Pget_chunk(dcpl_id, NELMTS(chsize), chsize/*out*/)) < 0)
-            HGOTO_ERROR(FAIL, H5E_tools_min_id_g, "H5Pget_chunk failed");
+            H5TOOLS_GOTO_ERROR((-1), "H5Pget_chunk failed");
         objout->chunk.rank = rank;
         for (u = 0; u < (unsigned)rank; u++)
             objout->chunk.chunk_lengths[u] = chsize[u];
@@ -238,18 +238,18 @@ int apply_filters(const char* name, /* object name from traverse list */
         pack_opt_t *options,        /* repack options */
         int *has_filter)            /* (OUT) object NAME has a filter */
 {
-    int         ret_value = 0; /*no need to LEAVE() on ERROR: HERR_INIT(int, SUCCEED) */
-    int         nfilters;      /* number of filters in DCPL */
-    hsize_t     chsize[64];    /* chunk size in elements */
+    int          nfilters;      /* number of filters in DCPL */
+    hsize_t      chsize[64];    /* chunk size in elements */
     H5D_layout_t layout;
-    int         i;
-    pack_info_t obj;
-    pack_info_t filtobj;
+    int          i;
+    pack_info_t  obj;
+    pack_info_t  filtobj;
+    int          ret_value = 0;
 
     *has_filter = 0;
 
     if (rank == 0) /* scalar dataset, do not apply */
-        HGOTO_DONE(0);
+        H5TOOLS_GOTO_DONE(0);
 
     /*-------------------------------------------------------------------------
      * initialize the assigment object
@@ -263,11 +263,11 @@ int apply_filters(const char* name, /* object name from traverse list */
      *-------------------------------------------------------------------------
      */
     if (aux_assign_obj(name, options, &obj) == 0)
-        HGOTO_DONE(0);
+        H5TOOLS_GOTO_DONE(0);
 
     /* get information about input filters */
     if ((nfilters = H5Pget_nfilters(dcpl_id)) < 0)
-        HGOTO_ERROR(FAIL, H5E_tools_min_id_g, "H5Pget_nfilters failed");
+        H5TOOLS_GOTO_ERROR((-1), "H5Pget_nfilters failed");
 
 
     /*-------------------------------------------------------------------------
@@ -279,12 +279,12 @@ int apply_filters(const char* name, /* object name from traverse list */
     if (nfilters && obj.nfilters) {
         *has_filter = 1;
         if (H5Premove_filter(dcpl_id, H5Z_FILTER_ALL) < 0)
-            HGOTO_ERROR(FAIL, H5E_tools_min_id_g, "H5Premove_filter failed");
+            H5TOOLS_GOTO_ERROR((-1), "H5Premove_filter failed");
     }
     else if(nfilters) {
         *has_filter = 1;
         if (aux_copy_obj(dcpl_id, name, &filtobj) < 0)
-            HGOTO_ERROR(FAIL, H5E_tools_min_id_g, "aux_copy_obj failed");
+            H5TOOLS_GOTO_ERROR((-1), "aux_copy_obj failed");
     }
 
     /*-------------------------------------------------------------------------
@@ -294,11 +294,11 @@ int apply_filters(const char* name, /* object name from traverse list */
      */
     if (obj.layout == -1) {
         if ((layout = H5Pget_layout(dcpl_id)) < 0)
-            HGOTO_ERROR(FAIL, H5E_tools_min_id_g, "H5Pget_layout failed");
+            H5TOOLS_GOTO_ERROR((-1), "H5Pget_layout failed");
 
         if (layout == H5D_CHUNKED) {
             if ((rank = H5Pget_chunk(dcpl_id, NELMTS(chsize), chsize/*out*/)) < 0)
-                HGOTO_ERROR(FAIL, H5E_tools_min_id_g, "H5Pget_chunk failed");
+                H5TOOLS_GOTO_ERROR((-1), "H5Pget_chunk failed");
             obj.layout = H5D_CHUNKED;
             obj.chunk.rank = rank;
             for (i = 0; i < rank; i++)
@@ -340,7 +340,7 @@ int apply_filters(const char* name, /* object name from traverse list */
             for (i = rank; i > 0; --i) {
                 hsize_t size = 0;
                 if(sm_nbytes == 0)
-                    HGOTO_ERROR(FAIL, H5E_tools_min_id_g, "number of bytes per stripmine must be > 0");
+                    H5TOOLS_GOTO_ERROR((-1), "number of bytes per stripmine must be > 0");
                 size = H5TOOLS_BUFSIZE / sm_nbytes;
                 if (size == 0) /* datum size > H5TOOLS_BUFSIZE */
                     size = 1;
@@ -355,7 +355,7 @@ int apply_filters(const char* name, /* object name from traverse list */
 
         for (i = 0; i < obj.nfilters; i++) {
             if (obj.filter[i].filtn < 0)
-                HGOTO_ERROR(FAIL, H5E_tools_min_id_g, "invalid filter");
+                H5TOOLS_GOTO_ERROR((-1), "invalid filter");
 
             switch (obj.filter[i].filtn) {
             /*-------------------------------------------------------------------------
@@ -376,9 +376,9 @@ int apply_filters(const char* name, /* object name from traverse list */
                     aggression = obj.filter[i].cd_values[0];
                     /* set up for deflated data */
                     if (H5Pset_chunk(dcpl_id, obj.chunk.rank, obj.chunk.chunk_lengths) < 0)
-                        HGOTO_ERROR(FAIL, H5E_tools_min_id_g, "H5Pset_chunk failed");
+                        H5TOOLS_GOTO_ERROR((-1), "H5Pset_chunk failed");
                     if (H5Pset_deflate(dcpl_id, aggression) < 0)
-                        HGOTO_ERROR(FAIL, H5E_tools_min_id_g, "H5Pset_deflate failed");
+                        H5TOOLS_GOTO_ERROR((-1), "H5Pset_deflate failed");
                 }
                 break;
 
@@ -396,9 +396,9 @@ int apply_filters(const char* name, /* object name from traverse list */
 
                     /* set up for szip data */
                     if (H5Pset_chunk(dcpl_id, obj.chunk.rank, obj.chunk.chunk_lengths) < 0)
-                        HGOTO_ERROR(FAIL, H5E_tools_min_id_g, "H5Pset_chunk failed");
+                        H5TOOLS_GOTO_ERROR((-1), "H5Pset_chunk failed");
                     if (H5Pset_szip(dcpl_id, options_mask, pixels_per_block) < 0)
-                        HGOTO_ERROR(FAIL, H5E_tools_min_id_g, "H5Pset_szip failed");
+                        H5TOOLS_GOTO_ERROR((-1), "H5Pset_szip failed");
                 }
                 break;
 
@@ -408,9 +408,9 @@ int apply_filters(const char* name, /* object name from traverse list */
              */
             case H5Z_FILTER_SHUFFLE:
                 if (H5Pset_chunk(dcpl_id, obj.chunk.rank, obj.chunk.chunk_lengths) < 0)
-                    HGOTO_ERROR(FAIL, H5E_tools_min_id_g, "H5Pset_chunk failed");
+                    H5TOOLS_GOTO_ERROR((-1), "H5Pset_chunk failed");
                 if (H5Pset_shuffle(dcpl_id) < 0)
-                    HGOTO_ERROR(FAIL, H5E_tools_min_id_g, "H5Pset_shuffle failed");
+                    H5TOOLS_GOTO_ERROR((-1), "H5Pset_shuffle failed");
                 break;
 
             /*-------------------------------------------------------------------------
@@ -419,9 +419,9 @@ int apply_filters(const char* name, /* object name from traverse list */
              */
             case H5Z_FILTER_FLETCHER32:
                 if (H5Pset_chunk(dcpl_id, obj.chunk.rank, obj.chunk.chunk_lengths) < 0)
-                    HGOTO_ERROR(FAIL, H5E_tools_min_id_g, "H5Pset_chunk failed");
+                    H5TOOLS_GOTO_ERROR((-1), "H5Pset_chunk failed");
                 if (H5Pset_fletcher32(dcpl_id) < 0)
-                    HGOTO_ERROR(FAIL, H5E_tools_min_id_g, "H5Pset_fletcher32 failed");
+                    H5TOOLS_GOTO_ERROR((-1), "H5Pset_fletcher32 failed");
                 break;
             /*----------- -------------------------------------------------------------
              * H5Z_FILTER_NBIT , NBIT compression
@@ -429,9 +429,9 @@ int apply_filters(const char* name, /* object name from traverse list */
              */
             case H5Z_FILTER_NBIT:
                 if (H5Pset_chunk(dcpl_id, obj.chunk.rank, obj.chunk.chunk_lengths) < 0)
-                    HGOTO_ERROR(FAIL, H5E_tools_min_id_g, "H5Pset_chunk failed");
+                    H5TOOLS_GOTO_ERROR((-1), "H5Pset_chunk failed");
                 if (H5Pset_nbit(dcpl_id) < 0)
-                    HGOTO_ERROR(FAIL, H5E_tools_min_id_g, "H5Pset_nbit failed");
+                    H5TOOLS_GOTO_ERROR((-1), "H5Pset_nbit failed");
                 break;
             /*----------- -------------------------------------------------------------
              * H5Z_FILTER_SCALEOFFSET , scale+offset compression
@@ -446,19 +446,19 @@ int apply_filters(const char* name, /* object name from traverse list */
                     scale_factor = (int) obj.filter[i].cd_values[1];
 
                     if (H5Pset_chunk(dcpl_id, obj.chunk.rank, obj.chunk.chunk_lengths) < 0)
-                        HGOTO_ERROR(FAIL, H5E_tools_min_id_g, "H5Pset_chunk failed");
+                        H5TOOLS_GOTO_ERROR((-1), "H5Pset_chunk failed");
                     if (H5Pset_scaleoffset(dcpl_id, scale_type, scale_factor) < 0)
-                        HGOTO_ERROR(FAIL, H5E_tools_min_id_g, "H5Pset_scaleoffset failed");
+                        H5TOOLS_GOTO_ERROR((-1), "H5Pset_scaleoffset failed");
                 }
                 break;
             default:
                 {
                     if (H5Pset_chunk(dcpl_id, obj.chunk.rank, obj.chunk.chunk_lengths) < 0)
-                        HGOTO_ERROR(FAIL, H5E_tools_min_id_g, "H5Pset_chunk failed");
+                        H5TOOLS_GOTO_ERROR((-1), "H5Pset_chunk failed");
                     if (H5Pset_filter(dcpl_id, obj.filter[i].filtn,
                             obj.filter[i].filt_flag, obj.filter[i].cd_nelmts,
                             obj.filter[i].cd_values) < 0)
-                        HGOTO_ERROR(FAIL, H5E_tools_min_id_g, "H5Pset_filter failed");
+                        H5TOOLS_GOTO_ERROR((-1), "H5Pset_filter failed");
                 }
                 break;
             } /* switch */
@@ -469,10 +469,10 @@ int apply_filters(const char* name, /* object name from traverse list */
     if (filtobj.nfilters) {
         for (i = 0; i < filtobj.nfilters; i++) {
             if (filtobj.filter[i].filtn < 0)
-                HGOTO_ERROR(FAIL, H5E_tools_min_id_g, "invalid filter");
+                H5TOOLS_GOTO_ERROR((-1), "invalid filter");
 
             if (H5Zfilter_avail(filtobj.filter[i].filtn) <= 0)
-                HGOTO_ERROR(FAIL, H5E_tools_min_id_g, "%d filter unavailable", filtobj.filter[i].filtn);
+                H5TOOLS_GOTO_ERROR((-1), "%d filter unavailable", filtobj.filter[i].filtn);
         } /* for */
     } /* nfilters */
 
@@ -484,20 +484,20 @@ int apply_filters(const char* name, /* object name from traverse list */
     if (obj.layout >= 0) {
         /* a layout was defined */
         if (H5Pset_layout(dcpl_id, obj.layout) < 0)
-            HGOTO_ERROR(FAIL, H5E_tools_min_id_g, "H5Pset_layout failed");
+            H5TOOLS_GOTO_ERROR((-1), "H5Pset_layout failed");
 
         if (H5D_CHUNKED == obj.layout) {
             if (H5Pset_chunk(dcpl_id, obj.chunk.rank, obj.chunk.chunk_lengths) < 0)
-                HGOTO_ERROR(FAIL, H5E_tools_min_id_g, "H5Pset_chunk failed");
+                H5TOOLS_GOTO_ERROR((-1), "H5Pset_chunk failed");
         }
         else if (H5D_COMPACT == obj.layout) {
             if (H5Pset_alloc_time(dcpl_id, H5D_ALLOC_TIME_EARLY) < 0)
-                HGOTO_ERROR(FAIL, H5E_tools_min_id_g, "H5Pset_alloc_time failed");
+                H5TOOLS_GOTO_ERROR((-1), "H5Pset_alloc_time failed");
         }
         /* remove filters for the H5D_CONTIGUOUS case */
         else if (H5D_CONTIGUOUS == obj.layout) {
             if (H5Premove_filter(dcpl_id, H5Z_FILTER_ALL) < 0)
-                HGOTO_ERROR(FAIL, H5E_tools_min_id_g, "H5Premove_filter failed");
+                H5TOOLS_GOTO_ERROR((-1), "H5Premove_filter failed");
         }
     }
 
diff --git a/tools/src/h5repack/h5repack_main.c b/tools/src/h5repack/h5repack_main.c
index b4e1985..de14566 100644
--- a/tools/src/h5repack/h5repack_main.c
+++ b/tools/src/h5repack/h5repack_main.c
@@ -279,7 +279,7 @@ int read_info(const char *filename, pack_opt_t *options)
     char comp_info[1024];
     FILE *fp = NULL;
     char c;
-    int i, rc = 1;
+    int i;
     int ret_value = EXIT_SUCCESS;
 
     if (NULL == (fp = HDfopen(filename, "r"))) {
@@ -410,7 +410,7 @@ set_sort_order(const char *form)
 static
 int parse_command_line(int argc, const char **argv, pack_opt_t* options)
 {
-    int opt;
+    int bound, opt;
     int ret_value = 0;
 
     /* parse command line options */
@@ -490,19 +490,21 @@ int parse_command_line(int argc, const char **argv, pack_opt_t* options)
                 break;
 
             case 'j':
-                options->low_bound = (H5F_libver_t)HDatoi(opt_arg);
-                if (options->low_bound < H5F_LIBVER_EARLIEST || options->low_bound > H5F_LIBVER_LATEST) {
+                bound = HDatoi(opt_arg);
+                if (bound < H5F_LIBVER_EARLIEST || bound > H5F_LIBVER_LATEST) {
                     error_msg("in parsing low bound\n");
                     goto done;
                 }
+                options->low_bound = bound;
                 break;
 
             case 'k':
-                options->high_bound = (H5F_libver_t)HDatoi(opt_arg);
-                if (options->high_bound < H5F_LIBVER_EARLIEST || options->high_bound > H5F_LIBVER_LATEST) {
+                bound = HDatoi(opt_arg);
+                if (bound < H5F_LIBVER_EARLIEST || bound > H5F_LIBVER_LATEST) {
                     error_msg("in parsing high bound\n");
                     goto done;
                 }
+                options->high_bound = bound;
                 break;
 
             case 'c':
diff --git a/tools/src/h5repack/h5repack_opttable.c b/tools/src/h5repack/h5repack_opttable.c
index 7ab8c6e..56fc12d 100644
--- a/tools/src/h5repack/h5repack_opttable.c
+++ b/tools/src/h5repack/h5repack_opttable.c
@@ -24,7 +24,8 @@
   *-------------------------------------------------------------------------
  */
 
-void init_packobject(pack_info_t *obj) {
+void init_packobject(pack_info_t *obj)
+{
     int j, k;
 
     HDstrcpy(obj->path, "\0");
@@ -49,11 +50,12 @@ void init_packobject(pack_info_t *obj) {
  *-------------------------------------------------------------------------
  */
 
-static void aux_tblinsert_filter(pack_opttbl_t *table, unsigned int I, filter_info_t filt) {
+static void aux_tblinsert_filter(pack_opttbl_t *table, unsigned int I, filter_info_t filt)
+{
     if (table->objs[I].nfilters < H5_REPACK_MAX_NFILTERS)
         table->objs[I].filter[table->objs[I].nfilters++] = filt;
     else
-        H5TOOLS_INFO(H5E_tools_min_id_g, "cannot insert the filter in this object. Maximum capacity exceeded");
+        H5TOOLS_INFO("cannot insert the filter in this object. Maximum capacity exceeded");
 }
 
 /*-------------------------------------------------------------------------
@@ -64,7 +66,8 @@ static void aux_tblinsert_filter(pack_opttbl_t *table, unsigned int I, filter_in
  * Return: void
  *-------------------------------------------------------------------------
  */
-static void aux_tblinsert_layout(pack_opttbl_t *table, unsigned int I, pack_info_t *pack) {
+static void aux_tblinsert_layout(pack_opttbl_t *table, unsigned int I, pack_info_t *pack)
+{
     int k;
 
     table->objs[I].layout = pack->layout;
@@ -97,21 +100,23 @@ static int
 aux_inctable(pack_opttbl_t *table, unsigned n_objs)
 {
     unsigned u;
+    int ret_value = 0;
 
     table->size += n_objs;
     table->objs = (pack_info_t*) HDrealloc(table->objs, table->size * sizeof(pack_info_t));
     if (table->objs == NULL) {
-        H5TOOLS_INFO(H5E_tools_min_id_g, "not enough memory for options table");
-        return -1;
+        H5TOOLS_INFO("not enough memory for options table");
+        ret_value = -1;
+    }
+    else {
+        for (u = table->nelems; u < table->size; u++)
+            init_packobject(&table->objs[u]);
     }
 
-    for (u = table->nelems; u < table->size; u++)
-        init_packobject(&table->objs[u]);
-
-    return 0;
+    return ret_value;
 }
 
-
+
 /*-------------------------------------------------------------------------
  * Function: options_table_init
  *
@@ -123,28 +128,28 @@ aux_inctable(pack_opttbl_t *table, unsigned n_objs)
 int options_table_init(pack_opttbl_t **tbl) {
     unsigned int i;
     pack_opttbl_t *table;
+    int ret_value = 0;
 
     if (NULL == (table = (pack_opttbl_t *) HDmalloc(sizeof(pack_opttbl_t)))) {
-        H5TOOLS_INFO(H5E_tools_min_id_g, "not enough memory for options table");
-        return -1;
+        H5TOOLS_GOTO_ERROR((-1), "not enough memory for options table");
     }
 
     table->size = 30;
     table->nelems = 0;
     if (NULL == (table->objs = (pack_info_t*) HDmalloc(table->size * sizeof(pack_info_t)))) {
-        H5TOOLS_INFO(H5E_tools_min_id_g, "not enough memory for options table");
         HDfree(table);
-        return -1;
+        H5TOOLS_GOTO_ERROR((-1), "not enough memory for options table");
     }
 
     for (i = 0; i < table->size; i++)
         init_packobject(&table->objs[i]);
 
     *tbl = table;
-    return 0;
+done:
+    return ret_value;
 }
 
-
+
 /*-------------------------------------------------------------------------
  * Function: options_table_free
  *
@@ -174,6 +179,7 @@ options_add_layout(obj_list_t *obj_list, unsigned  n_objs, pack_info_t *pack, pa
     unsigned i, j, I;
     unsigned added = 0;
     hbool_t found = FALSE;
+    int ret_value = 0;
 
     /* increase the size of the collection by N_OBJS if necessary */
     if (table->nelems + n_objs >= table->size)
@@ -190,7 +196,7 @@ options_add_layout(obj_list_t *obj_list, unsigned  n_objs, pack_info_t *pack, pa
                 if (HDstrcmp(obj_list[j].obj,table->objs[i].path) == 0) {
                     /* already chunk info inserted for this one; exit */
                     if (table->objs[i].chunk.rank > 0) {
-                        H5TOOLS_INFO(H5E_tools_min_id_g, "chunk information already inserted for <%s>\n", obj_list[j].obj);
+                        H5TOOLS_INFO("chunk information already inserted for <%s>\n", obj_list[j].obj);
                         HDexit(EXIT_FAILURE);
                     }
                     /* insert the layout info */
@@ -237,7 +243,7 @@ options_add_layout(obj_list_t *obj_list, unsigned  n_objs, pack_info_t *pack, pa
 
     table->nelems += added;
 
-    return 0;
+    return ret_value;
 }
 
 /*-------------------------------------------------------------------------
diff --git a/tools/src/h5repack/h5repack_parse.c b/tools/src/h5repack/h5repack_parse.c
index 03fcf0e..95cacc1 100644
--- a/tools/src/h5repack/h5repack_parse.c
+++ b/tools/src/h5repack/h5repack_parse.c
@@ -228,7 +228,7 @@ obj_list_t* parse_filter(const char *str, unsigned *n_objs, filter_info_t *filt,
                                 l = 0;
                             }
                             else if (f == -1) {
-                                filt->filt_flag = HDstrtoul(stype, NULL, 0);
+                                filt->filt_flag = (unsigned)HDstrtoul(stype, NULL, 0);
                                 f = 0;
                             }
                             else if (p == -1) {
diff --git a/tools/src/h5repack/h5repack_refs.c b/tools/src/h5repack/h5repack_refs.c
index f62ad74..23dc8c2 100644
--- a/tools/src/h5repack/h5repack_refs.c
+++ b/tools/src/h5repack/h5repack_refs.c
@@ -22,7 +22,7 @@
  */
 
 static const char* MapIdToName(hid_t refobj_id,trav_table_t *travt);
-static int copy_refs_attr(hid_t loc_in, hid_t loc_out, 
+static int copy_refs_attr(hid_t loc_in, hid_t loc_out,
                           trav_table_t *travt, hid_t fidout);
 static herr_t update_ref_value(hid_t obj_id, H5R_type_t ref_type, void *ref_in,
         hid_t fid_out, void *ref_out, trav_table_t *travt);
@@ -42,16 +42,15 @@ int do_copy_refobjs(hid_t fidin,
                     trav_table_t *travt,
                     pack_opt_t *options) /* repack options */
 {
-    int       ret_value = 0;          /*no need to LEAVE() on ERROR: HERR_INIT(int, SUCCEED) */
-    hid_t     grp_in = -1;            /* read group ID */
-    hid_t     grp_out = -1;           /* write group ID */
-    hid_t     dset_in = -1;           /* read dataset ID */
-    hid_t     dset_out = -1;          /* write dataset ID */
-    hid_t     type_in = -1;           /* named type ID */
-    hid_t     dcpl_id = -1;           /* dataset creation property list ID */
-    hid_t     space_id = -1;          /* space ID */
-    hid_t     ftype_id = -1;          /* file data type ID */
-    hid_t     mtype_id = -1;          /* memory data type ID */
+    hid_t     grp_in = H5I_INVALID_HID;            /* read group ID */
+    hid_t     grp_out = H5I_INVALID_HID;           /* write group ID */
+    hid_t     dset_in = H5I_INVALID_HID;           /* read dataset ID */
+    hid_t     dset_out = H5I_INVALID_HID;          /* write dataset ID */
+    hid_t     type_in = H5I_INVALID_HID;           /* named type ID */
+    hid_t     dcpl_id = H5I_INVALID_HID;           /* dataset creation property list ID */
+    hid_t     space_id = H5I_INVALID_HID;          /* space ID */
+    hid_t     ftype_id = H5I_INVALID_HID;          /* file data type ID */
+    hid_t     mtype_id = H5I_INVALID_HID;          /* memory data type ID */
     size_t    msize;                  /* memory size of memory type */
     hsize_t   nelmts;                 /* number of elements in dataset */
     int       rank;                   /* rank of dataset */
@@ -59,6 +58,7 @@ int do_copy_refobjs(hid_t fidin,
     unsigned int i, j;
     int       k;
     named_dt_t *named_dt_head = NULL; /* Pointer to the stack of named datatypes copied */
+    int       ret_value = 0;
 
     /*-------------------------------------------------------------------------
     * browse
@@ -76,18 +76,18 @@ int do_copy_refobjs(hid_t fidin,
                  *-------------------------------------------------------------------------
                  */
                 if((grp_out = H5Gopen2(fidout, travt->objs[i].name, H5P_DEFAULT)) < 0)
-                    HGOTO_ERROR(FAIL, H5E_tools_min_id_g, "H5Gopen2 failed");
+                    H5TOOLS_GOTO_ERROR((-1), "H5Gopen2 failed");
 
                 if((grp_in = H5Gopen2(fidin, travt->objs[i].name, H5P_DEFAULT)) < 0)
-                    HGOTO_ERROR(FAIL, H5E_tools_min_id_g, "H5Gopen2 failed");
+                    H5TOOLS_GOTO_ERROR((-1), "H5Gopen2 failed");
 
                 if(copy_refs_attr(grp_in, grp_out, travt, fidout) < 0)
-                    HGOTO_ERROR(FAIL, H5E_tools_min_id_g, "copy_refs_attr failed");
+                    H5TOOLS_GOTO_ERROR((-1), "copy_refs_attr failed");
 
                 if(H5Gclose(grp_out) < 0)
-                    HGOTO_ERROR(FAIL, H5E_tools_min_id_g, "H5Gclose failed");
+                    H5TOOLS_GOTO_ERROR((-1), "H5Gclose failed");
                 if(H5Gclose(grp_in) < 0)
-                    HGOTO_ERROR(FAIL, H5E_tools_min_id_g, "H5Gclose failed");
+                    H5TOOLS_GOTO_ERROR((-1), "H5Gclose failed");
 
                 /*-------------------------------------------------------------------------
                  * check for hard links
@@ -104,26 +104,26 @@ int do_copy_refobjs(hid_t fidin,
              */
             case H5TRAV_TYPE_DATASET:
                 if((dset_in = H5Dopen2(fidin, travt->objs[i].name, H5P_DEFAULT)) < 0)
-                    HGOTO_ERROR(FAIL, H5E_tools_min_id_g, "H5Dopen2 failed");
+                    H5TOOLS_GOTO_ERROR((-1), "H5Dopen2 failed");
                 if((space_id = H5Dget_space(dset_in)) < 0)
-                    HGOTO_ERROR(FAIL, H5E_tools_min_id_g, "H5Dget_space failed");
+                    H5TOOLS_GOTO_ERROR((-1), "H5Dget_space failed");
                 if((ftype_id = H5Dget_type(dset_in)) < 0)
-                    HGOTO_ERROR(FAIL, H5E_tools_min_id_g, "H5Dget_type failed");
+                    H5TOOLS_GOTO_ERROR((-1), "H5Dget_type failed");
                 if((dcpl_id = H5Dget_create_plist(dset_in)) < 0)
-                    HGOTO_ERROR(FAIL, H5E_tools_min_id_g, "H5Dget_create_plist failed");
+                    H5TOOLS_GOTO_ERROR((-1), "H5Dget_create_plist failed");
                 if((rank = H5Sget_simple_extent_ndims(space_id)) < 0)
-                    HGOTO_ERROR(FAIL, H5E_tools_min_id_g, "H5Sget_simple_extent_ndims failed");
+                    H5TOOLS_GOTO_ERROR((-1), "H5Sget_simple_extent_ndims failed");
                 if(H5Sget_simple_extent_dims(space_id, dims, NULL) < 0)
-                    HGOTO_ERROR(FAIL, H5E_tools_min_id_g, "H5Sget_simple_extent_dims failed");
+                    H5TOOLS_GOTO_ERROR((-1), "H5Sget_simple_extent_dims failed");
                 nelmts = 1;
                 for(k = 0; k < rank; k++)
                     nelmts *= dims[k];
 
                 if((mtype_id = H5Tget_native_type(ftype_id, H5T_DIR_DEFAULT)) < 0)
-                    HGOTO_ERROR(FAIL, H5E_tools_min_id_g, "H5Tget_native_type failed");
+                    H5TOOLS_GOTO_ERROR((-1), "H5Tget_native_type failed");
 
                 if((msize = H5Tget_size(mtype_id)) == 0)
-                    HGOTO_ERROR(FAIL, H5E_tools_min_id_g, "H5Tget_size failed");
+                    H5TOOLS_GOTO_ERROR((-1), "H5Tget_size failed");
 
                 /*-------------------------------------------------------------------------
                  * check if the dataset creation property list has filters that
@@ -145,7 +145,7 @@ int do_copy_refobjs(hid_t fidin,
                      *-------------------------------------------------------------------------
                      */
                     if(H5Tequal(mtype_id, H5T_STD_REF_OBJ)) {
-                        hid_t            refobj_id = -1;
+                        hid_t            refobj_id = H5I_INVALID_HID;
                         hobj_ref_t       *refbuf = NULL; /* buffer for object references */
                         hobj_ref_t       *buf = NULL;
                         const char*      refname;
@@ -159,15 +159,15 @@ int do_copy_refobjs(hid_t fidin,
                             buf = (hobj_ref_t *)HDmalloc((unsigned)(nelmts * msize));
                             if(buf==NULL) {
                                 HDprintf("cannot read into memory\n" );
-                                HGOTO_ERROR(FAIL, H5E_tools_min_id_g, "HDmalloc failed");
+                                H5TOOLS_GOTO_ERROR((-1), "HDmalloc failed");
                             } /* end if */
                             if(H5Dread(dset_in, mtype_id, H5S_ALL, H5S_ALL, H5P_DEFAULT, buf) < 0)
-                                HGOTO_ERROR(FAIL, H5E_tools_min_id_g, "H5Dread failed");
+                                H5TOOLS_GOTO_ERROR((-1), "H5Dread failed");
 
                             refbuf = (hobj_ref_t*) HDcalloc((unsigned)nelmts, msize);
                             if(refbuf == NULL){
                                 HDprintf("cannot allocate memory\n" );
-                                HGOTO_ERROR(FAIL, H5E_tools_min_id_g, "HDcalloc failed");
+                                H5TOOLS_GOTO_ERROR((-1), "HDcalloc failed");
                             } /* end if */
                             for(u = 0; u < nelmts; u++) {
                                 H5E_BEGIN_TRY {
@@ -181,7 +181,7 @@ int do_copy_refobjs(hid_t fidin,
                                 if((refname = MapIdToName(refobj_id, travt)) != NULL) {
                                     /* create the reference, -1 parameter for objects */
                                     if(H5Rcreate(&refbuf[u], fidout, refname, H5R_OBJECT, (hid_t)-1) < 0)
-                                        HGOTO_ERROR(FAIL, H5E_tools_min_id_g, "H5Rcreate failed");
+                                        H5TOOLS_GOTO_ERROR((-1), "H5Rcreate failed");
                                     if(options->verbose) {
                                         HDprintf(FORMAT_OBJ,"dset",travt->objs[i].name );
                                         HDprintf("object <%s> object reference created to <%s>\n",
@@ -190,7 +190,7 @@ int do_copy_refobjs(hid_t fidin,
                                     }
                                 } /*refname*/
                                 if (H5Oclose(refobj_id) < 0)
-                                    H5TOOLS_INFO(H5E_tools_min_id_g, "H5Oclose refob failed");
+                                    H5TOOLS_ERROR((-1), "H5Oclose refob failed");
                             } /* u */
                         } /*nelmts*/
 
@@ -199,10 +199,10 @@ int do_copy_refobjs(hid_t fidin,
                          *-------------------------------------------------------------------------
                          */
                         if((dset_out = H5Dcreate2(fidout, travt->objs[i].name, mtype_id, space_id, H5P_DEFAULT, dcpl_id, H5P_DEFAULT)) < 0)
-                            HGOTO_ERROR(FAIL, H5E_tools_min_id_g, "H5Dcreate2 failed");
+                            H5TOOLS_GOTO_ERROR((-1), "H5Dcreate2 failed");
                         if(nelmts)
                             if(H5Dwrite(dset_out, mtype_id, H5S_ALL, H5S_ALL, H5P_DEFAULT, refbuf) < 0)
-                                HGOTO_ERROR(FAIL, H5E_tools_min_id_g, "H5Dwrite failed");
+                                H5TOOLS_GOTO_ERROR((-1), "H5Dwrite failed");
 
                         if(buf)
                             HDfree(buf);
@@ -213,7 +213,7 @@ int do_copy_refobjs(hid_t fidin,
                         * copy attrs
                         *----------------------------------------------------*/
                         if(copy_attr(dset_in, dset_out, &named_dt_head, travt, options) < 0)
-                            HGOTO_ERROR(FAIL, H5E_tools_min_id_g, "copy_attr failed");
+                            H5TOOLS_GOTO_ERROR((-1), "copy_attr failed");
                     } /*H5T_STD_REF_OBJ*/
 
                     /*-------------------------------------------------------------------------
@@ -221,7 +221,7 @@ int do_copy_refobjs(hid_t fidin,
                      *-------------------------------------------------------------------------
                      */
                     else if(H5Tequal(mtype_id, H5T_STD_REF_DSETREG)) {
-                        hid_t            refobj_id = -1;
+                        hid_t            refobj_id = H5I_INVALID_HID;
                         hdset_reg_ref_t  *refbuf = NULL; /* input buffer for region references */
                         hdset_reg_ref_t  *buf = NULL;    /* output buffer */
                         const char*      refname;
@@ -235,10 +235,10 @@ int do_copy_refobjs(hid_t fidin,
                             buf = (hdset_reg_ref_t *)HDmalloc((unsigned)(nelmts * msize));
                             if(buf == NULL) {
                                 HDprintf("cannot read into memory\n");
-                                HGOTO_ERROR(FAIL, H5E_tools_min_id_g, "HDmalloc failed");
+                                H5TOOLS_GOTO_ERROR((-1), "HDmalloc failed");
                             } /* end if */
                             if(H5Dread(dset_in, mtype_id, H5S_ALL, H5S_ALL, H5P_DEFAULT, buf) < 0)
-                                HGOTO_ERROR(FAIL, H5E_tools_min_id_g, "H5Dread failed");
+                                H5TOOLS_GOTO_ERROR((-1), "H5Dread failed");
 
                             /*-------------------------------------------------------------------------
                              * create output
@@ -247,7 +247,7 @@ int do_copy_refobjs(hid_t fidin,
                             refbuf = (hdset_reg_ref_t *)HDcalloc(sizeof(hdset_reg_ref_t), (size_t)nelmts); /*init to zero */
                             if(refbuf == NULL) {
                                 HDprintf("cannot allocate memory\n");
-                                HGOTO_ERROR(FAIL, H5E_tools_min_id_g, "HDcalloc failed");
+                                H5TOOLS_GOTO_ERROR((-1), "HDcalloc failed");
                             } /* end if */
 
                             for(u = 0; u < nelmts; u++) {
@@ -260,16 +260,16 @@ int do_copy_refobjs(hid_t fidin,
                                  * in the second traversal of the file
                                  */
                                 if((refname = MapIdToName(refobj_id, travt)) != NULL) {
-                                    hid_t region_id = -1;    /* region id of the referenced dataset */
+                                    hid_t region_id = H5I_INVALID_HID;    /* region id of the referenced dataset */
 
                                     if((region_id = H5Rget_region(dset_in, H5R_DATASET_REGION, &buf[u])) < 0)
-                                        HGOTO_ERROR(FAIL, H5E_tools_min_id_g, "H5Rget_region failed");
+                                        H5TOOLS_GOTO_ERROR((-1), "H5Rget_region failed");
 
                                     /* create the reference, we need the space_id */
                                     if(H5Rcreate(&refbuf[u], fidout, refname, H5R_DATASET_REGION, region_id) < 0)
-                                        HGOTO_ERROR(FAIL, H5E_tools_min_id_g, "H5Rcreate failed");
+                                        H5TOOLS_GOTO_ERROR((-1), "H5Rcreate failed");
                                     if(H5Sclose(region_id) < 0)
-                                        HGOTO_ERROR(FAIL, H5E_tools_min_id_g, "H5Sclose failed");
+                                        H5TOOLS_GOTO_ERROR((-1), "H5Sclose failed");
                                     if(options->verbose) {
                                         HDprintf(FORMAT_OBJ,"dset",travt->objs[i].name );
                                         HDprintf("object <%s> region reference created to <%s>\n",
@@ -278,7 +278,7 @@ int do_copy_refobjs(hid_t fidin,
                                     }
                                 } /*refname*/
                                 if (H5Oclose(refobj_id) < 0)
-                                    H5TOOLS_INFO(H5E_tools_min_id_g, "H5Oclose refobj_id failed");
+                                    H5TOOLS_ERROR((-1), "H5Oclose refobj_id failed");
                             } /* u */
                         } /*nelmts*/
 
@@ -287,10 +287,10 @@ int do_copy_refobjs(hid_t fidin,
                          *-------------------------------------------------------------------------
                          */
                         if((dset_out = H5Dcreate2(fidout, travt->objs[i].name, mtype_id, space_id, H5P_DEFAULT, dcpl_id, H5P_DEFAULT)) < 0)
-                            HGOTO_ERROR(FAIL, H5E_tools_min_id_g, "H5Dcreate2 failed");
+                            H5TOOLS_GOTO_ERROR((-1), "H5Dcreate2 failed");
                         if(nelmts)
                             if(H5Dwrite(dset_out, mtype_id, H5S_ALL, H5S_ALL, H5P_DEFAULT, refbuf) < 0)
-                                HGOTO_ERROR(FAIL, H5E_tools_min_id_g, "H5Dwrite failed");
+                                H5TOOLS_GOTO_ERROR((-1), "H5Dwrite failed");
 
                         if(buf)
                             HDfree(buf);
@@ -301,7 +301,7 @@ int do_copy_refobjs(hid_t fidin,
                         * copy attrs
                         *----------------------------------------------------*/
                         if(copy_attr(dset_in, dset_out, &named_dt_head, travt, options) < 0)
-                            HGOTO_ERROR(FAIL, H5E_tools_min_id_g, "copy_attr failed");
+                            H5TOOLS_GOTO_ERROR((-1), "copy_attr failed");
                     } /* H5T_STD_REF_DSETREG */
                     /*-------------------------------------------------------------------------
                      * not references, open previously created object in 1st traversal
@@ -309,7 +309,7 @@ int do_copy_refobjs(hid_t fidin,
                      */
                     else {
                         if((dset_out = H5Dopen2(fidout, travt->objs[i].name, H5P_DEFAULT)) < 0)
-                            HGOTO_ERROR(FAIL, H5E_tools_min_id_g, "H5Dopen2 failed");
+                            H5TOOLS_GOTO_ERROR((-1), "H5Dopen2 failed");
                     } /* end else */
 
                     /*-------------------------------------------------------------------------
@@ -317,7 +317,7 @@ int do_copy_refobjs(hid_t fidin,
                      *-------------------------------------------------------------------------
                      */
                     if(copy_refs_attr(dset_in, dset_out, travt, fidout) < 0)
-                        HGOTO_ERROR(FAIL, H5E_tools_min_id_g, "copy_refs_attr failed");
+                        H5TOOLS_GOTO_ERROR((-1), "copy_refs_attr failed");
 
                     /*-------------------------------------------------------------------------
                      * check for hard links
@@ -328,7 +328,7 @@ int do_copy_refobjs(hid_t fidin,
                             H5Lcreate_hard(fidout, travt->objs[i].name, H5L_SAME_LOC, travt->objs[i].links[j].new_name, H5P_DEFAULT, H5P_DEFAULT);
 
                     if(H5Dclose(dset_out) < 0)
-                        HGOTO_ERROR(FAIL, H5E_tools_min_id_g, "H5Dclose failed");
+                        H5TOOLS_GOTO_ERROR((-1), "H5Dclose failed");
                 } /*can_read*/
 
                 /*-------------------------------------------------------------------------
@@ -336,15 +336,15 @@ int do_copy_refobjs(hid_t fidin,
                  *-------------------------------------------------------------------------
                  */
                 if(H5Tclose(ftype_id) < 0)
-                    HGOTO_ERROR(FAIL, H5E_tools_min_id_g, "H5Tclose failed");
+                    H5TOOLS_GOTO_ERROR((-1), "H5Tclose failed");
                 if(H5Tclose(mtype_id) < 0)
-                    HGOTO_ERROR(FAIL, H5E_tools_min_id_g, "H5Tclose failed");
+                    H5TOOLS_GOTO_ERROR((-1), "H5Tclose failed");
                 if(H5Pclose(dcpl_id) < 0)
-                    HGOTO_ERROR(FAIL, H5E_tools_min_id_g, "H5Pclose failed");
+                    H5TOOLS_GOTO_ERROR((-1), "H5Pclose failed");
                 if(H5Sclose(space_id) < 0)
-                    HGOTO_ERROR(FAIL, H5E_tools_min_id_g, "H5Sclose failed");
+                    H5TOOLS_GOTO_ERROR((-1), "H5Sclose failed");
                 if(H5Dclose(dset_in) < 0)
-                    HGOTO_ERROR(FAIL, H5E_tools_min_id_g, "H5Dclose failed");
+                    H5TOOLS_GOTO_ERROR((-1), "H5Dclose failed");
                 break;
 
             /*-------------------------------------------------------------------------
@@ -353,9 +353,9 @@ int do_copy_refobjs(hid_t fidin,
              */
             case H5TRAV_TYPE_NAMED_DATATYPE:
                 if((type_in = H5Topen2(fidin, travt->objs[i].name, H5P_DEFAULT)) < 0)
-                    HGOTO_ERROR(FAIL, H5E_tools_min_id_g, "H5Topen2 failed");
+                    H5TOOLS_GOTO_ERROR((-1), "H5Topen2 failed");
                 if(H5Tclose(type_in) < 0)
-                    HGOTO_ERROR(FAIL, H5E_tools_min_id_g, "H5Tclose failed");
+                    H5TOOLS_GOTO_ERROR((-1), "H5Tclose failed");
                 break;
 
             /*-------------------------------------------------------------------------
@@ -368,7 +368,8 @@ int do_copy_refobjs(hid_t fidin,
 
             case H5TRAV_TYPE_UNKNOWN:
             case H5TRAV_TYPE_UDLINK:
-                HGOTO_ERROR(FAIL, H5E_tools_min_id_g, "H5TRAV invalid type");
+                H5TOOLS_GOTO_ERROR((-1), "H5TRAV invalid type");
+                break;
 
             default:
                 break;
@@ -380,7 +381,7 @@ int do_copy_refobjs(hid_t fidin,
      * in copy_attr(), so need to free.
      */
     if (named_datatype_free(&named_dt_head, 0) < 0)
-        H5TOOLS_INFO(H5E_tools_min_id_g, "named_datatype_free failed");
+        H5TOOLS_ERROR((-1), "named_datatype_free failed");
 
     return ret_value;
 
@@ -429,12 +430,11 @@ static int copy_refs_attr(hid_t loc_in,
                           trav_table_t *travt,
                           hid_t fidout)         /* for saving references */
 {
-    int         ret_value = 0;     /*no need to LEAVE() on ERROR: HERR_INIT(int, SUCCEED) */
-    hid_t       attr_id = -1;      /* attr ID */
-    hid_t       attr_out = -1;     /* attr ID */
-    hid_t       space_id = -1;     /* space ID */
-    hid_t       ftype_id = -1;     /* file data type ID */
-    hid_t       mtype_id = -1;     /* memory data type ID */
+    hid_t       attr_id = H5I_INVALID_HID;      /* attr ID */
+    hid_t       attr_out = H5I_INVALID_HID;     /* attr ID */
+    hid_t       space_id = H5I_INVALID_HID;     /* space ID */
+    hid_t       ftype_id = H5I_INVALID_HID;     /* file data type ID */
+    hid_t       mtype_id = H5I_INVALID_HID;     /* memory data type ID */
     size_t      msize;             /* memory size of type */
     hsize_t     nelmts;            /* number of elements in dataset */
     hsize_t     dims[H5S_MAX_RANK];/* dimensions of dataset */
@@ -452,29 +452,30 @@ static int copy_refs_attr(hid_t loc_in,
     unsigned   *ref_comp_index = NULL;
     size_t     *ref_comp_size = NULL;
     int         ref_comp_field_n = 0;
+    int         ret_value = 0;
 
 
     if(H5Oget_info2(loc_in, &oinfo, H5O_INFO_NUM_ATTRS) < 0)
-        HGOTO_ERROR(FAIL, H5E_tools_min_id_g, "H5Oget_info failed");
+        H5TOOLS_GOTO_ERROR((-1), "H5Oget_info failed");
 
     for(u = 0; u < (unsigned)oinfo.num_attrs; u++) {
         is_ref = is_ref_vlen = is_ref_array = is_ref_comp = 0;
 
         /* open attribute */
         if((attr_id = H5Aopen_by_idx(loc_in, ".", H5_INDEX_CRT_ORDER, H5_ITER_INC, (hsize_t)u, H5P_DEFAULT, H5P_DEFAULT)) < 0)
-            HGOTO_ERROR(FAIL, H5E_tools_min_id_g, "H5Aopen_by_idx failed");
+            H5TOOLS_GOTO_ERROR((-1), "H5Aopen_by_idx failed");
 
         /* get the file datatype  */
         if((ftype_id = H5Aget_type(attr_id)) < 0)
-            HGOTO_ERROR(FAIL, H5E_tools_min_id_g, "H5Aget_type failed");
+            H5TOOLS_GOTO_ERROR((-1), "H5Aget_type failed");
 
         type_class = H5Tget_class(ftype_id);
 
         if((mtype_id = H5Tget_native_type(ftype_id, H5T_DIR_DEFAULT)) < 0)
-            HGOTO_ERROR(FAIL, H5E_tools_min_id_g, "H5Tget_native_type failed");
+            H5TOOLS_GOTO_ERROR((-1), "H5Tget_native_type failed");
 
         if((msize = H5Tget_size(mtype_id)) == 0)
-            HGOTO_ERROR(FAIL, H5E_tools_min_id_g, "H5Tget_size failed");
+            H5TOOLS_GOTO_ERROR((-1), "H5Tget_size failed");
 
         is_ref = (type_class == H5T_REFERENCE);
 
@@ -484,7 +485,7 @@ static int copy_refs_attr(hid_t loc_in,
             is_ref_vlen = (H5Tget_class(base_type) == H5T_REFERENCE);
             msize = H5Tget_size(base_type);
             if (H5Tclose(base_type) < 0)
-                H5TOOLS_INFO(H5E_tools_min_id_g, "H5Tclose base_type failed");
+                H5TOOLS_ERROR((-1), "H5Tclose base_type failed");
         }
         else if(type_class == H5T_ARRAY ) {
             hid_t base_type = H5Tget_super(ftype_id);
@@ -492,13 +493,13 @@ static int copy_refs_attr(hid_t loc_in,
             is_ref_array = (H5Tget_class(base_type) == H5T_REFERENCE);
             msize = H5Tget_size(base_type);
             if (H5Tclose(base_type) < 0)
-                H5TOOLS_INFO(H5E_tools_min_id_g, "H5Tclose base_type failed");
+                H5TOOLS_GOTO_ERROR((-1), "H5Tclose base_type failed");
         }
         else if(type_class == H5T_COMPOUND) {
             int nmembers = H5Tget_nmembers(ftype_id) ;
 
             if (nmembers < 1)
-                HGOTO_ERROR(FAIL, H5E_tools_min_id_g, "H5Tget_nmembers failed");
+                H5TOOLS_GOTO_ERROR((-1), "H5Tget_nmembers failed");
 
             ref_comp_index = (unsigned *)HDmalloc((size_t)nmembers*sizeof(unsigned));
             ref_comp_size = (size_t *)HDmalloc((size_t)nmembers*sizeof(ref_comp_size));
@@ -513,7 +514,7 @@ static int copy_refs_attr(hid_t loc_in,
                     ref_comp_field_n++;
                 }
                 if (H5Tclose(mtid) < 0)
-                    H5TOOLS_INFO(H5E_tools_min_id_g, "H5Tclose mtid failed");
+                    H5TOOLS_ERROR((-1), "H5Tclose mtid failed");
             }
 
             /* if compound don't contain reference type member, free the above
@@ -543,25 +544,25 @@ static int copy_refs_attr(hid_t loc_in,
 
         if (!(is_ref || is_ref_vlen || is_ref_array || is_ref_comp)) {
             if (H5Tclose(mtype_id) < 0)
-                H5TOOLS_INFO(H5E_tools_min_id_g, "H5Tclose mtype_id failed");
+                H5TOOLS_ERROR((-1), "H5Tclose mtype_id failed");
             if (H5Tclose(ftype_id) < 0)
-                H5TOOLS_INFO(H5E_tools_min_id_g, "H5Tclose ftype_id failed");
+                H5TOOLS_ERROR((-1), "H5Tclose ftype_id failed");
             if (H5Aclose(attr_id) < 0)
-                H5TOOLS_INFO(H5E_tools_min_id_g, "H5Aclose attr_id failed");
+                H5TOOLS_ERROR((-1), "H5Aclose attr_id failed");
             continue;
         }
 
         /* get name */
         if(H5Aget_name(attr_id, 255, name) < 0)
-            HGOTO_ERROR(FAIL, H5E_tools_min_id_g, "H5Aget_name failed");
+            H5TOOLS_GOTO_ERROR((-1), "H5Aget_name failed");
 
         /* get the dataspace handle  */
         if((space_id = H5Aget_space(attr_id)) < 0)
-            HGOTO_ERROR(FAIL, H5E_tools_min_id_g, "H5Aget_space failed");
+            H5TOOLS_GOTO_ERROR((-1), "H5Aget_space failed");
 
         /* get dimensions  */
         if((rank = H5Sget_simple_extent_dims(space_id, dims, NULL)) < 0)
-            HGOTO_ERROR(FAIL, H5E_tools_min_id_g, "H5Sget_simple_extent_dims failed");
+            H5TOOLS_GOTO_ERROR((-1), "H5Sget_simple_extent_dims failed");
 
 
         /*-------------------------------------------------------------------------
@@ -580,7 +581,7 @@ static int copy_refs_attr(hid_t loc_in,
 
             msize = H5Tget_size(base_type);
             if (H5Tclose(base_type) < 0)
-                H5TOOLS_INFO(H5E_tools_min_id_g, "H5Tclose base_type failed");
+                H5TOOLS_ERROR((-1), "H5Tclose base_type failed");
 
             array_rank = (unsigned)H5Tget_array_ndims(mtype_id);
             H5Tget_array_dims2(mtype_id, array_dims);
@@ -590,7 +591,7 @@ static int copy_refs_attr(hid_t loc_in,
         }
 
         if((attr_out = H5Acreate2(loc_out, name, ftype_id, space_id, H5P_DEFAULT, H5P_DEFAULT)) < 0)
-            HGOTO_ERROR(FAIL, H5E_tools_min_id_g, "H5Acreate2 failed");
+            H5TOOLS_GOTO_ERROR((-1), "H5Acreate2 failed");
 
         if (nelmts>0) {
             /* handle object references */
@@ -598,15 +599,15 @@ static int copy_refs_attr(hid_t loc_in,
                 buf = (hobj_ref_t *)HDmalloc((unsigned)(nelmts * msize));
                 if(buf == NULL) {
                     HDprintf("cannot read into memory\n");
-                    HGOTO_ERROR(FAIL, H5E_tools_min_id_g, "HDmalloc failed");
+                    H5TOOLS_GOTO_ERROR((-1), "HDmalloc failed");
                 } /* end if */
                 if(H5Aread(attr_id, mtype_id, buf) < 0)
-                    HGOTO_ERROR(FAIL, H5E_tools_min_id_g, "H5Aread failed");
+                    H5TOOLS_GOTO_ERROR((-1), "H5Aread failed");
 
                 refbuf = (hobj_ref_t *)HDcalloc((unsigned)nelmts, msize);
                 if(refbuf == NULL) {
                     HDprintf("cannot allocate memory\n");
-                    HGOTO_ERROR(FAIL, H5E_tools_min_id_g, "HDcalloc failed");
+                    H5TOOLS_GOTO_ERROR((-1), "HDcalloc failed");
                 } /* end if */
 
                 for(i = 0; i < (unsigned)nelmts; i++)
@@ -619,10 +620,10 @@ static int copy_refs_attr(hid_t loc_in,
 
                 if(buf == NULL) {
                     HDprintf( "cannot read into memory\n" );
-                    HGOTO_ERROR(FAIL, H5E_tools_min_id_g, "HDmalloc failed");
+                    H5TOOLS_GOTO_ERROR((-1), "HDmalloc failed");
                 } /* end if */
                 if(H5Aread(attr_id, mtype_id, buf) < 0)
-                    HGOTO_ERROR(FAIL, H5E_tools_min_id_g, "H5Aread failed");
+                    H5TOOLS_GOTO_ERROR((-1), "H5Aread failed");
 
                 /*-------------------------------------------------------------------------
                  * create output
@@ -631,7 +632,7 @@ static int copy_refs_attr(hid_t loc_in,
                 refbuf = (hdset_reg_ref_t *)HDcalloc(sizeof(hdset_reg_ref_t), (size_t)nelmts); /*init to zero */
                 if(refbuf == NULL) {
                     HDprintf( "cannot allocate memory\n" );
-                    HGOTO_ERROR(FAIL, H5E_tools_min_id_g, "HDcalloc failed");
+                    H5TOOLS_GOTO_ERROR((-1), "HDcalloc failed");
                 } /* end if */
 
                 for(i = 0; i < (unsigned)nelmts; i++)
@@ -646,11 +647,11 @@ static int copy_refs_attr(hid_t loc_in,
 
                 if(buf == NULL) {
                     HDprintf( "cannot read into memory\n" );
-                    HGOTO_ERROR(FAIL, H5E_tools_min_id_g, "HDmalloc failed");
+                    H5TOOLS_GOTO_ERROR((-1), "HDmalloc failed");
                 } /* end if */
 
                 if(H5Aread(attr_id, mtype_id, buf) < 0)
-                    HGOTO_ERROR(FAIL, H5E_tools_min_id_g, "H5Aread failed");
+                    H5TOOLS_GOTO_ERROR((-1), "H5Aread failed");
 
                 if (H5R_OBJ_REF_BUF_SIZE==msize) {
                     hobj_ref_t ref_out;
@@ -687,11 +688,11 @@ static int copy_refs_attr(hid_t loc_in,
 
                 if(buf == NULL) {
                     HDprintf( "cannot read into memory\n" );
-                    HGOTO_ERROR(FAIL, H5E_tools_min_id_g, "HDmalloc failed");
+                    H5TOOLS_GOTO_ERROR((-1), "HDmalloc failed");
                 } /* end if */
 
                 if(H5Aread(attr_id, mtype_id, buf) < 0)
-                    HGOTO_ERROR(FAIL, H5E_tools_min_id_g, "H5Aread failed");
+                    H5TOOLS_GOTO_ERROR((-1), "H5Aread failed");
 
                 for (i=0; i<(unsigned)nelmts; i++) {
                     for (j=0; j<(unsigned)ref_comp_field_n; j++) {
@@ -716,7 +717,7 @@ static int copy_refs_attr(hid_t loc_in,
             } /* else if (is_ref_comp) */
 
             if(H5Awrite(attr_out, mtype_id, refbuf) < 0)
-                HGOTO_ERROR(FAIL, H5E_tools_min_id_g, "H5Awrite failed");
+                H5TOOLS_GOTO_ERROR((-1), "H5Awrite failed");
 
             if (is_ref_vlen && buf)
                 H5Dvlen_reclaim (mtype_id, space_id, H5P_DEFAULT, buf);
@@ -746,20 +747,20 @@ static int copy_refs_attr(hid_t loc_in,
         }
 
         if(H5Aclose(attr_out) < 0)
-            HGOTO_ERROR(FAIL, H5E_tools_min_id_g, "H5Aclose failed");
+            H5TOOLS_GOTO_ERROR((-1), "H5Aclose failed");
 
         /*-------------------------------------------------------------------------
         * close
         *-------------------------------------------------------------------------
         */
         if(H5Tclose(ftype_id) < 0)
-            HGOTO_ERROR(FAIL, H5E_tools_min_id_g, "H5Tclose failed");
+            H5TOOLS_GOTO_ERROR((-1), "H5Tclose failed");
         if(H5Tclose(mtype_id) < 0)
-            HGOTO_ERROR(FAIL, H5E_tools_min_id_g, "H5Tclose failed");
+            H5TOOLS_GOTO_ERROR((-1), "H5Tclose failed");
         if(H5Sclose(space_id) < 0)
-            HGOTO_ERROR(FAIL, H5E_tools_min_id_g, "H5Sclose failed");
+            H5TOOLS_GOTO_ERROR((-1), "H5Sclose failed");
         if(H5Aclose(attr_id) < 0)
-            HGOTO_ERROR(FAIL, H5E_tools_min_id_g, "H5Aclose failed");
+            H5TOOLS_GOTO_ERROR((-1), "H5Aclose failed");
     } /* for(u = 0; u < (unsigned)oinfo.num_attrs; u++) */
 
 done:
@@ -812,7 +813,7 @@ MapIdToName(hid_t refobj_id, trav_table_t *travt)
             if(ref_oinfo.addr == travt->objs[u].objno) {
                 ret = travt->objs[u].name;
                 goto out;
-            } /* end if */
+            }
         }  /* end if */
     } /* u */
 
@@ -829,27 +830,27 @@ out:
 static herr_t update_ref_value(hid_t obj_id, H5R_type_t ref_type, void *ref_in,
         hid_t fid_out, void *ref_out, trav_table_t *travt)
 {
-    int         ret_value = 0;   /*no need to LEAVE() on ERROR: HERR_INIT(int, SUCCEED) */
     const char *ref_obj_name;
-    hid_t       space_id = -1;
-    hid_t       ref_obj_id = -1;
+    hid_t       space_id = H5I_INVALID_HID;
+    hid_t       ref_obj_id = H5I_INVALID_HID;
+    herr_t      ret_value = SUCCEED;
 
     ref_obj_id = H5Rdereference2(obj_id, H5P_DEFAULT, ref_type, ref_in);
     if (ref_obj_id < 0)
-        HGOTO_ERROR(FAIL, H5E_tools_min_id_g, "H5Rdereference2 failed");
+        H5TOOLS_GOTO_ERROR(FAIL, "H5Rdereference2 failed");
 
     ref_obj_name = MapIdToName(ref_obj_id, travt);
     if (ref_obj_name == NULL)
-        HGOTO_ERROR(FAIL, H5E_tools_min_id_g, "MapIdToName failed");
+        H5TOOLS_GOTO_ERROR(FAIL, "MapIdToName failed");
 
     if (ref_type == H5R_DATASET_REGION) {
         space_id = H5Rget_region(obj_id, H5R_DATASET_REGION, ref_in);
         if (space_id < 0)
-            HGOTO_ERROR(FAIL, H5E_tools_min_id_g, "H5Rget_region failed");
+            H5TOOLS_GOTO_ERROR(FAIL, "H5Rget_region failed");
     }
 
     if(H5Rcreate(ref_out, fid_out, ref_obj_name, ref_type, space_id) < 0)
-        HGOTO_ERROR(FAIL, H5E_tools_min_id_g, "H5Rcreate failed");
+        H5TOOLS_GOTO_ERROR(FAIL, "H5Rcreate failed");
 
 done:
     H5E_BEGIN_TRY {
diff --git a/tools/src/h5repack/h5repack_verify.c b/tools/src/h5repack/h5repack_verify.c
index dbe8e1a..48de8d7 100644
--- a/tools/src/h5repack/h5repack_verify.c
+++ b/tools/src/h5repack/h5repack_verify.c
@@ -39,26 +39,26 @@ static int verify_filters(hid_t pid, hid_t tid, int nfilters, filter_info_t *fil
 int
 h5repack_verify(const char *in_fname, const char *out_fname, pack_opt_t *options)
 {
-    int          ret_value  = 0;    /*no need to LEAVE() on ERROR: HERR_INIT(int, SUCCEED) */
-    hid_t        fidin      = -1;   /* file ID for input file*/
-    hid_t        fidout     = -1;   /* file ID for output file*/
-    hid_t        did        = -1;   /* dataset ID */
-    hid_t        pid        = -1;   /* dataset creation property list ID */
-    hid_t        sid        = -1;   /* space ID */
-    hid_t        tid        = -1;   /* type ID */
+    hid_t        fidin      = H5I_INVALID_HID;   /* file ID for input file*/
+    hid_t        fidout     = H5I_INVALID_HID;   /* file ID for output file*/
+    hid_t        did        = H5I_INVALID_HID;   /* dataset ID */
+    hid_t        pid        = H5I_INVALID_HID;   /* dataset creation property list ID */
+    hid_t        sid        = H5I_INVALID_HID;   /* space ID */
+    hid_t        tid        = H5I_INVALID_HID;   /* type ID */
     int          ok         = 1;    /* step results */
     unsigned int i;
     trav_table_t *travt = NULL;
-    hid_t        fcpl_in     = -1;   /* file creation property for input file */
-    hid_t        fcpl_out    = -1;   /* file creation property for output file */
+    hid_t        fcpl_in     = H5I_INVALID_HID;   /* file creation property for input file */
+    hid_t        fcpl_out    = H5I_INVALID_HID;   /* file creation property for output file */
     H5F_fspace_strategy_t in_strategy, out_strategy;    /* file space handling strategy for in/output file */
     hbool_t      in_persist, out_persist;         /* free-space persist status for in/output file */
     hsize_t      in_threshold, out_threshold;     /* free-space section threshold for in/output file */
     hsize_t      in_pagesize, out_pagesize;       /* file space page size for input/output file */
+    int          ret_value = 0;
 
     /* open the output file */
     if((fidout = H5Fopen(out_fname, H5F_ACC_RDONLY, H5P_DEFAULT)) < 0 )
-        HGOTO_ERROR(FAIL, H5E_tools_min_id_g, "H5Fopen failed on <%s>", out_fname);
+        H5TOOLS_GOTO_ERROR((-1), "H5Fopen failed on <%s>", out_fname);
 
     for(i = 0; i < options->op_tbl->nelems; i++) {
         char *name = options->op_tbl->objs[i].path;
@@ -69,13 +69,13 @@ h5repack_verify(const char *in_fname, const char *out_fname, pack_opt_t *options
         *-------------------------------------------------------------------------
         */
         if((did = H5Dopen2(fidout, name, H5P_DEFAULT)) < 0)
-            HGOTO_ERROR(FAIL, H5E_tools_min_id_g, "H5Dopen2 failed on <%s>", name);
+            H5TOOLS_GOTO_ERROR((-1), "H5Dopen2 failed on <%s>", name);
         if((sid = H5Dget_space(did)) < 0)
-            HGOTO_ERROR(FAIL, H5E_tools_min_id_g, "H5Dget_space failed");
+            H5TOOLS_GOTO_ERROR((-1), "H5Dget_space failed");
         if((pid = H5Dget_create_plist(did)) < 0)
-            HGOTO_ERROR(FAIL, H5E_tools_min_id_g, "H5Dget_create_plist failed");
+            H5TOOLS_GOTO_ERROR((-1), "H5Dget_create_plist failed");
         if((tid = H5Dget_type(did)) < 0)
-            HGOTO_ERROR(FAIL, H5E_tools_min_id_g, "H5Dget_type failed");
+            H5TOOLS_GOTO_ERROR((-1), "H5Dget_type failed");
 
        /*-------------------------------------------------------------------------
         * filter check
@@ -95,14 +95,14 @@ h5repack_verify(const char *in_fname, const char *out_fname, pack_opt_t *options
         * close
         *-------------------------------------------------------------------------
         */
-        if(H5Pclose(pid) < 0)
-            HGOTO_ERROR(FAIL, H5E_tools_min_id_g, "H5Pclose failed");
+        if (H5Pclose(pid) < 0)
+            H5TOOLS_GOTO_ERROR((-1), "H5Pclose failed");
         if (H5Sclose(sid) < 0)
-            HGOTO_ERROR(FAIL, H5E_tools_min_id_g, "H5Sclose failed");
+            H5TOOLS_GOTO_ERROR((-1), "H5Sclose failed");
         if (H5Dclose(did) < 0)
-            HGOTO_ERROR(FAIL, H5E_tools_min_id_g, "H5Dclose failed");
+            H5TOOLS_GOTO_ERROR((-1), "H5Dclose failed");
         if (H5Tclose(tid) < 0)
-            HGOTO_ERROR(FAIL, H5E_tools_min_id_g, "H5Tclose failed");
+            H5TOOLS_GOTO_ERROR((-1), "H5Tclose failed");
     }
 
    /*-------------------------------------------------------------------------
@@ -118,7 +118,7 @@ h5repack_verify(const char *in_fname, const char *out_fname, pack_opt_t *options
 
         /* get the list of objects in the file */
         if(h5trav_gettable(fidout, travt) < 0)
-            HGOTO_ERROR(FAIL, H5E_tools_min_id_g, "h5trav_gettable failed");
+            H5TOOLS_GOTO_ERROR((-1), "h5trav_gettable failed");
 
         for(i = 0; i < travt->nobjs; i++) {
             char *name = travt->objs[i].name;
@@ -129,13 +129,13 @@ h5repack_verify(const char *in_fname, const char *out_fname, pack_opt_t *options
                 *-------------------------------------------------------------------------
                 */
                 if((did = H5Dopen2(fidout, name, H5P_DEFAULT)) < 0)
-                    HGOTO_ERROR(FAIL, H5E_tools_min_id_g, "H5Dopen2 failed on <%s>", name);
+                    H5TOOLS_GOTO_ERROR((-1), "H5Dopen2 failed on <%s>", name);
                 if((sid = H5Dget_space(did)) < 0)
-                    HGOTO_ERROR(FAIL, H5E_tools_min_id_g, "H5Dget_space failed");
+                    H5TOOLS_GOTO_ERROR((-1), "H5Dget_space failed");
                 if((pid = H5Dget_create_plist(did)) < 0)
-                    HGOTO_ERROR(FAIL, H5E_tools_min_id_g, "H5Dget_create_plist failed");
+                    H5TOOLS_GOTO_ERROR((-1), "H5Dget_create_plist failed");
                 if((tid = H5Dget_type(did)) < 0)
-                    HGOTO_ERROR(FAIL, H5E_tools_min_id_g, "H5Dget_type failed");
+                    H5TOOLS_GOTO_ERROR((-1), "H5Dget_type failed");
 
                /*-------------------------------------------------------------------------
                 * filter check
@@ -165,13 +165,13 @@ h5repack_verify(const char *in_fname, const char *out_fname, pack_opt_t *options
                 *-------------------------------------------------------------------------
                 */
                 if (H5Pclose(pid) < 0)
-                    HGOTO_ERROR(FAIL, H5E_tools_min_id_g, "H5Pclose failed");
+                    H5TOOLS_GOTO_ERROR((-1), "H5Pclose failed");
                 if (H5Sclose(sid) < 0)
-                    HGOTO_ERROR(FAIL, H5E_tools_min_id_g, "H5Sclose failed");
+                    H5TOOLS_GOTO_ERROR((-1), "H5Sclose failed");
                 if (H5Dclose(did) < 0)
-                    HGOTO_ERROR(FAIL, H5E_tools_min_id_g, "H5Dclose failed");
+                    H5TOOLS_GOTO_ERROR((-1), "H5Dclose failed");
                 if (H5Tclose(tid) < 0)
-                    HGOTO_ERROR(FAIL, H5E_tools_min_id_g, "H5Tclose failed");
+                    H5TOOLS_GOTO_ERROR((-1), "H5Tclose failed");
             } /* if */
         } /* i */
 
@@ -187,32 +187,32 @@ h5repack_verify(const char *in_fname, const char *out_fname, pack_opt_t *options
 
     /* open the input file */
     if((fidin = H5Fopen(in_fname, H5F_ACC_RDONLY, H5P_DEFAULT)) < 0)
-        HGOTO_ERROR(FAIL, H5E_tools_min_id_g, "H5Fopen failed on file <%s>", in_fname);
+        H5TOOLS_GOTO_ERROR((-1), "H5Fopen failed on file <%s>", in_fname);
 
     /* Get file creation property list for input file */
     if((fcpl_in = H5Fget_create_plist(fidin)) < 0)
-        HGOTO_ERROR(FAIL, H5E_tools_min_id_g, "H5Fget_create_plist failed to retrieve file creation property list");
+        H5TOOLS_GOTO_ERROR((-1), "H5Fget_create_plist failed to retrieve file creation property list");
 
     /* Get file space info for input file */
     if(H5Pget_file_space_strategy(fcpl_in, &in_strategy, &in_persist, &in_threshold) < 0)
-        HGOTO_ERROR(FAIL, H5E_tools_min_id_g, "H5Pget_file_space_strategy failed to retrieve file space strategy & threshold");
+        H5TOOLS_GOTO_ERROR((-1), "H5Pget_file_space_strategy failed to retrieve file space strategy & threshold");
 
     /* Get file space page size for input file */
     if(H5Pget_file_space_page_size(fcpl_in, &in_pagesize) < 0)
-        HGOTO_ERROR(FAIL, H5E_tools_min_id_g, "H5Pget_file_space_page_size failed to retrieve file space page size");
+        H5TOOLS_GOTO_ERROR((-1), "H5Pget_file_space_page_size failed to retrieve file space page size");
 
     /* Output file is already opened */
     /* Get file creation property list for output file */
     if((fcpl_out = H5Fget_create_plist(fidout)) < 0)
-        HGOTO_ERROR(FAIL, H5E_tools_min_id_g, "H5Fget_create_plist failed to retrieve file creation property list");
+        H5TOOLS_GOTO_ERROR((-1), "H5Fget_create_plist failed to retrieve file creation property list");
 
     /* Get file space info for output file */
     if(H5Pget_file_space_strategy(fcpl_out, &out_strategy, &out_persist, &out_threshold) < 0)
-        HGOTO_ERROR(FAIL, H5E_tools_min_id_g, "H5Pget_file_space_strategy failed to retrieve file space strategy & threshold");
+        H5TOOLS_GOTO_ERROR((-1), "H5Pget_file_space_strategy failed to retrieve file space strategy & threshold");
 
     /* Get file space page size for output file */
     if(H5Pget_file_space_page_size(fcpl_out, &out_pagesize) < 0)
-        HGOTO_ERROR(FAIL, H5E_tools_min_id_g, "H5Pget_file_space_page_size failed to retrieve file space page size");
+        H5TOOLS_GOTO_ERROR((-1), "H5Pget_file_space_page_size failed to retrieve file space page size");
 
     /*
      * If -S option is set, the file space handling strategy should be set as specified.
@@ -221,11 +221,11 @@ h5repack_verify(const char *in_fname, const char *out_fname, pack_opt_t *options
      */
     if(options->fs_strategy) {
         if(out_strategy != (options->fs_strategy == (H5F_fspace_strategy_t)-1 ? 0 : options->fs_strategy))
-            HGOTO_ERROR(FAIL, H5E_tools_min_id_g, "file space strategy not set as unexpected");
+            H5TOOLS_GOTO_ERROR((-1), "file space strategy not set as unexpected");
     }
     else {
         if(out_strategy != in_strategy)
-            HGOTO_ERROR(FAIL, H5E_tools_min_id_g, "file space strategy not set as unexpected");
+            H5TOOLS_GOTO_ERROR((-1), "file space strategy not set as unexpected");
     }
 
     /*
@@ -235,11 +235,11 @@ h5repack_verify(const char *in_fname, const char *out_fname, pack_opt_t *options
      */
     if(options->fs_persist) {
         if(out_persist != (hbool_t)(options->fs_persist == (-1) ? FALSE : options->fs_persist))
-            HGOTO_ERROR(FAIL, H5E_tools_min_id_g, "free-space persist status not set as unexpected");
+            H5TOOLS_GOTO_ERROR((-1), "free-space persist status not set as unexpected");
     }
     else {
         if(out_persist != in_persist)
-            HGOTO_ERROR(FAIL, H5E_tools_min_id_g, "free-space persist status not set as unexpected");
+            H5TOOLS_GOTO_ERROR((-1), "free-space persist status not set as unexpected");
     }
 
     /*
@@ -249,11 +249,11 @@ h5repack_verify(const char *in_fname, const char *out_fname, pack_opt_t *options
      */
     if(options->fs_threshold) {
         if(out_threshold != (hsize_t)(options->fs_threshold == (-1) ? 0 : options->fs_threshold))
-            HGOTO_ERROR(FAIL, H5E_tools_min_id_g, "threshold not set as unexpected");
+            H5TOOLS_GOTO_ERROR((-1), "threshold not set as unexpected");
     }
     else {
         if(out_threshold != in_threshold)
-            HGOTO_ERROR(FAIL, H5E_tools_min_id_g, "threshold not set as unexpected");
+            H5TOOLS_GOTO_ERROR((-1), "threshold not set as unexpected");
     }
 
     /*
@@ -263,11 +263,11 @@ h5repack_verify(const char *in_fname, const char *out_fname, pack_opt_t *options
      */
     if(options->fs_pagesize) {
         if(out_pagesize != (hsize_t)(options->fs_pagesize == (-1) ? 0 : options->fs_pagesize))
-            HGOTO_ERROR(FAIL, H5E_tools_min_id_g, "file space page size not set as unexpected");
+            H5TOOLS_GOTO_ERROR((-1), "file space page size not set as unexpected");
     }
     else { /* "-G" is not set */
         if(out_pagesize != in_pagesize)
-            HGOTO_ERROR(FAIL, H5E_tools_min_id_g, "file space page size not set as unexpected");
+            H5TOOLS_GOTO_ERROR((-1), "file space page size not set as unexpected");
 
     }
 
@@ -355,19 +355,19 @@ int verify_layout(hid_t pid, pack_info_t *obj)
 
 int h5repack_cmp_pl(const char *fname1, const char *fname2)
 {
-    int           ret_value = 1;    /*no need to LEAVE() on ERROR: HERR_INIT(int, SUCCEED) */
-    hid_t         fid1 =-1;         /* file ID */
-    hid_t         fid2 =-1;         /* file ID */
-    hid_t         dset1 =-1;        /* dataset ID */
-    hid_t         dset2 =-1;        /* dataset ID */
-    hid_t         gid =-1;          /* group ID */
-    hid_t         dcpl1 =-1;        /* dataset creation property list ID */
-    hid_t         dcpl2 =-1;        /* dataset creation property list ID */
-    hid_t         gcplid =-1;       /* group creation property list */
+    hid_t         fid1 =H5I_INVALID_HID;         /* file ID */
+    hid_t         fid2 =H5I_INVALID_HID;         /* file ID */
+    hid_t         dset1 =H5I_INVALID_HID;        /* dataset ID */
+    hid_t         dset2 =H5I_INVALID_HID;        /* dataset ID */
+    hid_t         gid =H5I_INVALID_HID;          /* group ID */
+    hid_t         dcpl1 =H5I_INVALID_HID;        /* dataset creation property list ID */
+    hid_t         dcpl2 =H5I_INVALID_HID;        /* dataset creation property list ID */
+    hid_t         gcplid =H5I_INVALID_HID;       /* group creation property list */
     unsigned      crt_order_flag1;  /* group creation order flag */
     unsigned      crt_order_flag2;  /* group creation order flag */
-    trav_table_t  *trav = NULL;
+    trav_table_t *trav = NULL;
     unsigned int  i;
+    int           ret_value = 1;
 
    /*-------------------------------------------------------------------------
     * open the files
@@ -375,9 +375,9 @@ int h5repack_cmp_pl(const char *fname1, const char *fname2)
     */
     /* Open the files */
     if ((fid1 = H5Fopen(fname1, H5F_ACC_RDONLY, H5P_DEFAULT)) < 0)
-        HGOTO_ERROR(FAIL, H5E_tools_min_id_g, "h5tools_fopen failed <%s>: %s", fname1, H5FOPENERROR);
+        H5TOOLS_GOTO_ERROR((-1), "h5tools_fopen failed <%s>: %s", fname1, H5FOPENERROR);
     if ((fid2 = H5Fopen(fname2, H5F_ACC_RDONLY, H5P_DEFAULT)) < 0)
-        HGOTO_ERROR(FAIL, H5E_tools_min_id_g, "h5tools_fopen failed <%s>: %s", fname2, H5FOPENERROR);
+        H5TOOLS_GOTO_ERROR((-1), "h5tools_fopen failed <%s>: %s", fname2, H5FOPENERROR);
 
    /*-------------------------------------------------------------------------
     * get file table list of objects
@@ -388,7 +388,7 @@ int h5repack_cmp_pl(const char *fname1, const char *fname2)
     /* init table */
     trav_table_init(&trav);
     if(h5trav_gettable(fid1, trav) < 0)
-        HGOTO_ERROR(FAIL, H5E_tools_min_id_g, "h5trav_gettable failed");
+        H5TOOLS_GOTO_ERROR((-1), "h5trav_gettable failed");
 
    /*-------------------------------------------------------------------------
     * traverse the suppplied object list
@@ -397,62 +397,62 @@ int h5repack_cmp_pl(const char *fname1, const char *fname2)
     for(i = 0; i < trav->nobjs; i++) {
         if(trav->objs[i].type == H5TRAV_TYPE_GROUP) {
             if ((gid = H5Gopen2(fid1, trav->objs[i].name, H5P_DEFAULT)) < 0)
-                HGOTO_ERROR(FAIL, H5E_tools_min_id_g, "H5Gopen2 failed on first <%s>", trav->objs[i].name);
+                H5TOOLS_GOTO_ERROR((-1), "H5Gopen2 failed on first <%s>", trav->objs[i].name);
             if ((gcplid = H5Gget_create_plist(gid)) < 0)
-                HGOTO_ERROR(FAIL, H5E_tools_min_id_g, "H5Gget_create_plist failed");
+                H5TOOLS_GOTO_ERROR((-1), "H5Gget_create_plist failed");
             if (H5Pget_link_creation_order(gcplid, &crt_order_flag1) < 0)
-                HGOTO_ERROR(FAIL, H5E_tools_min_id_g, "H5Pget_link_creation_order failed");
+                H5TOOLS_GOTO_ERROR((-1), "H5Pget_link_creation_order failed");
             if (H5Pclose(gcplid) < 0)
-                HGOTO_ERROR(FAIL, H5E_tools_min_id_g, "H5Pclose failed");
+                H5TOOLS_GOTO_ERROR((-1), "H5Pclose failed");
             if (H5Gclose(gid) < 0)
-                HGOTO_ERROR(FAIL, H5E_tools_min_id_g, "H5Gclose failed");
+                H5TOOLS_GOTO_ERROR((-1), "H5Gclose failed");
 
             if ((gid = H5Gopen2(fid2, trav->objs[i].name, H5P_DEFAULT)) < 0)
-                HGOTO_ERROR(FAIL, H5E_tools_min_id_g, "H5Gopen2 failed on second <%s>", trav->objs[i].name);
+                H5TOOLS_GOTO_ERROR((-1), "H5Gopen2 failed on second <%s>", trav->objs[i].name);
             if ((gcplid = H5Gget_create_plist(gid)) < 0)
-                HGOTO_ERROR(FAIL, H5E_tools_min_id_g, "H5Gget_create_plist failed");
+                H5TOOLS_GOTO_ERROR((-1), "H5Gget_create_plist failed");
             if (H5Pget_link_creation_order(gcplid, &crt_order_flag2) < 0)
-                HGOTO_ERROR(FAIL, H5E_tools_min_id_g, "H5Pget_link_creation_order failed");
+                H5TOOLS_GOTO_ERROR((-1), "H5Pget_link_creation_order failed");
             if (H5Pclose(gcplid) < 0)
-                HGOTO_ERROR(FAIL, H5E_tools_min_id_g, "H5Pclose failed");
+                H5TOOLS_GOTO_ERROR((-1), "H5Pclose failed");
             if (H5Gclose(gid) < 0)
-                HGOTO_ERROR(FAIL, H5E_tools_min_id_g, "H5Gclose failed");
+                H5TOOLS_GOTO_ERROR((-1), "H5Gclose failed");
 
             if (crt_order_flag1 != crt_order_flag2)
-                HGOTO_ERROR(0, H5E_tools_min_id_g, "property lists failed for <%s> are different", trav->objs[i].name);
+                H5TOOLS_GOTO_ERROR(0, "property lists failed for <%s> are different", trav->objs[i].name);
         }
         else if(trav->objs[i].type == H5TRAV_TYPE_DATASET) {
             if((dset1 = H5Dopen2(fid1, trav->objs[i].name, H5P_DEFAULT)) < 0)
-                HGOTO_ERROR(FAIL, H5E_tools_min_id_g, "H5Dopen2 failed on first <%s>", trav->objs[i].name);
+                H5TOOLS_GOTO_ERROR((-1), "H5Dopen2 failed on first <%s>", trav->objs[i].name);
             if((dset2 = H5Dopen2(fid2, trav->objs[i].name, H5P_DEFAULT)) < 0)
-                HGOTO_ERROR(FAIL, H5E_tools_min_id_g, "H5Dopen2 failed on second <%s>", trav->objs[i].name);
+                H5TOOLS_GOTO_ERROR((-1), "H5Dopen2 failed on second <%s>", trav->objs[i].name);
             if((dcpl1 = H5Dget_create_plist(dset1)) < 0)
-                HGOTO_ERROR(FAIL, H5E_tools_min_id_g, "H5Dget_create_plist failed");
+                H5TOOLS_GOTO_ERROR((-1), "H5Dget_create_plist failed");
             if((dcpl2 = H5Dget_create_plist(dset2)) < 0)
-                HGOTO_ERROR(FAIL, H5E_tools_min_id_g, "H5Dget_create_plist failed");
+                H5TOOLS_GOTO_ERROR((-1), "H5Dget_create_plist failed");
 
            /*-------------------------------------------------------------------------
             * compare the property lists
             *-------------------------------------------------------------------------
             */
             if((ret_value = H5Pequal(dcpl1, dcpl2)) < 0)
-                HGOTO_ERROR(FAIL, H5E_tools_min_id_g, "H5Pequal failed");
+                H5TOOLS_GOTO_ERROR((-1), "H5Pequal failed");
 
             if(ret_value == 0)
-                HGOTO_ERROR(0, H5E_tools_min_id_g, "property lists failed for <%s> are different", trav->objs[i].name);
+                H5TOOLS_GOTO_ERROR(0, "property lists failed for <%s> are different", trav->objs[i].name);
 
            /*-------------------------------------------------------------------------
             * close
             *-------------------------------------------------------------------------
             */
             if(H5Pclose(dcpl1) < 0)
-                HGOTO_ERROR(FAIL, H5E_tools_min_id_g, "H5Pclose failed");
+                H5TOOLS_GOTO_ERROR((-1), "H5Pclose failed");
             if(H5Pclose(dcpl2) < 0)
-                HGOTO_ERROR(FAIL, H5E_tools_min_id_g, "H5Pclose failed");
+                H5TOOLS_GOTO_ERROR((-1), "H5Pclose failed");
             if(H5Dclose(dset1) < 0)
-                HGOTO_ERROR(FAIL, H5E_tools_min_id_g, "H5Dclose failed");
+                H5TOOLS_GOTO_ERROR((-1), "H5Dclose failed");
             if(H5Dclose(dset2) < 0)
-                HGOTO_ERROR(FAIL, H5E_tools_min_id_g, "H5Dclose failed");
+                H5TOOLS_GOTO_ERROR((-1), "H5Dclose failed");
         } /*if*/
     } /*for*/
 
diff --git a/tools/src/h5stat/CMakeLists.txt b/tools/src/h5stat/CMakeLists.txt
index 55c675f..f6cc542 100644
--- a/tools/src/h5stat/CMakeLists.txt
+++ b/tools/src/h5stat/CMakeLists.txt
@@ -1,4 +1,4 @@
-cmake_minimum_required (VERSION 3.10)
+cmake_minimum_required (VERSION 3.12)
 project (HDF5_TOOLS_SRC_H5STAT C)
 
 # --------------------------------------------------------------------
diff --git a/tools/src/h5stat/h5stat.c b/tools/src/h5stat/h5stat.c
index dba15e4..9bb81b5 100644
--- a/tools/src/h5stat/h5stat.c
+++ b/tools/src/h5stat/h5stat.c
@@ -399,7 +399,7 @@ attribute_stats(iter_t *iter, const H5O_info_t *oi)
         iter->attr_bins = (unsigned long *)HDrealloc(iter->attr_bins, (bin + 1) * sizeof(unsigned long));
         HDassert(iter->attr_bins);
 
-  /* Initialize counts for intermediate bins */
+        /* Initialize counts for intermediate bins */
         while(iter->attr_nbins < bin)
             iter->attr_bins[iter->attr_nbins++] = 0;
         iter->attr_nbins++;
@@ -444,7 +444,7 @@ group_stats(iter_t *iter, const char *name, const H5O_info_t *oi)
 {
     H5G_info_t ginfo;           /* Group information */
     unsigned bin;               /* "bin" the number of objects falls in */
-    herr_t ret_value = SUCCEED; /* Return value */
+    herr_t ret_value = SUCCEED;
 
     /* Gather statistics about this type of object */
     iter->uniq_groups++;
@@ -455,7 +455,7 @@ group_stats(iter_t *iter, const char *name, const H5O_info_t *oi)
 
     /* Get group information */
     if((ret_value = H5Gget_info_by_name(iter->fid, name, &ginfo, H5P_DEFAULT)) < 0)
-        HGOTO_ERROR(FAIL, H5E_tools_min_id_g, "H5Gget_info_by_name() failed");
+        H5TOOLS_GOTO_ERROR(FAIL, "H5Gget_info_by_name() failed");
 
     /* Update link stats */
     /* Collect statistics for small groups */
@@ -470,7 +470,7 @@ group_stats(iter_t *iter, const char *name, const H5O_info_t *oi)
     if((bin + 1) > iter->group_nbins) {
         /* Allocate more storage for info about dataset's datatype */
         if((iter->group_bins = (unsigned long *)HDrealloc(iter->group_bins, (bin + 1) * sizeof(unsigned long))) == NULL)
-            HGOTO_ERROR(FAIL, H5E_tools_min_id_g, "H5Drealloc() failed");
+            H5TOOLS_GOTO_ERROR(FAIL, "H5Drealloc() failed");
 
         /* Initialize counts for intermediate bins */
         while(iter->group_nbins < bin)
@@ -489,7 +489,7 @@ group_stats(iter_t *iter, const char *name, const H5O_info_t *oi)
 
     /* Update attribute metadata info */
     if((ret_value = attribute_stats(iter, oi)) < 0)
-        HGOTO_ERROR(FAIL, H5E_tools_min_id_g, "attribute_stats failed");
+        H5TOOLS_GOTO_ERROR(FAIL, "attribute_stats failed");
 
 done:
     return ret_value;
@@ -527,7 +527,7 @@ dataset_stats(iter_t *iter, const char *name, const H5O_info_t *oi)
     int num_ext;                /* Number of external files for a dataset */
     int nfltr;                  /* Number of filters for a dataset */
     H5Z_filter_t fltr;          /* Filter identifier */
-    herr_t ret_value = SUCCEED; /* Return value */
+    herr_t ret_value = SUCCEED;
 
     /* Gather statistics about this type of object */
     iter->uniq_dsets++;
@@ -537,7 +537,7 @@ dataset_stats(iter_t *iter, const char *name, const H5O_info_t *oi)
     iter->dset_ohdr_info.free_size += oi->hdr.space.free;
 
     if((did = H5Dopen2(iter->fid, name, H5P_DEFAULT)) < 0)
-        HGOTO_ERROR(FAIL, H5E_tools_min_id_g, "H5Dopen() failed");
+        H5TOOLS_GOTO_ERROR(FAIL, "H5Dopen() failed");
 
     /* Update dataset metadata info */
     iter->datasets_index_storage_size += oi->meta_size.obj.index_size;
@@ -545,7 +545,7 @@ dataset_stats(iter_t *iter, const char *name, const H5O_info_t *oi)
 
     /* Update attribute metadata info */
     if((ret_value = attribute_stats(iter, oi)) < 0)
-        HGOTO_ERROR(FAIL, H5E_tools_min_id_g, "attribute_stats() failed");
+        H5TOOLS_GOTO_ERROR(FAIL, "attribute_stats() failed");
 
     /* Get storage info */
     /* Failure 0 indistinguishable from no-data-stored 0 */
@@ -553,10 +553,10 @@ dataset_stats(iter_t *iter, const char *name, const H5O_info_t *oi)
 
     /* Gather layout statistics */
     if((dcpl = H5Dget_create_plist(did)) < 0)
-        HGOTO_ERROR(FAIL, H5E_tools_min_id_g, "H5Dget_create_plist() failed");
+        H5TOOLS_GOTO_ERROR(FAIL, "H5Dget_create_plist() failed");
 
     if((lout = H5Pget_layout(dcpl)) < 0)
-        HGOTO_ERROR(FAIL, H5E_tools_min_id_g, "H5Pget_layout() failed");
+        H5TOOLS_GOTO_ERROR(FAIL, "H5Pget_layout() failed");
 
     /* Object header's total size for H5D_COMPACT layout includes raw data size */
     /* "storage" also includes H5D_COMPACT raw data size */
@@ -568,7 +568,7 @@ dataset_stats(iter_t *iter, const char *name, const H5O_info_t *oi)
 
     /* Get the number of external files for the dataset */
     if((num_ext = H5Pget_external_count(dcpl)) < 0)
-        HGOTO_ERROR(FAIL, H5E_tools_min_id_g, "H5Pget_external_count() failed");
+        H5TOOLS_GOTO_ERROR(FAIL, "H5Pget_external_count() failed");
 
     /* Accumulate raw data size accordingly */
     if(num_ext) {
@@ -580,10 +580,10 @@ dataset_stats(iter_t *iter, const char *name, const H5O_info_t *oi)
 
     /* Gather dataspace statistics */
     if((sid = H5Dget_space(did)) < 0)
-        HGOTO_ERROR(FAIL, H5E_tools_min_id_g, "H5Sget_space() failed");
+        H5TOOLS_GOTO_ERROR(FAIL, "H5Sget_space() failed");
 
     if((ndims = H5Sget_simple_extent_dims(sid, dims, NULL)) < 0)
-        HGOTO_ERROR(FAIL, H5E_tools_min_id_g, "H5Sget_simple_extent_dims() failed");
+        H5TOOLS_GOTO_ERROR(FAIL, "H5Sget_simple_extent_dims() failed");
 
     /* Check for larger rank of dataset */
     if((unsigned)ndims > iter->max_dset_rank)
@@ -606,7 +606,7 @@ dataset_stats(iter_t *iter, const char *name, const H5O_info_t *oi)
         if((bin + 1) > iter->dset_dim_nbins) {
             /* Allocate more storage for info about dataset's datatype */
             if((iter->dset_dim_bins = (unsigned long *)HDrealloc(iter->dset_dim_bins, (bin + 1) * sizeof(unsigned long))) == NULL)
-                HGOTO_ERROR(FAIL, H5E_tools_min_id_g, "H5Drealloc() failed");
+                H5TOOLS_GOTO_ERROR(FAIL, "H5Drealloc() failed");
 
             /* Initialize counts for intermediate bins */
             while(iter->dset_dim_nbins < bin)
@@ -621,11 +621,11 @@ dataset_stats(iter_t *iter, const char *name, const H5O_info_t *oi)
     } /* end if */
 
     if(H5Sclose(sid) < 0)
-        HGOTO_ERROR(FAIL, H5E_tools_min_id_g, "H5Sclose() failed");
+        H5TOOLS_GOTO_ERROR(FAIL, "H5Sclose() failed");
 
     /* Gather datatype statistics */
     if((tid = H5Dget_type(did)) < 0)
-        HGOTO_ERROR(FAIL, H5E_tools_min_id_g, "H5Dget_type() failed");
+        H5TOOLS_GOTO_ERROR(FAIL, "H5Dget_type() failed");
 
     type_found = FALSE;
     for(u = 0; u < iter->dset_ntypes; u++)
@@ -644,11 +644,11 @@ dataset_stats(iter_t *iter, const char *name, const H5O_info_t *oi)
 
         /* Allocate more storage for info about dataset's datatype */
         if((iter->dset_type_info = (dtype_info_t *)HDrealloc(iter->dset_type_info, iter->dset_ntypes * sizeof(dtype_info_t))) == NULL)
-            HGOTO_ERROR(FAIL, H5E_tools_min_id_g, "H5Drealloc() failed");
+            H5TOOLS_GOTO_ERROR(FAIL, "H5Drealloc() failed");
 
         /* Initialize information about datatype */
         if((iter->dset_type_info[curr_ntype].tid = H5Tcopy(tid)) < 0)
-            HGOTO_ERROR(FAIL, H5E_tools_min_id_g, "H5Tcopy() failed");
+            H5TOOLS_GOTO_ERROR(FAIL, "H5Tcopy() failed");
         iter->dset_type_info[curr_ntype].count = 1;
         iter->dset_type_info[curr_ntype].named = 0;
 
@@ -661,7 +661,7 @@ dataset_stats(iter_t *iter, const char *name, const H5O_info_t *oi)
         (iter->dset_type_info[u].named)++;
 
     if(H5Tclose(tid) < 0)
-        HGOTO_ERROR(FAIL, H5E_tools_min_id_g, "H5Tclose() failed");
+        H5TOOLS_GOTO_ERROR(FAIL, "H5Tclose() failed");
 
     /* Track different filters */
     if((nfltr = H5Pget_nfilters(dcpl)) >= 0) {
@@ -679,10 +679,10 @@ dataset_stats(iter_t *iter, const char *name, const H5O_info_t *oi)
     } /* endif nfltr */
 
      if(H5Pclose(dcpl) < 0)
-        HGOTO_ERROR(FAIL, H5E_tools_min_id_g, "H5Pclose() failed");
+        H5TOOLS_GOTO_ERROR(FAIL, "H5Pclose() failed");
 
      if(H5Dclose(did) < 0)
-        HGOTO_ERROR(FAIL, H5E_tools_min_id_g, "H5Dclose() failed");
+        H5TOOLS_GOTO_ERROR(FAIL, "H5Dclose() failed");
 
 done:
      return ret_value;
@@ -715,7 +715,7 @@ datatype_stats(iter_t *iter, const H5O_info_t *oi)
 
     /* Update attribute metadata info */
     if((ret_value = attribute_stats(iter, oi)) < 0)
-        HGOTO_ERROR(FAIL, H5E_tools_min_id_g, "attribute_stats() failed");
+        H5TOOLS_GOTO_ERROR(FAIL, "attribute_stats() failed");
 done:
      return ret_value;
 }  /* end datatype_stats() */
@@ -750,17 +750,17 @@ obj_stats(const char *path, const H5O_info_t *oi, const char *already_visited,
         switch(oi->type) {
             case H5O_TYPE_GROUP:
                 if(group_stats(iter, path, oi) < 0)
-                    HGOTO_ERROR(FAIL, H5E_tools_min_id_g, "group_stats failed");
+                    H5TOOLS_GOTO_ERROR(FAIL, "group_stats failed");
                 break;
 
             case H5O_TYPE_DATASET:
                 if(dataset_stats(iter, path, oi) < 0)
-                    HGOTO_ERROR(FAIL, H5E_tools_min_id_g, "dataset_stats failed");
+                    H5TOOLS_GOTO_ERROR(FAIL, "dataset_stats failed");
                 break;
 
             case H5O_TYPE_NAMED_DATATYPE:
                 if(datatype_stats(iter, oi) < 0)
-                    HGOTO_ERROR(FAIL, H5E_tools_min_id_g, "datatype_stats failed");
+                    H5TOOLS_GOTO_ERROR(FAIL, "datatype_stats failed");
                 break;
 
             case H5O_TYPE_UNKNOWN:
@@ -1852,7 +1852,7 @@ main(int argc, const char *argv[])
 {
     iter_t              iter;
     const char         *fname = NULL;
-    hid_t               fid = -1;
+    hid_t               fid = H5I_INVALID_HID;
     H5E_auto2_t         func;
     H5E_auto2_t         tools_func;
     void               *edata;
diff --git a/tools/src/misc/CMakeLists.txt b/tools/src/misc/CMakeLists.txt
index 6b41d7f..16e4555 100644
--- a/tools/src/misc/CMakeLists.txt
+++ b/tools/src/misc/CMakeLists.txt
@@ -1,4 +1,4 @@
-cmake_minimum_required (VERSION 3.10)
+cmake_minimum_required (VERSION 3.12)
 project (HDF5_TOOLS_SRC_MISC C)
 
 # --------------------------------------------------------------------
diff --git a/tools/src/misc/h5clear.c b/tools/src/misc/h5clear.c
index 927167b..38fa6a2 100644
--- a/tools/src/misc/h5clear.c
+++ b/tools/src/misc/h5clear.c
@@ -175,7 +175,7 @@ parse_command_line(int argc, const char **argv)
                         usage(h5tools_getprogname());
                         goto done;
                     }
-                    increment = HDatoi(opt_arg);
+                    increment = (hsize_t)HDatoi(opt_arg);
                 }
                 break;