[svn-r30113] Description:

    Clean up warnings (from 2774 -> 1560, with my standard debug build)

Tested on:
    MacOSX/64 10.11.5 (amazon) w/serial, parallel & production
    (h5committest forthcoming)

3 files changed, 1286 insertions, 1415 deletions

diff --git a/tools/h5repack/h5repack_copy.c b/tools/h5repack/h5repack_copy.c
index 9c01b7e..547f61a 100644
--- a/tools/h5repack/h5repack_copy.c
+++ b/tools/h5repack/h5repack_copy.c
@@ -36,7 +36,7 @@
 #define USERBLOCK_XFER_SIZE     512     
 
 /* check H5Dread()/H5Dwrite() error, e.g. memory allocation error inside the library. */
-#define CHECK_H5DRW_ERROR(_fun, _did, _mtid, _msid, _fsid, _pid, _buf)  {  \
+#define CHECK_H5DRW_ERROR(_fun, _fail, _did, _mtid, _msid, _fsid, _pid, _buf)  {  \
     H5E_BEGIN_TRY {  \
         if(_fun(_did, _mtid, _msid, _fsid, _pid, _buf) < 0) {  \
             hid_t _err_num = 0; \
@@ -44,7 +44,7 @@
             H5Ewalk2(H5E_DEFAULT, H5E_WALK_DOWNWARD, walk_error_callback, &_err_num); \
             H5Eget_msg(_err_num, NULL, _msg, (size_t)80); \
             error_msg("%s %s -- %s\n", #_fun, "failed", _msg); \
-            goto done; \
+            HGOTO_DONE(_fail) \
         } \
     } H5E_END_TRY; \
 }
@@ -97,170 +97,166 @@ static herr_t walk_error_callback(H5_ATTR_UNUSED unsigned n, const H5E_error2_t
  *-------------------------------------------------------------------------
  */
 
-int copy_objects(const char* fnamein, const char* fnameout, pack_opt_t *options) {
+int copy_objects(const char* fnamein, const char* fnameout, pack_opt_t *options)
+{
     int   ret_value = 0; /*no need to LEAVE() on ERROR: HERR_INIT(int, SUCCEED) */
     hid_t fidin;
-	hid_t fidout = -1;
-	trav_table_t *travt = NULL;
-	hsize_t ub_size = 0; /* size of user block */
-	hid_t fcpl = H5P_DEFAULT; /* file creation property list ID */
-	hid_t fapl = H5P_DEFAULT; /* file access property list ID */
-
-	/*-------------------------------------------------------------------------
-	 * open input file
-	 *-------------------------------------------------------------------------
-	 */
-	if ((fidin = h5tools_fopen(fnamein, H5F_ACC_RDONLY, H5P_DEFAULT, NULL, NULL,
-			(size_t) 0)) < 0) {
-		error_msg("<%s>: %s\n", fnamein, H5FOPENERROR);
-        HGOTO_ERROR(H5E_tools_g, H5E_tools_min_id_g, "H5Pclose failed");
+    hid_t fidout = -1;
+    trav_table_t *travt = NULL;
+    hsize_t ub_size = 0; /* size of user block */
+    hid_t fcpl = H5P_DEFAULT; /* file creation property list ID */
+    hid_t fapl = H5P_DEFAULT; /* file access property list ID */
+
+    /*-------------------------------------------------------------------------
+     * open input file
+     *-------------------------------------------------------------------------
+     */
+    if ((fidin = h5tools_fopen(fnamein, H5F_ACC_RDONLY, H5P_DEFAULT, NULL, NULL, (size_t) 0)) < 0) {
+        error_msg("<%s>: %s\n", fnamein, H5FOPENERROR);
+        HGOTO_ERROR(FAIL, H5E_tools_min_id_g, "H5Pclose failed");
     }
 
-	/* get user block size and file space strategy/threshold */
-	{
-		hid_t fcpl_in; /* file creation property list ID for input file */
+    /* get user block size and file space strategy/threshold */
+    {
+        hid_t fcpl_in; /* file creation property list ID for input file */
 
-		if ((fcpl_in = H5Fget_create_plist(fidin)) < 0) {
-			error_msg("failed to retrieve file creation property list\n");
-            HGOTO_ERROR(H5E_tools_g, H5E_tools_min_id_g, "H5Pclose failed");
+        if ((fcpl_in = H5Fget_create_plist(fidin)) < 0) {
+            error_msg("failed to retrieve file creation property list\n");
+            HGOTO_ERROR(FAIL, H5E_tools_min_id_g, "H5Pclose failed");
         }
 
-		if (H5Pget_userblock(fcpl_in, &ub_size) < 0) {
-			error_msg("failed to retrieve userblock size\n");
-            HGOTO_ERROR(H5E_tools_g, H5E_tools_min_id_g, "H5Pclose failed");
+        if (H5Pget_userblock(fcpl_in, &ub_size) < 0) {
+            error_msg("failed to retrieve userblock size\n");
+            HGOTO_ERROR(FAIL, H5E_tools_min_id_g, "H5Pclose failed");
         }
 
-		if (!options->fs_strategy) {
-			if (H5Pget_file_space(fcpl_in, &options->fs_strategy, NULL) < 0) {
-				error_msg("failed to retrieve file space strategy\n");
-                HGOTO_ERROR(H5E_tools_g, H5E_tools_min_id_g, "H5Pclose failed");
+        if (!options->fs_strategy) {
+            if (H5Pget_file_space(fcpl_in, &options->fs_strategy, NULL) < 0) {
+                error_msg("failed to retrieve file space strategy\n");
+                HGOTO_ERROR(FAIL, H5E_tools_min_id_g, "H5Pclose failed");
             }
-		}
+        }
 
-		if (!options->fs_threshold) {
-			if (H5Pget_file_space(fcpl_in, NULL, &options->fs_threshold) < 0) {
-				error_msg("failed to retrieve file space threshold\n");
-                HGOTO_ERROR(H5E_tools_g, H5E_tools_min_id_g, "H5Pclose failed");
+        if (!options->fs_threshold) {
+            if (H5Pget_file_space(fcpl_in, NULL, &options->fs_threshold) < 0) {
+                error_msg("failed to retrieve file space threshold\n");
+                HGOTO_ERROR(FAIL, H5E_tools_min_id_g, "H5Pclose failed");
             }
-		}
+        }
 
-		if (H5Pclose(fcpl_in) < 0) {
-			error_msg("failed to close property list\n");
-            HGOTO_ERROR(H5E_tools_g, H5E_tools_min_id_g, "H5Pclose failed");
+        if (H5Pclose(fcpl_in) < 0) {
+            error_msg("failed to close property list\n");
+            HGOTO_ERROR(FAIL, H5E_tools_min_id_g, "H5Pclose failed");
         }
-	}
+    }
 
-	/* Check if we need to create a non-default file creation property list */
-	if (options->latest || ub_size > 0) {
-		/* Create file creation property list */
-		if ((fcpl = H5Pcreate(H5P_FILE_CREATE)) < 0) {
-			error_msg("fail to create a file creation property list\n");
-            HGOTO_ERROR(H5E_tools_g, H5E_tools_min_id_g, "H5Pclose failed");
+    /* Check if we need to create a non-default file creation property list */
+    if (options->latest || ub_size > 0) {
+        /* Create file creation property list */
+        if ((fcpl = H5Pcreate(H5P_FILE_CREATE)) < 0) {
+            error_msg("fail to create a file creation property list\n");
+            HGOTO_ERROR(FAIL, H5E_tools_min_id_g, "H5Pclose failed");
         }
 
-		if (ub_size > 0) {
-			if (H5Pset_userblock(fcpl, ub_size) < 0) {
-				error_msg("failed to set non-default userblock size\n");
-                HGOTO_ERROR(H5E_tools_g, H5E_tools_min_id_g, "H5Pclose failed");
+        if (ub_size > 0) {
+            if (H5Pset_userblock(fcpl, ub_size) < 0) {
+                error_msg("failed to set non-default userblock size\n");
+                HGOTO_ERROR(FAIL, H5E_tools_min_id_g, "H5Pclose failed");
             }
-		}
+        }
 
-		if (options->latest) {
-			unsigned i = 0, nindex = 0, mesg_type_flags[5], min_mesg_sizes[5];
+        if (options->latest) {
+            unsigned i = 0, nindex = 0, mesg_type_flags[5], min_mesg_sizes[5];
 
-			/* 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) {
-				error_msg(
-						"fail to adjust group creation parameters for root group\n");
-                HGOTO_ERROR(H5E_tools_g, H5E_tools_min_id_g, "H5Pclose failed");
+            /* 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) {
+                error_msg("fail to adjust group creation parameters for root group\n");
+                HGOTO_ERROR(FAIL, H5E_tools_min_id_g, "H5Pclose failed");
             }
 
-			for (i = 0; i < 5; i++) {
-				if (options->msg_size[i] > 0) {
-					switch (i) {
-					case 0:
-						mesg_type_flags[nindex] = H5O_SHMESG_SDSPACE_FLAG;
-						break;
-
-					case 1:
-						mesg_type_flags[nindex] = H5O_SHMESG_DTYPE_FLAG;
-						break;
-
-					case 2:
-						mesg_type_flags[nindex] = H5O_SHMESG_FILL_FLAG;
-						break;
-
-					case 3:
-						mesg_type_flags[nindex] = H5O_SHMESG_PLINE_FLAG;
-						break;
-
-					case 4:
-						mesg_type_flags[nindex] = H5O_SHMESG_ATTR_FLAG;
-						break;
-					default:
-						break;
-					} /* end switch */
-					min_mesg_sizes[nindex] = (unsigned) options->msg_size[i];
-
-					nindex++;
-				} /* end if */
-			} /* end for */
-
-			if (nindex > 0) {
-				if (H5Pset_shared_mesg_nindexes(fcpl, nindex) < 0) {
-					error_msg(
-							"fail to set the number of shared object header message indexes\n");
-                    HGOTO_ERROR(H5E_tools_g, H5E_tools_min_id_g, "H5Pclose failed");
+            for (i = 0; i < 5; i++) {
+                if (options->msg_size[i] > 0) {
+                    switch (i) {
+                        case 0:
+                            mesg_type_flags[nindex] = H5O_SHMESG_SDSPACE_FLAG;
+                            break;
+
+                        case 1:
+                            mesg_type_flags[nindex] = H5O_SHMESG_DTYPE_FLAG;
+                            break;
+
+                        case 2:
+                            mesg_type_flags[nindex] = H5O_SHMESG_FILL_FLAG;
+                            break;
+
+                        case 3:
+                            mesg_type_flags[nindex] = H5O_SHMESG_PLINE_FLAG;
+                            break;
+
+                        case 4:
+                            mesg_type_flags[nindex] = H5O_SHMESG_ATTR_FLAG;
+                            break;
+
+                        default:
+                            break;
+                    } /* end switch */
+                    min_mesg_sizes[nindex] = (unsigned) options->msg_size[i];
+
+                    nindex++;
+                } /* end if */
+            } /* end for */
+
+            if (nindex > 0) {
+                if (H5Pset_shared_mesg_nindexes(fcpl, nindex) < 0) {
+                    error_msg("fail to set the number of shared object header message indexes\n");
+                    HGOTO_ERROR(FAIL, H5E_tools_min_id_g, "H5Pclose failed");
                 }
 
-				/* 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) {
-						error_msg(
-								"fail to configure the specified shared object header message index\n");
-                        HGOTO_ERROR(H5E_tools_g, H5E_tools_min_id_g, "H5Pclose failed");
+                /* 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) {
+                        error_msg("fail to configure the specified shared object header message index\n");
+                        HGOTO_ERROR(FAIL, H5E_tools_min_id_g, "H5Pclose failed");
                     } /* end if */
-				} /* end for */
-			} /* if (nindex>0) */
+                } /* end for */
+            } /* if (nindex>0) */
 
-			/* Create file access property list */
-			if ((fapl = H5Pcreate(H5P_FILE_ACCESS)) < 0) {
-				error_msg("Could not create file access property list\n");
-                HGOTO_ERROR(H5E_tools_g, H5E_tools_min_id_g, "H5Pclose failed");
+            /* Create file access property list */
+            if ((fapl = H5Pcreate(H5P_FILE_ACCESS)) < 0) {
+                error_msg("Could not create file access property list\n");
+                HGOTO_ERROR(FAIL, H5E_tools_min_id_g, "H5Pclose failed");
             } /* end if */
 
-			if (H5Pset_libver_bounds(fapl, H5F_LIBVER_LATEST, H5F_LIBVER_LATEST) < 0) {
-				error_msg(
-						"Could not set property for using latest version of the format\n");
-                HGOTO_ERROR(H5E_tools_g, H5E_tools_min_id_g, "H5Pclose failed");
+            if (H5Pset_libver_bounds(fapl, H5F_LIBVER_LATEST, H5F_LIBVER_LATEST) < 0) {
+                error_msg("Could not set property for using latest version of the format\n");
+                HGOTO_ERROR(FAIL, H5E_tools_min_id_g, "H5Pclose failed");
             } /* end if */
-		} /* end if */
-	} /* end if */
+        } /* end if */
+    } /* end if */
 #if defined (H5REPACK_DEBUG_USER_BLOCK)
-	print_user_block(fnamein, fidin);
+print_user_block(fnamein, fidin);
 #endif
 
-	/*-------------------------------------------------------------------------
-	 * set the new user userblock options in the FCPL (before H5Fcreate )
-	 *-------------------------------------------------------------------------
-	 */
-	if (options->ublock_size > 0) {
-		/* either use the FCPL already created or create a new one */
-		if (fcpl == H5P_DEFAULT) {
-			/* create a file creation property list */
-			if ((fcpl = H5Pcreate(H5P_FILE_CREATE)) < 0) {
-				error_msg("fail to create a file creation property list\n");
-                HGOTO_ERROR(H5E_tools_g, H5E_tools_min_id_g, "H5Pclose failed");
+    /*-------------------------------------------------------------------------
+     * set the new user userblock options in the FCPL (before H5Fcreate )
+     *-------------------------------------------------------------------------
+     */
+    if (options->ublock_size > 0) {
+        /* either use the FCPL already created or create a new one */
+        if (fcpl == H5P_DEFAULT) {
+            /* create a file creation property list */
+            if ((fcpl = H5Pcreate(H5P_FILE_CREATE)) < 0) {
+                error_msg("fail to create a file creation property list\n");
+                HGOTO_ERROR(FAIL, H5E_tools_min_id_g, "H5Pclose failed");
             }
-	    }
+        }
 
         /* set user block size */
         if (H5Pset_userblock(fcpl, options->ublock_size) < 0) {
             error_msg("failed to set userblock size\n");
-            HGOTO_ERROR(H5E_tools_g, H5E_tools_min_id_g, "H5Pclose failed");
+            HGOTO_ERROR(FAIL, H5E_tools_min_id_g, "H5Pclose failed");
         }
     }
 
@@ -274,13 +270,13 @@ int copy_objects(const char* fnamein, const char* fnameout, pack_opt_t *options)
             /* create a file access property list */
             if ((fapl = H5Pcreate(H5P_FILE_ACCESS)) < 0) {
                 error_msg("Could not create file access property list\n");
-                HGOTO_ERROR(H5E_tools_g, H5E_tools_min_id_g, "H5Pclose failed");
+                HGOTO_ERROR(FAIL, H5E_tools_min_id_g, "H5Pclose failed");
             }
         }
 
         if (H5Pset_alignment(fapl, options->threshold, options->alignment) < 0) {
             error_msg("failed to set alignment\n");
-            HGOTO_ERROR(H5E_tools_g, H5E_tools_min_id_g, "H5Pclose failed");
+            HGOTO_ERROR(FAIL, H5E_tools_min_id_g, "H5Pclose failed");
         }
     }
 
@@ -294,13 +290,13 @@ int copy_objects(const char* fnamein, const char* fnameout, pack_opt_t *options)
             /* create a file access property list */
             if ((fapl = H5Pcreate(H5P_FILE_ACCESS)) < 0) {
                 error_msg("Could not create file access property list\n");
-                HGOTO_ERROR(H5E_tools_g, H5E_tools_min_id_g, "H5Pclose failed");
+                HGOTO_ERROR(FAIL, H5E_tools_min_id_g, "H5Pclose failed");
             }
         }
 
         if (H5Pset_meta_block_size(fapl, options->meta_block_size) < 0) {
             error_msg("failed to set metadata block size\n");
-            HGOTO_ERROR(H5E_tools_g, H5E_tools_min_id_g, "H5Pclose failed");
+            HGOTO_ERROR(FAIL, H5E_tools_min_id_g, "H5Pclose failed");
         }
     }
 
@@ -314,14 +310,14 @@ int copy_objects(const char* fnamein, const char* fnameout, pack_opt_t *options)
         /* create a file creation property list */
         if ((fcpl = H5Pcreate(H5P_FILE_CREATE)) < 0) {
             error_msg("fail to create a file creation property list\n");
-            HGOTO_ERROR(H5E_tools_g, H5E_tools_min_id_g, "H5Pclose failed");
+            HGOTO_ERROR(FAIL, H5E_tools_min_id_g, "H5Pclose failed");
         }
     }
 
     /* set file space strategy and free space threshold */
     if (H5Pset_file_space(fcpl, options->fs_strategy, options->fs_threshold) < 0) {
         error_msg("failed to set file space strategy & threshold \n");
-        HGOTO_ERROR(H5E_tools_g, H5E_tools_min_id_g, "H5Pclose failed");
+        HGOTO_ERROR(FAIL, H5E_tools_min_id_g, "H5Pclose failed");
     }
 
     /*-------------------------------------------------------------------------
@@ -333,7 +329,7 @@ int copy_objects(const char* fnamein, const char* fnameout, pack_opt_t *options)
 
     if ((fidout = H5Fcreate(fnameout, H5F_ACC_TRUNC, fcpl, fapl)) < 0) {
         error_msg("<%s>: Could not create file\n", fnameout);
-        HGOTO_ERROR(H5E_tools_g, H5E_tools_min_id_g, "H5Pclose failed");
+        HGOTO_ERROR(FAIL, H5E_tools_min_id_g, "H5Pclose failed");
     }
 
     /*-------------------------------------------------------------------------
@@ -341,95 +337,91 @@ int copy_objects(const char* fnamein, const char* fnameout, pack_opt_t *options)
      *-------------------------------------------------------------------------
      */
     if (options->ublock_size > 0) {
-        if (copy_user_block(options->ublock_filename, fnameout,
-                options->ublock_size) < 0) {
+        if (copy_user_block(options->ublock_filename, fnameout, options->ublock_size) < 0) {
             error_msg("Could not copy user block. Exiting...\n");
-            HGOTO_ERROR(H5E_tools_g, H5E_tools_min_id_g, "H5Pclose failed");
+            HGOTO_ERROR(FAIL, H5E_tools_min_id_g, "H5Pclose failed");
         }
     }
 
-	/*-------------------------------------------------------------------------
-	 * get list of objects
-	 *-------------------------------------------------------------------------
-	 */
+    /*-------------------------------------------------------------------------
+     * get list of objects
+     *-------------------------------------------------------------------------
+     */
 
-	/* init table */
-	trav_table_init(&travt);
+    /* init table */
+    trav_table_init(&travt);
 
-	/* get the list of objects in the file */
-	if (h5trav_gettable(fidin, travt) < 0)
-        HGOTO_ERROR(H5E_tools_g, H5E_tools_min_id_g, "H5Pclose failed");
+    /* get the list of objects in the file */
+    if (h5trav_gettable(fidin, travt) < 0)
+        HGOTO_ERROR(FAIL, H5E_tools_min_id_g, "H5Pclose failed");
 
-	/*-------------------------------------------------------------------------
-	 * do the copy
-	 *-------------------------------------------------------------------------
-	 */
-	if (do_copy_objects(fidin, fidout, travt, options) < 0) {
-		error_msg("<%s>: Could not copy data to: %s\n", fnamein, fnameout);
-        HGOTO_ERROR(H5E_tools_g, H5E_tools_min_id_g, "H5Pclose failed");
+    /*-------------------------------------------------------------------------
+     * do the copy
+     *-------------------------------------------------------------------------
+     */
+    if (do_copy_objects(fidin, fidout, travt, options) < 0) {
+        error_msg("<%s>: Could not copy data to: %s\n", fnamein, fnameout);
+        HGOTO_ERROR(FAIL, H5E_tools_min_id_g, "H5Pclose failed");
     } /* end if */
 
-	/*-------------------------------------------------------------------------
-	 * do the copy of referenced objects
-	 * and create hard links
-	 *-------------------------------------------------------------------------
-	 */
-	if (do_copy_refobjs(fidin, fidout, travt, options) < 0) {
-		printf("h5repack: <%s>: Could not copy data to: %s\n", fnamein,
-				fnameout);
-        HGOTO_ERROR(H5E_tools_g, H5E_tools_min_id_g, "H5Pclose failed");
+    /*-------------------------------------------------------------------------
+     * do the copy of referenced objects
+     * and create hard links
+     *-------------------------------------------------------------------------
+     */
+    if (do_copy_refobjs(fidin, fidout, travt, options) < 0) {
+        printf("h5repack: <%s>: Could not copy data to: %s\n", fnamein, fnameout);
+        HGOTO_ERROR(FAIL, H5E_tools_min_id_g, "H5Pclose failed");
     }
 
-	/*-------------------------------------------------------------------------
-	 * close
-	 *-------------------------------------------------------------------------
-	 */
-
-	if (fapl > 0)
-		H5Pclose(fapl);
+    /*-------------------------------------------------------------------------
+     * close
+     *-------------------------------------------------------------------------
+     */
 
-	if (fcpl > 0)
-		H5Pclose(fcpl);
+    if (fapl > 0)
+        H5Pclose(fapl);
 
-	H5Fclose(fidin);
-	H5Fclose(fidout);
+    if (fcpl > 0)
+        H5Pclose(fcpl);
 
-	/* free table */
-	trav_table_free(travt);
-	travt = NULL;
+    H5Fclose(fidin);
+    H5Fclose(fidout);
 
-	/*-------------------------------------------------------------------------
-	 * write only the input file user block if there is no user block file input
-	 *-------------------------------------------------------------------------
-	 */
+    /* free table */
+    trav_table_free(travt);
+    travt = NULL;
 
-	if (ub_size > 0 && options->ublock_size == 0) {
-		if (copy_user_block(fnamein, fnameout, ub_size) < 0) {
-			error_msg("Could not copy user block. Exiting...\n");
-            HGOTO_ERROR(H5E_tools_g, H5E_tools_min_id_g, "H5Pclose failed");
+    /*-------------------------------------------------------------------------
+     * write only the input file user block if there is no user block file input
+     *-------------------------------------------------------------------------
+     */
 
-		}
-	}
+    if (ub_size > 0 && options->ublock_size == 0) {
+        if (copy_user_block(fnamein, fnameout, ub_size) < 0) {
+            error_msg("Could not copy user block. Exiting...\n");
+            HGOTO_ERROR(FAIL, H5E_tools_min_id_g, "H5Pclose failed");
+        }
+    }
 
-	return 0;
+    return 0;
 
-	/*-------------------------------------------------------------------------
-	 * out
-	 *-------------------------------------------------------------------------
-	 */
+    /*-------------------------------------------------------------------------
+     * out
+     *-------------------------------------------------------------------------
+     */
 
 done:
-	H5E_BEGIN_TRY
-		{
-			H5Pclose(fapl);
-			H5Pclose(fcpl);
-			H5Fclose(fidin);
-			H5Fclose(fidout);
-		}H5E_END_TRY;
-	if (travt)
-		trav_table_free(travt);
-
-	return -1;
+    H5E_BEGIN_TRY {
+        H5Pclose(fapl);
+        H5Pclose(fcpl);
+        H5Fclose(fidin);
+        H5Fclose(fidout);
+    } H5E_END_TRY;
+    if (travt)
+        trav_table_free(travt);
+
+    return ret_value;
 }
 
 /*-------------------------------------------------------------------------
@@ -470,133 +462,126 @@ done:
  *-----------------------------------------*/
 
 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) {
+        size_t size_datum, hsize_t dims_hslab[], hsize_t * hslab_nbytes_p)
+{
     int ret_value = 0; /*no need to LEAVE() on ERROR: HERR_INIT(int, SUCCEED) */
-    int status = 0;
-	int k;
-	H5D_layout_t dset_layout;
-	int rank_chunk;
-	hsize_t dims_chunk[H5S_MAX_RANK];
-	hsize_t size_chunk = 1;
-	hsize_t nchunk_fit; /* number of chunks that fits in hyperslab buffer (H5TOOLS_BUFSIZE) */
-	hsize_t ndatum_fit; /* number of dataum that fits in hyperslab buffer (H5TOOLS_BUFSIZE) */
-	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 */
-
-	/* init to set as size of a data element */
-	hslab_nbytes = size_datum;
-
-	/* get layout of dataset */
-	dset_layout = H5Pget_layout(dcpl_id);
-
-	/* if dataset is chunked */
-	if (dset_layout == H5D_CHUNKED) {
-		/* get chunk dims */
-		rank_chunk = H5Pget_chunk(dcpl_id, rank_dset, dims_chunk);
-		if (rank_chunk < 0) {
-			status = -1;
-            HGOTO_ERROR(H5E_tools_g, H5E_tools_min_id_g, "H5Pclose failed");
+    int k;
+    H5D_layout_t dset_layout;
+    int rank_chunk;
+    hsize_t dims_chunk[H5S_MAX_RANK];
+    hsize_t size_chunk = 1;
+    hsize_t nchunk_fit; /* number of chunks that fits in hyperslab buffer (H5TOOLS_BUFSIZE) */
+    hsize_t ndatum_fit; /* number of dataum that fits in hyperslab buffer (H5TOOLS_BUFSIZE) */
+    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 */
+
+    /* init to set as size of a data element */
+    hslab_nbytes = size_datum;
+
+    /* get layout of dataset */
+    dset_layout = H5Pget_layout(dcpl_id);
+
+    /* if dataset is chunked */
+    if (dset_layout == H5D_CHUNKED) {
+        /* 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, "H5Pclose failed");
+
+        for (k = rank_dset; k > 0; --k)
+            size_chunk *= dims_chunk[k - 1];
+
+        /* figure out how many chunks can fit in the hyperslab buffer */
+        nchunk_fit = (H5TOOLS_BUFSIZE / size_datum) / size_chunk;
+
+        /* 1. if a chunk fit in hyperslab buffer */
+        if (nchunk_fit >= 1) {
+            /* Calulate a hyperslab that contains as many chunks that can fit
+             * in hyperslab buffer. Hyperslab will be increased starting from
+             * the last dimention of the dataset (see h5dump's dims output).
+             * The calculation boundary is dataset dims.
+             * In the loop, used mapping from a datum to a chunk to figure out
+             * chunk based hyperslab.
+             */
+            for (k = rank_dset; k > 0; --k) {
+                /* map dataset dimentions with a chunk dims */
+                chunk_dims_map[k - 1] = dims_dset[k - 1] / dims_chunk[k - 1];
+
+                /* if reminder exist, increse by 1 to cover partial edge chunks */
+                if (dims_dset[k - 1] % dims_chunk[k - 1] > 0)
+                    chunk_dims_map[k - 1]++;
+
+                /* get mapped hyperslab dims */
+                hs_dims_map[k - 1] = MIN (nchunk_fit, chunk_dims_map[k-1]);
+
+                /* prepare next round */
+                nchunk_fit = nchunk_fit / chunk_dims_map[k - 1];
+                /* if a chunk is bigger than the rest of buffer */
+                if (nchunk_fit == 0)
+                    nchunk_fit = 1;
+
+                /* get hyperslab dimentions as unmapping to actual size */
+                dims_hslab[k - 1] = MIN( (hs_dims_map[k-1] * dims_chunk[k-1]), dims_dset[k-1]);
+
+                /* calculate total size for the hyperslab */
+                hslab_nbytes *= dims_hslab[k - 1];
+            }
         }
-
-		for (k = rank_dset; k > 0; --k)
-			size_chunk *= dims_chunk[k - 1];
-
-		/* figure out how many chunks can fit in the hyperslab buffer */
-		nchunk_fit = (H5TOOLS_BUFSIZE / size_datum) / size_chunk;
-
-		/* 1. if a chunk fit in hyperslab buffer */
-		if (nchunk_fit >= 1) {
-			/* Calulate a hyperslab that contains as many chunks that can fit
-			 * in hyperslab buffer. Hyperslab will be increased starting from
-			 * the last dimention of the dataset (see h5dump's dims output).
-			 * The calculation boundary is dataset dims.
-			 * In the loop, used mapping from a datum to a chunk to figure out
-			 * chunk based hyperslab.
-			 */
-			for (k = rank_dset; k > 0; --k) {
-				/* map dataset dimentions with a chunk dims */
-				chunk_dims_map[k - 1] = dims_dset[k - 1] / dims_chunk[k - 1];
-
-				/* if reminder exist, increse by 1 to cover partial edge chunks */
-				if (dims_dset[k - 1] % dims_chunk[k - 1] > 0)
-					chunk_dims_map[k - 1]++;
-
-				/* get mapped hyperslab dims */
-				hs_dims_map[k - 1] = MIN (nchunk_fit, chunk_dims_map[k-1]);
-
-				/* prepare next round */
-				nchunk_fit = nchunk_fit / chunk_dims_map[k - 1];
-				/* if a chunk is bigger than the rest of buffer */
-				if (nchunk_fit == 0)
-					nchunk_fit = 1;
-
-				/* get hyperslab dimentions as unmapping to actual size */
-				dims_hslab[k - 1] =
-						MIN( (hs_dims_map[k-1] * dims_chunk[k-1]), dims_dset[k-1]);
-
-				/* calculate total size for the hyperslab */
-				hslab_nbytes *= dims_hslab[k - 1];
-			}
-		}
-		/* 2. if a chunk is bigger than hyperslab buffer */
-		else {
-			/* Calulate a hyperslab that contains as many data elements that
-			 * can fit in hyperslab buffer. Hyperslab will be increased
-			 * starting from the last dimention of the chunk (see h5dump's dims
-			 * output).
-			 * The calculation boundary is a chunk dims.
-			 */
-			for (k = rank_dset; k > 0; --k) {
-				ndatum_fit = H5TOOLS_BUFSIZE / hslab_nbytes;
-
-				/* if a datum is bigger than rest of buffer */
-				if (ndatum_fit == 0)
-					ndatum_fit = 1;
-				/* get hyperslab dimentions within a chunk boundary */
-				dims_hslab[k - 1] = MIN (dims_chunk[k-1], ndatum_fit);
-
-				/* calculate total size for the hyperslab */
-				hslab_nbytes *= dims_hslab[k - 1];
-
-				if (hslab_nbytes <= 0) {
-					status = -1;
-                    HGOTO_ERROR(H5E_tools_g, H5E_tools_min_id_g, "H5Pclose failed");
-                }
-			}
-		}
-	}
-	/* 3. if dataset is not chunked */
-	else {
-		/* Calulate a hyperslab that contains as many data elements that can
-		 * fit in hyperslab buffer. Hyperslab will be increased starting from
-		 * the last dimention of the dataset (see h5dump's dims output).
-		 * The calculation boundary is dataset dims.
-		 */
-		for (k = rank_dset; k > 0; --k) {
-			ndatum_fit = H5TOOLS_BUFSIZE / hslab_nbytes;
-
-			/* if a datum is bigger than rest of buffer */
-			if (ndatum_fit == 0)
-				ndatum_fit = 1;
-			/* get hyperslab dimentions within dataset boundary */
-			dims_hslab[k - 1] = MIN(dims_dset[k - 1], ndatum_fit);
-
-			/* calculate total size for the hyperslab */
-			hslab_nbytes *= dims_hslab[k - 1];
-
-			if (hslab_nbytes <= 0) {
-				status = -1;
-                HGOTO_ERROR(H5E_tools_g, H5E_tools_min_id_g, "H5Pclose failed");
+        /* 2. if a chunk is bigger than hyperslab buffer */
+        else {
+            /* Calulate a hyperslab that contains as many data elements that
+             * can fit in hyperslab buffer. Hyperslab will be increased
+             * starting from the last dimention of the chunk (see h5dump's dims
+             * output).
+             * The calculation boundary is a chunk dims.
+             */
+            for (k = rank_dset; k > 0; --k) {
+                ndatum_fit = H5TOOLS_BUFSIZE / hslab_nbytes;
+
+                /* if a datum is bigger than rest of buffer */
+                if (ndatum_fit == 0)
+                    ndatum_fit = 1;
+                /* get hyperslab dimentions within a chunk boundary */
+                dims_hslab[k - 1] = MIN (dims_chunk[k-1], ndatum_fit);
+
+                /* calculate total size for the hyperslab */
+                hslab_nbytes *= dims_hslab[k - 1];
+
+                if (hslab_nbytes <= 0)
+                    HGOTO_ERROR(FAIL, H5E_tools_min_id_g, "H5Pclose failed");
             }
-		}
-	}
+        }
+    }
+    /* 3. if dataset is not chunked */
+    else {
+        /* Calulate a hyperslab that contains as many data elements that can
+         * fit in hyperslab buffer. Hyperslab will be increased starting from
+         * the last dimention of the dataset (see h5dump's dims output).
+         * The calculation boundary is dataset dims.
+         */
+        for (k = rank_dset; k > 0; --k) {
+            ndatum_fit = H5TOOLS_BUFSIZE / hslab_nbytes;
+
+            /* if a datum is bigger than rest of buffer */
+            if (ndatum_fit == 0)
+                ndatum_fit = 1;
+            /* get hyperslab dimentions within dataset boundary */
+            dims_hslab[k - 1] = MIN(dims_dset[k - 1], ndatum_fit);
+
+            /* calculate total size for the hyperslab */
+            hslab_nbytes *= dims_hslab[k - 1];
+
+            if (hslab_nbytes <= 0)
+                HGOTO_ERROR(FAIL, H5E_tools_min_id_g, "H5Pclose failed");
+        }
+    }
 
-	/* pass out the hyperslab size*/
-	*hslab_nbytes_p = hslab_nbytes;
+    /* pass out the hyperslab size*/
+    *hslab_nbytes_p = hslab_nbytes;
 
 done:
-	return status;
+    return ret_value;
 }
 
 /*-------------------------------------------------------------------------
@@ -698,709 +683,637 @@ int do_copy_objects(hid_t fidin, hid_t fidout, trav_table_t *travt,
 {
     int   ret_value = 0; /*no need to LEAVE() on ERROR: HERR_INIT(int, SUCCEED) */
     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 */
-	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 */
-	H5D_space_status_t space_status; /* determines whether space has been allocated for the dataset  */
-	int rank; /* rank of dataset */
-	hsize_t dims[H5S_MAX_RANK];/* dimensions of dataset */
-	hsize_t dsize_in; /* input dataset size before filter */
-	hsize_t dsize_out; /* output dataset size after filter */
-	int apply_s; /* flag for apply filter to small dataset sizes */
-	int apply_f; /* flag for apply filter to return error on H5Dcreate */
-	void *buf = NULL; /* buffer for raw data */
-	void *hslab_buf = NULL; /* hyperslab buffer for raw data */
-	int has_filter; /* current object has a filter */
-	int req_filter; /* there was a request for a filter */
-	int req_obj_layout = 0; /* request layout to current object */
-	unsigned crt_order_flags; /* group creation order flag */
-	unsigned i;
-	unsigned u;
-	int is_ref = 0;
-	htri_t is_named;
-	hbool_t limit_maxdims;
-	hsize_t size_dset;
-
-	/*-------------------------------------------------------------------------
-	 * copy the suppplied object list
-	 *-------------------------------------------------------------------------
-	 */
-
-	if (options->verbose) {
-		printf("-----------------------------------------\n");
-		printf(" Type     Filter (Compression)     Name\n");
-		printf("-----------------------------------------\n");
-	}
-
-	for (i = 0; i < travt->nobjs; i++) {
-		/* init variables per obj */
-		buf = NULL;
-		limit_maxdims = FALSE;
-
-		switch (travt->objs[i].type) {
-
-		case H5TRAV_TYPE_UNKNOWN:
-			HDassert(0);
-			break;
-			/*-------------------------------------------------------------------------
-			 * H5TRAV_TYPE_GROUP
-			 *-------------------------------------------------------------------------
-			 */
-		case H5TRAV_TYPE_GROUP:
-
-			if (options->verbose) {
-				printf(FORMAT_OBJ, "group", travt->objs[i].name);
-			}
-
-			/* open input group */
-			if ((grp_in = H5Gopen2(fidin, travt->objs[i].name, H5P_DEFAULT))
-					< 0)
-                HGOTO_ERROR(H5E_tools_g, H5E_tools_min_id_g, "H5Gopen2 failed");
-
-			/* get input group creation property list */
-			if ((gcpl_in = H5Gget_create_plist(grp_in)) < 0)
-                HGOTO_ERROR(H5E_tools_g, H5E_tools_min_id_g, "H5Gget_create_plist failed");
-
-			/* query and set the group creation properties */
-			if (H5Pget_link_creation_order(gcpl_in, &crt_order_flags) < 0)
-                HGOTO_ERROR(H5E_tools_g, H5E_tools_min_id_g, "H5Pget_link_creation_order failed");
-
-			/* set up group creation property list */
-			if ((gcpl_out = H5Pcreate(H5P_GROUP_CREATE)) < 0)
-                HGOTO_ERROR(H5E_tools_g, H5E_tools_min_id_g, "H5Pcreate failed");
-
-			if (H5Pset_link_creation_order(gcpl_out, crt_order_flags) < 0)
-                HGOTO_ERROR(H5E_tools_g, H5E_tools_min_id_g, "H5Pset_link_creation_order failed");
-
-			/*-------------------------------------------------------------------------
-			 * the root is a special case, we get an ID for the root group
-			 * and copy its attributes using that ID
-			 *-------------------------------------------------------------------------
-			 */
-			if (HDstrcmp(travt->objs[i].name, "/") == 0) {
-				if ((grp_out = H5Gopen2(fidout, "/", H5P_DEFAULT)) < 0)
-                    HGOTO_ERROR(H5E_tools_g, H5E_tools_min_id_g, "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(H5E_tools_g, H5E_tools_min_id_g, "H5Pset_link_phase_change failed");
-                }
-
-				if ((grp_out = H5Gcreate2(fidout, travt->objs[i].name,
-						H5P_DEFAULT, gcpl_out, H5P_DEFAULT)) < 0)
-                    HGOTO_ERROR(H5E_tools_g, H5E_tools_min_id_g, "H5Gcreate2 failed");
-
-			}
-
-			/*-------------------------------------------------------------------------
-			 * copy attrs
-			 *-------------------------------------------------------------------------
-			 */
-			if (copy_attr(grp_in, grp_out, &named_dt_head, travt, options) < 0)
-                HGOTO_ERROR(H5E_tools_g, H5E_tools_min_id_g, "copy_attr failed");
-
-            if (H5Pclose(gcpl_out) < 0)
-                HGOTO_ERROR(H5E_tools_g, H5E_tools_min_id_g, "H5Pclose failed");
-            if (H5Pclose(gcpl_in) < 0)
-                HGOTO_ERROR(H5E_tools_g, H5E_tools_min_id_g, "H5Pclose failed");
-            if (H5Gclose(grp_out) < 0)
-                HGOTO_ERROR(H5E_tools_g, H5E_tools_min_id_g, "H5Gclose failed");
-            if (H5Gclose(grp_in) < 0)
-                HGOTO_ERROR(H5E_tools_g, H5E_tools_min_id_g, "H5Gclose failed");
-
-			break;
-
-			/*-------------------------------------------------------------------------
-			 * H5TRAV_TYPE_DATASET
-			 *-------------------------------------------------------------------------
-			 */
-		case H5TRAV_TYPE_DATASET:
-
-			has_filter = 0;
-			req_filter = 0;
-
-			/* check if global filters were requested */
-			if (options->n_filter_g)
-				req_filter = 1;
-
-			/* check if filters were requested for individual objects */
-			for (u = 0; u < options->op_tbl->nelems; u++) {
-
-				if (HDstrcmp(travt->objs[i].name, options->op_tbl->objs[u].path) == 0) {
-					if (options->op_tbl->objs[u].filter->filtn > 0) {
-						req_filter = 1;
-					}
-				}
-			}
-
-			/* check if layout change requested individual object */
-			if (options->layout_g != H5D_LAYOUT_ERROR) {
-				pack_info_t *pckinfo;
-				/* any dataset is specified */
-				if (options->op_tbl->nelems > 0) {
-					/* check if object exist */
-					pckinfo = options_get_object(travt->objs[i].name,
-							options->op_tbl);
-					if (pckinfo) {
-						req_obj_layout = 1;
-					}
-				}
-			}
-
-			/* early detection of references */
-			if ((dset_in = H5Dopen2(fidin, travt->objs[i].name, H5P_DEFAULT))
-					< 0)
-                HGOTO_ERROR(H5E_tools_g, H5E_tools_min_id_g, "H5Dopen2 failed");
-            if ((ftype_id = H5Dget_type(dset_in)) < 0)
-                HGOTO_ERROR(H5E_tools_g, H5E_tools_min_id_g, "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(H5E_tools_g, H5E_tools_min_id_g, "H5Tcommitted failed");
-            if (is_named)
-				if ((wtype_id = copy_named_datatype(ftype_id, fidout,
-						&named_dt_head, travt, options)) < 0)
-                    HGOTO_ERROR(H5E_tools_g, H5E_tools_min_id_g, "copy_named_datatype failed");
-
-			if (H5Tclose(ftype_id) < 0)
-                HGOTO_ERROR(H5E_tools_g, H5E_tools_min_id_g, "H5Tclose failed");
-            if (H5Dclose(dset_in) < 0)
-                HGOTO_ERROR(H5E_tools_g, H5E_tools_min_id_g, "H5Dclose failed");
-
-			/*-------------------------------------------------------------------------
-			 * check if we should use H5Ocopy or not
-			 * if there is a request for filters/layout, we read/write the object
-			 * otherwise we do a copy using H5Ocopy
-			 *-------------------------------------------------------------------------
-			 */
-			if (options->op_tbl->nelems || options->all_filter == 1
-					|| options->all_layout == 1 || is_ref || is_named) {
-
-				int j;
-
-				if ((dset_in = H5Dopen2(fidin, travt->objs[i].name, H5P_DEFAULT)) < 0)
-                    HGOTO_ERROR(H5E_tools_g, H5E_tools_min_id_g, "H5Dopen2 failed");
-                if ((f_space_id = H5Dget_space(dset_in)) < 0)
-                    HGOTO_ERROR(H5E_tools_g, H5E_tools_min_id_g, "H5Dget_space failed");
-                if ((ftype_id = H5Dget_type(dset_in)) < 0)
-                    HGOTO_ERROR(H5E_tools_g, H5E_tools_min_id_g, "H5Dget_type failed");
-                if ((dcpl_in = H5Dget_create_plist(dset_in)) < 0)
-                    HGOTO_ERROR(H5E_tools_g, H5E_tools_min_id_g, "H5Dget_create_plist failed");
-                if ((dcpl_out = H5Pcopy(dcpl_in)) < 0)
-                    HGOTO_ERROR(H5E_tools_g, H5E_tools_min_id_g, "H5Pcopy failed");
-                if ((rank = H5Sget_simple_extent_ndims(f_space_id)) < 0)
-                    HGOTO_ERROR(H5E_tools_g, H5E_tools_min_id_g, "H5Sget_simple_extent_ndims failed");
-                HDmemset(dims, 0, sizeof dims);
-				if (H5Sget_simple_extent_dims(f_space_id, dims, NULL) < 0)
-                    HGOTO_ERROR(H5E_tools_g, H5E_tools_min_id_g, "H5Sget_simple_extent_dims failed");
-
-				if (H5Dget_space_status(dset_in, &space_status) < 0)
-                    HGOTO_ERROR(H5E_tools_g, H5E_tools_min_id_g, "H5Dget_space_status failed");
-
-				nelmts = 1;
-				for (j = 0; j < rank; j++)
-					nelmts *= dims[j];
-
-				/* wtype_id will have already been set if using a named dtype */
-				if (!is_named) {
-					if (options->use_native == 1)
-						wtype_id = h5tools_get_native_type(ftype_id);
-					else
-						wtype_id = H5Tcopy(ftype_id);
-				} /* end if */
-
-				if ((msize = H5Tget_size(wtype_id)) == 0)
-                    HGOTO_ERROR(H5E_tools_g, H5E_tools_min_id_g, "H5Tget_size failed");
-
-				/* size of current dset */
-				size_dset = nelmts * msize;
-
-				/*-------------------------------------------------------------------------
-				 * check if the dataset creation property list has filters that
-				 * are not registered in the current configuration
-				 * 1) the external filters GZIP and SZIP might not be available
-				 * 2) the internal filters might be turned off
-				 *-------------------------------------------------------------------------
-				 */
-				if (h5tools_canreadf((travt->objs[i].name), dcpl_in) == 1) {
-					apply_s = 1;
-					apply_f = 1;
-
-					/*-------------------------------------------------------------------------
-					 * references are a special case
-					 * we cannot just copy the buffers, but instead we recreate the reference
-					 * in a second traversal of the output file
-					 *-------------------------------------------------------------------------
-					 */
-					if (H5T_REFERENCE != H5Tget_class(wtype_id)) {
-						/* get the storage size of the input dataset */
-						dsize_in = H5Dget_storage_size(dset_in);
-
-						/* check for small size datasets (less than 1k) except
-						 * changing to COMPACT. For the reference, COMPACT is limited
-						 * by size 64K by library.
-						 */
-						if (options->layout_g != H5D_COMPACT) {
-							if (size_dset < options->min_comp)
-								apply_s = 0;
-						}
-
-						/* apply the filter */
-						if (apply_s) {
-							if (apply_filters(travt->objs[i].name, rank, dims,
-									msize, dcpl_out, options, &has_filter) < 0)
-                                HGOTO_ERROR(H5E_tools_g, H5E_tools_min_id_g, "apply_filters failed");
-                        }
-
-						/* only if layout change requested for entire file or
-						 * individual obj */
-						if (options->all_layout > 0 || req_obj_layout == 1)
-							/*-------------------------------------------------
-							 * Unset the unlimited max dims if convert to other
-							 * than chunk layouts, because unlimited max dims
-							 * only can be applied to chunk layout.
-							 * Also perform only for targeted dataset
-							 * Also check for size limit to convert to compact
-							 *-------------------------------------------------*/
-							if (options->layout_g != H5D_CHUNKED) {
-								/* any dataset is specified */
-								if (options->op_tbl->nelems > 0) {
-									/* if current obj match specified obj */
-									if (options_get_object(travt->objs[i].name,
-											options->op_tbl))
-										limit_maxdims = TRUE;
-								}
-								else { /* no dataset is specified */
-									limit_maxdims = TRUE;
-								}
-
-								/* if convert to COMPACT */
-								if (options->layout_g == H5D_COMPACT) {
-									/* should be smaller than 64K */
-									if (size_dset > MAX_COMPACT_DSIZE)
-										limit_maxdims = FALSE;
-								}
-
-								/* unset unlimited max dims */
-								if (limit_maxdims)
-									H5Sset_extent_simple(f_space_id, rank, dims,
-											NULL);
-							}
-
-						/*-------------------------------------------------------------------------
-						 * create the output dataset;
-						 * disable error checking in case the dataset cannot be created with the
-						 * modified dcpl; in that case use the original instead
-						 *-------------------------------------------------------------------------
-						 */
-                        dset_out = H5Dcreate2(fidout,
-										travt->objs[i].name, wtype_id,
-										f_space_id, H5P_DEFAULT, dcpl_out,
-										H5P_DEFAULT);
-
-						if (dset_out == FAIL) {
-                            HERROR(H5E_tools_g, H5E_tools_min_id_g, "H5Dcreate2 failed");
-                            if (options->verbose)
-								printf(
-										" 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(H5E_tools_g, H5E_tools_min_id_g, "H5Dcreate2 failed");
-                            apply_f = 0;
-						}
-
-						/*-------------------------------------------------------------------------
-						 * read/write
-						 *-------------------------------------------------------------------------
-						 */
-						if (nelmts > 0 && space_status != H5D_SPACE_STATUS_NOT_ALLOCATED) {
-							size_t need = (size_t)(nelmts * msize); /* bytes needed */
-
-							/* have to read the whole dataset if there is only one element in the dataset */
-							if (need < H5TOOLS_MALLOCSIZE)
-								buf = HDmalloc(need);
-
-							if (buf != NULL) {
-								/* read/write: use the macro to check error, e.g. memory allocation error inside the library. */
-								CHECK_H5DRW_ERROR(H5Dread, dset_in, wtype_id,
-										H5S_ALL, H5S_ALL, H5P_DEFAULT, buf);
-								CHECK_H5DRW_ERROR(H5Dwrite, dset_out, wtype_id,
-										H5S_ALL, H5S_ALL, H5P_DEFAULT, buf);
-
-								/* 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(H5E_tools_g, H5E_tools_min_id_g, "H5Dvlen_reclaim failed");
-                            }
-							else { /* possibly not enough memory, read/write by hyperslabs */
-								size_t p_type_nbytes = msize; /*size of memory type */
-								hsize_t p_nelmts = nelmts; /*total elements */
-								hsize_t elmtno; /*counter  */
-								int carry; /*counter carry value */
-								unsigned int vl_data = 0; /*contains VL datatypes */
-
-								/* hyperslab info */
-								hsize_t hslab_dims[H5S_MAX_RANK]; /*hyperslab dims */
-								hsize_t hslab_nbytes; /*bytes per hyperslab */
-								hsize_t hslab_nelmts; /*elements per hyperslab*/
-								hid_t hslab_space; /*hyperslab data space */
-
-								/* hyperslab selection info */
-								hsize_t hs_sel_offset[H5S_MAX_RANK];/* selection offset */
-								hsize_t hs_sel_count[H5S_MAX_RANK]; /* selection count */
-								hsize_t hs_select_nelmts; /* selected elements */
-								hsize_t zero[8]; /*vector of zeros */
-								int k;
-								H5D_layout_t dset_layout;
-								hid_t dcpl_tmp = -1; /* dataset creation property list ID */
-
-								/* check if we have VL data in the dataset's datatype */
-								if (H5Tdetect_class(wtype_id, H5T_VLEN) == TRUE)
-									vl_data = TRUE;
-
-								/* check first if writing dataset is chunked,
-								 * if so use its chunk layout for better performance. */
-								dset_layout = H5Pget_layout(dcpl_out);
-								if (dset_layout == H5D_CHUNKED)
-									dcpl_tmp = dcpl_out; /* writing dataset */
-								else { /* if reading dataset is chunked */
-									dset_layout = H5Pget_layout(dcpl_in);
-									if (dset_layout == H5D_CHUNKED)
-										dcpl_tmp = dcpl_in; /* reading dataset */
-								}
-
-								/* get hyperslab dims and size in byte */
-								if (Get_hyperslab(dcpl_tmp, rank, dims,
-										p_type_nbytes, hslab_dims,
-										&hslab_nbytes) < 0)
-                                    HGOTO_ERROR(H5E_tools_g, H5E_tools_min_id_g, "Get_hyperslab failed");
-
-								hslab_buf = HDmalloc((size_t)hslab_nbytes);
-
-								hslab_nelmts = hslab_nbytes / p_type_nbytes;
-								hslab_space = H5Screate_simple(1, &hslab_nelmts,
-										NULL);
-
-								/* the hyperslab selection loop */
-								HDmemset(hs_sel_offset, 0,
-										sizeof hs_sel_offset);
-								HDmemset(zero, 0, sizeof zero);
-
-								for (elmtno = 0; elmtno < p_nelmts; elmtno +=
-										hs_select_nelmts) {
-									if (rank > 0) {
-										/* calculate the hyperslab selections. The selection would be same as the hyperslab except for remaining edge portion of the dataset which is smaller then the hyperslab.
-										 */
-										for (k = 0, hs_select_nelmts = 1;
-												k < rank; k++) {
-											/* MIN() is used to get the remaining edge portion if exist.
-											 * "dims[k] - hs_sel_offset[k]" is remaining edge portion that is smaller then the hyperslab.*/
-											hs_sel_count[k] =
-													MIN(dims[k] - hs_sel_offset[k], hslab_dims[k]);
-											hs_select_nelmts *= hs_sel_count[k];
-										}
-
-										if (H5Sselect_hyperslab(f_space_id,
-												H5S_SELECT_SET, hs_sel_offset,
-												NULL, hs_sel_count, NULL) < 0)
-                                            HGOTO_ERROR(H5E_tools_g, H5E_tools_min_id_g, "H5Sselect_hyperslab failed");
-                                        if (H5Sselect_hyperslab(hslab_space,
-												H5S_SELECT_SET, zero, NULL,
-												&hs_select_nelmts, NULL) < 0)
-                                            HGOTO_ERROR(H5E_tools_g, H5E_tools_min_id_g, "H5Sselect_hyperslab failed");
-                                    }
-									else {
-										H5Sselect_all(f_space_id);
-										H5Sselect_all(hslab_space);
-										hs_select_nelmts = 1;
-									} /* rank */
-
-									/* read/write: use the macro to check error, e.g. memory allocation error inside the library. */
-									CHECK_H5DRW_ERROR(H5Dread, dset_in,
-											wtype_id, hslab_space, f_space_id,
-											H5P_DEFAULT, hslab_buf);
-									CHECK_H5DRW_ERROR(H5Dwrite, dset_out,
-											wtype_id, hslab_space, f_space_id,
-											H5P_DEFAULT, hslab_buf);
-
-									/* reclaim any VL memory, if necessary */
-									if (vl_data)
-										H5Dvlen_reclaim(wtype_id, hslab_space,
-												H5P_DEFAULT, hslab_buf);
-
-									/* calculate the next hyperslab offset */
-									for (k = rank, carry = 1; k > 0 && carry;
-											--k) {
-										hs_sel_offset[k - 1] += hs_sel_count[k
-												- 1];
-										/* if reached the end of a dim */
-										if (hs_sel_offset[k - 1] == dims[k - 1])
-											hs_sel_offset[k - 1] = 0;
-										else
-											carry = 0;
-									} /* k */
-								} /* elmtno */
-
-								H5Sclose(hslab_space);
-								/* free */
-								if (hslab_buf != NULL) {
-									HDfree(hslab_buf);
-									hslab_buf = NULL;
-								}
-							} /* hyperslab read */
-						} /* if (nelmts>0 && space_status==H5D_SPACE_STATUS_NOT_ALLOCATED) */
-
-						/*-------------------------------------------------------------------------
-						 * amount of compression used
-						 *-------------------------------------------------------------------------
-						 */
-						if (options->verbose) {
-							double ratio = 0;
-
-							/* only print the compression ration if there was a filter request */
-							if (apply_s && apply_f && req_filter) {
-								/* get the storage size of the output dataset */
-								dsize_out = H5Dget_storage_size(dset_out);
-
-								/* compression ratio = uncompressed size /  compressed size */
-								if (dsize_out != 0)
-									ratio = (double) dsize_in
-											/ (double) dsize_out;
-
-								print_dataset_info(dcpl_out,
-										travt->objs[i].name, ratio, 1);
-							}
-							else
-								print_dataset_info(dcpl_in, travt->objs[i].name,
-										ratio, 0);
-
-							/* print a message that the filter was not applied
-							 (in case there was a filter)
-							 */
-							if (has_filter && apply_s == 0)
-								printf(
-										" <warning: filter not applied to %s. dataset smaller than %d bytes>\n",
-										travt->objs[i].name,
-										(int) options->min_comp);
-
-							if (has_filter && apply_f == 0)
-								printf(
-										" <warning: could not apply the filter to %s>\n",
-										travt->objs[i].name);
-
-						} /* verbose */
-
-						/*-------------------------------------------------------------------------
-						 * copy attrs
-						 *-------------------------------------------------------------------------
-						 */
-						if (copy_attr(dset_in, dset_out, &named_dt_head, travt,
-								options) < 0)
-                            HGOTO_ERROR(H5E_tools_g, H5E_tools_min_id_g, "copy_attr failed");
-                        /*close */
-						if (H5Dclose(dset_out) < 0)
-                            HGOTO_ERROR(H5E_tools_g, H5E_tools_min_id_g, "H5Dclose failed");
-
-					}/*!H5T_REFERENCE*/
-				}/*h5tools_canreadf*/
-
-				/*-------------------------------------------------------------------------
-				 * close
-				 *-------------------------------------------------------------------------
-				 */
-				if (H5Tclose(ftype_id) < 0)
-                    HGOTO_ERROR(H5E_tools_g, H5E_tools_min_id_g, "H5Tclose failed");
-                if (H5Tclose(wtype_id) < 0)
-                    HGOTO_ERROR(H5E_tools_g, H5E_tools_min_id_g, "H5Tclose failed");
-                if (H5Pclose(dcpl_in) < 0)
-                    HGOTO_ERROR(H5E_tools_g, H5E_tools_min_id_g, "H5Pclose failed");
-                if (H5Pclose(dcpl_out) < 0)
-                    HGOTO_ERROR(H5E_tools_g, H5E_tools_min_id_g, "H5Pclose failed");
-                if (H5Sclose(f_space_id) < 0)
-                    HGOTO_ERROR(H5E_tools_g, H5E_tools_min_id_g, "H5Sclose failed");
-                if (H5Dclose(dset_in) < 0)
-                    HGOTO_ERROR(H5E_tools_g, H5E_tools_min_id_g, "H5Dclose failed");
-
-			}
-			/*-------------------------------------------------------------------------
-			 * we do not have request for filter/chunking use H5Ocopy instead
-			 *-------------------------------------------------------------------------
-			 */
-			else {
-				hid_t pid;
-
-				/* create property to pass copy options */
-				if ((pid = H5Pcreate(H5P_OBJECT_COPY)) < 0)
-                    HGOTO_ERROR(H5E_tools_g, H5E_tools_min_id_g, "H5Pcreate failed");
-
-				/* set options for object copy */
-				if (H5Pset_copy_object(pid, H5O_COPY_WITHOUT_ATTR_FLAG) < 0)
-                    HGOTO_ERROR(H5E_tools_g, H5E_tools_min_id_g, "H5Pset_copy_object failed");
-
-				/*-------------------------------------------------------------------------
-				 * do the copy
-				 *-------------------------------------------------------------------------
-				 */
-
-				if (H5Ocopy(fidin, /* Source file or group identifier */
-				travt->objs[i].name, /* Name of the source object to be copied */
-				fidout, /* Destination file or group identifier  */
-				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(H5E_tools_g, H5E_tools_min_id_g, "H5Ocopy failed");
-
-				/* close property */
-				if (H5Pclose(pid) < 0)
-                    HGOTO_ERROR(H5E_tools_g, H5E_tools_min_id_g, "H5Pclose failed");
-
-				/*-------------------------------------------------------------------------
-				 * copy attrs manually
-				 *-------------------------------------------------------------------------
-				 */
-				if ((dset_in = H5Dopen2(fidin, travt->objs[i].name, H5P_DEFAULT))
-						< 0)
-                    HGOTO_ERROR(H5E_tools_g, H5E_tools_min_id_g, "H5Dopen2 failed");
-                if ((dset_out = H5Dopen2(fidout, travt->objs[i].name, H5P_DEFAULT)) < 0)
-                    HGOTO_ERROR(H5E_tools_g, H5E_tools_min_id_g, "H5Dopen2 failed");
-                if (copy_attr(dset_in, dset_out, &named_dt_head, travt, options) < 0)
-                    HGOTO_ERROR(H5E_tools_g, H5E_tools_min_id_g, "copy_attr failed");
-                if (H5Dclose(dset_in) < 0)
-                    HGOTO_ERROR(H5E_tools_g, H5E_tools_min_id_g, "H5Dclose failed");
-                if (H5Dclose(dset_out) < 0)
-                    HGOTO_ERROR(H5E_tools_g, H5E_tools_min_id_g, "H5Dclose failed");
-
-				if (options->verbose)
-					printf(FORMAT_OBJ, "dset", travt->objs[i].name);
-
-			} /* end do we have request for filter/chunking */
-
-			break;
-
-			/*-------------------------------------------------------------------------
-			 * H5TRAV_TYPE_NAMED_DATATYPE
-			 *-------------------------------------------------------------------------
-			 */
-		case H5TRAV_TYPE_NAMED_DATATYPE:
-
-			if (options->verbose)
-				printf(FORMAT_OBJ, "type", travt->objs[i].name);
-
-			if ((type_in = H5Topen2(fidin, travt->objs[i].name, H5P_DEFAULT)) < 0)
-                HGOTO_ERROR(H5E_tools_g, H5E_tools_min_id_g, "H5Topen2 failed");
+    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 */
+    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 */
+    H5D_space_status_t space_status; /* determines whether space has been allocated for the dataset  */
+    int rank; /* rank of dataset */
+    hsize_t dims[H5S_MAX_RANK];/* dimensions of dataset */
+    hsize_t dsize_in; /* input dataset size before filter */
+    hsize_t dsize_out; /* output dataset size after filter */
+    int apply_s; /* flag for apply filter to small dataset sizes */
+    int apply_f; /* flag for apply filter to return error on H5Dcreate */
+    void *buf = NULL; /* buffer for raw data */
+    void *hslab_buf = NULL; /* hyperslab buffer for raw data */
+    int has_filter; /* current object has a filter */
+    int req_filter; /* there was a request for a filter */
+    int req_obj_layout = 0; /* request layout to current object */
+    unsigned crt_order_flags; /* group creation order flag */
+    unsigned i;
+    unsigned u;
+    int is_ref = 0;
+    htri_t is_named;
+    hbool_t limit_maxdims;
+    hsize_t size_dset;
 
-			/* Copy the datatype anonymously */
-			if ((type_out = copy_named_datatype(type_in, fidout, &named_dt_head,
-					travt, options)) < 0)
-                HGOTO_ERROR(H5E_tools_g, H5E_tools_min_id_g, "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(H5E_tools_g, H5E_tools_min_id_g, "H5Lcreate_hard failed");
-
-			/*-------------------------------------------------------------------------
-			 * copy attrs
-			 *-------------------------------------------------------------------------
-			 */
-			if (copy_attr(type_in, type_out, &named_dt_head, travt, options) < 0)
-                HGOTO_ERROR(H5E_tools_g, H5E_tools_min_id_g, "copy_attr failed");
-
-			if (H5Tclose(type_in) < 0)
-                HGOTO_ERROR(H5E_tools_g, H5E_tools_min_id_g, "H5Tclose failed");
-            if (H5Tclose(type_out) < 0)
-                HGOTO_ERROR(H5E_tools_g, H5E_tools_min_id_g, "H5Tclose failed");
+    /*-------------------------------------------------------------------------
+     * copy the suppplied object list
+     *-------------------------------------------------------------------------
+     */
 
-			break;
+    if (options->verbose) {
+        printf("-----------------------------------------\n");
+        printf(" Type     Filter (Compression)     Name\n");
+        printf("-----------------------------------------\n");
+    }
 
-			/*-------------------------------------------------------------------------
-			 * H5TRAV_TYPE_LINK
-			 * H5TRAV_TYPE_UDLINK
-			 *
-			 * Only handles external links; H5Lcopy will fail for other UD link types
-			 * since we don't have creation or copy callbacks for them.
-			 *-------------------------------------------------------------------------
-			 */
+    for (i = 0; i < travt->nobjs; i++) {
+        /* init variables per obj */
+        buf = NULL;
+        limit_maxdims = FALSE;
+
+        switch (travt->objs[i].type) {
+            case H5TRAV_TYPE_UNKNOWN:
+                HDassert(0);
+                break;
+
+                /*-------------------------------------------------------------------------
+                 * H5TRAV_TYPE_GROUP
+                 *-------------------------------------------------------------------------
+                 */
+            case H5TRAV_TYPE_GROUP:
+                if (options->verbose)
+                    printf(FORMAT_OBJ, "group", travt->objs[i].name);
+
+                /* 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");
+
+                /* 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");
+
+                /* 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");
+
+                /* set up group creation property list */
+                if ((gcpl_out = H5Pcreate(H5P_GROUP_CREATE)) < 0)
+                    HGOTO_ERROR(FAIL, H5E_tools_min_id_g, "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");
+
+                /*-------------------------------------------------------------------------
+                 * the root is a special case, we get an ID for the root group
+                 * and copy its attributes using that ID
+                 *-------------------------------------------------------------------------
+                 */
+                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");
+                }
+                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");
 
-		case H5TRAV_TYPE_LINK:
-		case H5TRAV_TYPE_UDLINK: {
+                    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");
+                }
 
-			if (options->verbose)
-				printf(FORMAT_OBJ, "link", travt->objs[i].name);
+                /*-------------------------------------------------------------------------
+                 * copy attrs
+                 *-------------------------------------------------------------------------
+                 */
+                if (copy_attr(grp_in, grp_out, &named_dt_head, travt, options) < 0)
+                    HGOTO_ERROR(FAIL, H5E_tools_min_id_g, "copy_attr failed");
+
+                if (H5Pclose(gcpl_out) < 0)
+                    HGOTO_ERROR(FAIL, H5E_tools_min_id_g, "H5Pclose failed");
+                if (H5Pclose(gcpl_in) < 0)
+                    HGOTO_ERROR(FAIL, H5E_tools_min_id_g, "H5Pclose failed");
+                if (H5Gclose(grp_out) < 0)
+                    HGOTO_ERROR(FAIL, H5E_tools_min_id_g, "H5Gclose failed");
+                if (H5Gclose(grp_in) < 0)
+                    HGOTO_ERROR(FAIL, H5E_tools_min_id_g, "H5Gclose failed");
+
+                break;
+
+                /*-------------------------------------------------------------------------
+                 * H5TRAV_TYPE_DATASET
+                 *-------------------------------------------------------------------------
+                 */
+            case H5TRAV_TYPE_DATASET:
+                has_filter = 0;
+                req_filter = 0;
+
+                /* check if global filters were requested */
+                if (options->n_filter_g)
+                    req_filter = 1;
+
+                /* check if filters were requested for individual objects */
+                for (u = 0; u < options->op_tbl->nelems; u++)
+                    if (HDstrcmp(travt->objs[i].name, options->op_tbl->objs[u].path) == 0)
+                        if (options->op_tbl->objs[u].filter->filtn > 0)
+                            req_filter = 1;
+
+                /* check if layout change requested individual object */
+                if (options->layout_g != H5D_LAYOUT_ERROR) {
+                    pack_info_t *pckinfo;
+
+                    /* any dataset is specified */
+                    if (options->op_tbl->nelems > 0) {
+                        /* check if object exist */
+                        pckinfo = options_get_object(travt->objs[i].name, options->op_tbl);
+                        if (pckinfo)
+                            req_obj_layout = 1;
+                    }
+                }
 
-			if (H5Lcopy(fidin, travt->objs[i].name, fidout, travt->objs[i].name,
-                    H5P_DEFAULT, H5P_DEFAULT) < 0)
-                HGOTO_ERROR(H5E_tools_g, H5E_tools_min_id_g, "H5Lcopy failed");
+                /* 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");
+                if ((ftype_id = H5Dget_type(dset_in)) < 0)
+                    HGOTO_ERROR(FAIL, H5E_tools_min_id_g, "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");
+                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");
+
+                if (H5Tclose(ftype_id) < 0)
+                    HGOTO_ERROR(FAIL, H5E_tools_min_id_g, "H5Tclose failed");
+                if (H5Dclose(dset_in) < 0)
+                    HGOTO_ERROR(FAIL, H5E_tools_min_id_g, "H5Dclose failed");
+
+                /*-------------------------------------------------------------------------
+                 * check if we should use H5Ocopy or not
+                 * if there is a request for filters/layout, we read/write the object
+                 * otherwise we do a copy using H5Ocopy
+                 *-------------------------------------------------------------------------
+                 */
+                if (options->op_tbl->nelems || options->all_filter == 1
+                        || options->all_layout == 1 || is_ref || is_named) {
+
+                    int j;
+
+                    if ((dset_in = H5Dopen2(fidin, travt->objs[i].name, H5P_DEFAULT)) < 0)
+                        HGOTO_ERROR(FAIL, H5E_tools_min_id_g, "H5Dopen2 failed");
+                    if ((f_space_id = H5Dget_space(dset_in)) < 0)
+                        HGOTO_ERROR(FAIL, H5E_tools_min_id_g, "H5Dget_space failed");
+                    if ((ftype_id = H5Dget_type(dset_in)) < 0)
+                        HGOTO_ERROR(FAIL, H5E_tools_min_id_g, "H5Dget_type failed");
+                    if ((dcpl_in = H5Dget_create_plist(dset_in)) < 0)
+                        HGOTO_ERROR(FAIL, H5E_tools_min_id_g, "H5Dget_create_plist failed");
+                    if ((dcpl_out = H5Pcopy(dcpl_in)) < 0)
+                        HGOTO_ERROR(FAIL, H5E_tools_min_id_g, "H5Pcopy failed");
+                    if ((rank = H5Sget_simple_extent_ndims(f_space_id)) < 0)
+                        HGOTO_ERROR(FAIL, H5E_tools_min_id_g, "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");
+                    if (H5Dget_space_status(dset_in, &space_status) < 0)
+                        HGOTO_ERROR(FAIL, H5E_tools_min_id_g, "H5Dget_space_status failed");
+
+                    nelmts = 1;
+                    for (j = 0; j < rank; j++)
+                        nelmts *= dims[j];
+
+                    /* wtype_id will have already been set if using a named dtype */
+                    if (!is_named) {
+                        if (options->use_native == 1)
+                            wtype_id = h5tools_get_native_type(ftype_id);
+                        else
+                            wtype_id = H5Tcopy(ftype_id);
+                    } /* end if */
 
-			if (options->verbose)
-				printf(FORMAT_OBJ, "link", travt->objs[i].name);
+                    if ((msize = H5Tget_size(wtype_id)) == 0)
+                        HGOTO_ERROR(FAIL, H5E_tools_min_id_g, "H5Tget_size failed");
+
+                    /* size of current dset */
+                    size_dset = nelmts * msize;
+
+                    /*-------------------------------------------------------------------------
+                     * check if the dataset creation property list has filters that
+                     * are not registered in the current configuration
+                     * 1) the external filters GZIP and SZIP might not be available
+                     * 2) the internal filters might be turned off
+                     *-------------------------------------------------------------------------
+                     */
+                    if (h5tools_canreadf((travt->objs[i].name), dcpl_in) == 1) {
+                        apply_s = 1;
+                        apply_f = 1;
+
+                        /*-------------------------------------------------------------------------
+                         * references are a special case
+                         * we cannot just copy the buffers, but instead we recreate the reference
+                         * in a second traversal of the output file
+                         *-------------------------------------------------------------------------
+                         */
+                        if (H5T_REFERENCE != H5Tget_class(wtype_id)) {
+                            /* get the storage size of the input dataset */
+                            dsize_in = H5Dget_storage_size(dset_in);
+
+                            /* check for small size datasets (less than 1k) except
+                             * changing to COMPACT. For the reference, COMPACT is limited
+                             * by size 64K by library.
+                             */
+                            if (options->layout_g != H5D_COMPACT)
+                                if (size_dset < options->min_comp)
+                                    apply_s = 0;
+
+                            /* 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");
+
+                            /* only if layout change requested for entire file or
+                             * individual obj */
+                            if (options->all_layout > 0 || req_obj_layout == 1)
+                                /*-------------------------------------------------
+                                 * Unset the unlimited max dims if convert to other
+                                 * than chunk layouts, because unlimited max dims
+                                 * only can be applied to chunk layout.
+                                 * Also perform only for targeted dataset
+                                 * Also check for size limit to convert to compact
+                                 *-------------------------------------------------*/
+                                if (options->layout_g != H5D_CHUNKED) {
+                                    /* any dataset is specified */
+                                    if (options->op_tbl->nelems > 0) {
+                                        /* if current obj match specified obj */
+                                        if (options_get_object(travt->objs[i].name, options->op_tbl))
+                                            limit_maxdims = TRUE;
+                                    }
+                                    else  /* no dataset is specified */
+                                        limit_maxdims = TRUE;
+
+                                    /* if convert to COMPACT */
+                                    if (options->layout_g == H5D_COMPACT)
+                                        /* should be smaller than 64K */
+                                        if (size_dset > MAX_COMPACT_DSIZE)
+                                            limit_maxdims = FALSE;
+
+                                    /* unset unlimited max dims */
+                                    if (limit_maxdims)
+                                        H5Sset_extent_simple(f_space_id, rank, dims, NULL);
+                                }
+
+                            /*-------------------------------------------------------------------------
+                             * create the output dataset;
+                             * disable error checking in case the dataset cannot be created with the
+                             * modified dcpl; in that case use the original instead
+                             *-------------------------------------------------------------------------
+                             */
+                            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 (options->verbose)
+                                    printf(" 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");
+                                apply_f = 0;
+                            }
 
-		}
-			break;
+                            /*-------------------------------------------------------------------------
+                             * read/write
+                             *-------------------------------------------------------------------------
+                             */
+                            if (nelmts > 0 && space_status != H5D_SPACE_STATUS_NOT_ALLOCATED) {
+                                size_t need = (size_t)(nelmts * msize); /* bytes needed */
+
+                                /* have to read the whole dataset if there is only one element in the dataset */
+                                if (need < H5TOOLS_MALLOCSIZE)
+                                    buf = HDmalloc(need);
+
+                                if (buf != NULL) {
+                                    /* read/write: use the macro to check error, e.g. memory allocation error inside the library. */
+                                    CHECK_H5DRW_ERROR(H5Dread, FAIL, dset_in, wtype_id, H5S_ALL, H5S_ALL, H5P_DEFAULT, buf);
+                                    CHECK_H5DRW_ERROR(H5Dwrite, FAIL, dset_out, wtype_id, H5S_ALL, H5S_ALL, H5P_DEFAULT, buf);
+
+                                    /* 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");
+                                }
+                                else { /* possibly not enough memory, read/write by hyperslabs */
+                                    size_t p_type_nbytes = msize; /*size of memory type */
+                                    hsize_t p_nelmts = nelmts; /*total elements */
+                                    hsize_t elmtno; /*counter  */
+                                    int carry; /*counter carry value */
+                                    unsigned int vl_data = 0; /*contains VL datatypes */
+
+                                    /* hyperslab info */
+                                    hsize_t hslab_dims[H5S_MAX_RANK]; /*hyperslab dims */
+                                    hsize_t hslab_nbytes; /*bytes per hyperslab */
+                                    hsize_t hslab_nelmts; /*elements per hyperslab*/
+                                    hid_t hslab_space; /*hyperslab data space */
+
+                                    /* hyperslab selection info */
+                                    hsize_t hs_sel_offset[H5S_MAX_RANK];/* selection offset */
+                                    hsize_t hs_sel_count[H5S_MAX_RANK]; /* selection count */
+                                    hsize_t hs_select_nelmts; /* selected elements */
+                                    hsize_t zero[8]; /*vector of zeros */
+                                    int k;
+                                    H5D_layout_t dset_layout;
+                                    hid_t dcpl_tmp = -1; /* dataset creation property list ID */
+
+                                    /* check if we have VL data in the dataset's datatype */
+                                    if (H5Tdetect_class(wtype_id, H5T_VLEN) == TRUE)
+                                        vl_data = TRUE;
+
+                                    /* check first if writing dataset is chunked,
+                                     * if so use its chunk layout for better performance. */
+                                    dset_layout = H5Pget_layout(dcpl_out);
+                                    if (dset_layout == H5D_CHUNKED)
+                                        dcpl_tmp = dcpl_out; /* writing dataset */
+                                    else { /* if reading dataset is chunked */
+                                        dset_layout = H5Pget_layout(dcpl_in);
+                                        if (dset_layout == H5D_CHUNKED)
+                                            dcpl_tmp = dcpl_in; /* reading dataset */
+                                    }
 
-		default:
-            HGOTO_ERROR(H5E_tools_g, H5E_tools_min_id_g, "Object type not found");
+                                    /* 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");
+
+                                    hslab_buf = HDmalloc((size_t)hslab_nbytes);
+
+                                    hslab_nelmts = hslab_nbytes / p_type_nbytes;
+                                    hslab_space = H5Screate_simple(1, &hslab_nelmts, NULL);
+
+                                    /* the hyperslab selection loop */
+                                    HDmemset(hs_sel_offset, 0, sizeof hs_sel_offset);
+                                    HDmemset(zero, 0, sizeof zero);
+
+                                    for (elmtno = 0; elmtno < p_nelmts; elmtno += hs_select_nelmts) {
+                                        if (rank > 0) {
+                                            /* calculate the hyperslab selections.
+                                             * The selection would be same as the hyperslab
+                                             * except for remaining edge portion of the dataset
+                                             * which is smaller then the hyperslab.
+                                             */
+                                            for (k = 0, hs_select_nelmts = 1; k < rank; k++) {
+                                                /* MIN() is used to get the remaining edge portion if exist.
+                                                 * "dims[k] - hs_sel_offset[k]" is remaining edge portion that is smaller then the hyperslab.*/
+                                                hs_sel_count[k] = MIN(dims[k] - hs_sel_offset[k], hslab_dims[k]);
+                                                hs_select_nelmts *= hs_sel_count[k];
+                                            }
+
+                                            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");
+                                            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");
+                                        }
+                                        else {
+                                            H5Sselect_all(f_space_id);
+                                            H5Sselect_all(hslab_space);
+                                            hs_select_nelmts = 1;
+                                        } /* rank */
+
+                                        /* read/write: use the macro to check error, e.g. memory allocation error inside the library. */
+                                        CHECK_H5DRW_ERROR(H5Dread, FAIL, dset_in, wtype_id, hslab_space, f_space_id, H5P_DEFAULT, hslab_buf);
+                                        CHECK_H5DRW_ERROR(H5Dwrite, FAIL, dset_out, wtype_id, hslab_space, f_space_id, H5P_DEFAULT, hslab_buf);
+
+                                        /* reclaim any VL memory, if necessary */
+                                        if (vl_data)
+                                            H5Dvlen_reclaim(wtype_id, hslab_space, H5P_DEFAULT, hslab_buf);
+
+                                        /* calculate the next hyperslab offset */
+                                        for (k = rank, carry = 1; k > 0 && carry; --k) {
+                                            hs_sel_offset[k - 1] += hs_sel_count[k - 1];
+                                            /* if reached the end of a dim */
+                                            if (hs_sel_offset[k - 1] == dims[k - 1])
+                                                hs_sel_offset[k - 1] = 0;
+                                            else
+                                                carry = 0;
+                                        } /* k */
+                                    } /* elmtno */
+
+                                    H5Sclose(hslab_space);
+                                    /* free */
+                                    if (hslab_buf != NULL) {
+                                        HDfree(hslab_buf);
+                                        hslab_buf = NULL;
+                                    }
+                                } /* hyperslab read */
+                            } /* if (nelmts>0 && space_status==H5D_SPACE_STATUS_NOT_ALLOCATED) */
+
+                            /*-------------------------------------------------------------------------
+                             * amount of compression used
+                             *-------------------------------------------------------------------------
+                             */
+                            if (options->verbose) {
+                                double ratio = 0;
+
+                                /* only print the compression ration if there was a filter request */
+                                if (apply_s && apply_f && req_filter) {
+                                    /* get the storage size of the output dataset */
+                                    dsize_out = H5Dget_storage_size(dset_out);
+
+                                    /* compression ratio = uncompressed size /  compressed size */
+                                    if (dsize_out != 0)
+                                        ratio = (double) dsize_in / (double) dsize_out;
+                                    print_dataset_info(dcpl_out, travt->objs[i].name, ratio, 1);
+                                }
+                                else
+                                    print_dataset_info(dcpl_in, travt->objs[i].name, ratio, 0);
+
+                                /* print a message that the filter was not applied
+                                 (in case there was a filter)
+                                 */
+                                if (has_filter && apply_s == 0)
+                                    printf(" <warning: filter not applied to %s. dataset smaller than %d bytes>\n", travt->objs[i].name, (int) options->min_comp);
+
+                                if (has_filter && apply_f == 0)
+                                    printf(" <warning: could not apply the filter to %s>\n", travt->objs[i].name);
+                            } /* verbose */
+
+                            /*-------------------------------------------------------------------------
+                             * 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");
+
+                            /*close */
+                            if (H5Dclose(dset_out) < 0)
+                                HGOTO_ERROR(FAIL, H5E_tools_min_id_g, "H5Dclose failed");
+                        }/*!H5T_REFERENCE*/
+                    }/*h5tools_canreadf*/
+
+                    /*-------------------------------------------------------------------------
+                     * close
+                     *-------------------------------------------------------------------------
+                     */
+                    if (H5Tclose(ftype_id) < 0)
+                        HGOTO_ERROR(FAIL, H5E_tools_min_id_g, "H5Tclose failed");
+                    if (H5Tclose(wtype_id) < 0)
+                        HGOTO_ERROR(FAIL, H5E_tools_min_id_g, "H5Tclose failed");
+                    if (H5Pclose(dcpl_in) < 0)
+                        HGOTO_ERROR(FAIL, H5E_tools_min_id_g, "H5Pclose failed");
+                    if (H5Pclose(dcpl_out) < 0)
+                        HGOTO_ERROR(FAIL, H5E_tools_min_id_g, "H5Pclose failed");
+                    if (H5Sclose(f_space_id) < 0)
+                        HGOTO_ERROR(FAIL, H5E_tools_min_id_g, "H5Sclose failed");
+                    if (H5Dclose(dset_in) < 0)
+                        HGOTO_ERROR(FAIL, H5E_tools_min_id_g, "H5Dclose failed");
+                }
+                /*-------------------------------------------------------------------------
+                 * we do not have request for filter/chunking use H5Ocopy instead
+                 *-------------------------------------------------------------------------
+                 */
+                else {
+                    hid_t pid;
+
+                    /* create property to pass copy options */
+                    if ((pid = H5Pcreate(H5P_OBJECT_COPY)) < 0)
+                        HGOTO_ERROR(FAIL, H5E_tools_min_id_g, "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");
+
+                    /*-------------------------------------------------------------------------
+                     * do the copy
+                     *-------------------------------------------------------------------------
+                     */
+
+                    if (H5Ocopy(fidin, /* Source file or group identifier */
+                            travt->objs[i].name, /* Name of the source object to be copied */
+                            fidout, /* Destination file or group identifier  */
+                            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");
+
+                    /* close property */
+                    if (H5Pclose(pid) < 0)
+                        HGOTO_ERROR(FAIL, H5E_tools_min_id_g, "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");
+                    if ((dset_out = H5Dopen2(fidout, travt->objs[i].name, H5P_DEFAULT)) < 0)
+                        HGOTO_ERROR(FAIL, H5E_tools_min_id_g, "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");
+                    if (H5Dclose(dset_in) < 0)
+                        HGOTO_ERROR(FAIL, H5E_tools_min_id_g, "H5Dclose failed");
+                    if (H5Dclose(dset_out) < 0)
+                        HGOTO_ERROR(FAIL, H5E_tools_min_id_g, "H5Dclose failed");
+
+                    if (options->verbose)
+                        printf(FORMAT_OBJ, "dset", travt->objs[i].name);
+
+                } /* end do we have request for filter/chunking */
+                break;
+
+            /*-------------------------------------------------------------------------
+             * H5TRAV_TYPE_NAMED_DATATYPE
+             *-------------------------------------------------------------------------
+             */
+            case H5TRAV_TYPE_NAMED_DATATYPE:
+                if (options->verbose)
+                    printf(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");
+
+                /* 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");
+
+                /* 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");
+
+                /*-------------------------------------------------------------------------
+                 * 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");
+
+                if (H5Tclose(type_in) < 0)
+                    HGOTO_ERROR(FAIL, H5E_tools_min_id_g, "H5Tclose failed");
+                if (H5Tclose(type_out) < 0)
+                    HGOTO_ERROR(FAIL, H5E_tools_min_id_g, "H5Tclose failed");
+
+                break;
+
+            /*-------------------------------------------------------------------------
+             * H5TRAV_TYPE_LINK
+             * H5TRAV_TYPE_UDLINK
+             *
+             * Only handles external links; H5Lcopy will fail for other UD link types
+             * since we don't have creation or copy callbacks for them.
+             *-------------------------------------------------------------------------
+             */
+            case H5TRAV_TYPE_LINK:
+            case H5TRAV_TYPE_UDLINK:
+                if (options->verbose)
+                    printf(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");
+
+                if (options->verbose)
+                    printf(FORMAT_OBJ, "link", travt->objs[i].name);
+                break;
+
+            default:
+                HGOTO_ERROR(FAIL, H5E_tools_min_id_g, "Object type not found");
         } /* switch */
 
-		/* free */
-		if (buf != NULL) {
-			HDfree(buf);
-			buf = NULL;
-		}
+        /* free */
+        if (buf != NULL) {
+            HDfree(buf);
+            buf = NULL;
+        }
+    } /* i */
 
-	} /* i */
+    /* Finalize (link) the stack of named datatypes (if any) */
+    named_datatype_free(&named_dt_head, 0);
 
-	/* Finalize (link) the stack of named datatypes (if any) */
-	named_datatype_free(&named_dt_head, 0);
-
-	return 0;
+    return ret_value;
 
 done:
-	H5E_BEGIN_TRY
-		{
-			H5Gclose(grp_in);
-			H5Gclose(grp_out);
-			H5Pclose(dcpl_in);
-			H5Pclose(gcpl_in);
-			H5Pclose(gcpl_out);
-			H5Sclose(f_space_id);
-			H5Dclose(dset_in);
-			H5Dclose(dset_out);
-			H5Tclose(ftype_id);
-			H5Tclose(wtype_id);
-			H5Tclose(type_in);
-			H5Tclose(type_out);
-			named_datatype_free(&named_dt_head, 1);
-		}H5E_END_TRY;
-	/* free */
-	if (buf != NULL)
-		HDfree(buf);
-	if (hslab_buf != NULL)
-		HDfree(hslab_buf);
-	return -1;
+    H5E_BEGIN_TRY
+    {
+        H5Gclose(grp_in);
+        H5Gclose(grp_out);
+        H5Pclose(dcpl_in);
+        H5Pclose(gcpl_in);
+        H5Pclose(gcpl_out);
+        H5Sclose(f_space_id);
+        H5Dclose(dset_in);
+        H5Dclose(dset_out);
+        H5Tclose(ftype_id);
+        H5Tclose(wtype_id);
+        H5Tclose(type_in);
+        H5Tclose(type_out);
+        named_datatype_free(&named_dt_head, 1);
+    }H5E_END_TRY;
+
+    /* free */
+    if (buf != NULL)
+        HDfree(buf);
+    if (hslab_buf != NULL)
+        HDfree(hslab_buf);
+
+    return ret_value;
 }
 
 /*-------------------------------------------------------------------------
@@ -1411,101 +1324,102 @@ done:
  *-------------------------------------------------------------------------
  */
 static void print_dataset_info(hid_t dcpl_id, char *objname, double ratio,
-		int pr) {
-	char strfilter[255];
+    int pr)
+{
+    char strfilter[255];
 #if defined (PRINT_DEBUG )
-	char temp[255];
+    char temp[255];
 #endif
-	int nfilters; /* number of filters */
-	unsigned filt_flags; /* filter flags */
-	H5Z_filter_t filtn; /* filter identification number */
-	unsigned cd_values[20]; /* filter client data values */
-	size_t cd_nelmts; /* filter client number of values */
-	char f_objname[256]; /* filter objname */
-	int i;
-
-	HDstrcpy(strfilter, "\0");
+    int nfilters; /* number of filters */
+    unsigned filt_flags; /* filter flags */
+    H5Z_filter_t filtn; /* filter identification number */
+    unsigned cd_values[20]; /* filter client data values */
+    size_t cd_nelmts; /* filter client number of values */
+    char f_objname[256]; /* filter objname */
+    int i;
 
-	/* get information about input filters */
-	if ((nfilters = H5Pget_nfilters(dcpl_id)) < 0)
-		return;
+    HDstrcpy(strfilter, "\0");
 
-	for (i = 0; i < nfilters; i++) {
-		cd_nelmts = NELMTS(cd_values);
+    /* get information about input filters */
+    if ((nfilters = H5Pget_nfilters(dcpl_id)) < 0)
+        return;
 
-		filtn = H5Pget_filter2(dcpl_id, (unsigned) i, &filt_flags, &cd_nelmts,
-				cd_values, sizeof(f_objname), f_objname, NULL);
+    for (i = 0; i < nfilters; i++) {
+        cd_nelmts = NELMTS(cd_values);
 
-		switch (filtn) {
+        filtn = H5Pget_filter2(dcpl_id, (unsigned) i, &filt_flags, &cd_nelmts,
+                        cd_values, sizeof(f_objname), f_objname, NULL);
 
-		case H5Z_FILTER_NONE:
-			HDstrcat(strfilter, "NONE ");
-			break;
+        switch (filtn) {
+            case H5Z_FILTER_NONE:
+                HDstrcat(strfilter, "NONE ");
+                break;
 
-		case H5Z_FILTER_DEFLATE:
-			HDstrcat(strfilter, "GZIP ");
+            case H5Z_FILTER_DEFLATE:
+                HDstrcat(strfilter, "GZIP ");
 
 #if defined (PRINT_DEBUG)
-			{
-				unsigned level=cd_values[0];
-				sprintf(temp,"(%d)",level);
-				HDstrcat(strfilter,temp);
-			}
+                {
+                    unsigned level = cd_values[0];
+
+                    sprintf(temp,"(%d)", level);
+                    HDstrcat(strfilter, temp);
+                }
 #endif
-			break;
+                break;
 
-		case H5Z_FILTER_SZIP:
-			HDstrcat(strfilter, "SZIP ");
+            case H5Z_FILTER_SZIP:
+                HDstrcat(strfilter, "SZIP ");
 
 #if defined (PRINT_DEBUG)
-			{
-				unsigned options_mask=cd_values[0]; /* from dcpl, not filt*/
-				unsigned ppb=cd_values[1];
-				sprintf(temp,"(%d,",ppb);
-				HDstrcat(strfilter,temp);
-				if (options_mask & H5_SZIP_EC_OPTION_MASK)
-				HDstrcpy(temp,"EC) ");
-				else if (options_mask & H5_SZIP_NN_OPTION_MASK)
-				HDstrcpy(temp,"NN) ");
-			}
-			HDstrcat(strfilter,temp);
-
+                {
+                    unsigned options_mask = cd_values[0]; /* from dcpl, not filt*/
+                    unsigned ppb = cd_values[1];
+
+                    sprintf(temp,"(%d,", ppb);
+                    HDstrcat(strfilter, temp);
+                    if (options_mask & H5_SZIP_EC_OPTION_MASK)
+                        HDstrcpy(temp, "EC) ");
+                    else if (options_mask & H5_SZIP_NN_OPTION_MASK)
+                        HDstrcpy(temp, "NN) ");
+                }
+                HDstrcat(strfilter, temp);
 #endif
+                break;
 
-			break;
-
-		case H5Z_FILTER_SHUFFLE:
-			HDstrcat(strfilter, "SHUF ");
-			break;
-
-		case H5Z_FILTER_FLETCHER32:
-			HDstrcat(strfilter, "FLET ");
-			break;
-
-		case H5Z_FILTER_NBIT:
-			HDstrcat(strfilter, "NBIT ");
-			break;
-
-		case H5Z_FILTER_SCALEOFFSET:
-			HDstrcat(strfilter, "SCALEOFFSET ");
-			break;
-
-		default:
-			HDstrcat(strfilter, "UD ");
-			break;
-		} /* switch */
-	}/*i*/
-
-	if (!pr)
-		printf(FORMAT_OBJ, "dset", objname);
-	else {
-		char str[255], temp[28];
-		HDstrcpy(str, "dset     ");
-		HDstrcat(str, strfilter);
-		sprintf(temp, "  (%.3f:1)", ratio);
-		HDstrcat(str, temp);
-		printf(FORMAT_OBJ, str, objname);
-	}
+            case H5Z_FILTER_SHUFFLE:
+                HDstrcat(strfilter, "SHUF ");
+                break;
+
+            case H5Z_FILTER_FLETCHER32:
+                HDstrcat(strfilter, "FLET ");
+                break;
+
+            case H5Z_FILTER_NBIT:
+                HDstrcat(strfilter, "NBIT ");
+                break;
+
+            case H5Z_FILTER_SCALEOFFSET:
+                HDstrcat(strfilter, "SCALEOFFSET ");
+                break;
+
+            default:
+                HDstrcat(strfilter, "UD ");
+                break;
+        } /* switch */
+    }/*i*/
+
+    if (!pr)
+        printf(FORMAT_OBJ, "dset", objname);
+    else {
+        char str[255], temp[28];
+
+        HDstrcpy(str, "dset     ");
+        HDstrcat(str, strfilter);
+        sprintf(temp, "  (%.3f:1)", ratio);
+        HDstrcat(str, temp);
+        printf(FORMAT_OBJ, str, objname);
+    }
 }
 
 /*-------------------------------------------------------------------------
@@ -1522,74 +1436,66 @@ static void print_dataset_info(hid_t dcpl_id, char *objname, double ratio,
  *-------------------------------------------------------------------------
  */
 static int copy_user_block(const char *infile, const char *outfile,
-        hsize_t size) {
+    hsize_t size)
+{
     int ret_value = 0; /*no need to LEAVE() on ERROR: HERR_INIT(int, SUCCEED) */
     int infid = -1, outfid = -1; /* File descriptors */
-	int status = 0; /* Return value */
-
-	/* User block must be any power of 2 equal to 512 or greater (512, 1024, 2048, etc.) */
-	HDassert(size > 0);
-
-	/* Open files */
-	if ((infid = HDopen(infile, O_RDONLY, 0)) < 0) {
-		status = -1;
-        HGOTO_ERROR(H5E_tools_g, H5E_tools_min_id_g, "HDopen failed");
-    }
-	if ((outfid = HDopen(outfile, O_WRONLY, 0644)) < 0) {
-		status = -1;
-        HGOTO_ERROR(H5E_tools_g, H5E_tools_min_id_g, "HDopen failed");
-    }
-
-	/* Copy the userblock from the input file to the output file */
-	while (size > 0) {
-		ssize_t nread, nbytes; /* # of bytes transfered, etc. */
-		char rbuf[USERBLOCK_XFER_SIZE]; /* Buffer for reading */
-		const char *wbuf; /* Pointer into buffer, for writing */
-
-		/* Read buffer from source file */
-		if (size > USERBLOCK_XFER_SIZE)
-			nread = HDread(infid, rbuf, (size_t)USERBLOCK_XFER_SIZE);
-		else
-			nread = HDread(infid, rbuf, (size_t)size);
-		if (nread < 0) {
-			status = -1;
-            HGOTO_ERROR(H5E_tools_g, H5E_tools_min_id_g, "HDread failed");
-        } /* end if */
-
-		/* Write buffer to destination file */
-		/* (compensating for interrupted writes & checking for errors, etc.) */
-		nbytes = nread;
-		wbuf = rbuf;
-		while (nbytes > 0) {
-			ssize_t nwritten; /* # of bytes written */
-
-			do {
-				nwritten = HDwrite(outfid, wbuf, (size_t)nbytes);
-			} while (-1 == nwritten && EINTR == errno);
-			if (-1 == nwritten) { /* error */
-				status = -1;
-                HGOTO_ERROR(H5E_tools_g, H5E_tools_min_id_g, "HDwrite failed");
-            } /* end if */
-			HDassert(nwritten > 0);
-			HDassert(nwritten <= nbytes);
-
-			/* Update # of bytes left & offset in buffer */
-			nbytes -= nwritten;
-			wbuf += nwritten;
-			HDassert(nbytes == 0 || wbuf < (rbuf + USERBLOCK_XFER_SIZE));
-		} /* end while */
 
-		/* Update size of userblock left to transfer */
-		size = size - (hsize_t) nread;
-	} /* end while */
+    /* User block must be any power of 2 equal to 512 or greater (512, 1024, 2048, etc.) */
+    HDassert(size > 0);
+
+    /* Open files */
+    if ((infid = HDopen(infile, O_RDONLY, 0)) < 0)
+        HGOTO_ERROR(FAIL, H5E_tools_min_id_g, "HDopen failed");
+    if ((outfid = HDopen(outfile, O_WRONLY, 0644)) < 0)
+        HGOTO_ERROR(FAIL, H5E_tools_min_id_g, "HDopen failed");
+
+    /* Copy the userblock from the input file to the output file */
+    while (size > 0) {
+        ssize_t nread, nbytes; /* # of bytes transfered, etc. */
+        char rbuf[USERBLOCK_XFER_SIZE]; /* Buffer for reading */
+        const char *wbuf; /* Pointer into buffer, for writing */
+
+        /* Read buffer from source file */
+        if (size > USERBLOCK_XFER_SIZE)
+            nread = HDread(infid, rbuf, (size_t)USERBLOCK_XFER_SIZE);
+        else
+            nread = HDread(infid, rbuf, (size_t)size);
+        if (nread < 0)
+            HGOTO_ERROR(FAIL, H5E_tools_min_id_g, "HDread failed");
+
+        /* Write buffer to destination file */
+        /* (compensating for interrupted writes & checking for errors, etc.) */
+        nbytes = nread;
+        wbuf = rbuf;
+        while (nbytes > 0) {
+            ssize_t nwritten; /* # of bytes written */
+
+            do {
+                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");
+            HDassert(nwritten > 0);
+            HDassert(nwritten <= nbytes);
+
+            /* Update # of bytes left & offset in buffer */
+            nbytes -= nwritten;
+            wbuf += nwritten;
+            HDassert(nbytes == 0 || wbuf < (rbuf + USERBLOCK_XFER_SIZE));
+        } /* end while */
+
+        /* Update size of userblock left to transfer */
+        size = size - (hsize_t) nread;
+    } /* end while */
 
 done:
-	if (infid > 0)
-		HDclose(infid);
-	if (outfid > 0)
-		HDclose(outfid);
+    if (infid > 0)
+        HDclose(infid);
+    if (outfid > 0)
+        HDclose(outfid);
 
-	return status;
+    return ret_value;
 }
 
 /*-------------------------------------------------------------------------
diff --git a/tools/h5repack/h5repack_refs.c b/tools/h5repack/h5repack_refs.c
index b2755c2..f0f32c3 100644
--- a/tools/h5repack/h5repack_refs.c
+++ b/tools/h5repack/h5repack_refs.c
@@ -1,4 +1,3 @@
-
 /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
  * Copyright by The HDF Group.                                               *
  * Copyright by the Board of Trustees of the University of Illinois.         *
@@ -86,18 +85,18 @@ int do_copy_refobjs(hid_t fidin,
                 *-------------------------------------------------------------------------
                 */
                 if((grp_out = H5Gopen2(fidout, travt->objs[i].name, H5P_DEFAULT)) < 0)
-                    HGOTO_ERROR(H5E_tools_g, H5E_tools_min_id_g, "H5Gopen2 failed");
+                    HGOTO_ERROR(FAIL, H5E_tools_min_id_g, "H5Gopen2 failed");
 
                 if((grp_in = H5Gopen2(fidin, travt->objs[i].name, H5P_DEFAULT)) < 0)
-                    HGOTO_ERROR(H5E_tools_g, H5E_tools_min_id_g, "H5Gopen2 failed");
+                    HGOTO_ERROR(FAIL, H5E_tools_min_id_g, "H5Gopen2 failed");
 
                 if(copy_refs_attr(grp_in, grp_out, options, travt, fidout) < 0)
-                    HGOTO_ERROR(H5E_tools_g, H5E_tools_min_id_g, "copy_refs_attr failed");
+                    HGOTO_ERROR(FAIL, H5E_tools_min_id_g, "copy_refs_attr failed");
 
                 if(H5Gclose(grp_out) < 0)
-                    HGOTO_ERROR(H5E_tools_g, H5E_tools_min_id_g, "H5Gclose failed");
+                    HGOTO_ERROR(FAIL, H5E_tools_min_id_g, "H5Gclose failed");
                 if(H5Gclose(grp_in) < 0)
-                    HGOTO_ERROR(H5E_tools_g, H5E_tools_min_id_g, "H5Gclose failed");
+                    HGOTO_ERROR(FAIL, H5E_tools_min_id_g, "H5Gclose failed");
 
                 /*-------------------------------------------------------------------------
                 * check for hard links
@@ -114,26 +113,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(H5E_tools_g, H5E_tools_min_id_g, "H5Dopen2 failed");
+                    HGOTO_ERROR(FAIL, H5E_tools_min_id_g, "H5Dopen2 failed");
                 if((space_id = H5Dget_space(dset_in)) < 0)
-                    HGOTO_ERROR(H5E_tools_g, H5E_tools_min_id_g, "H5Dget_space failed");
+                    HGOTO_ERROR(FAIL, H5E_tools_min_id_g, "H5Dget_space failed");
                 if((ftype_id = H5Dget_type(dset_in)) < 0)
-                    HGOTO_ERROR(H5E_tools_g, H5E_tools_min_id_g, "H5Dget_type failed");
+                    HGOTO_ERROR(FAIL, H5E_tools_min_id_g, "H5Dget_type failed");
                 if((dcpl_id = H5Dget_create_plist(dset_in)) < 0)
-                    HGOTO_ERROR(H5E_tools_g, H5E_tools_min_id_g, "H5Dget_create_plist failed");
+                    HGOTO_ERROR(FAIL, H5E_tools_min_id_g, "H5Dget_create_plist failed");
                 if((rank = H5Sget_simple_extent_ndims(space_id)) < 0)
-                    HGOTO_ERROR(H5E_tools_g, H5E_tools_min_id_g, "H5Sget_simple_extent_ndims failed");
+                    HGOTO_ERROR(FAIL, H5E_tools_min_id_g, "H5Sget_simple_extent_ndims failed");
                 if(H5Sget_simple_extent_dims(space_id, dims, NULL) < 0)
-                    HGOTO_ERROR(H5E_tools_g, H5E_tools_min_id_g, "H5Sget_simple_extent_dims failed");
+                    HGOTO_ERROR(FAIL, H5E_tools_min_id_g, "H5Sget_simple_extent_dims failed");
                 nelmts = 1;
                 for(k = 0; k < rank; k++)
                     nelmts *= dims[k];
 
                 if((mtype_id = h5tools_get_native_type(ftype_id)) < 0)
-                    HGOTO_ERROR(H5E_tools_g, H5E_tools_min_id_g, "h5tools_get_native_type failed");
+                    HGOTO_ERROR(FAIL, H5E_tools_min_id_g, "h5tools_get_native_type failed");
 
                 if((msize = H5Tget_size(mtype_id)) == 0)
-                    HGOTO_ERROR(H5E_tools_g, H5E_tools_min_id_g, "H5Tget_size failed");
+                    HGOTO_ERROR(FAIL, H5E_tools_min_id_g, "H5Tget_size failed");
 
                 /*-------------------------------------------------------------------------
                  * check if the dataset creation property list has filters that
@@ -169,15 +168,15 @@ int do_copy_refobjs(hid_t fidin,
                             buf = (hobj_ref_t *)HDmalloc((unsigned)(nelmts * msize));
                             if(buf==NULL) {
                                 printf("cannot read into memory\n" );
-                                HGOTO_ERROR(H5E_tools_g, H5E_tools_min_id_g, "HDmalloc failed");
+                                HGOTO_ERROR(FAIL, H5E_tools_min_id_g, "HDmalloc failed");
                             } /* end if */
                             if(H5Dread(dset_in, mtype_id, H5S_ALL, H5S_ALL, H5P_DEFAULT, buf) < 0)
-                                HGOTO_ERROR(H5E_tools_g, H5E_tools_min_id_g, "H5Dread failed");
+                                HGOTO_ERROR(FAIL, H5E_tools_min_id_g, "H5Dread failed");
 
                             refbuf = (hobj_ref_t*) HDcalloc((unsigned)nelmts, msize);
                             if(refbuf == NULL){
                                 printf("cannot allocate memory\n" );
-                                HGOTO_ERROR(H5E_tools_g, H5E_tools_min_id_g, "HDcalloc failed");
+                                HGOTO_ERROR(FAIL, H5E_tools_min_id_g, "HDcalloc failed");
                             } /* end if */
                             for(u = 0; u < nelmts; u++) {
                                 H5E_BEGIN_TRY {
@@ -191,7 +190,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(H5E_tools_g, H5E_tools_min_id_g, "H5Rcreate failed");
+                                        HGOTO_ERROR(FAIL, H5E_tools_min_id_g, "H5Rcreate failed");
                                     if(options->verbose)
                                     {
                                         printf(FORMAT_OBJ,"dset",travt->objs[i].name );
@@ -209,10 +208,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(H5E_tools_g, H5E_tools_min_id_g, "H5Dcreate2 failed");
+                            HGOTO_ERROR(FAIL, H5E_tools_min_id_g, "H5Dcreate2 failed");
                         if(nelmts)
                             if(H5Dwrite(dset_out, mtype_id, H5S_ALL, H5S_ALL, H5P_DEFAULT, refbuf) < 0)
-                                HGOTO_ERROR(H5E_tools_g, H5E_tools_min_id_g, "H5Dwrite failed");
+                                HGOTO_ERROR(FAIL, H5E_tools_min_id_g, "H5Dwrite failed");
 
                         if(buf)
                             HDfree(buf);
@@ -223,7 +222,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(H5E_tools_g, H5E_tools_min_id_g, "copy_attr failed");
+                            HGOTO_ERROR(FAIL, H5E_tools_min_id_g, "copy_attr failed");
                     } /*H5T_STD_REF_OBJ*/
 
                     /*-------------------------------------------------------------------------
@@ -246,10 +245,10 @@ int do_copy_refobjs(hid_t fidin,
                             buf = (hdset_reg_ref_t *)HDmalloc((unsigned)(nelmts * msize));
                             if(buf == NULL) {
                                 printf("cannot read into memory\n");
-                                HGOTO_ERROR(H5E_tools_g, H5E_tools_min_id_g, "HDmalloc failed");
+                                HGOTO_ERROR(FAIL, H5E_tools_min_id_g, "HDmalloc failed");
                             } /* end if */
                             if(H5Dread(dset_in, mtype_id, H5S_ALL, H5S_ALL, H5P_DEFAULT, buf) < 0)
-                                HGOTO_ERROR(H5E_tools_g, H5E_tools_min_id_g, "H5Dread failed");
+                                HGOTO_ERROR(FAIL, H5E_tools_min_id_g, "H5Dread failed");
 
                             /*-------------------------------------------------------------------------
                             * create output
@@ -258,7 +257,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) {
                                 printf("cannot allocate memory\n");
-                                HGOTO_ERROR(H5E_tools_g, H5E_tools_min_id_g, "HDcalloc failed");
+                                HGOTO_ERROR(FAIL, H5E_tools_min_id_g, "HDcalloc failed");
                             } /* end if */
 
                             for(u = 0; u < nelmts; u++) {
@@ -274,18 +273,15 @@ int do_copy_refobjs(hid_t fidin,
                                     hid_t region_id;    /* region id of the referenced dataset */
 
                                     if((region_id = H5Rget_region(dset_in, H5R_DATASET_REGION, &buf[u])) < 0)
-                                        HGOTO_ERROR(H5E_tools_g, H5E_tools_min_id_g, "H5Rget_region failed");
+                                        HGOTO_ERROR(FAIL, H5E_tools_min_id_g, "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(H5E_tools_g, H5E_tools_min_id_g, "H5Rcreate failed");
+                                        HGOTO_ERROR(FAIL, H5E_tools_min_id_g, "H5Rcreate failed");
                                     if(H5Sclose(region_id) < 0)
-                                        HGOTO_ERROR(H5E_tools_g, H5E_tools_min_id_g, "H5Sclose failed");
+                                        HGOTO_ERROR(FAIL, H5E_tools_min_id_g, "H5Sclose failed");
                                     if(options->verbose)
                                     {
-
-
-
                                         printf(FORMAT_OBJ,"dset",travt->objs[i].name );
                                         printf("object <%s> region reference created to <%s>\n",
                                             travt->objs[i].name,
@@ -301,10 +297,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(H5E_tools_g, H5E_tools_min_id_g, "H5Dcreate2 failed");
+                            HGOTO_ERROR(FAIL, H5E_tools_min_id_g, "H5Dcreate2 failed");
                         if(nelmts)
                             if(H5Dwrite(dset_out, mtype_id, H5S_ALL, H5S_ALL, H5P_DEFAULT, refbuf) < 0)
-                                HGOTO_ERROR(H5E_tools_g, H5E_tools_min_id_g, "H5Dwrite failed");
+                                HGOTO_ERROR(FAIL, H5E_tools_min_id_g, "H5Dwrite failed");
 
                         if(buf)
                             HDfree(buf);
@@ -315,7 +311,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(H5E_tools_g, H5E_tools_min_id_g, "copy_attr failed");
+                            HGOTO_ERROR(FAIL, H5E_tools_min_id_g, "copy_attr failed");
                     } /* H5T_STD_REF_DSETREG */
                     /*-------------------------------------------------------------------------
                     * not references, open previously created object in 1st traversal
@@ -323,7 +319,7 @@ int do_copy_refobjs(hid_t fidin,
                     */
                     else {
                         if((dset_out = H5Dopen2(fidout, travt->objs[i].name, H5P_DEFAULT)) < 0)
-                            HGOTO_ERROR(H5E_tools_g, H5E_tools_min_id_g, "H5Dopen2 failed");
+                            HGOTO_ERROR(FAIL, H5E_tools_min_id_g, "H5Dopen2 failed");
                     } /* end else */
 
                     HDassert(dset_out != FAIL);
@@ -333,7 +329,7 @@ int do_copy_refobjs(hid_t fidin,
                     *-------------------------------------------------------------------------
                     */
                     if(copy_refs_attr(dset_in, dset_out, options, travt, fidout) < 0)
-                        HGOTO_ERROR(H5E_tools_g, H5E_tools_min_id_g, "copy_refs_attr failed");
+                        HGOTO_ERROR(FAIL, H5E_tools_min_id_g, "copy_refs_attr failed");
 
                     /*-------------------------------------------------------------------------
                     * check for hard links
@@ -344,7 +340,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(H5E_tools_g, H5E_tools_min_id_g, "H5Dclose failed");
+                        HGOTO_ERROR(FAIL, H5E_tools_min_id_g, "H5Dclose failed");
                 } /*can_read*/
 
                 /*-------------------------------------------------------------------------
@@ -352,15 +348,15 @@ int do_copy_refobjs(hid_t fidin,
                 *-------------------------------------------------------------------------
                 */
                 if(H5Tclose(ftype_id) < 0)
-                    HGOTO_ERROR(H5E_tools_g, H5E_tools_min_id_g, "H5Tclose failed");
+                    HGOTO_ERROR(FAIL, H5E_tools_min_id_g, "H5Tclose failed");
                 if(H5Tclose(mtype_id) < 0)
-                    HGOTO_ERROR(H5E_tools_g, H5E_tools_min_id_g, "H5Tclose failed");
+                    HGOTO_ERROR(FAIL, H5E_tools_min_id_g, "H5Tclose failed");
                 if(H5Pclose(dcpl_id) < 0)
-                    HGOTO_ERROR(H5E_tools_g, H5E_tools_min_id_g, "H5Pclose failed");
+                    HGOTO_ERROR(FAIL, H5E_tools_min_id_g, "H5Pclose failed");
                 if(H5Sclose(space_id) < 0)
-                    HGOTO_ERROR(H5E_tools_g, H5E_tools_min_id_g, "H5Sclose failed");
+                    HGOTO_ERROR(FAIL, H5E_tools_min_id_g, "H5Sclose failed");
                 if(H5Dclose(dset_in) < 0)
-                    HGOTO_ERROR(H5E_tools_g, H5E_tools_min_id_g, "H5Dclose failed");
+                    HGOTO_ERROR(FAIL, H5E_tools_min_id_g, "H5Dclose failed");
                 break;
 
             /*-------------------------------------------------------------------------
@@ -369,9 +365,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(H5E_tools_g, H5E_tools_min_id_g, "H5Topen2 failed");
+                    HGOTO_ERROR(FAIL, H5E_tools_min_id_g, "H5Topen2 failed");
                 if(H5Tclose(type_in) < 0)
-                    HGOTO_ERROR(H5E_tools_g, H5E_tools_min_id_g, "H5Tclose failed");
+                    HGOTO_ERROR(FAIL, H5E_tools_min_id_g, "H5Tclose failed");
                 break;
 
             /*-------------------------------------------------------------------------
@@ -384,7 +380,7 @@ int do_copy_refobjs(hid_t fidin,
 
             case H5TRAV_TYPE_UNKNOWN:
             case H5TRAV_TYPE_UDLINK:
-                HGOTO_ERROR(H5E_tools_g, H5E_tools_min_id_g, "H5TRAV invalid type");
+                HGOTO_ERROR(FAIL, H5E_tools_min_id_g, "H5TRAV invalid type");
 
             default:
                 break;
@@ -397,7 +393,7 @@ int do_copy_refobjs(hid_t fidin,
      */
     named_datatype_free(&named_dt_head, 0);
 
-    return 0;
+    return ret_value;
 
 done:
     H5E_BEGIN_TRY {
@@ -413,7 +409,7 @@ done:
         named_datatype_free(&named_dt_head, 0);
     } H5E_END_TRY;
 
-    return -1;
+    return ret_value;
 }
 
 
@@ -469,32 +465,32 @@ static int copy_refs_attr(hid_t loc_in,
     void  *refbuf = NULL;
     void  *buf = NULL;
     const char* refname = NULL;
-    int   *ref_comp_index = NULL;
+    unsigned *ref_comp_index = NULL;
     size_t *ref_comp_size = NULL;
     int    ref_comp_field_n = 0;
 
 
     if(H5Oget_info(loc_in, &oinfo) < 0)
-        HGOTO_ERROR(H5E_tools_g, H5E_tools_min_id_g, "H5Oget_info failed");
+        HGOTO_ERROR(FAIL, H5E_tools_min_id_g, "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(H5E_tools_g, H5E_tools_min_id_g, "H5Aopen_by_idx failed");
+            HGOTO_ERROR(FAIL, H5E_tools_min_id_g, "H5Aopen_by_idx failed");
 
         /* get the file datatype  */
         if((ftype_id = H5Aget_type(attr_id)) < 0)
-            HGOTO_ERROR(H5E_tools_g, H5E_tools_min_id_g, "H5Aget_type failed");
+            HGOTO_ERROR(FAIL, H5E_tools_min_id_g, "H5Aget_type failed");
 
         type_class = H5Tget_class(ftype_id);
 
         if((mtype_id = h5tools_get_native_type(ftype_id)) < 0)
-            HGOTO_ERROR(H5E_tools_g, H5E_tools_min_id_g, "h5tools_get_native_type failed");
+            HGOTO_ERROR(FAIL, H5E_tools_min_id_g, "h5tools_get_native_type failed");
 
         if((msize = H5Tget_size(mtype_id)) == 0)
-            HGOTO_ERROR(H5E_tools_g, H5E_tools_min_id_g, "H5Tget_size failed");
+            HGOTO_ERROR(FAIL, H5E_tools_min_id_g, "H5Tget_size failed");
 
         is_ref = (type_class == H5T_REFERENCE);
 
@@ -518,10 +514,10 @@ static int copy_refs_attr(hid_t loc_in,
             int nmembers = H5Tget_nmembers(ftype_id) ;
 
             if (nmembers < 1)
-                HGOTO_ERROR(H5E_tools_g, H5E_tools_min_id_g, "H5Tget_nmembers failed");
+                HGOTO_ERROR(FAIL, H5E_tools_min_id_g, "H5Tget_nmembers failed");
 
-            ref_comp_index = (int *)HDmalloc(nmembers*sizeof (int));
-            ref_comp_size = (size_t *)HDmalloc(nmembers*sizeof(ref_comp_size));
+            ref_comp_index = (unsigned *)HDmalloc((size_t)nmembers*sizeof(unsigned));
+            ref_comp_size = (size_t *)HDmalloc((size_t)nmembers*sizeof(ref_comp_size));
             ref_comp_field_n = 0;
 
             for (i=0; i<(unsigned)nmembers; i++) {
@@ -562,15 +558,15 @@ static int copy_refs_attr(hid_t loc_in,
 
         /* get name */
         if(H5Aget_name(attr_id, 255, name) < 0)
-            HGOTO_ERROR(H5E_tools_g, H5E_tools_min_id_g, "H5Aget_name failed");
+            HGOTO_ERROR(FAIL, H5E_tools_min_id_g, "H5Aget_name failed");
 
         /* get the dataspace handle  */
         if((space_id = H5Aget_space(attr_id)) < 0)
-            HGOTO_ERROR(H5E_tools_g, H5E_tools_min_id_g, "H5Aget_space failed");
+            HGOTO_ERROR(FAIL, H5E_tools_min_id_g, "H5Aget_space failed");
 
         /* get dimensions  */
         if((rank = H5Sget_simple_extent_dims(space_id, dims, NULL)) < 0)
-            HGOTO_ERROR(H5E_tools_g, H5E_tools_min_id_g, "H5Sget_simple_extent_dims failed");
+            HGOTO_ERROR(FAIL, H5E_tools_min_id_g, "H5Sget_simple_extent_dims failed");
 
 
         /*-------------------------------------------------------------------------
@@ -582,8 +578,8 @@ static int copy_refs_attr(hid_t loc_in,
             nelmts *= dims[j];
 
         if (is_ref_array) {
-            unsigned        array_rank = 0;
-            hsize_t    array_size = 1;
+            unsigned  array_rank = 0;
+            hsize_t   array_size = 1;
             hsize_t array_dims[H5S_MAX_RANK];
             hid_t base_type;
 
@@ -591,7 +587,7 @@ static int copy_refs_attr(hid_t loc_in,
             msize = H5Tget_size(base_type);
             H5Tclose(base_type);
 
-            array_rank = H5Tget_array_ndims(mtype_id);
+            array_rank = (unsigned)H5Tget_array_ndims(mtype_id);
             H5Tget_array_dims2(mtype_id, array_dims);
             for(j = 0; j <array_rank; j++)
             	array_size *= array_dims[j];
@@ -599,7 +595,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(H5E_tools_g, H5E_tools_min_id_g, "H5Acreate2 failed");
+            HGOTO_ERROR(FAIL, H5E_tools_min_id_g, "H5Acreate2 failed");
 
         if (nelmts>0) {
             /* handle object references */
@@ -607,15 +603,15 @@ static int copy_refs_attr(hid_t loc_in,
                 buf = (hobj_ref_t *)HDmalloc((unsigned)(nelmts * msize));
                 if(buf == NULL) {
                     printf("cannot read into memory\n");
-                    HGOTO_ERROR(H5E_tools_g, H5E_tools_min_id_g, "HDmalloc failed");
+                    HGOTO_ERROR(FAIL, H5E_tools_min_id_g, "HDmalloc failed");
                 } /* end if */
                 if(H5Aread(attr_id, mtype_id, buf) < 0)
-                    HGOTO_ERROR(H5E_tools_g, H5E_tools_min_id_g, "H5Aread failed");
+                    HGOTO_ERROR(FAIL, H5E_tools_min_id_g, "H5Aread failed");
 
                 refbuf = (hobj_ref_t *)HDcalloc((unsigned)nelmts, msize);
                 if(refbuf == NULL) {
                     printf("cannot allocate memory\n");
-                    HGOTO_ERROR(H5E_tools_g, H5E_tools_min_id_g, "HDcalloc failed");
+                    HGOTO_ERROR(FAIL, H5E_tools_min_id_g, "HDcalloc failed");
                 } /* end if */
 
                 for(i = 0; i < (unsigned)nelmts; i++) {
@@ -631,10 +627,10 @@ static int copy_refs_attr(hid_t loc_in,
 
                 if(buf == NULL) {
                     printf( "cannot read into memory\n" );
-                    HGOTO_ERROR(H5E_tools_g, H5E_tools_min_id_g, "HDmalloc failed");
+                    HGOTO_ERROR(FAIL, H5E_tools_min_id_g, "HDmalloc failed");
                 } /* end if */
                 if(H5Aread(attr_id, mtype_id, buf) < 0)
-                    HGOTO_ERROR(H5E_tools_g, H5E_tools_min_id_g, "H5Aread failed");
+                    HGOTO_ERROR(FAIL, H5E_tools_min_id_g, "H5Aread failed");
 
                 /*-------------------------------------------------------------------------
                 * create output
@@ -643,7 +639,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) {
                     printf( "cannot allocate memory\n" );
-                    HGOTO_ERROR(H5E_tools_g, H5E_tools_min_id_g, "HDcalloc failed");
+                    HGOTO_ERROR(FAIL, H5E_tools_min_id_g, "HDcalloc failed");
                 } /* end if */
 
                 for(i = 0; i < (unsigned)nelmts; i++) {
@@ -661,11 +657,11 @@ static int copy_refs_attr(hid_t loc_in,
 
                 if(buf == NULL) {
                     printf( "cannot read into memory\n" );
-                    HGOTO_ERROR(H5E_tools_g, H5E_tools_min_id_g, "HDmalloc failed");
+                    HGOTO_ERROR(FAIL, H5E_tools_min_id_g, "HDmalloc failed");
                 } /* end if */
 
                 if(H5Aread(attr_id, mtype_id, buf) < 0)
-                    HGOTO_ERROR(H5E_tools_g, H5E_tools_min_id_g, "H5Aread failed");
+                    HGOTO_ERROR(FAIL, H5E_tools_min_id_g, "H5Aread failed");
 
                 if (H5R_OBJ_REF_BUF_SIZE==msize) {
                     hobj_ref_t ref_out;
@@ -702,41 +698,43 @@ static int copy_refs_attr(hid_t loc_in,
                 if(buf == NULL)
                 {
                     printf( "cannot read into memory\n" );
-                    HGOTO_ERROR(H5E_tools_g, H5E_tools_min_id_g, "HDmalloc failed");
+                    HGOTO_ERROR(FAIL, H5E_tools_min_id_g, "HDmalloc failed");
                 } /* end if */
 
                 if(H5Aread(attr_id, mtype_id, buf) < 0)
-                    HGOTO_ERROR(H5E_tools_g, H5E_tools_min_id_g, "H5Aread failed");
+                    HGOTO_ERROR(FAIL, H5E_tools_min_id_g, "H5Aread failed");
 
                 for (i=0; i<(unsigned)nelmts; i++) {
-                	for (j=0; j<(unsigned)ref_comp_field_n; j++) {
-                		if (ref_comp_size[j] == H5R_OBJ_REF_BUF_SIZE) {
-                			int idx = i*msize+H5Tget_member_offset( mtype_id, (unsigned)ref_comp_index[j]);
-                			hobj_ref_t ref_out;
-                			if (update_ref_value(attr_id, H5R_OBJECT, (hobj_ref_t *)(((char *)buf)+idx), fidout, &ref_out, travt)<0)
-                				continue;
-                			HDmemcpy(((char *)buf)+idx, &ref_out, ref_comp_size[j]);
-                 		} /* if */
-                		else if (ref_comp_size[j] == H5R_DSET_REG_REF_BUF_SIZE) {
-                			int idx = i*msize+H5Tget_member_offset( mtype_id, (unsigned)ref_comp_index[j]);
-                			hdset_reg_ref_t ref_out;
-                			if (update_ref_value(attr_id, H5R_DATASET_REGION, (hdset_reg_ref_t *)(((char *)buf)+idx), fidout, &ref_out, travt)<0)
-                				continue;
-                			HDmemcpy(((char *)buf)+idx, &ref_out, ref_comp_size[j]);
-                 		} /* else if */
-                	} /* j */
+                    for (j=0; j<(unsigned)ref_comp_field_n; j++) {
+                        if (ref_comp_size[j] == H5R_OBJ_REF_BUF_SIZE) {
+                            size_t idx = (i * msize) + H5Tget_member_offset(mtype_id, ref_comp_index[j]);
+                            hobj_ref_t ref_out;
+
+                            if (update_ref_value(attr_id, H5R_OBJECT, (hobj_ref_t *)(((char *)buf)+idx), fidout, &ref_out, travt)<0)
+                                continue;
+                            HDmemcpy(((char *)buf)+idx, &ref_out, ref_comp_size[j]);
+                        } /* if */
+                        else if (ref_comp_size[j] == H5R_DSET_REG_REF_BUF_SIZE) {
+                            size_t idx = i * msize + H5Tget_member_offset(mtype_id, ref_comp_index[j]);
+                            hdset_reg_ref_t ref_out;
+
+                            if (update_ref_value(attr_id, H5R_DATASET_REGION, (hdset_reg_ref_t *)(((char *)buf)+idx), fidout, &ref_out, travt)<0)
+                                continue;
+                            HDmemcpy(((char *)buf)+idx, &ref_out, ref_comp_size[j]);
+                        } /* else if */
+                    } /* j */
                 } /* i */
             } /* else if (is_ref_comp) */
 
             if(H5Awrite(attr_out, mtype_id, refbuf) < 0)
-                HGOTO_ERROR(H5E_tools_g, H5E_tools_min_id_g, "H5Awrite failed");
+                HGOTO_ERROR(FAIL, H5E_tools_min_id_g, "H5Awrite failed");
 
             if (is_ref_vlen && buf)
             	H5Dvlen_reclaim (mtype_id, space_id, H5P_DEFAULT, buf);
         } /* if (nelmts) */
 
         if (refbuf == buf)
-        	refbuf = NULL; /* set it to NULL to avoid double free since buf and refbuf are the same. */
+            refbuf = NULL; /* set it to NULL to avoid double free since buf and refbuf are the same. */
 
         if(buf) {
             HDfree(buf);
@@ -749,39 +747,39 @@ static int copy_refs_attr(hid_t loc_in,
         }
 
         if (ref_comp_index) {
-        	HDfree(ref_comp_index);
-        	ref_comp_index = NULL;
+            HDfree(ref_comp_index);
+            ref_comp_index = NULL;
         }
 
         if (ref_comp_size) {
-        	HDfree(ref_comp_size);
-        	ref_comp_size = NULL;
+            HDfree(ref_comp_size);
+            ref_comp_size = NULL;
         }
 
         if(H5Aclose(attr_out) < 0)
-            HGOTO_ERROR(H5E_tools_g, H5E_tools_min_id_g, "H5Aclose failed");
+            HGOTO_ERROR(FAIL, H5E_tools_min_id_g, "H5Aclose failed");
 
         /*-------------------------------------------------------------------------
         * close
         *-------------------------------------------------------------------------
         */
         if(H5Tclose(ftype_id) < 0)
-            HGOTO_ERROR(H5E_tools_g, H5E_tools_min_id_g, "H5Tclose failed");
+            HGOTO_ERROR(FAIL, H5E_tools_min_id_g, "H5Tclose failed");
         if(H5Tclose(mtype_id) < 0)
-            HGOTO_ERROR(H5E_tools_g, H5E_tools_min_id_g, "H5Tclose failed");
+            HGOTO_ERROR(FAIL, H5E_tools_min_id_g, "H5Tclose failed");
         if(H5Sclose(space_id) < 0)
-            HGOTO_ERROR(H5E_tools_g, H5E_tools_min_id_g, "H5Sclose failed");
+            HGOTO_ERROR(FAIL, H5E_tools_min_id_g, "H5Sclose failed");
         if(H5Aclose(attr_id) < 0)
-            HGOTO_ERROR(H5E_tools_g, H5E_tools_min_id_g, "H5Aclose failed");
+            HGOTO_ERROR(FAIL, H5E_tools_min_id_g, "H5Aclose failed");
     } /* for(u = 0; u < (unsigned)oinfo.num_attrs; u++) */
 
-    return 0;
+    return ret_value;
 
 done:
-	if(refbuf)
-		HDfree(refbuf);
-	if(buf)
-		HDfree(buf);
+    if(refbuf)
+        HDfree(refbuf);
+    if(buf)
+        HDfree(buf);
 
     if (ref_comp_index)
     	HDfree(ref_comp_index);
@@ -797,7 +795,7 @@ done:
         H5Aclose(attr_out);
     } H5E_END_TRY;
 
-    return -1;
+    return ret_value;
 }
 
 /*-------------------------------------------------------------------------
@@ -848,30 +846,25 @@ 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) */
-    herr_t ret = -1;
-	const char* ref_obj_name;
-	hid_t space_id=-1, ref_obj_id=-1;
+    const char* ref_obj_name;
+    hid_t space_id=-1, ref_obj_id=-1;
 
     ref_obj_id = H5Rdereference2(obj_id, H5P_DEFAULT, ref_type, ref_in);
-    if (ref_obj_id<0)
-        HGOTO_ERROR(H5E_tools_g, H5E_tools_min_id_g, "H5Rdereference2 failed");
+    if (ref_obj_id < 0)
+        HGOTO_ERROR(FAIL, H5E_tools_min_id_g, "H5Rdereference2 failed");
 
-	ref_obj_name = MapIdToName(ref_obj_id, travt);
-	if (ref_obj_name == NULL)
-        HGOTO_ERROR(H5E_tools_g, H5E_tools_min_id_g, "MapIdToName failed");
+    ref_obj_name = MapIdToName(ref_obj_id, travt);
+    if (ref_obj_name == NULL)
+        HGOTO_ERROR(FAIL, H5E_tools_min_id_g, "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(H5E_tools_g, H5E_tools_min_id_g, "H5Rget_region 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");
     }
 
-    ret = H5Rcreate(ref_out, fid_out, ref_obj_name, ref_type, space_id);
-
-    if (ret < 0)
-        HGOTO_ERROR(H5E_tools_g, H5E_tools_min_id_g, "H5Rcreate failed");
-
-	ret = 0;
+    if(H5Rcreate(ref_out, fid_out, ref_obj_name, ref_type, space_id) < 0)
+        HGOTO_ERROR(FAIL, H5E_tools_min_id_g, "H5Rcreate failed");
 
 done:
     H5E_BEGIN_TRY {
@@ -879,6 +872,6 @@ done:
       H5Oclose(ref_obj_id);
     } H5E_END_TRY;
 
-	return ret;
+    return ret_value;
 }
 
diff --git a/tools/h5repack/h5repack_verify.c b/tools/h5repack/h5repack_verify.c
index 9565ce3..6765c49 100644
--- a/tools/h5repack/h5repack_verify.c
+++ b/tools/h5repack/h5repack_verify.c
@@ -80,20 +80,20 @@ h5repack_verify(const char *in_fname, const char *out_fname, pack_opt_t *options
         *-------------------------------------------------------------------------
         */
         if((did = H5Dopen2(fidout, name, H5P_DEFAULT)) < 0)
-            HGOTO_ERROR(H5E_tools_g, H5E_tools_min_id_g, "H5Dopen2 failed");
+            HGOTO_ERROR(FAIL, H5E_tools_min_id_g, "H5Dopen2 failed");
         if((sid = H5Dget_space(did)) < 0)
-            HGOTO_ERROR(H5E_tools_g, H5E_tools_min_id_g, "H5Dget_space failed");
+            HGOTO_ERROR(FAIL, H5E_tools_min_id_g, "H5Dget_space failed");
         if((pid = H5Dget_create_plist(did)) < 0)
-            HGOTO_ERROR(H5E_tools_g, H5E_tools_min_id_g, "H5Dget_create_plist failed");
+            HGOTO_ERROR(FAIL, H5E_tools_min_id_g, "H5Dget_create_plist failed");
         if((tid = H5Dget_type(did)) < 0)
-            HGOTO_ERROR(H5E_tools_g, H5E_tools_min_id_g, "H5Dget_type failed");
+            HGOTO_ERROR(FAIL, H5E_tools_min_id_g, "H5Dget_type failed");
 
        /*-------------------------------------------------------------------------
         * filter check
         *-------------------------------------------------------------------------
         */
         if(verify_filters(pid, tid, obj->nfilters, obj->filter) <= 0)
-                ok = 0;
+            ok = 0;
 
 
        /*-------------------------------------------------------------------------
@@ -108,13 +108,13 @@ h5repack_verify(const char *in_fname, const char *out_fname, pack_opt_t *options
         *-------------------------------------------------------------------------
         */
         if(H5Pclose(pid) < 0)
-            HGOTO_ERROR(H5E_tools_g, H5E_tools_min_id_g, "H5Pclose failed");
+            HGOTO_ERROR(FAIL, H5E_tools_min_id_g, "H5Pclose failed");
         if (H5Sclose(sid) < 0)
-            HGOTO_ERROR(H5E_tools_g, H5E_tools_min_id_g, "H5Sclose failed");
+            HGOTO_ERROR(FAIL, H5E_tools_min_id_g, "H5Sclose failed");
         if (H5Dclose(did) < 0)
-            HGOTO_ERROR(H5E_tools_g, H5E_tools_min_id_g, "H5Dclose failed");
+            HGOTO_ERROR(FAIL, H5E_tools_min_id_g, "H5Dclose failed");
         if (H5Tclose(tid) < 0)
-            HGOTO_ERROR(H5E_tools_g, H5E_tools_min_id_g, "H5Tclose failed");
+            HGOTO_ERROR(FAIL, H5E_tools_min_id_g, "H5Tclose failed");
 
     }
 
@@ -132,7 +132,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(H5E_tools_g, H5E_tools_min_id_g, "h5trav_gettable failed");
+            HGOTO_ERROR(FAIL, H5E_tools_min_id_g, "h5trav_gettable failed");
 
         for(i = 0; i < travt->nobjs; i++)
         {
@@ -146,13 +146,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(H5E_tools_g, H5E_tools_min_id_g, "H5Dopen2 failed");
+                    HGOTO_ERROR(FAIL, H5E_tools_min_id_g, "H5Dopen2 failed");
                 if((sid = H5Dget_space(did)) < 0)
-                    HGOTO_ERROR(H5E_tools_g, H5E_tools_min_id_g, "H5Dget_space failed");
+                    HGOTO_ERROR(FAIL, H5E_tools_min_id_g, "H5Dget_space failed");
                 if((pid = H5Dget_create_plist(did)) < 0)
-                    HGOTO_ERROR(H5E_tools_g, H5E_tools_min_id_g, "H5Dget_create_plist failed");
+                    HGOTO_ERROR(FAIL, H5E_tools_min_id_g, "H5Dget_create_plist failed");
                 if((tid = H5Dget_type(did)) < 0)
-                    HGOTO_ERROR(H5E_tools_g, H5E_tools_min_id_g, "H5Dget_type failed");
+                    HGOTO_ERROR(FAIL, H5E_tools_min_id_g, "H5Dget_type failed");
 
                /*-------------------------------------------------------------------------
                 * filter check
@@ -160,7 +160,6 @@ h5repack_verify(const char *in_fname, const char *out_fname, pack_opt_t *options
                 */
                 if(options->all_filter == 1)
                 {
-
                     if(verify_filters(pid, tid, options->n_filter_g, options->filter_g) <= 0)
                         ok = 0;
                 }
@@ -172,6 +171,7 @@ h5repack_verify(const char *in_fname, const char *out_fname, pack_opt_t *options
                 if(options->all_layout == 1)
                 {
                     pack_info_t pack;
+
                     init_packobject(&pack);
                     pack.layout = options->layout_g;
                     pack.chunk = options->chunk_g;
@@ -185,13 +185,13 @@ h5repack_verify(const char *in_fname, const char *out_fname, pack_opt_t *options
                 *-------------------------------------------------------------------------
                 */
                 if (H5Pclose(pid) < 0)
-                    HGOTO_ERROR(H5E_tools_g, H5E_tools_min_id_g, "H5Pclose failed");
+                    HGOTO_ERROR(FAIL, H5E_tools_min_id_g, "H5Pclose failed");
                 if (H5Sclose(sid) < 0)
-                    HGOTO_ERROR(H5E_tools_g, H5E_tools_min_id_g, "H5Sclose failed");
+                    HGOTO_ERROR(FAIL, H5E_tools_min_id_g, "H5Sclose failed");
                 if (H5Dclose(did) < 0)
-                    HGOTO_ERROR(H5E_tools_g, H5E_tools_min_id_g, "H5Dclose failed");
+                    HGOTO_ERROR(FAIL, H5E_tools_min_id_g, "H5Dclose failed");
                 if (H5Tclose(tid) < 0)
-                    HGOTO_ERROR(H5E_tools_g, H5E_tools_min_id_g, "H5Tclose failed");
+                    HGOTO_ERROR(FAIL, H5E_tools_min_id_g, "H5Tclose failed");
             } /* if */
 
         } /* i */
@@ -208,31 +208,31 @@ 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(H5E_tools_g, H5E_tools_min_id_g, "H5Fopen failed");
+        HGOTO_ERROR(FAIL, H5E_tools_min_id_g, "H5Fopen failed");
 
     /* Get file creation property list for input file */
     if((fcpl_in = H5Fget_create_plist(fidin)) < 0) {
         error_msg("failed to retrieve file creation property list\n");
-        HGOTO_ERROR(H5E_tools_g, H5E_tools_min_id_g, "H5Fget_create_plist failed");
+        HGOTO_ERROR(FAIL, H5E_tools_min_id_g, "H5Fget_create_plist failed");
     }
 
     /* Get file space management info for input file */
     if(H5Pget_file_space(fcpl_in, &in_strat, &in_thresh) < 0) {
         error_msg("failed to retrieve file space strategy & threshold\n");
-        HGOTO_ERROR(H5E_tools_g, H5E_tools_min_id_g, "H5Pget_file_space failed");
+        HGOTO_ERROR(FAIL, H5E_tools_min_id_g, "H5Pget_file_space failed");
     }
 
     /* Output file is already opened */
     /* Get file creation property list for output file */
     if((fcpl_out = H5Fget_create_plist(fidout)) < 0) {
         error_msg("failed to retrieve file creation property list\n");
-        HGOTO_ERROR(H5E_tools_g, H5E_tools_min_id_g, "H5Fget_create_plist failed");
+        HGOTO_ERROR(FAIL, H5E_tools_min_id_g, "H5Fget_create_plist failed");
     }
 
     /* Get file space management info for output file */
     if(H5Pget_file_space(fcpl_out, &out_strat, &out_thresh) < 0) {
         error_msg("failed to retrieve file space strategy & threshold\n");
-        HGOTO_ERROR(H5E_tools_g, H5E_tools_min_id_g, "H5Pget_file_space failed");
+        HGOTO_ERROR(FAIL, H5E_tools_min_id_g, "H5Pget_file_space failed");
     }
 
     /*
@@ -245,12 +245,12 @@ h5repack_verify(const char *in_fname, const char *out_fname, pack_opt_t *options
      */
     if(!options->fs_strategy && out_strat != in_strat) {
         error_msg("file space strategy not set as unexpected\n");
-        HGOTO_ERROR(H5E_tools_g, H5E_tools_min_id_g, "file space strategy not set as unexpected");
+        HGOTO_ERROR(FAIL, H5E_tools_min_id_g, "file space strategy not set as unexpected");
 
     }
     else if(options->fs_strategy && out_strat!= options->fs_strategy)  {
         error_msg("file space strategy not set as unexpected\n");
-        HGOTO_ERROR(H5E_tools_g, H5E_tools_min_id_g, "file space strategy not set as unexpected");
+        HGOTO_ERROR(FAIL, H5E_tools_min_id_g, "file space strategy not set as unexpected");
     }
 
     /*
@@ -263,22 +263,22 @@ h5repack_verify(const char *in_fname, const char *out_fname, pack_opt_t *options
      */
     if(!options->fs_threshold && out_thresh != in_thresh) {
         error_msg("free space threshold not set as unexpected\n");
-        HGOTO_ERROR(H5E_tools_g, H5E_tools_min_id_g, "free space threshold not set as unexpected");
+        HGOTO_ERROR(FAIL, H5E_tools_min_id_g, "free space threshold not set as unexpected");
     }
     else if(options->fs_threshold && out_thresh != options->fs_threshold) {
         error_msg("free space threshold not set as unexpected\n");
-        HGOTO_ERROR(H5E_tools_g, H5E_tools_min_id_g, "free space threshold not set as unexpected");
+        HGOTO_ERROR(FAIL, H5E_tools_min_id_g, "free space threshold not set as unexpected");
     }
 
     /* Closing */
     if (H5Pclose(fcpl_in) < 0)
-        HGOTO_ERROR(H5E_tools_g, H5E_tools_min_id_g, "H5Pclose failed");
+        HGOTO_ERROR(FAIL, H5E_tools_min_id_g, "H5Pclose failed");
     if (H5Pclose(fcpl_out) < 0)
-        HGOTO_ERROR(H5E_tools_g, H5E_tools_min_id_g, "H5Pclose failed");
+        HGOTO_ERROR(FAIL, H5E_tools_min_id_g, "H5Pclose failed");
     if (H5Fclose(fidin) < 0)
-        HGOTO_ERROR(H5E_tools_g, H5E_tools_min_id_g, "H5Fclose failed");
+        HGOTO_ERROR(FAIL, H5E_tools_min_id_g, "H5Fclose failed");
     if (H5Fclose(fidout) < 0)
-        HGOTO_ERROR(H5E_tools_g, H5E_tools_min_id_g, "H5Fclose failed");
+        HGOTO_ERROR(FAIL, H5E_tools_min_id_g, "H5Fclose failed");
 
     return ok;
 
@@ -294,7 +294,8 @@ done:
         if (travt)
             trav_table_free(travt);
     } H5E_END_TRY;
-    return -1;
+
+    return ret_value;
 } /* h5repack_verify() */
 
 
@@ -397,12 +398,12 @@ int h5repack_cmp_pl(const char *fname1,
     {
 
         /* Open the files */
-        if ((fid1=H5Fopen(fname1,H5F_ACC_RDONLY,H5P_DEFAULT)) < 0 )
+        if ((fid1 = H5Fopen(fname1,H5F_ACC_RDONLY,H5P_DEFAULT)) < 0 )
         {
             error_msg("<%s>: %s\n", fname1, H5FOPENERROR );
             return -1;
         }
-        if ((fid2=H5Fopen(fname2,H5F_ACC_RDONLY,H5P_DEFAULT)) < 0 )
+        if ((fid2 = H5Fopen(fname2,H5F_ACC_RDONLY,H5P_DEFAULT)) < 0 )
         {
             error_msg("<%s>: %s\n", fname2, H5FOPENERROR );
             H5Fclose(fid1);
@@ -417,7 +418,7 @@ int h5repack_cmp_pl(const char *fname1,
     */
     trav_table_init(&trav);
     if(h5trav_gettable(fid1, trav) < 0)
-        HGOTO_ERROR(H5E_tools_g, H5E_tools_min_id_g, "h5trav_gettable failed");
+        HGOTO_ERROR(FAIL, H5E_tools_min_id_g, "h5trav_gettable failed");
 
    /*-------------------------------------------------------------------------
     * traverse the suppplied object list
@@ -430,30 +431,30 @@ int h5repack_cmp_pl(const char *fname1,
         {
 
             if ((gid = H5Gopen2(fid1, trav->objs[i].name, H5P_DEFAULT)) < 0)
-                HGOTO_ERROR(H5E_tools_g, H5E_tools_min_id_g, "H5Gopen2 failed");
+                HGOTO_ERROR(FAIL, H5E_tools_min_id_g, "H5Gopen2 failed");
             if ((gcplid = H5Gget_create_plist(gid)) < 0)
-                HGOTO_ERROR(H5E_tools_g, H5E_tools_min_id_g, "H5Gget_create_plist failed");
+                HGOTO_ERROR(FAIL, H5E_tools_min_id_g, "H5Gget_create_plist failed");
             if (H5Pget_link_creation_order(gcplid, &crt_order_flag1) < 0)
-                HGOTO_ERROR(H5E_tools_g, H5E_tools_min_id_g, "H5Pget_link_creation_order failed");
+                HGOTO_ERROR(FAIL, H5E_tools_min_id_g, "H5Pget_link_creation_order failed");
             if (H5Pclose(gcplid) < 0)
-                HGOTO_ERROR(H5E_tools_g, H5E_tools_min_id_g, "H5Pclose failed");
+                HGOTO_ERROR(FAIL, H5E_tools_min_id_g, "H5Pclose failed");
             if (H5Gclose(gid) < 0)
-                HGOTO_ERROR(H5E_tools_g, H5E_tools_min_id_g, "H5Gclose failed");
+                HGOTO_ERROR(FAIL, H5E_tools_min_id_g, "H5Gclose failed");
 
             if ((gid = H5Gopen2(fid2, trav->objs[i].name, H5P_DEFAULT)) < 0)
-                HGOTO_ERROR(H5E_tools_g, H5E_tools_min_id_g, "H5Gopen2 failed");
+                HGOTO_ERROR(FAIL, H5E_tools_min_id_g, "H5Gopen2 failed");
             if ((gcplid = H5Gget_create_plist(gid)) < 0)
-                HGOTO_ERROR(H5E_tools_g, H5E_tools_min_id_g, "H5Gget_create_plist failed");
+                HGOTO_ERROR(FAIL, H5E_tools_min_id_g, "H5Gget_create_plist failed");
             if (H5Pget_link_creation_order(gcplid, &crt_order_flag2) < 0)
-                HGOTO_ERROR(H5E_tools_g, H5E_tools_min_id_g, "H5Pget_link_creation_order failed");
+                HGOTO_ERROR(FAIL, H5E_tools_min_id_g, "H5Pget_link_creation_order failed");
             if (H5Pclose(gcplid) < 0)
-                HGOTO_ERROR(H5E_tools_g, H5E_tools_min_id_g, "H5Pclose failed");
+                HGOTO_ERROR(FAIL, H5E_tools_min_id_g, "H5Pclose failed");
             if (H5Gclose(gid) < 0)
-                HGOTO_ERROR(H5E_tools_g, H5E_tools_min_id_g, "H5Gclose failed");
+                HGOTO_ERROR(FAIL, H5E_tools_min_id_g, "H5Gclose failed");
 
             if (crt_order_flag1 != crt_order_flag2) {
                 error_msg("property lists for <%s> are different\n",trav->objs[i].name);
-                HGOTO_ERROR(H5E_tools_g, H5E_tools_min_id_g, "property lists failed");
+                HGOTO_ERROR(FAIL, H5E_tools_min_id_g, "property lists failed");
             }
 
         }
@@ -463,24 +464,24 @@ int h5repack_cmp_pl(const char *fname1,
         else if(trav->objs[i].type == H5TRAV_TYPE_DATASET)
         {
             if((dset1 = H5Dopen2(fid1, trav->objs[i].name, H5P_DEFAULT)) < 0)
-                HGOTO_ERROR(H5E_tools_g, H5E_tools_min_id_g, "H5Dopen2 failed");
+                HGOTO_ERROR(FAIL, H5E_tools_min_id_g, "H5Dopen2 failed");
             if((dset2 = H5Dopen2(fid2, trav->objs[i].name, H5P_DEFAULT)) < 0)
-                HGOTO_ERROR(H5E_tools_g, H5E_tools_min_id_g, "H5Dopen2 failed");
+                HGOTO_ERROR(FAIL, H5E_tools_min_id_g, "H5Dopen2 failed");
             if((dcpl1 = H5Dget_create_plist(dset1)) < 0)
-                HGOTO_ERROR(H5E_tools_g, H5E_tools_min_id_g, "H5Dget_create_plist failed");
+                HGOTO_ERROR(FAIL, H5E_tools_min_id_g, "H5Dget_create_plist failed");
             if((dcpl2 = H5Dget_create_plist(dset2)) < 0)
-                HGOTO_ERROR(H5E_tools_g, H5E_tools_min_id_g, "H5Dget_create_plist failed");
+                HGOTO_ERROR(FAIL, H5E_tools_min_id_g, "H5Dget_create_plist failed");
 
            /*-------------------------------------------------------------------------
             * compare the property lists
             *-------------------------------------------------------------------------
             */
             if((ret = H5Pequal(dcpl1, dcpl2)) < 0)
-                HGOTO_ERROR(H5E_tools_g, H5E_tools_min_id_g, "H5Pequal failed");
+                HGOTO_ERROR(FAIL, H5E_tools_min_id_g, "H5Pequal failed");
 
             if(ret == 0) {
                 error_msg("property lists for <%s> are different\n",trav->objs[i].name);
-                HGOTO_ERROR(H5E_tools_g, H5E_tools_min_id_g, "property lists failed");
+                HGOTO_ERROR(FAIL, H5E_tools_min_id_g, "property lists failed");
             }
 
            /*-------------------------------------------------------------------------
@@ -488,13 +489,13 @@ int h5repack_cmp_pl(const char *fname1,
             *-------------------------------------------------------------------------
             */
             if(H5Pclose(dcpl1) < 0)
-                HGOTO_ERROR(H5E_tools_g, H5E_tools_min_id_g, "H5Pclose failed");
+                HGOTO_ERROR(FAIL, H5E_tools_min_id_g, "H5Pclose failed");
             if(H5Pclose(dcpl2) < 0)
-                HGOTO_ERROR(H5E_tools_g, H5E_tools_min_id_g, "H5Pclose failed");
+                HGOTO_ERROR(FAIL, H5E_tools_min_id_g, "H5Pclose failed");
             if(H5Dclose(dset1) < 0)
-                HGOTO_ERROR(H5E_tools_g, H5E_tools_min_id_g, "H5Dclose failed");
+                HGOTO_ERROR(FAIL, H5E_tools_min_id_g, "H5Dclose failed");
             if(H5Dclose(dset2) < 0)
-                HGOTO_ERROR(H5E_tools_g, H5E_tools_min_id_g, "H5Dclose failed");
+                HGOTO_ERROR(FAIL, H5E_tools_min_id_g, "H5Dclose failed");
         } /*if*/
     } /*i*/
 
@@ -512,13 +513,13 @@ int h5repack_cmp_pl(const char *fname1,
 
     H5Fclose(fid1);
     H5Fclose(fid2);
-    return ret;
 
-   /*-------------------------------------------------------------------------
-    * error
-    *-------------------------------------------------------------------------
-    */
+    return ret;
 
+/*-------------------------------------------------------------------------
+* error
+*-------------------------------------------------------------------------
+*/
 done:
     H5E_BEGIN_TRY
     {
@@ -532,8 +533,8 @@ done:
         H5Gclose(gid);
         trav_table_free(trav);
     } H5E_END_TRY;
-    return -1;
 
+    return ret_value;
 }
 
 
@@ -602,100 +603,71 @@ int verify_filters(hid_t pid, hid_t tid, int nfilters, filter_info_t *filter)
         switch (filtn)
         {
 
-        case H5Z_FILTER_NONE:
+            case H5Z_FILTER_NONE:
         	break;
 
-        case H5Z_FILTER_SHUFFLE:
-
-            /* 1 private client value is returned by DCPL */
-            if ( cd_nelmts != H5Z_SHUFFLE_TOTAL_NPARMS && filter[i].cd_nelmts != H5Z_SHUFFLE_USER_NPARMS )
-                return 0;
-
-            /* get dataset's type size */
-            if((size = H5Tget_size(tid)) <= 0)
-                return -1;
-
-            /* the private client value holds the dataset's type size */
-            if ( size != cd_values[0] )
-                return 0;
-
-
-            break;
-
-        case H5Z_FILTER_SZIP:
-
-            /* 4 private client values are returned by DCPL */
-            if ( cd_nelmts != H5Z_SZIP_TOTAL_NPARMS && filter[i].cd_nelmts != H5Z_SZIP_USER_NPARMS )
-                return 0;
-
-            /* "User" parameter for pixels-per-block (index 1) */
-            if ( cd_values[H5Z_SZIP_PARM_PPB] != filter[i].cd_values[H5Z_SZIP_PARM_PPB] )
-                return 0;
-
-
-            break;
-
-        case H5Z_FILTER_NBIT:
-
-            /* only client data values number of values checked */
-            if ( H5Z_NBIT_USER_NPARMS != filter[i].cd_nelmts)
-                return 0;
-
-
-
-            break;
+            case H5Z_FILTER_SHUFFLE:
+                /* 1 private client value is returned by DCPL */
+                if ( cd_nelmts != H5Z_SHUFFLE_TOTAL_NPARMS && filter[i].cd_nelmts != H5Z_SHUFFLE_USER_NPARMS )
+                    return 0;
 
-        case H5Z_FILTER_SCALEOFFSET:
+                /* get dataset's type size */
+                if((size = H5Tget_size(tid)) <= 0)
+                    return -1;
 
-            /* only client data values checked */
-            for( j = 0; j < H5Z_SCALEOFFSET_USER_NPARMS; j++)
-            {
-                if (cd_values[j] != filter[i].cd_values[j])
-                {
+                /* the private client value holds the dataset's type size */
+                if ( size != cd_values[0] )
                     return 0;
-                }
 
-            }
+                break;
 
+            case H5Z_FILTER_SZIP:
+                /* 4 private client values are returned by DCPL */
+                if ( cd_nelmts != H5Z_SZIP_TOTAL_NPARMS && filter[i].cd_nelmts != H5Z_SZIP_USER_NPARMS )
+                    return 0;
 
-            break;
-
-        /* for these filters values must match, no local values set in DCPL */
-        case H5Z_FILTER_FLETCHER32:
-        case H5Z_FILTER_DEFLATE:
+                /* "User" parameter for pixels-per-block (index 1) */
+                if ( cd_values[H5Z_SZIP_PARM_PPB] != filter[i].cd_values[H5Z_SZIP_PARM_PPB] )
+                    return 0;
 
-            if ( cd_nelmts != filter[i].cd_nelmts)
-                return 0;
+                break;
 
-            for( j = 0; j < cd_nelmts; j++)
-            {
-                if (cd_values[j] != filter[i].cd_values[j])
-                {
+            case H5Z_FILTER_NBIT:
+                /* only client data values number of values checked */
+                if ( H5Z_NBIT_USER_NPARMS != filter[i].cd_nelmts)
                     return 0;
-                }
+                break;
 
-            }
+            case H5Z_FILTER_SCALEOFFSET:
+                /* only client data values checked */
+                for( j = 0; j < H5Z_SCALEOFFSET_USER_NPARMS; j++)
+                    if (cd_values[j] != filter[i].cd_values[j])
+                        return 0;
+                break;
 
+            /* for these filters values must match, no local values set in DCPL */
+            case H5Z_FILTER_FLETCHER32:
+            case H5Z_FILTER_DEFLATE:
 
+                if ( cd_nelmts != filter[i].cd_nelmts)
+                    return 0;
 
-            break;
+                for( j = 0; j < cd_nelmts; j++)
+                    if (cd_values[j] != filter[i].cd_values[j])
+                        return 0;
 
-        default:
-			if ( cd_nelmts != filter[i].cd_nelmts)
-				return 0;
+                break;
 
-			for( j = 0; j < cd_nelmts; j++)
-			{
-				if (cd_values[j] != filter[i].cd_values[j])
-				{
-					return 0;
-				}
+            default:
+                if ( cd_nelmts != filter[i].cd_nelmts)
+                    return 0;
 
-			}
-            break;
+                for( j = 0; j < cd_nelmts; j++)
+                    if (cd_values[j] != filter[i].cd_values[j])
+                        return 0;
+                break;
 
         } /* switch */
-
     }
 
     return 1;