Develop normalization with vol_integration.

Mostly peripheral things like the tools and wrappers,
with just enough core library code to support that.

31 files changed, 1033 insertions, 1074 deletions

diff --git a/MANIFEST b/MANIFEST
index f011e94..117c531 100644
--- a/MANIFEST
+++ b/MANIFEST
@@ -526,8 +526,8 @@
 ./src/H5CS.c
 ./src/H5CSprivate.h
 ./src/H5CX.c
-./src/H5CXprivate.h
 ./src/H5CXmodule.h
+./src/H5CXprivate.h
 ./src/H5D.c
 ./src/H5Dbtree.c
 ./src/H5Dbtree2.c
diff --git a/bin/make_err b/bin/make_err
index bfe8861..623c1b6 100755
--- a/bin/make_err
+++ b/bin/make_err
@@ -244,8 +244,8 @@ sub create_init ($) {
     print HEADER   "/* Major error codes */\n";
     print HEADER   "/*********************/\n\n";
     foreach $name (keys %major) {
-        print HEADER " "x(0*$indent),"assert(${name}_g==(-1));\n";
-        print HEADER " "x(0*$indent),"if((msg = H5E_create_msg(cls, H5E_MAJOR, \"${major{$name}}\"))==NULL)\n";
+        print HEADER " "x(0*$indent),"HDassert(${name}_g==(-1));\n";
+        print HEADER " "x(0*$indent),"if((msg = H5E__create_msg(cls, H5E_MAJOR, \"${major{$name}}\"))==NULL)\n";
         print HEADER " "x(1*$indent),"HGOTO_ERROR(H5E_ERROR, H5E_CANTINIT, FAIL, \"error message initialization failed\")\n";
         print HEADER " "x(0*$indent),"if((${name}_g = H5I_register(H5I_ERROR_MSG, msg, FALSE))<0)\n";
         print HEADER " "x(1*$indent),"HGOTO_ERROR(H5E_ERROR, H5E_CANTREGISTER, FAIL, \"can't register error message\")\n";
@@ -260,8 +260,8 @@ sub create_init ($) {
 
         # Iterate over all the minor errors in each section
         for $name ( @{$section_list{$sect_name}}) {
-            print HEADER " "x(0*$indent),"assert(${name}_g==(-1));\n";
-            print HEADER " "x(0*$indent),"if((msg = H5E_create_msg(cls, H5E_MINOR, \"${minor{$name}}\"))==NULL)\n";
+            print HEADER " "x(0*$indent),"HDassert(${name}_g==(-1));\n";
+            print HEADER " "x(0*$indent),"if((msg = H5E__create_msg(cls, H5E_MINOR, \"${minor{$name}}\"))==NULL)\n";
             print HEADER " "x(1*$indent),"HGOTO_ERROR(H5E_ERROR, H5E_CANTINIT, FAIL, \"error message initialization failed\")\n";
             print HEADER " "x(0*$indent),"if((${name}_g = H5I_register(H5I_ERROR_MSG, msg, FALSE))<0)\n";
             print HEADER " "x(1*$indent),"HGOTO_ERROR(H5E_ERROR, H5E_CANTREGISTER, FAIL, \"can't register error message\")\n";
diff --git a/c++/src/Makefile.am b/c++/src/Makefile.am
index 949325a..eb50209 100644
--- a/c++/src/Makefile.am
+++ b/c++/src/Makefile.am
@@ -32,15 +32,15 @@ bin_SCRIPTS=h5c++
 
 # Source files for the library
 libhdf5_cpp_la_SOURCES=H5Exception.cpp H5IdComponent.cpp	\
-	H5DataSpace.cpp H5PropList.cpp H5Library.cpp			\
-	H5FaccProp.cpp H5FcreatProp.cpp H5LcreatProp.cpp		\
-	H5LaccProp.cpp H5DaccProp.cpp H5DxferProp.cpp			\
+    H5DataSpace.cpp H5PropList.cpp H5Library.cpp			\
+    H5FaccProp.cpp H5FcreatProp.cpp H5LcreatProp.cpp		\
+    H5LaccProp.cpp H5DaccProp.cpp H5DxferProp.cpp			\
     H5DcreatProp.cpp H5Location.cpp H5AbstractDs.cpp		\
     H5Attribute.cpp H5Object.cpp H5OcreatProp.cpp			\
-	H5DataType.cpp H5AtomType.cpp H5PredType.cpp			\
+    H5DataType.cpp H5AtomType.cpp H5PredType.cpp			\
     H5EnumType.cpp H5IntType.cpp H5FloatType.cpp			\
     H5StrType.cpp H5ArrayType.cpp H5VarLenType.cpp			\
-	H5CompType.cpp H5DataSet.cpp H5CommonFG.cpp H5Group.cpp	\
+    H5CompType.cpp H5DataSet.cpp H5CommonFG.cpp H5Group.cpp	\
     H5File.cpp
 
 # HDF5 C++ library depends on HDF5 Library.
diff --git a/c++/test/tattr.cpp b/c++/test/tattr.cpp
index bdf6d80..4734755 100644
--- a/c++/test/tattr.cpp
+++ b/c++/test/tattr.cpp
@@ -1712,7 +1712,7 @@ static void test_attr_dense_create(FileCreatPropList& fcpl,
         // Close property list
         dcpl.close();
 
-        // H5O_is_attr_dense_test - un-usable
+        // H5O__is_attr_dense_test - un-usable
 
         // Add attributes, until just before converting to dense storage
         char attr_name[NAME_BUF_SIZE];
@@ -1727,7 +1727,7 @@ static void test_attr_dense_create(FileCreatPropList& fcpl,
             attr.write(PredType::NATIVE_UINT, &attr_num);
         } // end for
 
-        // H5O_is_attr_dense_test - un-usable
+        // H5O__is_attr_dense_test - un-usable
 
         { // Add one more attribute, to push into "dense" storage
 
@@ -1815,8 +1815,8 @@ static void test_attr_corder_create_basic(FileCreatPropList& fcpl,
         ds_space.close();
 
         // Check on dataset's attribute storage status.
-        // NOTE: Wrappers not available yet (H5O_is_attr_empty_test
-        // and H5O_is_attr_dense_test)
+        // NOTE: Wrappers not available yet (H5O__is_attr_empty_test
+        // and H5O__is_attr_dense_test)
 
         // Close dataset
         dataset.close();
diff --git a/fortran/test/tH5F.F90 b/fortran/test/tH5F.F90
index 72920f2..ee386dd 100644
--- a/fortran/test/tH5F.F90
+++ b/fortran/test/tH5F.F90
@@ -30,8 +30,6 @@
 !  access the dataset from the second file as a member of a group 
 !  in the first file. 
 
-
-
 MODULE TH5F
 
 CONTAINS
diff --git a/hl/tools/h5watch/swmr_check_compat_vfd.c b/hl/tools/h5watch/swmr_check_compat_vfd.c
index 7d11a73..26f76cb 100644
--- a/hl/tools/h5watch/swmr_check_compat_vfd.c
+++ b/hl/tools/h5watch/swmr_check_compat_vfd.c
@@ -48,7 +48,7 @@ main(void)
 
     driver = HDgetenv("HDF5_DRIVER");
 
-    if(H5FD_supports_swmr_test(driver))
+    if(H5FD__supports_swmr_test(driver))
         return EXIT_SUCCESS;
     else
         return EXIT_FAILURE;
diff --git a/src/H5.c b/src/H5.c
index 1b13fea..32af55b 100644
--- a/src/H5.c
+++ b/src/H5.c
@@ -262,7 +262,7 @@ H5_term_library(void)
 
     /* Don't do anything if the library is already closed */
     if(!(H5_INIT_GLOBAL))
-	goto done;
+        goto done;
 
     /* Indicate that the library is being shut down */
     H5_TERM_GLOBAL = TRUE;
@@ -379,18 +379,18 @@ H5_term_library(void)
      * down if any of the below code involves using the instrumentation code.
      */
     if(H5_MPEinit_g) {
-	int mpi_initialized;
-	int mpi_finalized;
-	int mpe_code;
+        int mpi_initialized;
+        int mpi_finalized;
+        int mpe_code;
 
-	MPI_Initialized(&mpi_initialized);
-	MPI_Finalized(&mpi_finalized);
+        MPI_Initialized(&mpi_initialized);
+        MPI_Finalized(&mpi_finalized);
 
         if (mpi_initialized && !mpi_finalized) {
-	    mpe_code = MPE_Finish_log("h5log");
-	    HDassert(mpe_code >=0);
-	} /* end if */
-	H5_MPEinit_g = FALSE;	/* turn it off no matter what */
+            mpe_code = MPE_Finish_log("h5log");
+            HDassert(mpe_code >=0);
+        } /* end if */
+        H5_MPEinit_g = FALSE;	/* turn it off no matter what */
     } /* end if */
 #endif
 
diff --git a/src/H5E.c b/src/H5E.c
index eecf6e7..170133e 100644
--- a/src/H5E.c
+++ b/src/H5E.c
@@ -49,11 +49,12 @@
 /***********/
 /* Headers */
 /***********/
-#include "H5private.h"		/* Generic Functions			*/
-#include "H5Iprivate.h"		/* IDs                                  */
-#include "H5Epkg.h"		/* Error handling		  	*/
-#include "H5FLprivate.h"	/* Free lists                           */
-#include "H5MMprivate.h"	/* Memory management			*/
+#include "H5private.h"          /* Generic Functions                        */
+#include "H5CXprivate.h"        /* API Contexts                             */
+#include "H5Epkg.h"             /* Error handling                           */
+#include "H5FLprivate.h"        /* Free lists                               */
+#include "H5Iprivate.h"         /* IDs                                      */
+#include "H5MMprivate.h"        /* Memory management                        */
 
 /****************/
 /* Local Macros */
@@ -78,18 +79,17 @@
 /* Local Prototypes */
 /********************/
 /* Static function declarations */
-static herr_t H5E_set_default_auto(H5E_t *stk);
-static H5E_cls_t *H5E_register_class(const char *cls_name, const char *lib_name,
-                                const char *version);
-static herr_t  H5E_unregister_class(H5E_cls_t *cls);
-static ssize_t H5E_get_class_name(const H5E_cls_t *cls, char *name, size_t size);
-static int H5E_close_msg_cb(void *obj_ptr, hid_t obj_id, void *udata);
-static herr_t  H5E_close_msg(H5E_msg_t *err);
-static H5E_msg_t *H5E_create_msg(H5E_cls_t *cls, H5E_type_t msg_type, const char *msg);
-static H5E_t  *H5E_get_current_stack(void);
-static herr_t  H5E_set_current_stack(H5E_t *estack);
-static herr_t  H5E_close_stack(H5E_t *err_stack);
-static ssize_t H5E_get_num(const H5E_t *err_stack);
+static herr_t H5E__set_default_auto(H5E_t *stk);
+static H5E_cls_t *H5E__register_class(const char *cls_name, const char *lib_name, const char *version);
+static herr_t  H5E__unregister_class(H5E_cls_t *cls);
+static ssize_t H5E__get_class_name(const H5E_cls_t *cls, char *name, size_t size);
+static int H5E__close_msg_cb(void *obj_ptr, hid_t obj_id, void *udata);
+static herr_t  H5E__close_msg(H5E_msg_t *err);
+static H5E_msg_t *H5E__create_msg(H5E_cls_t *cls, H5E_type_t msg_type, const char *msg);
+static H5E_t  *H5E__get_current_stack(void);
+static herr_t  H5E__set_current_stack(H5E_t *estack);
+static herr_t  H5E__close_stack(H5E_t *err_stack);
+static ssize_t H5E__get_num(const H5E_t *err_stack);
 
 
 /*********************/
@@ -123,7 +123,7 @@ static const H5I_class_t H5I_ERRCLS_CLS[1] = {{
     H5I_ERROR_CLASS,		/* ID class value */
     0,				/* Class flags */
     0,				/* # of reserved IDs for class */
-    (H5I_free_t)H5E_unregister_class /* Callback routine for closing objects of this class */
+    (H5I_free_t)H5E__unregister_class /* Callback routine for closing objects of this class */
 }};
 
 /* Error message ID class */
@@ -131,7 +131,7 @@ static const H5I_class_t H5I_ERRMSG_CLS[1] = {{
     H5I_ERROR_MSG,		/* ID class value */
     0,				/* Class flags */
     0,				/* # of reserved IDs for class */
-    (H5I_free_t)H5E_close_msg   /* Callback routine for closing objects of this class */
+    (H5I_free_t)H5E__close_msg   /* Callback routine for closing objects of this class */
 }};
 
 /* Error stack ID class */
@@ -139,19 +139,17 @@ static const H5I_class_t H5I_ERRSTK_CLS[1] = {{
     H5I_ERROR_STACK,		/* ID class value */
     0,				/* Class flags */
     0,				/* # of reserved IDs for class */
-    (H5I_free_t)H5E_close_stack /* Callback routine for closing objects of this class */
+    (H5I_free_t)H5E__close_stack /* Callback routine for closing objects of this class */
 }};
 
 
 
 /*-------------------------------------------------------------------------
- * Function:	H5E_init
+ * Function:    H5E_init
  *
- * Purpose:	Initialize the interface from some other layer.
+ * Purpose:     Initialize the interface from some other layer.
  *
- * Return:	Success:	non-negative
- *
- *		Failure:	negative
+ * Return:      SUCCEED/FAIL
  *
  * Programmer:	Quincey Koziol
  *              Tuesday, June 29, 2004
@@ -176,7 +174,7 @@ done:
  *
  * Purpose:     Initialize interface-specific information
  *
- * Return:      Non-negative on success/Negative on failure
+ * Return:      SUCCEED/FAIL
  *
  * Programmer:  Raymond Lu
  *              Friday, July 11, 2003
@@ -207,13 +205,13 @@ H5E__init_package(void)
 
 #ifndef H5_HAVE_THREADSAFE
     H5E_stack_g[0].nused = 0;
-    H5E_set_default_auto(H5E_stack_g);
+    H5E__set_default_auto(H5E_stack_g);
 #endif /* H5_HAVE_THREADSAFE */
 
     /* Allocate the HDF5 error class */
     HDassert(H5E_ERR_CLS_g == (-1));
     HDsnprintf(lib_vers, sizeof(lib_vers), "%u.%u.%u%s", H5_VERS_MAJOR, H5_VERS_MINOR, H5_VERS_RELEASE, (HDstrlen(H5_VERS_SUBRELEASE) > 0 ? "-"H5_VERS_SUBRELEASE : ""));
-    if(NULL == (cls = H5E_register_class(H5E_CLS_NAME, H5E_CLS_LIB_NAME, lib_vers)))
+    if(NULL == (cls = H5E__register_class(H5E_CLS_NAME, H5E_CLS_LIB_NAME, lib_vers)))
         HGOTO_ERROR(H5E_ERROR, H5E_CANTINIT, FAIL, "class initialization failed")
     if((H5E_ERR_CLS_g = H5I_register(H5I_ERROR_CLASS, cls, FALSE)) < 0)
         HGOTO_ERROR(H5E_ERROR, H5E_CANTREGISTER, FAIL, "can't register error class")
@@ -227,14 +225,14 @@ done:
 
 
 /*-------------------------------------------------------------------------
- * Function:	H5E_term_package
+ * Function:    H5E_term_package
  *
- * Purpose:	Terminates the H5E interface
+ * Purpose:     Terminates the H5E interface
  *
- * Return:	Success:	Positive if anything is done that might
- *				affect other interfaces; zero otherwise.
+ * Return:      Success:    Positive if anything is done that might
+ *                          affect other interfaces; zero otherwise.
  *
- * 		Failure:	Negative.
+ *              Failure:    Negative
  *
  * Programmer:	Raymond Lu
  *	        Tuesday, July 22, 2003
@@ -262,8 +260,8 @@ H5E_term_package(void)
 	        (void)H5I_clear_type(H5I_ERROR_STACK, FALSE, FALSE);
 
             /* Clear all the error classes */
-	    if(ncls > 0) {
-	        (void)H5I_clear_type(H5I_ERROR_CLASS, FALSE, FALSE);
+            if(ncls > 0) {
+                (void)H5I_clear_type(H5I_ERROR_CLASS, FALSE, FALSE);
 
                 /* Reset the HDF5 error class, if its been closed */
                 if(H5I_nmembers(H5I_ERROR_CLASS) == 0)
@@ -271,8 +269,8 @@ H5E_term_package(void)
             } /* end if */
 
             /* Clear all the error messages */
-	    if(nmsg > 0) {
-	        (void)H5I_clear_type(H5I_ERROR_MSG, FALSE, FALSE);
+            if(nmsg > 0) {
+                (void)H5I_clear_type(H5I_ERROR_MSG, FALSE, FALSE);
 
                 /* Reset the HDF5 error messages, if they've been closed */
                 if(H5I_nmembers(H5I_ERROR_MSG) == 0) {
@@ -282,17 +280,17 @@ H5E_term_package(void)
             } /* end if */
 
             n++; /*H5I*/
-	} /* end if */
+        } /* end if */
         else {
-	    /* Destroy the error class, message, and stack id groups */
-	    n += (H5I_dec_type_ref(H5I_ERROR_STACK) > 0);
-	    n += (H5I_dec_type_ref(H5I_ERROR_CLASS) > 0);
-	    n += (H5I_dec_type_ref(H5I_ERROR_MSG) > 0);
+            /* Destroy the error class, message, and stack id groups */
+            n += (H5I_dec_type_ref(H5I_ERROR_STACK) > 0);
+            n += (H5I_dec_type_ref(H5I_ERROR_CLASS) > 0);
+            n += (H5I_dec_type_ref(H5I_ERROR_MSG) > 0);
 
-	    /* Mark closed */
+            /* Mark closed */
             if(0 == n)
                 H5_PKG_INIT_VAR = FALSE;
-	} /* end else */
+        } /* end else */
     } /* end if */
 
     FUNC_LEAVE_NOAPI(n)
@@ -300,12 +298,12 @@ H5E_term_package(void)
 
 
 /*--------------------------------------------------------------------------
- * Function:    H5E_set_default_auto
+ * Function:    H5E__set_default_auto
  *
  * Purpose:     Initialize "automatic" error stack reporting info to library
  *              default
  *
- * Return:      Non-negative on success/Negative on failure
+ * Return:      SUCCEED/FAIL
  *
  * Programmer:  Quincey Koziol
  *              Thursday, November 1, 2007
@@ -313,9 +311,9 @@ H5E_term_package(void)
  *--------------------------------------------------------------------------
  */
 static herr_t
-H5E_set_default_auto(H5E_t *stk)
+H5E__set_default_auto(H5E_t *stk)
 {
-    FUNC_ENTER_NOAPI_NOINIT_NOERR
+    FUNC_ENTER_STATIC_NOERR
 
 #ifndef H5_NO_DEPRECATED_SYMBOLS
 #ifdef H5_USE_16_API_DEFAULT
@@ -334,19 +332,19 @@ H5E_set_default_auto(H5E_t *stk)
     stk->auto_data = NULL;
 
     FUNC_LEAVE_NOAPI(SUCCEED)
-} /* end H5E_set_default_auto() */
+} /* end H5E__set_default_auto() */
 
 
 #ifdef H5_HAVE_THREADSAFE
 /*-------------------------------------------------------------------------
- * Function:	H5E_get_stack
+ * Function:    H5E__get_stack
  *
- * Purpose:	Support function for H5E_get_my_stack() to initialize and
+ * Purpose:     Support function for H5E__get_my_stack() to initialize and
  *              acquire per-thread error stack.
  *
- * Return:	Success:	error stack (H5E_t *)
+ * Return:      Success:    Pointer to an error stack struct (H5E_t *)
  *
- *		Failure:	NULL
+ *              Failure:    NULL
  *
  * Programmer:	Chee Wai LEE
  *              April 24, 2000
@@ -354,11 +352,11 @@ H5E_set_default_auto(H5E_t *stk)
  *-------------------------------------------------------------------------
  */
 H5E_t *
-H5E_get_stack(void)
+H5E__get_stack(void)
 {
     H5E_t *estack = NULL;
 
-    FUNC_ENTER_NOAPI_NOINIT_NOERR
+    FUNC_ENTER_PACKAGE_NOERR
 
     estack = (H5E_t *)H5TS_get_thread_local_value(H5TS_errstk_key_g);
 
@@ -377,7 +375,7 @@ H5E_get_stack(void)
 
         /* Set the thread-specific info */
         estack->nused = 0;
-        H5E_set_default_auto(estack);
+        H5E__set_default_auto(estack);
 
         /* (It's not necessary to release this in this API, it is
          *      released by the "key destructor" set up in the H5TS
@@ -388,16 +386,16 @@ H5E_get_stack(void)
 
     /* Set return value */
     FUNC_LEAVE_NOAPI(estack)
-} /* end H5E_get_stack() */
+} /* end H5E__get_stack() */
 #endif  /* H5_HAVE_THREADSAFE */
 
 
 /*-------------------------------------------------------------------------
- * Function:	H5E_free_class
+ * Function:    H5E_free_class
  *
- * Purpose:	Private function to free an error class.
+ * Purpose:     Private function to free an error class.
  *
- * Return:	Non-negative value on success/Negative on failure
+ * Return:      SUCCEED/FAIL
  *
  * Programmer:	Quincey Koziol
  *              Friday, January 22, 2009
@@ -423,11 +421,12 @@ H5E_free_class(H5E_cls_t *cls)
 
 
 /*-------------------------------------------------------------------------
- * Function:	H5Eregister_class
+ * Function:    H5Eregister_class
  *
- * Purpose:	Registers an error class.
+ * Purpose:     Registers an error class.
  *
- * Return:	Non-negative value as class ID on success/Negative on failure
+ * Return:      Success:    An ID for the error class
+ *              Failure:    H5I_INVALID_HID
  *
  * Programmer:	Raymond Lu
  *              Friday, July 11, 2003
@@ -438,22 +437,22 @@ hid_t
 H5Eregister_class(const char *cls_name, const char *lib_name, const char *version)
 {
     H5E_cls_t   *cls;        /* Pointer to error class */
-    hid_t       ret_value;   /* Return value */
+    hid_t       ret_value = H5I_INVALID_HID;   /* Return value */
 
-    FUNC_ENTER_API(FAIL)
+    FUNC_ENTER_API(H5I_INVALID_HID)
     H5TRACE3("i", "*s*s*s", cls_name, lib_name, version);
 
     /* Check arguments */
     if(cls_name == NULL || lib_name == NULL || version == NULL)
-	HGOTO_ERROR(H5E_ARGS, H5E_BADVALUE, FAIL, "invalid string")
+        HGOTO_ERROR(H5E_ARGS, H5E_BADVALUE, H5I_INVALID_HID, "invalid string")
 
     /* Create the new error class object */
-    if(NULL == (cls = H5E_register_class(cls_name, lib_name, version)))
-	HGOTO_ERROR(H5E_ERROR, H5E_CANTCREATE, FAIL, "can't create error class")
+    if(NULL == (cls = H5E__register_class(cls_name, lib_name, version)))
+        HGOTO_ERROR(H5E_ERROR, H5E_CANTCREATE, H5I_INVALID_HID, "can't create error class")
 
     /* Register the new error class to get an ID for it */
     if((ret_value = H5I_register(H5I_ERROR_CLASS, cls, TRUE)) < 0)
-        HGOTO_ERROR(H5E_ERROR, H5E_CANTREGISTER, FAIL, "can't register error class")
+        HGOTO_ERROR(H5E_ERROR, H5E_CANTREGISTER, H5I_INVALID_HID, "can't register error class")
 
 done:
     FUNC_LEAVE_API(ret_value)
@@ -461,11 +460,12 @@ done:
 
 
 /*-------------------------------------------------------------------------
- * Function:	H5E_register_class
+ * Function:    H5E__register_class
  *
- * Purpose:	Private function to register an error class.
+ * Purpose:     Private function to register an error class.
  *
- * Return:	Non-negative value as class ID on success/Negative on failure
+ * Return:      Success:    Pointer to an error class struct
+ *              Failure:    NULL
  *
  * Programmer:	Raymond Lu
  *              Friday, July 11, 2003
@@ -473,12 +473,12 @@ done:
  *-------------------------------------------------------------------------
  */
 static H5E_cls_t *
-H5E_register_class(const char *cls_name, const char *lib_name, const char *version)
+H5E__register_class(const char *cls_name, const char *lib_name, const char *version)
 {
     H5E_cls_t   *cls = NULL;            /* Pointer to error class */
     H5E_cls_t   *ret_value = NULL;      /* Return value */
 
-    FUNC_ENTER_NOAPI_NOINIT
+    FUNC_ENTER_STATIC
 
     /* Check arguments */
     HDassert(cls_name);
@@ -506,15 +506,15 @@ done:
             HDONE_ERROR(H5E_ERROR, H5E_CANTRELEASE, NULL, "unable to free error class")
 
     FUNC_LEAVE_NOAPI(ret_value)
-} /* end H5E_register_class() */
+} /* end H5E__register_class() */
 
 
 /*-------------------------------------------------------------------------
- * Function:	H5Eunregister_class
+ * Function:    H5Eunregister_class
  *
- * Purpose:	Closes an error class.
+ * Purpose:     Closes an error class.
  *
- * Return:	Non-negative value on success/Negative on failure
+ * Return:      SUCCEED/FAIL
  *
  * Programmer:	Raymond Lu
  *              Friday, July 11, 2003
@@ -546,11 +546,11 @@ done:
 
 
 /*-------------------------------------------------------------------------
- * Function:	H5E_unregister_class
+ * Function:    H5E__unregister_class
  *
- * Purpose:	Private function to close an error class.
+ * Purpose:     Private function to close an error class.
  *
- * Return:	Non-negative value on success/Negative on failure
+ * Return:      SUCCEED/FAIL
  *
  * Programmer:	Raymond Lu
  *              Friday, July 11, 2003
@@ -558,17 +558,17 @@ done:
  *-------------------------------------------------------------------------
  */
 static herr_t
-H5E_unregister_class(H5E_cls_t *cls)
+H5E__unregister_class(H5E_cls_t *cls)
 {
     herr_t      ret_value = SUCCEED;       /* Return value */
 
-    FUNC_ENTER_NOAPI_NOINIT
+    FUNC_ENTER_STATIC
 
     /* Check arguments */
     HDassert(cls);
 
     /* Iterate over all the messages and delete those in this error class */
-    if(H5I_iterate(H5I_ERROR_MSG, H5E_close_msg_cb, cls, FALSE) < 0)
+    if(H5I_iterate(H5I_ERROR_MSG, H5E__close_msg_cb, cls, FALSE) < 0)
         HGOTO_ERROR(H5E_ERROR, H5E_BADITER, FAIL, "unable to free all messages in this error class")
 
     /* Free error class structure */
@@ -577,16 +577,16 @@ H5E_unregister_class(H5E_cls_t *cls)
 
 done:
     FUNC_LEAVE_NOAPI(ret_value)
-} /* end H5E_unregister_class() */
+} /* end H5E__unregister_class() */
 
 
 /*-------------------------------------------------------------------------
- * Function:	H5Eget_class_name
+ * Function:    H5Eget_class_name
  *
- * Purpose:	Retrieves error class name.
+ * Purpose:     Retrieves error class name.
  *
- * Return:      Non-negative for name length if succeeds(zero means no name);
- *              otherwise returns negative value.
+ * Return:      Success:    Name length (zero means no name)
+ *              Failure:    -1
  *
  * Programmer:	Raymond Lu
  *              Friday, July 11, 2003
@@ -597,18 +597,18 @@ ssize_t
 H5Eget_class_name(hid_t class_id, char *name, size_t size)
 {
     H5E_cls_t   *cls;        /* Pointer to error class */
-    ssize_t     ret_value;   /* Return value */
+    ssize_t     ret_value = -1;   /* Return value */
 
-    FUNC_ENTER_API(FAIL)
+    FUNC_ENTER_API((-1))
     H5TRACE3("Zs", "i*sz", class_id, name, size);
 
     /* Get the error class */
     if(NULL == (cls = (H5E_cls_t *)H5I_object_verify(class_id, H5I_ERROR_CLASS)))
-	HGOTO_ERROR(H5E_ARGS, H5E_BADTYPE, FAIL, "not a error class ID")
+        HGOTO_ERROR(H5E_ARGS, H5E_BADTYPE, (-1), "not a error class ID")
 
     /* Retrieve the class name */
-    if((ret_value = H5E_get_class_name(cls, name, size)) < 0)
-	HGOTO_ERROR(H5E_ERROR, H5E_CANTGET, FAIL, "can't get error class name")
+    if((ret_value = H5E__get_class_name(cls, name, size)) < 0)
+        HGOTO_ERROR(H5E_ERROR, H5E_CANTGET, (-1), "can't get error class name")
 
 done:
     FUNC_LEAVE_API(ret_value)
@@ -616,12 +616,12 @@ done:
 
 
 /*-------------------------------------------------------------------------
- * Function:	H5E_get_class_name
+ * Function:    H5E__get_class_name
  *
- * Purpose:	Private function to retrieve error class name.
+ * Purpose:     Private function to retrieve error class name.
  *
- * Return:      Non-negative for name length if succeeds(zero means no name);
- *              otherwise returns negative value.
+ * Return:      Success:    Name length (zero means no name)
+ *              Failure:    -1
  *
  * Programmer:	Raymond Lu
  *              Friday, July 11, 2003
@@ -629,11 +629,11 @@ done:
  *-------------------------------------------------------------------------
  */
 static ssize_t
-H5E_get_class_name(const H5E_cls_t *cls, char *name, size_t size)
+H5E__get_class_name(const H5E_cls_t *cls, char *name, size_t size)
 {
-    ssize_t       len = 0;          /* Length of error class's name */
+    ssize_t       len = -1;          /* Length of error class's name */
 
-    FUNC_ENTER_NOAPI_NOINIT_NOERR
+    FUNC_ENTER_STATIC_NOERR
 
     /* Check arguments */
     HDassert(cls);
@@ -650,16 +650,17 @@ H5E_get_class_name(const H5E_cls_t *cls, char *name, size_t size)
 
     /* Return the full length */
     FUNC_LEAVE_NOAPI(len)
-} /* end H5E_get_class_name() */
+} /* end H5E__get_class_name() */
 
 
 /*-------------------------------------------------------------------------
- * Function:    H5E_close_msg_cb
+ * Function:    H5E__close_msg_cb
  *
  * Purpose:     H5I_iterate callback function to close error messages in the
  *              error class.
  *
- * Return:	Non-negative value on success/Negative on failure
+ * Return:      Success:    H5_ITER_CONT (0)
+ *              Failure:    H5_ITER_ERROR (-1)
  *
  * Programmer:  Raymond Lu
  *              July 14, 2003
@@ -667,36 +668,36 @@ H5E_get_class_name(const H5E_cls_t *cls, char *name, size_t size)
  *-------------------------------------------------------------------------
  */
 static int
-H5E_close_msg_cb(void *obj_ptr, hid_t obj_id, void *udata)
+H5E__close_msg_cb(void *obj_ptr, hid_t obj_id, void *udata)
 {
     H5E_msg_t   *err_msg = (H5E_msg_t*)obj_ptr;
     H5E_cls_t   *cls = (H5E_cls_t*)udata;
-    herr_t      ret_value = SUCCEED;       /* Return value */
+    int         ret_value = H5_ITER_CONT;       /* Return value */
 
-    FUNC_ENTER_NOAPI_NOINIT
+    FUNC_ENTER_STATIC
 
     /* Check arguments */
     HDassert(err_msg);
 
     /* Close the message if it is in the class being closed */
     if(err_msg->cls == cls) {
-        if(H5E_close_msg(err_msg) < 0)
-            HGOTO_ERROR(H5E_ERROR, H5E_CANTCLOSEOBJ, FAIL, "unable to close error message")
+        if(H5E__close_msg(err_msg) < 0)
+            HGOTO_ERROR(H5E_ERROR, H5E_CANTCLOSEOBJ, H5_ITER_ERROR, "unable to close error message")
         if(NULL == H5I_remove(obj_id))
-            HGOTO_ERROR(H5E_ERROR, H5E_CANTREMOVE, FAIL, "unable to remove error message")
+            HGOTO_ERROR(H5E_ERROR, H5E_CANTREMOVE, H5_ITER_ERROR, "unable to remove error message")
     } /* end if */
 
 done:
     FUNC_LEAVE_NOAPI(ret_value)
-} /* end H5E_close_msg_cb() */
+} /* end H5E__close_msg_cb() */
 
 
 /*-------------------------------------------------------------------------
- * Function:	H5Eclose_msg
+ * Function:    H5Eclose_msg
  *
- * Purpose:	Closes a major or minor error.
+ * Purpose:     Closes a major or minor error.
  *
- * Return:	Non-negative value on success/Negative on failure
+ * Return:      SUCCEED/FAIL
  *
  * Programmer:	Raymond Lu
  *              Friday, July 11, 2003
@@ -725,11 +726,11 @@ done:
 
 
 /*-------------------------------------------------------------------------
- * Function:	H5E_close_msg
+ * Function:    H5E__close_msg
  *
- * Purpose:	Private function to close an error messge.
+ * Purpose:     Private function to close an error messge.
  *
- * Return:	Non-negative value on success/Negative on failure
+ * Return:      SUCCEED/FAIL
  *
  * Programmer:	Raymond Lu
  *              Friday, July 11, 2003
@@ -737,9 +738,9 @@ done:
  *-------------------------------------------------------------------------
  */
 static herr_t
-H5E_close_msg(H5E_msg_t *err)
+H5E__close_msg(H5E_msg_t *err)
 {
-    FUNC_ENTER_NOAPI_NOINIT_NOERR
+    FUNC_ENTER_STATIC_NOERR
 
     /* Check arguments */
     HDassert(err);
@@ -750,15 +751,16 @@ H5E_close_msg(H5E_msg_t *err)
     err = H5FL_FREE(H5E_msg_t, err);
 
     FUNC_LEAVE_NOAPI(SUCCEED)
-} /* end H5E_close_msg() */
+} /* end H5E__close_msg() */
 
 
 /*-------------------------------------------------------------------------
- * Function:	H5Ecreate_msg
+ * Function:    H5Ecreate_msg
  *
- * Purpose:	Creates a major or minor error, returns an ID.
+ * Purpose:     Creates a major or minor error, returns an ID.
  *
- * Return:	Non-negative value on success/Negative on failure
+ * Return:      Success:    An error ID
+ *              Failure:    H5I_INVALID_HID
  *
  * Programmer:	Raymond Lu
  *              Friday, July 11, 2003
@@ -770,39 +772,40 @@ H5Ecreate_msg(hid_t class_id, H5E_type_t msg_type, const char *msg_str)
 {
     H5E_cls_t   *cls;           /* Pointer to error class */
     H5E_msg_t   *msg;           /* Pointer to new error message */
-    hid_t       ret_value;      /* Return value */
+    hid_t       ret_value = H5I_INVALID_HID;      /* Return value */
 
-    FUNC_ENTER_API(FAIL)
+    FUNC_ENTER_API(H5I_INVALID_HID)
     H5TRACE3("i", "iEt*s", class_id, msg_type, msg_str);
 
     /* Check arguments */
     if(msg_type != H5E_MAJOR && msg_type != H5E_MINOR)
-	HGOTO_ERROR(H5E_ARGS, H5E_BADVALUE, FAIL, "not a valid message type")
+        HGOTO_ERROR(H5E_ARGS, H5E_BADVALUE, H5I_INVALID_HID, "not a valid message type")
     if(msg_str == NULL)
-	HGOTO_ERROR(H5E_ARGS, H5E_BADVALUE, FAIL, "message is NULL")
+        HGOTO_ERROR(H5E_ARGS, H5E_BADVALUE, H5I_INVALID_HID, "message is NULL")
 
     /* Get the error class */
     if(NULL == (cls = (H5E_cls_t *)H5I_object_verify(class_id, H5I_ERROR_CLASS)))
-	HGOTO_ERROR(H5E_ARGS, H5E_BADTYPE, FAIL, "not a error class ID")
+        HGOTO_ERROR(H5E_ARGS, H5E_BADTYPE, H5I_INVALID_HID, "not an error class ID")
 
     /* Create the new error message object */
-    if(NULL == (msg = H5E_create_msg(cls, msg_type, msg_str)))
-	HGOTO_ERROR(H5E_ERROR, H5E_CANTCREATE, FAIL, "can't create error message")
+    if(NULL == (msg = H5E__create_msg(cls, msg_type, msg_str)))
+        HGOTO_ERROR(H5E_ERROR, H5E_CANTCREATE, H5I_INVALID_HID, "can't create error message")
 
     /* Register the new error class to get an ID for it */
     if((ret_value = H5I_register(H5I_ERROR_MSG, msg, TRUE)) < 0)
-        HGOTO_ERROR(H5E_ERROR, H5E_CANTREGISTER, FAIL, "can't register error message")
+        HGOTO_ERROR(H5E_ERROR, H5E_CANTREGISTER, H5I_INVALID_HID, "can't register error message")
 
 done:
     FUNC_LEAVE_API(ret_value)
 } /* end H5Ecreate_msg() */
 
 /*-------------------------------------------------------------------------
- * Function:	H5E_create_msg
+ * Function:    H5E__create_msg
  *
- * Purpose:	Private function to create a major or minor error.
+ * Purpose:     Private function to create a major or minor error.
  *
- * Return:	Non-negative value on success/Negative on failure
+ * Return:      Success:    Pointer to a message struct
+ *              Failure:    NULL
  *
  * Programmer:	Raymond Lu
  *              Friday, July 11, 2003
@@ -810,12 +813,12 @@ done:
  *-------------------------------------------------------------------------
  */
 static H5E_msg_t *
-H5E_create_msg(H5E_cls_t *cls, H5E_type_t msg_type, const char *msg_str)
+H5E__create_msg(H5E_cls_t *cls, H5E_type_t msg_type, const char *msg_str)
 {
     H5E_msg_t   *msg = NULL;            /* Pointer to new error message */
     H5E_msg_t   *ret_value = NULL;      /* Return value */
 
-    FUNC_ENTER_NOAPI_NOINIT
+    FUNC_ENTER_STATIC
 
     /* Check arguments */
     HDassert(cls);
@@ -837,20 +840,20 @@ H5E_create_msg(H5E_cls_t *cls, H5E_type_t msg_type, const char *msg_str)
 
 done:
     if(!ret_value)
-        if(msg && H5E_close_msg(msg) < 0)
+        if(msg && H5E__close_msg(msg) < 0)
             HDONE_ERROR(H5E_ERROR, H5E_CANTCLOSEOBJ, NULL, "unable to close error message")
 
     FUNC_LEAVE_NOAPI(ret_value)
-} /* end H5E_create_msg() */
+} /* end H5E__create_msg() */
 
 
 /*-------------------------------------------------------------------------
- * Function:	H5Eget_msg
+ * Function:    H5Eget_msg
  *
- * Purpose:	Retrieves an error message.
+ * Purpose:     Retrieves an error message.
  *
- * Return:      Non-negative for message length if succeeds(zero means no message);
- *              otherwise returns negative value.
+ * Return:      Success:    Message length (zero means no message)
+ *              Failure:    -1
  *
  * Programmer:	Raymond Lu
  *              Friday, July 14, 2003
@@ -861,18 +864,18 @@ ssize_t
 H5Eget_msg(hid_t msg_id, H5E_type_t *type, char *msg_str, size_t size)
 {
     H5E_msg_t   *msg;           /* Pointer to error message */
-    ssize_t      ret_value;     /* Return value */
+    ssize_t      ret_value = -1;     /* Return value */
 
-    FUNC_ENTER_API(FAIL)
+    FUNC_ENTER_API((-1))
     H5TRACE4("Zs", "i*Et*sz", msg_id, type, msg_str, size);
 
     /* Get the message object */
     if(NULL == (msg = (H5E_msg_t *)H5I_object_verify(msg_id, H5I_ERROR_MSG)))
-	HGOTO_ERROR(H5E_ARGS, H5E_BADTYPE, FAIL, "not a error message ID")
+        HGOTO_ERROR(H5E_ARGS, H5E_BADTYPE, (-1), "not a error message ID")
 
     /* Get the message's text */
-    if((ret_value = H5E_get_msg(msg, type, msg_str, size)) < 0)
-	HGOTO_ERROR(H5E_ERROR, H5E_CANTGET, FAIL, "can't get error message text")
+    if((ret_value = H5E__get_msg(msg, type, msg_str, size)) < 0)
+        HGOTO_ERROR(H5E_ERROR, H5E_CANTGET, (-1), "can't get error message text")
 
 done:
     FUNC_LEAVE_API(ret_value)
@@ -880,11 +883,12 @@ done:
 
 
 /*-------------------------------------------------------------------------
- * Function:	H5Ecreate_stack
+ * Function:    H5Ecreate_stack
  *
- * Purpose:	Creates a new, empty, error stack.
+ * Purpose:     Creates a new, empty, error stack.
  *
- * Return:	Non-negative value as stack ID on success/Negative on failure
+ * Return:      Success:    An error stack ID
+ *              Failure:    H5I_INVALID_HID
  *
  * Programmer:	Quincey Koziol
  *              Thursday, November 1, 2007
@@ -895,21 +899,21 @@ hid_t
 H5Ecreate_stack(void)
 {
     H5E_t	*stk;           /* Error stack */
-    hid_t       ret_value;      /* Return value */
+    hid_t       ret_value = H5I_INVALID_HID;      /* Return value */
 
-    FUNC_ENTER_API(FAIL)
+    FUNC_ENTER_API(H5I_INVALID_HID)
     H5TRACE0("i","");
 
     /* Allocate a new error stack */
     if(NULL == (stk = H5FL_CALLOC(H5E_t)))
-        HGOTO_ERROR(H5E_RESOURCE, H5E_NOSPACE, FAIL, "memory allocation failed")
+        HGOTO_ERROR(H5E_RESOURCE, H5E_NOSPACE, H5I_INVALID_HID, "memory allocation failed")
 
     /* Set the "automatic" error reporting info to the library default */
-    H5E_set_default_auto(stk);
+    H5E__set_default_auto(stk);
 
     /* Register the stack */
     if((ret_value = H5I_register(H5I_ERROR_STACK, stk, TRUE)) < 0)
-	HGOTO_ERROR(H5E_ERROR, H5E_CANTREGISTER, FAIL, "can't create error stack")
+        HGOTO_ERROR(H5E_ERROR, H5E_CANTREGISTER, H5I_INVALID_HID, "can't create error stack")
 
 done:
     FUNC_LEAVE_API(ret_value)
@@ -917,12 +921,13 @@ done:
 
 
 /*-------------------------------------------------------------------------
- * Function:	H5Eget_current_stack
+ * Function:    H5Eget_current_stack
  *
- * Purpose:	Registers current error stack, returns object handle for it,
+ * Purpose:     Registers current error stack, returns object handle for it,
  *              clears it.
  *
- * Return:	Non-negative value as stack ID on success/Negative on failure
+ * Return:      Success:    An error stack ID
+ *              Failure:    H5I_INVALID_HID
  *
  * Programmer:	Raymond Lu
  *              Friday, July 14, 2003
@@ -933,19 +938,19 @@ hid_t
 H5Eget_current_stack(void)
 {
     H5E_t	*stk;           /* Error stack */
-    hid_t       ret_value;   /* Return value */
+    hid_t       ret_value = H5I_INVALID_HID;   /* Return value */
 
     /* Don't clear the error stack! :-) */
-    FUNC_ENTER_API_NOCLEAR(FAIL)
+    FUNC_ENTER_API_NOCLEAR(H5I_INVALID_HID)
     H5TRACE0("i","");
 
     /* Get the current stack */
-    if(NULL == (stk = H5E_get_current_stack()))
-	HGOTO_ERROR(H5E_ERROR, H5E_CANTCREATE, FAIL, "can't create error stack")
+    if(NULL == (stk = H5E__get_current_stack()))
+        HGOTO_ERROR(H5E_ERROR, H5E_CANTCREATE, H5I_INVALID_HID, "can't create error stack")
 
     /* Register the stack */
     if((ret_value = H5I_register(H5I_ERROR_STACK, stk, TRUE)) < 0)
-	HGOTO_ERROR(H5E_ERROR, H5E_CANTREGISTER, FAIL, "can't create error stack")
+        HGOTO_ERROR(H5E_ERROR, H5E_CANTREGISTER, H5I_INVALID_HID, "can't create error stack")
 
 done:
     FUNC_LEAVE_API(ret_value)
@@ -953,11 +958,12 @@ done:
 
 
 /*-------------------------------------------------------------------------
- * Function:	H5E_get_current_stack
+ * Function:    H5E__get_current_stack
  *
- * Purpose:	Private function to register an error stack.
+ * Purpose:     Private function to register an error stack.
  *
- * Return:	Non-negative value as class ID on success/Negative on failure
+ * Return:      Success:    Pointer to an error class struct
+ *              Failure:    NULL
  *
  * Programmer:	Raymond Lu
  *              Friday, July 11, 2003
@@ -965,17 +971,17 @@ done:
  *-------------------------------------------------------------------------
  */
 static H5E_t *
-H5E_get_current_stack(void)
+H5E__get_current_stack(void)
 {
     H5E_t	*current_stack;         /* Pointer to the current error stack */
     H5E_t	*estack_copy = NULL;    /* Pointer to new error stack to return */
     unsigned    u;                      /* Local index variable */
     H5E_t      *ret_value = NULL;       /* Return value */
 
-    FUNC_ENTER_NOAPI_NOINIT
+    FUNC_ENTER_STATIC
 
     /* Get a pointer to the current error stack */
-    if(NULL == (current_stack = H5E_get_my_stack())) /*lint !e506 !e774 Make lint 'constant value Boolean' in non-threaded case */
+    if(NULL == (current_stack = H5E__get_my_stack())) /*lint !e506 !e774 Make lint 'constant value Boolean' in non-threaded case */
 	HGOTO_ERROR(H5E_ERROR, H5E_CANTGET, NULL, "can't get current error stack")
 
     /* Allocate a new error stack */
@@ -1026,24 +1032,19 @@ done:
             estack_copy = H5FL_FREE(H5E_t, estack_copy);
 
     FUNC_LEAVE_NOAPI(ret_value)
-} /* end H5E_get_current_stack() */
+} /* end H5E__get_current_stack() */
 
 
 /*-------------------------------------------------------------------------
- * Function:	H5Eset_current_stack
+ * Function:    H5Eset_current_stack
  *
- * Purpose:     Replaces current stack with specified stack.  This closes the
- *		stack ID also.
+ * Purpose:     Replaces current stack with specified stack. This closes the
+ *              stack ID also.
  *
- * Return:	Non-negative value on success/Negative on failure
+ * Return:      SUCCEED/FAIL
  *
  * Programmer:	Raymond Lu
  *              Friday, July 15, 2003
- *
- * Modification:
- *              Raymond Lu
- *              7 September 2010
- *              Also closes the stack to avoid potential problem (bug 1799)
  * 
  *-------------------------------------------------------------------------
  */
@@ -1061,7 +1062,7 @@ H5Eset_current_stack(hid_t err_stack)
             HGOTO_ERROR(H5E_ARGS, H5E_BADTYPE, FAIL, "not a error stack ID")
 
         /* Set the current error stack */
-        if(H5E_set_current_stack(estack) < 0)
+        if(H5E__set_current_stack(estack) < 0)
             HGOTO_ERROR(H5E_ERROR, H5E_CANTSET, FAIL, "unable to set error stack")
 
         /*
@@ -1078,11 +1079,11 @@ done:
 
 
 /*-------------------------------------------------------------------------
- * Function:	H5E_set_current_stack
+ * Function:    H5E__set_current_stack
  *
- * Purpose:	Private function to replace an error stack.
+ * Purpose:     Private function to replace an error stack.
  *
- * Return:	Non-negative value on success/Negative on failure
+ * Return:      SUCCEED/FAIL
  *
  * Programmer:	Raymond Lu
  *              Friday, July 15, 2003
@@ -1090,19 +1091,19 @@ done:
  *-------------------------------------------------------------------------
  */
 static herr_t
-H5E_set_current_stack(H5E_t *estack)
+H5E__set_current_stack(H5E_t *estack)
 {
     H5E_t	*current_stack;         /* Default error stack */
     unsigned     u;                     /* Local index variable */
     herr_t       ret_value = SUCCEED;   /* Return value */
 
-    FUNC_ENTER_NOAPI_NOINIT
+    FUNC_ENTER_STATIC
 
     /* Sanity check */
     HDassert(estack);
 
     /* Get a pointer to the current error stack */
-    if(NULL == (current_stack = H5E_get_my_stack ())) /*lint !e506 !e774 Make lint 'constant value Boolean' in non-threaded case */
+    if(NULL == (current_stack = H5E__get_my_stack ())) /*lint !e506 !e774 Make lint 'constant value Boolean' in non-threaded case */
 	HGOTO_ERROR(H5E_ERROR, H5E_CANTGET, FAIL, "can't get current error stack")
 
     /* Empty current error stack */
@@ -1138,15 +1139,15 @@ H5E_set_current_stack(H5E_t *estack)
 
 done:
     FUNC_LEAVE_NOAPI(ret_value)
-} /* end H5E_set_current_stack() */
+} /* end H5E__set_current_stack() */
 
 
 /*-------------------------------------------------------------------------
- * Function:	H5Eclose_stack
+ * Function:    H5Eclose_stack
  *
- * Purpose:	Closes an error stack.
+ * Purpose:     Closes an error stack.
  *
- * Return:	Non-negative value on success/Negative on failure
+ * Return:      SUCCEED/FAIL
  *
  * Programmer:	Raymond Lu
  *              Friday, July 14, 2003
@@ -1180,11 +1181,11 @@ done:
 
 
 /*-------------------------------------------------------------------------
- * Function:	H5E_close_stack
+ * Function:    H5E__close_stack
  *
- * Purpose:	Private function to close an error stack.
+ * Purpose:     Private function to close an error stack.
  *
- * Return:	Non-negative value on success/Negative on failure
+ * Return:      SUCCEED/FAIL
  *
  * Programmer:	Raymond Lu
  *              Friday, July 14, 2003
@@ -1192,9 +1193,9 @@ done:
  *-------------------------------------------------------------------------
  */
 static herr_t
-H5E_close_stack(H5E_t *estack)
+H5E__close_stack(H5E_t *estack)
 {
-    FUNC_ENTER_NOAPI_NOINIT_NOERR
+    FUNC_ENTER_STATIC_NOERR
 
     /* Sanity check */
     HDassert(estack);
@@ -1206,15 +1207,16 @@ H5E_close_stack(H5E_t *estack)
     estack = H5FL_FREE(H5E_t, estack);
 
     FUNC_LEAVE_NOAPI(SUCCEED)
-} /* end H5E_close_stack() */
+} /* end H5E__close_stack() */
 
 
 /*-------------------------------------------------------------------------
- * Function:	H5Eget_num
+ * Function:    H5Eget_num
  *
- * Purpose:	Retrieves the number of error message.
+ * Purpose:     Retrieves the number of error messages.
  *
- * Return:	Non-negative value on success/Negative on failure
+ * Return:      Success:    The number of errors
+ *              Failure:    -1
  *
  * Programmer:	Raymond Lu
  *              Friday, July 15, 2003
@@ -1228,13 +1230,13 @@ H5Eget_num(hid_t error_stack_id)
     ssize_t ret_value;      /* Return value */
 
     /* Don't clear the error stack! :-) */
-    FUNC_ENTER_API_NOCLEAR(FAIL)
+    FUNC_ENTER_API_NOCLEAR((-1))
     H5TRACE1("Zs", "i", error_stack_id);
 
     /* Need to check for errors */
     if(error_stack_id == H5E_DEFAULT) {
-    	if(NULL == (estack = H5E_get_my_stack())) /*lint !e506 !e774 Make lint 'constant value Boolean' in non-threaded case */
-            HGOTO_ERROR(H5E_ERROR, H5E_CANTGET, FAIL, "can't get current error stack")
+    	if(NULL == (estack = H5E__get_my_stack())) /*lint !e506 !e774 Make lint 'constant value Boolean' in non-threaded case */
+            HGOTO_ERROR(H5E_ERROR, H5E_CANTGET, (-1), "can't get current error stack")
     } /* end if */
     else {
         /* Only clear the error stack if it's not the default stack */
@@ -1242,12 +1244,12 @@ H5Eget_num(hid_t error_stack_id)
 
         /* Get the error stack to operate on */
         if(NULL == (estack = (H5E_t *)H5I_object_verify(error_stack_id, H5I_ERROR_STACK)))
-            HGOTO_ERROR(H5E_ARGS, H5E_BADTYPE, FAIL, "not a error stack ID")
+            HGOTO_ERROR(H5E_ARGS, H5E_BADTYPE, (-1), "not an error stack ID")
     } /* end else */
 
     /* Get the number of errors on stack */
-    if((ret_value = H5E_get_num(estack)) < 0)
-        HGOTO_ERROR(H5E_ERROR, H5E_CANTGET, FAIL, "can't get number of errors")
+    if((ret_value = H5E__get_num(estack)) < 0)
+        HGOTO_ERROR(H5E_ERROR, H5E_CANTGET, (-1), "can't get number of errors")
 
 done:
     FUNC_LEAVE_API(ret_value)
@@ -1255,11 +1257,12 @@ done:
 
 
 /*-------------------------------------------------------------------------
- * Function:	H5E_get_num
+ * Function:    H5E__get_num
  *
- * Purpose:	Private function to retrieve number of errors in error stack.
+ * Purpose:     Private function to retrieve number of errors in error stack.
  *
- * Return:	Non-negative value on success/Negative on failure
+ * Return:      Success:    The number of errors
+ *              Failure:    -1 (can't fail at this time)
  *
  * Programmer:	Raymond Lu
  *              Friday, July 15, 2003
@@ -1267,22 +1270,22 @@ done:
  *-------------------------------------------------------------------------
  */
 static ssize_t
-H5E_get_num(const H5E_t *estack)
+H5E__get_num(const H5E_t *estack)
 {
-    FUNC_ENTER_NOAPI_NOINIT_NOERR
+    FUNC_ENTER_STATIC_NOERR
 
     HDassert(estack);
 
     FUNC_LEAVE_NOAPI((ssize_t)estack->nused)
-} /* end H5E_get_num() */
+} /* end H5E__get_num() */
 
 
 /*-------------------------------------------------------------------------
- * Function:	H5Epop
+ * Function:    H5Epop
  *
- * Purpose:	Deletes some error messages from the top of error stack.
+ * Purpose:     Deletes some error messages from the top of error stack.
  *
- * Return:	Non-negative value on success/Negative on failure
+ * Return:      SUCCEED/FAIL
  *
  * Programmer:	Raymond Lu
  *              Friday, July 16, 2003
@@ -1301,7 +1304,7 @@ H5Epop(hid_t err_stack, size_t count)
 
     /* Need to check for errors */
     if(err_stack == H5E_DEFAULT) {
-    	if(NULL == (estack = H5E_get_my_stack())) /*lint !e506 !e774 Make lint 'constant value Boolean' in non-threaded case */
+    	if(NULL == (estack = H5E__get_my_stack())) /*lint !e506 !e774 Make lint 'constant value Boolean' in non-threaded case */
             HGOTO_ERROR(H5E_ERROR, H5E_CANTGET, FAIL, "can't get current error stack")
     } /* end if */
     else {
@@ -1318,7 +1321,7 @@ H5Epop(hid_t err_stack, size_t count)
         count = estack->nused;
 
     /* Pop the errors off the stack */
-    if(H5E_pop(estack, count) < 0)
+    if(H5E__pop(estack, count) < 0)
         HGOTO_ERROR(H5E_ERROR, H5E_CANTRELEASE, FAIL, "can't pop errors from stack")
 
 done:
@@ -1327,22 +1330,22 @@ done:
 
 
 /*-------------------------------------------------------------------------
- * Function:	H5Epush2
+ * Function:    H5Epush2
  *
- * Purpose:	Pushes a new error record onto error stack for the current
- *		thread.  The error has major and minor IDs MAJ_ID and
- *		MIN_ID, the name of a function where the error was detected,
- *		the name of the file where the error was detected, the
- *		line within that file, and an error description string.  The
- *		function name, file name, and error description strings must
- *		be statically allocated.
+ * Purpose:     Pushes a new error record onto error stack for the current
+ *              thread. The error has major and minor IDs MAJ_ID and
+ *              MIN_ID, the name of a function where the error was detected,
+ *              the name of the file where the error was detected, the
+ *              line within that file, and an error description string.  The
+ *              function name, file name, and error description strings must
+ *              be statically allocated.
  *
- * Return:	Non-negative on success/Negative on failure
+ * Return:      SUCCEED/FAIL
  *
  * Programmer:	Quincey Koziol
  *		Monday, October 18, 1999
  *
- * Notes: 	Basically a new public API wrapper around the H5E__push_stack
+ * Notes:       Basically a new public API wrapper around the H5E__push_stack
  *              function.
  *
  *-------------------------------------------------------------------------
@@ -1435,11 +1438,11 @@ done:
 
 
 /*-------------------------------------------------------------------------
- * Function:	H5Eclear2
+ * Function:    H5Eclear2
  *
- * Purpose:	Clears the error stack for the specified error stack.
+ * Purpose:     Clears the error stack for the specified error stack.
  *
- * Return:	Non-negative on success/Negative on failure
+ * Return:      SUCCEED/FAIL
  *
  * Programmer:	Raymond Lu
  *              Wednesday, July 16, 2003
@@ -1477,14 +1480,14 @@ done:
 
 
 /*-------------------------------------------------------------------------
- * Function:	H5Eprint2
+ * Function:    H5Eprint2
  *
- * Purpose:	Prints the error stack in some default way.  This is just a
- *		convenience function for H5Ewalk() with a function that
- *		prints error messages.  Users are encouraged to write there
- *		own more specific error handlers.
+ * Purpose:     Prints the error stack in some default way. This is just a
+ *              convenience function for H5Ewalk() with a function that
+ *              prints error messages. Users are encouraged to write there
+ *              own more specific error handlers.
  *
- * Return:	Non-negative on success/Negative on failure
+ * Return:      SUCCEED/FAIL
  *
  * Programmer:	Robb Matzke
  *              Friday, February 27, 1998
@@ -1503,7 +1506,7 @@ H5Eprint2(hid_t err_stack, FILE *stream)
 
     /* Need to check for errors */
     if(err_stack == H5E_DEFAULT) {
-    	if(NULL == (estack = H5E_get_my_stack())) /*lint !e506 !e774 Make lint 'constant value Boolean' in non-threaded case */
+    	if(NULL == (estack = H5E__get_my_stack())) /*lint !e506 !e774 Make lint 'constant value Boolean' in non-threaded case */
             HGOTO_ERROR(H5E_ERROR, H5E_CANTGET, FAIL, "can't get current error stack")
     } /* end if */
     else {
@@ -1515,7 +1518,7 @@ H5Eprint2(hid_t err_stack, FILE *stream)
     } /* end else */
 
     /* Print error stack */
-    if(H5E_print(estack, stream, FALSE) < 0)
+    if(H5E__print(estack, stream, FALSE) < 0)
         HGOTO_ERROR(H5E_ERROR, H5E_CANTLIST, FAIL, "can't display error stack")
 
 done:
@@ -1524,12 +1527,12 @@ done:
 
 
 /*-------------------------------------------------------------------------
- * Function:	H5Ewalk2
+ * Function:    H5Ewalk2
  *
- * Purpose:	Walks the error stack for the current thread and calls some
- *		function for each error along the way.
+ * Purpose:     Walks the error stack for the current thread and calls some
+ *              function for each error along the way.
  *
- * Return:	Non-negative on success/Negative on failure
+ * Return:      SUCCEED/FAIL
  *
  * Programmer:	Robb Matzke
  *              Friday, February 27, 1998
@@ -1549,7 +1552,7 @@ H5Ewalk2(hid_t err_stack, H5E_direction_t direction, H5E_walk2_t stack_func, voi
 
     /* Need to check for errors */
     if(err_stack == H5E_DEFAULT) {
-    	if(NULL == (estack = H5E_get_my_stack())) /*lint !e506 !e774 Make lint 'constant value Boolean' in non-threaded case */
+    	if(NULL == (estack = H5E__get_my_stack())) /*lint !e506 !e774 Make lint 'constant value Boolean' in non-threaded case */
             HGOTO_ERROR(H5E_ERROR, H5E_CANTGET, FAIL, "can't get current error stack")
     } /* end if */
     else {
@@ -1563,7 +1566,7 @@ H5Ewalk2(hid_t err_stack, H5E_direction_t direction, H5E_walk2_t stack_func, voi
     /* Walk the error stack */
     op.vers = 2;
     op.u.func2 = stack_func;
-    if(H5E_walk(estack, direction, &op, client_data) < 0)
+    if(H5E__walk(estack, direction, &op, client_data) < 0)
         HGOTO_ERROR(H5E_ERROR, H5E_CANTLIST, FAIL, "can't walk error stack")
 
 done:
@@ -1572,23 +1575,18 @@ done:
 
 
 /*-------------------------------------------------------------------------
- * Function:	H5Eget_auto2
+ * Function:    H5Eget_auto2
  *
- * Purpose:	Returns the current settings for the automatic error stack
- *		traversal function and its data for specific error stack.
- *		Either (or both) arguments may be null in which case the
- *		value is not returned.
+ * Purpose:     Returns the current settings for the automatic error stack
+ *              traversal function and its data for specific error stack.
+ *              Either (or both) arguments may be null in which case the
+ *              value is not returned.
  *
- * Return:	Non-negative on success/Negative on failure
+ * Return:      SUCCEED/FAIL
  *
  * Programmer:	Robb Matzke
  *              Saturday, February 28, 1998
  *
- * Modification:Raymond Lu
- *              4 October 2010
- *              If the printing function isn't the default H5Eprint1 or 2, 
- *              and H5Eset_auto1 has been called to set the old style 
- *              printing function, a call to H5Eget_auto2 should fail.
  *-------------------------------------------------------------------------
  */
 herr_t
@@ -1602,7 +1600,7 @@ H5Eget_auto2(hid_t estack_id, H5E_auto2_t *func, void **client_data)
     H5TRACE3("e", "i*x**x", estack_id, func, client_data);
 
     if(estack_id == H5E_DEFAULT) {
-    	if(NULL == (estack = H5E_get_my_stack())) /*lint !e506 !e774 Make lint 'constant value Boolean' in non-threaded case */
+    	if(NULL == (estack = H5E__get_my_stack())) /*lint !e506 !e774 Make lint 'constant value Boolean' in non-threaded case */
             HGOTO_ERROR(H5E_ERROR, H5E_CANTGET, FAIL, "can't get current error stack")
     } /* end if */
     else
@@ -1610,7 +1608,7 @@ H5Eget_auto2(hid_t estack_id, H5E_auto2_t *func, void **client_data)
             HGOTO_ERROR(H5E_ARGS, H5E_BADTYPE, FAIL, "not a error stack ID")
 
     /* Get the automatic error reporting information */
-    if(H5E_get_auto(estack, &op, client_data) < 0)
+    if(H5E__get_auto(estack, &op, client_data) < 0)
         HGOTO_ERROR(H5E_ERROR, H5E_CANTGET, FAIL, "can't get automatic error info")
 
 #ifndef H5_NO_DEPRECATED_SYMBOLS
@@ -1628,28 +1626,25 @@ done:
 
 
 /*-------------------------------------------------------------------------
- * Function:	H5Eset_auto2
+ * Function:    H5Eset_auto2
  *
- * Purpose:	Turns on or off automatic printing of errors for certain
+ * Purpose:     Turns on or off automatic printing of errors for certain
  *              error stack.  When turned on (non-null FUNC pointer) any
  *              API function which returns an error indication will first
  *              call FUNC passing it CLIENT_DATA as an argument.
  *
- *		The default values before this function is called are
- *		H5Eprint2() with client data being the standard error stream,
- *		stderr.
+ *              The default values before this function is called are
+ *              H5Eprint2() with client data being the standard error stream,
+ *              stderr.
  *
- *		Automatic stack traversal is always in the H5E_WALK_DOWNWARD
- *		direction.
+ *              Automatic stack traversal is always in the H5E_WALK_DOWNWARD
+ *              direction.
  *
- * Return:	Non-negative on success/Negative on failure
+ * Return:      SUCCEED/FAIL
  *
  * Programmer:	Robb Matzke
  *              Friday, February 27, 1998
  *
- * Modification:Raymond Lu
- *              4 October 2010
- *              If the FUNC is H5Eprint2, put the IS_DEFAULT flag on.
  *-------------------------------------------------------------------------
  */
 herr_t
@@ -1664,7 +1659,7 @@ H5Eset_auto2(hid_t estack_id, H5E_auto2_t func, void *client_data)
     H5TRACE3("e", "ix*x", estack_id, func, client_data);
 
     if(estack_id == H5E_DEFAULT) {
-    	if(NULL == (estack = H5E_get_my_stack())) /*lint !e506 !e774 Make lint 'constant value Boolean' in non-threaded case */
+    	if(NULL == (estack = H5E__get_my_stack())) /*lint !e506 !e774 Make lint 'constant value Boolean' in non-threaded case */
             HGOTO_ERROR(H5E_ERROR, H5E_CANTGET, FAIL, "can't get current error stack")
     } /* end if */
     else
@@ -1673,7 +1668,7 @@ H5Eset_auto2(hid_t estack_id, H5E_auto2_t func, void *client_data)
 
 #ifndef H5_NO_DEPRECATED_SYMBOLS
     /* Get the automatic error reporting information */
-    if(H5E_get_auto(estack, &op, NULL) < 0)
+    if(H5E__get_auto(estack, &op, NULL) < 0)
         HGOTO_ERROR(H5E_ERROR, H5E_CANTGET, FAIL, "can't get automatic error info")
 
     /* Set the automatic error reporting information */
@@ -1688,7 +1683,7 @@ H5Eset_auto2(hid_t estack_id, H5E_auto2_t func, void *client_data)
     /* Set the automatic error reporting function */
     op.func2 = func;
 
-    if(H5E_set_auto(estack, &op, client_data) < 0)
+    if(H5E__set_auto(estack, &op, client_data) < 0)
         HGOTO_ERROR(H5E_ERROR, H5E_CANTSET, FAIL, "can't set automatic error info")
 
 done:
@@ -1697,14 +1692,14 @@ done:
 
 
 /*-------------------------------------------------------------------------
- * Function:	H5Eauto_is_v2
+ * Function:    H5Eauto_is_v2
  *
- * Purpose:	Determines if the error auto reporting function for an
+ * Purpose:     Determines if the error auto reporting function for an
  *              error stack conforms to the H5E_auto_stack_t typedef
  *              or the H5E_auto_t typedef.  The IS_STACK parameter is set
  *              to 1 for the first case and 0 for the latter case.
  *
- * Return:	Non-negative on success/Negative on failure
+ * Return:      SUCCEED/FAIL
  *
  * Programmer:	Quincey Koziol
  *              Wednesday, September  8, 2004
@@ -1721,7 +1716,7 @@ H5Eauto_is_v2(hid_t estack_id, unsigned *is_stack)
     H5TRACE2("e", "i*Iu", estack_id, is_stack);
 
     if(estack_id == H5E_DEFAULT) {
-    	if(NULL == (estack = H5E_get_my_stack())) /*lint !e506 !e774 Make lint 'constant value Boolean' in non-threaded case */
+    	if(NULL == (estack = H5E__get_my_stack())) /*lint !e506 !e774 Make lint 'constant value Boolean' in non-threaded case */
             HGOTO_ERROR(H5E_ERROR, H5E_CANTGET, FAIL, "can't get current error stack")
     } /* end if */
     else
diff --git a/src/H5Edeprec.c b/src/H5Edeprec.c
index fc3eb9c..603d448 100644
--- a/src/H5Edeprec.c
+++ b/src/H5Edeprec.c
@@ -35,11 +35,11 @@
 /***********/
 /* Headers */
 /***********/
-#include "H5private.h"		/* Generic Functions			*/
-#include "H5Iprivate.h"		/* IDs                                  */
-#include "H5Epkg.h"		/* Error handling		  	*/
-#include "H5FLprivate.h"	/* Free lists                           */
-#include "H5MMprivate.h"	/* Memory management			*/
+#include "H5private.h"          /* Generic Functions                        */
+#include "H5CXprivate.h"        /* API Contexts                             */
+#include "H5Epkg.h"             /* Error handling                           */
+#include "H5Iprivate.h"         /* IDs                                      */
+#include "H5MMprivate.h"        /* Memory management                        */
 
 
 /****************/
@@ -80,12 +80,12 @@
 #ifndef H5_NO_DEPRECATED_SYMBOLS
 
 /*-------------------------------------------------------------------------
- * Function:	H5Eget_major
+ * Function:    H5Eget_major
  *
- * Purpose:	Retrieves a major error message.
+ * Purpose:     Retrieves a major error message.
  *
- * Return:      Returns message if succeeds.
- *              otherwise returns NULL.
+ * Return:      Success:    Pointer to the message
+ *              Failure:    NULL
  *
  * Programmer:	Raymond Lu
  *              Friday, July 14, 2003
@@ -106,21 +106,21 @@ H5Eget_major(H5E_major_t maj)
 
     /* Get the message object */
     if(NULL == (msg = (H5E_msg_t *)H5I_object_verify(maj, H5I_ERROR_MSG)))
-	HGOTO_ERROR(H5E_ARGS, H5E_BADTYPE, NULL, "not a error message ID")
+        HGOTO_ERROR(H5E_ARGS, H5E_BADTYPE, NULL, "not a error message ID")
 
     /* Get the size & type of the message's text */
-    if((size = H5E_get_msg(msg, &type, NULL, (size_t)0)) < 0)
-	HGOTO_ERROR(H5E_ERROR, H5E_CANTGET, NULL, "can't get error message text")
+    if((size = H5E__get_msg(msg, &type, NULL, (size_t)0)) < 0)
+        HGOTO_ERROR(H5E_ERROR, H5E_CANTGET, NULL, "can't get error message text")
     if(type != H5E_MAJOR)
-	HGOTO_ERROR(H5E_ERROR, H5E_CANTGET, NULL, "Error message isn't a major one")
+        HGOTO_ERROR(H5E_ERROR, H5E_CANTGET, NULL, "Error message isn't a major one")
 
     /* Application will free this */
     size++;
     msg_str = (char *)H5MM_malloc((size_t)size);
 
     /* Get the text for the message */
-    if(H5E_get_msg(msg, NULL, msg_str, (size_t)size) < 0)
-	HGOTO_ERROR(H5E_ERROR, H5E_CANTGET, NULL, "can't get error message text")
+    if(H5E__get_msg(msg, NULL, msg_str, (size_t)size) < 0)
+        HGOTO_ERROR(H5E_ERROR, H5E_CANTGET, NULL, "can't get error message text")
 
     ret_value = msg_str;
 
@@ -133,12 +133,12 @@ done:
 
 
 /*-------------------------------------------------------------------------
- * Function:	H5Eget_minor
+ * Function:    H5Eget_minor
  *
- * Purpose:	Retrieves a minor error message.
+ * Purpose:     Retrieves a minor error message.
  *
- * Return:      Returns message if succeeds.
- *              otherwise returns NULL.
+ * Return:      Success:    Pointer to the message
+ *              Failure:    NULL
  *
  * Programmer:	Raymond Lu
  *              Friday, July 14, 2003
@@ -159,21 +159,21 @@ H5Eget_minor(H5E_minor_t min)
 
     /* Get the message object */
     if(NULL == (msg = (H5E_msg_t *)H5I_object_verify(min, H5I_ERROR_MSG)))
-	HGOTO_ERROR(H5E_ARGS, H5E_BADTYPE, NULL, "not a error message ID")
+        HGOTO_ERROR(H5E_ARGS, H5E_BADTYPE, NULL, "not a error message ID")
 
     /* Get the size & type of the message's text */
-    if((size = H5E_get_msg(msg, &type, NULL, (size_t)0)) < 0)
-	HGOTO_ERROR(H5E_ERROR, H5E_CANTGET, NULL, "can't get error message text")
+    if((size = H5E__get_msg(msg, &type, NULL, (size_t)0)) < 0)
+        HGOTO_ERROR(H5E_ERROR, H5E_CANTGET, NULL, "can't get error message text")
     if(type != H5E_MINOR)
-	HGOTO_ERROR(H5E_ERROR, H5E_CANTGET, NULL, "Error message isn't a minor one")
+        HGOTO_ERROR(H5E_ERROR, H5E_CANTGET, NULL, "Error message isn't a minor one")
 
     /* Application will free this */
     size++;
     msg_str = (char *)H5MM_malloc((size_t)size);
 
     /* Get the text for the message */
-    if(H5E_get_msg(msg, NULL, msg_str, (size_t)size) < 0)
-	HGOTO_ERROR(H5E_ERROR, H5E_CANTGET, NULL, "can't get error message text")
+    if(H5E__get_msg(msg, NULL, msg_str, (size_t)size) < 0)
+        HGOTO_ERROR(H5E_ERROR, H5E_CANTGET, NULL, "can't get error message text")
 
     ret_value = msg_str;
 
@@ -186,19 +186,19 @@ done:
 
 
 /*-------------------------------------------------------------------------
- * Function:	H5Epush1
+ * Function:    H5Epush1
  *
- * Purpose:	This function definition is for backward compatibility only.
+ * Purpose:     This function definition is for backward compatibility only.
  *              It doesn't have error stack and error class as parameters.
  *              The old definition of major and minor is casted as HID_T
  *              in H5Epublic.h
  *
- * Notes: 	Basically a public API wrapper around the H5E_push2
+ * Notes:       Basically a public API wrapper around the H5E_push2
  *              function.  For backward compatibility, it maintains the
  *              same parameter as the old function, in contrary to
  *              H5Epush2.
  *
- * Return:	Non-negative on success/Negative on failure
+ * Return:      SUCCEED/FAIL
  *
  * Programmer:	Raymond Lu
  *		Tuesday, Sep 16, 2003
@@ -225,12 +225,12 @@ done:
 
 
 /*-------------------------------------------------------------------------
- * Function:	H5Eclear1
+ * Function:    H5Eclear1
  *
- * Purpose:	This function is for backward compatibility.
+ * Purpose:     This function is for backward compatbility.
  *              Clears the error stack for the specified error stack.
  *
- * Return:	Non-negative on success/Negative on failure
+ * Return:      SUCCEED/FAIL
  *
  * Programmer:	Raymond Lu
  *              Wednesday, July 16, 2003
@@ -256,15 +256,15 @@ done:
 
 
 /*-------------------------------------------------------------------------
- * Function:	H5Eprint1
+ * Function:    H5Eprint1
  *
- * Purpose:	This function is for backward compatibility.
+ * Purpose:     This function is for backward compatbility.
  *              Prints the error stack in some default way.  This is just a
- *		convenience function for H5Ewalk() with a function that
- *		prints error messages.  Users are encouraged to write there
- *		own more specific error handlers.
+ *              convenience function for H5Ewalk() with a function that
+ *              prints error messages.  Users are encouraged to write there
+ *              own more specific error handlers.
  *
- * Return:	Non-negative on success/Negative on failure
+ * Return:      SUCCEED/FAIL
  *
  * Programmer:	Raymond Lu
  *              Sep 16, 2003
@@ -281,11 +281,11 @@ H5Eprint1(FILE *stream)
     FUNC_ENTER_API_NOCLEAR(FAIL)
     /*NO TRACE*/
 
-    if(NULL == (estack = H5E_get_my_stack())) /*lint !e506 !e774 Make lint 'constant value Boolean' in non-threaded case */
+    if(NULL == (estack = H5E__get_my_stack())) /*lint !e506 !e774 Make lint 'constant value Boolean' in non-threaded case */
         HGOTO_ERROR(H5E_ERROR, H5E_CANTGET, FAIL, "can't get current error stack")
 
     /* Print error stack */
-    if(H5E_print(estack, stream, TRUE) < 0)
+    if(H5E__print(estack, stream, TRUE) < 0)
         HGOTO_ERROR(H5E_ERROR, H5E_CANTLIST, FAIL, "can't display error stack")
 
 done:
@@ -294,13 +294,13 @@ done:
 
 
 /*-------------------------------------------------------------------------
- * Function:	H5Ewalk1
+ * Function:    H5Ewalk1
  *
- * Purpose:	This function is for backward compatibility.
+ * Purpose:     This function is for backward compatbility.
  *              Walks the error stack for the current thread and calls some
- *		function for each error along the way.
+ *              function for each error along the way.
  *
- * Return:	Non-negative on success/Negative on failure
+ * Return:      SUCCEED/FAIL
  *
  * Programmer:	Raymond Lu
  *              Sep 16, 2003
@@ -318,13 +318,13 @@ H5Ewalk1(H5E_direction_t direction, H5E_walk1_t func, void *client_data)
     FUNC_ENTER_API_NOCLEAR(FAIL)
     /*NO TRACE*/
 
-    if(NULL == (estack = H5E_get_my_stack())) /*lint !e506 !e774 Make lint 'constant value Boolean' in non-threaded case */
+    if(NULL == (estack = H5E__get_my_stack())) /*lint !e506 !e774 Make lint 'constant value Boolean' in non-threaded case */
         HGOTO_ERROR(H5E_ERROR, H5E_CANTGET, FAIL, "can't get current error stack")
 
     /* Walk the error stack */
     walk_op.vers = 1;
     walk_op.u.func1 = func;
-    if(H5E_walk(estack, direction, &walk_op, client_data) < 0)
+    if(H5E__walk(estack, direction, &walk_op, client_data) < 0)
         HGOTO_ERROR(H5E_ERROR, H5E_CANTLIST, FAIL, "can't walk error stack")
 
 done:
@@ -333,24 +333,19 @@ done:
 
 
 /*-------------------------------------------------------------------------
- * Function:	H5Eget_auto1
+ * Function:    H5Eget_auto1
  *
- * Purpose:	This function is for backward compatibility.
+ * Purpose:     This function is for backward compatbility.
  *              Returns the current settings for the automatic error stack
- *		traversal function and its data for specific error stack.
- *		Either (or both) arguments may be null in which case the
- *		value is not returned.
+ *              traversal function and its data for specific error stack.
+ *              Either (or both) arguments may be null in which case the
+ *              value is not returned.
  *
- * Return:	Non-negative on success/Negative on failure
+ * Return:      SUCCEED/FAIL
  *
  * Programmer:	Raymond Lu
  *              Sep 16, 2003
  *
- * Modification:Raymond Lu
- *              4 October 2010
- *              If the printing function isn't the default H5Eprint1 or 2, 
- *              and H5Eset_auto2 has been called to set the new style 
- *              printing function, a call to H5Eget_auto1 should fail.
  *-------------------------------------------------------------------------
  */
 herr_t
@@ -364,11 +359,11 @@ H5Eget_auto1(H5E_auto1_t *func, void **client_data)
     H5TRACE2("e", "*x**x", func, client_data);
 
     /* Retrieve default error stack */
-    if(NULL == (estack = H5E_get_my_stack())) /*lint !e506 !e774 Make lint 'constant value Boolean' in non-threaded case */
+    if(NULL == (estack = H5E__get_my_stack())) /*lint !e506 !e774 Make lint 'constant value Boolean' in non-threaded case */
         HGOTO_ERROR(H5E_ERROR, H5E_CANTGET, FAIL, "can't get current error stack")
 
     /* Get the automatic error reporting information */
-    if(H5E_get_auto(estack, &auto_op, client_data) < 0)
+    if(H5E__get_auto(estack, &auto_op, client_data) < 0)
         HGOTO_ERROR(H5E_ERROR, H5E_CANTGET, FAIL, "can't get automatic error info")
 
     /* Fail if the printing function isn't the default(user-set) and set through H5Eset_auto2 */
@@ -384,29 +379,26 @@ done:
 
 
 /*-------------------------------------------------------------------------
- * Function:	H5Eset_auto1
+ * Function:    H5Eset_auto1
  *
- * Purpose:	This function is for backward compatibility.
+ * Purpose:     This function is for backward compatbility.
  *              Turns on or off automatic printing of errors for certain
  *              error stack.  When turned on (non-null FUNC pointer) any
  *              API function which returns an error indication will first
  *              call FUNC passing it CLIENT_DATA as an argument.
  *
- *		The default values before this function is called are
- *		H5Eprint1() with client data being the standard error stream,
- *		stderr.
+ *              The default values before this function is called are
+ *              H5Eprint1() with client data being the standard error stream,
+ *              stderr.
  *
- *		Automatic stack traversal is always in the H5E_WALK_DOWNWARD
- *		direction.
+ *              Automatic stack traversal is always in the H5E_WALK_DOWNWARD
+ *              direction.
  *
- * Return:	Non-negative on success/Negative on failure
+ * Return:      SUCCEED/FAIL
  *
  * Programmer:	Raymond Lu
  *              Sep 16, 2003
  *
- * Modification:Raymond Lu
- *              4 October 2010
- *              If the FUNC is H5Eprint2, put the IS_DEFAULT flag on.
  *-------------------------------------------------------------------------
  */
 herr_t
@@ -420,11 +412,11 @@ H5Eset_auto1(H5E_auto1_t func, void *client_data)
     FUNC_ENTER_API_NOCLEAR(FAIL)
     H5TRACE2("e", "x*x", func, client_data);
 
-    if(NULL == (estack = H5E_get_my_stack())) /*lint !e506 !e774 Make lint 'constant value Boolean' in non-threaded case */
+    if(NULL == (estack = H5E__get_my_stack())) /*lint !e506 !e774 Make lint 'constant value Boolean' in non-threaded case */
         HGOTO_ERROR(H5E_ERROR, H5E_CANTGET, FAIL, "can't get current error stack")
 
     /* Get the automatic error reporting information */
-    if(H5E_get_auto(estack, &auto_op, NULL) < 0)
+    if(H5E__get_auto(estack, &auto_op, NULL) < 0)
         HGOTO_ERROR(H5E_ERROR, H5E_CANTGET, FAIL, "can't get automatic error info")
 
     /* Set the automatic error reporting information */
@@ -435,7 +427,7 @@ H5Eset_auto1(H5E_auto1_t func, void *client_data)
         auto_op.is_default = TRUE;
     auto_op.func1 = func;
 
-    if(H5E_set_auto(estack, &auto_op, client_data) < 0)
+    if(H5E__set_auto(estack, &auto_op, client_data) < 0)
         HGOTO_ERROR(H5E_ERROR, H5E_CANTSET, FAIL, "can't set automatic error info")
 
 done:
diff --git a/src/H5Eint.c b/src/H5Eint.c
index 15953af..540c9b1 100644
--- a/src/H5Eint.c
+++ b/src/H5Eint.c
@@ -32,11 +32,11 @@
 /***********/
 /* Headers */
 /***********/
-#include "H5private.h"		/* Generic Functions			*/
-#include "H5CXprivate.h"        /* API Contexts                         */
-#include "H5Epkg.h"		/* Error handling		  	*/
-#include "H5Iprivate.h"		/* IDs                                  */
-#include "H5MMprivate.h"	/* Memory management			*/
+#include "H5private.h"          /* Generic Functions                        */
+#include "H5CXprivate.h"        /* API Contexts                             */
+#include "H5Epkg.h"             /* Error handling                           */
+#include "H5Iprivate.h"         /* IDs                                      */
+#include "H5MMprivate.h"        /* Memory management                        */
 
 
 /****************/
@@ -64,12 +64,12 @@ typedef struct H5E_print_t {
 /* Local Prototypes */
 /********************/
 #ifndef H5_NO_DEPRECATED_SYMBOLS
-static herr_t H5E_walk1_cb(int n, H5E_error1_t *err_desc,
+static herr_t H5E__walk1_cb(int n, H5E_error1_t *err_desc,
     void *client_data);
 #endif /* H5_NO_DEPRECATED_SYMBOLS */
-static herr_t H5E_walk2_cb(unsigned n, const H5E_error2_t *err_desc,
+static herr_t H5E__walk2_cb(unsigned n, const H5E_error2_t *err_desc,
     void *client_data);
-static herr_t  H5E_clear_entries(H5E_t *estack, size_t nentries);
+static herr_t H5E__clear_entries(H5E_t *estack, size_t nentries);
 
 
 /*********************/
@@ -108,18 +108,18 @@ hid_t H5E_ERR_CLS_g = FAIL;
  * variables used for MPI error reporting
  */
 char	H5E_mpi_error_str[MPI_MAX_ERROR_STRING];
-int	H5E_mpi_error_str_len;
+int     H5E_mpi_error_str_len;
 #endif /* H5_HAVE_PARALLEL */
 
 
 
 /*-------------------------------------------------------------------------
- * Function:	H5E_get_msg
+ * Function:    H5E__get_msg
  *
- * Purpose:	Private function to retrieve an error message.
+ * Purpose:     Private function to retrieve an error message.
  *
- * Return:      Non-negative for name length if succeeds(zero means no name);
- *              otherwise returns negative value.
+ * Return:      Success:    Message length (zero means no message)
+ *              Failure:    -1
  *
  * Programmer:	Raymond Lu
  *              Friday, July 14, 2003
@@ -127,11 +127,11 @@ int	H5E_mpi_error_str_len;
  *-------------------------------------------------------------------------
  */
 ssize_t
-H5E_get_msg(const H5E_msg_t *msg, H5E_type_t *type, char *msg_str, size_t size)
+H5E__get_msg(const H5E_msg_t *msg, H5E_type_t *type, char *msg_str, size_t size)
 {
     ssize_t       len = -1;     /* Length of error message */
 
-    FUNC_ENTER_NOAPI_NOINIT_NOERR
+    FUNC_ENTER_PACKAGE_NOERR
 
     /* Check arguments */
     HDassert(msg);
@@ -152,37 +152,37 @@ H5E_get_msg(const H5E_msg_t *msg, H5E_type_t *type, char *msg_str, size_t size)
 
     /* Set the return value to the full length of the message */
     FUNC_LEAVE_NOAPI(len)
-} /* end H5E_get_msg() */
+} /* end H5E__get_msg() */
 
 #ifndef H5_NO_DEPRECATED_SYMBOLS
 
 /*-------------------------------------------------------------------------
- * Function:	H5E_walk1_cb
+ * Function:    H5E__walk1_cb
  *
- * Purpose:	This function is for backward compatibility.
+ * Purpose:     This function is for backward compatibility.
  *              This is a default error stack traversal callback function
- *		that prints error messages to the specified output stream.
- *		This function is for backward compatibility with v1.6.
- *		It is not meant to be called directly but rather as an
- *		argument to the H5Ewalk() function.  This function is called
- *		also by H5Eprint().  Application writers are encouraged to
- *		use this function as a model for their own error stack
- *		walking functions.
+ *              that prints error messages to the specified output stream.
+ *              This function is for backward compatibility with v1.6.
+ *              It is not meant to be called directly but rather as an
+ *              argument to the H5Ewalk() function.  This function is called
+ *              also by H5Eprint().  Application writers are encouraged to
+ *              use this function as a model for their own error stack
+ *              walking functions.
  *
- *		N is a counter for how many times this function has been
- *		called for this particular traversal of the stack.  It always
- *		begins at zero for the first error on the stack (either the
- *		top or bottom error, or even both, depending on the traversal
- *		direction and the size of the stack).
+ *              N is a counter for how many times this function has been
+ *              called for this particular traversal of the stack.  It always
+ *              begins at zero for the first error on the stack (either the
+ *              top or bottom error, or even both, depending on the traversal
+ *              direction and the size of the stack).
  *
- *		ERR_DESC is an error description.  It contains all the
- *		information about a particular error.
+ *              ERR_DESC is an error description.  It contains all the
+ *              information about a particular error.
  *
- *		CLIENT_DATA is the same pointer that was passed as the
- *		CLIENT_DATA argument of H5Ewalk().  It is expected to be a
- *		file pointer (or stderr if null).
+ *              CLIENT_DATA is the same pointer that was passed as the
+ *              CLIENT_DATA argument of H5Ewalk().  It is expected to be a
+ *              file pointer (or stderr if null).
  *
- * Return:	Non-negative on success/Negative on failure
+ * Return:      SUCCEED/FAIL
  *
  * Programmer:  Raymond Lu
  *		Thursday, May 11, 2006
@@ -190,7 +190,7 @@ H5E_get_msg(const H5E_msg_t *msg, H5E_type_t *type, char *msg_str, size_t size)
  *-------------------------------------------------------------------------
  */
 static herr_t
-H5E_walk1_cb(int n, H5E_error1_t *err_desc, void *client_data)
+H5E__walk1_cb(int n, H5E_error1_t *err_desc, void *client_data)
 {
     H5E_print_t         *eprint  = (H5E_print_t *)client_data;
     FILE		*stream;        /* I/O stream to print output to */
@@ -202,7 +202,7 @@ H5E_walk1_cb(int n, H5E_error1_t *err_desc, void *client_data)
     unsigned            have_desc = 1;  /* Flag to indicate whether the error has a "real" description */
     herr_t              ret_value = SUCCEED;
 
-    FUNC_ENTER_NOAPI_NOINIT_NOERR
+    FUNC_ENTER_STATIC_NOERR
 
     /* Check arguments */
     HDassert(err_desc);
@@ -239,7 +239,7 @@ H5E_walk1_cb(int n, H5E_error1_t *err_desc, void *client_data)
         if(cls_ptr->lib_vers)
             eprint->cls.lib_vers = cls_ptr->lib_vers;
 
-        fprintf(stream, "%s-DIAG: Error detected in %s (%s) ",
+        HDfprintf(stream, "%s-DIAG: Error detected in %s (%s) ",
             (cls_ptr->cls_name ? cls_ptr->cls_name : "(null)"),
             (cls_ptr->lib_name ? cls_ptr->lib_name : "(null)"),
             (cls_ptr->lib_vers ? cls_ptr->lib_vers : "(null)"));
@@ -249,22 +249,22 @@ H5E_walk1_cb(int n, H5E_error1_t *err_desc, void *client_data)
         {
             int mpi_rank, mpi_initialized, mpi_finalized;
 
-	    MPI_Initialized(&mpi_initialized);
+            MPI_Initialized(&mpi_initialized);
             MPI_Finalized(&mpi_finalized);
 
             if(mpi_initialized && !mpi_finalized) {
-	        MPI_Comm_rank(MPI_COMM_WORLD, &mpi_rank);
-	        fprintf(stream, "MPI-process %d", mpi_rank);
-	    } /* end if */
+                MPI_Comm_rank(MPI_COMM_WORLD, &mpi_rank);
+                HDfprintf(stream, "MPI-process %d", mpi_rank);
+            } /* end if */
             else
-	        fprintf(stream, "thread 0");
+                HDfprintf(stream, "thread 0");
         } /* end block */
 #elif defined(H5_HAVE_THREADSAFE)
-        fprintf(stream, "thread %lu", (unsigned long)HDpthread_self_ulong());
+        HDfprintf(stream, "thread %lu", (unsigned long)HDpthread_self_ulong());
 #else
-        fprintf(stream, "thread 0");
+        HDfprintf(stream, "thread 0");
 #endif
-        fprintf(stream, ":\n");
+        HDfprintf(stream, ":\n");
     } /* end if */
 
     /* Check for "real" error description - used to format output more nicely */
@@ -272,44 +272,44 @@ H5E_walk1_cb(int n, H5E_error1_t *err_desc, void *client_data)
         have_desc=0;
 
     /* Print error message */
-    fprintf(stream, "%*s#%03d: %s line %u in %s()%s%s\n",
+    HDfprintf(stream, "%*s#%03d: %s line %u in %s()%s%s\n",
 	     H5E_INDENT, "", n, err_desc->file_name, err_desc->line,
 	     err_desc->func_name, (have_desc ? ": " : ""),
              (have_desc ? err_desc->desc : ""));
-    fprintf(stream, "%*smajor: %s\n", (H5E_INDENT * 2), "", maj_str);
-    fprintf(stream, "%*sminor: %s\n", (H5E_INDENT * 2), "", min_str);
+    HDfprintf(stream, "%*smajor: %s\n", (H5E_INDENT * 2), "", maj_str);
+    HDfprintf(stream, "%*sminor: %s\n", (H5E_INDENT * 2), "", min_str);
 
 done:
     FUNC_LEAVE_NOAPI(ret_value)
-} /* end H5E_walk1_cb() */
+} /* end H5E__walk1_cb() */
 #endif /* H5_NO_DEPRECATED_SYMBOLS */
 
 
 /*-------------------------------------------------------------------------
- * Function:	H5E_walk2_cb
+ * Function:    H5E__walk2_cb
  *
- * Purpose:	This is a default error stack traversal callback function
- *		that prints error messages to the specified output stream.
- *		It is not meant to be called directly but rather as an
- *		argument to the H5Ewalk2() function.  This function is
- *		called also by H5Eprint2().  Application writers are
- *		encouraged to use this function as a model for their own
- *		error stack walking functions.
+ * Purpose:     This is a default error stack traversal callback function
+ *              that prints error messages to the specified output stream.
+ *              It is not meant to be called directly but rather as an
+ *              argument to the H5Ewalk2() function.  This function is
+ *              called also by H5Eprint2().  Application writers are
+ *              encouraged to use this function as a model for their own
+ *              error stack walking functions.
  *
- *		N is a counter for how many times this function has been
- *		called for this particular traversal of the stack.  It always
- *		begins at zero for the first error on the stack (either the
- *		top or bottom error, or even both, depending on the traversal
- *		direction and the size of the stack).
+ *              N is a counter for how many times this function has been
+ *              called for this particular traversal of the stack.  It always
+ *              begins at zero for the first error on the stack (either the
+ *              top or bottom error, or even both, depending on the traversal
+ *              direction and the size of the stack).
  *
- *		ERR_DESC is an error description.  It contains all the
- *		information about a particular error.
+ *              ERR_DESC is an error description.  It contains all the
+ *              information about a particular error.
  *
- *		CLIENT_DATA is the same pointer that was passed as the
- *		CLIENT_DATA argument of H5Ewalk().  It is expected to be a
- *		file pointer (or stderr if null).
+ *              CLIENT_DATA is the same pointer that was passed as the
+ *              CLIENT_DATA argument of H5Ewalk().  It is expected to be a
+ *              file pointer (or stderr if null).
  *
- * Return:	Non-negative on success/Negative on failure
+ * Return:      SUCCEED/FAIL
  *
  * Programmer:	Robb Matzke
  *		Friday, December 12, 1997
@@ -317,7 +317,7 @@ done:
  *-------------------------------------------------------------------------
  */
 static herr_t
-H5E_walk2_cb(unsigned n, const H5E_error2_t *err_desc, void *client_data)
+H5E__walk2_cb(unsigned n, const H5E_error2_t *err_desc, void *client_data)
 {
     H5E_print_t         *eprint  = (H5E_print_t *)client_data;
     FILE		*stream;        /* I/O stream to print output to */
@@ -329,7 +329,7 @@ H5E_walk2_cb(unsigned n, const H5E_error2_t *err_desc, void *client_data)
     unsigned            have_desc = 1;  /* Flag to indicate whether the error has a "real" description */
     herr_t              ret_value = SUCCEED;
 
-    FUNC_ENTER_NOAPI_NOINIT_NOERR
+    FUNC_ENTER_STATIC_NOERR
 
     /* Check arguments */
     HDassert(err_desc);
@@ -371,7 +371,7 @@ H5E_walk2_cb(unsigned n, const H5E_error2_t *err_desc, void *client_data)
         if(cls_ptr->lib_vers)
             eprint->cls.lib_vers = cls_ptr->lib_vers;
 
-        fprintf(stream, "%s-DIAG: Error detected in %s (%s) ",
+        HDfprintf(stream, "%s-DIAG: Error detected in %s (%s) ",
             (cls_ptr->cls_name ? cls_ptr->cls_name : "(null)"),
             (cls_ptr->lib_name ? cls_ptr->lib_name : "(null)"),
             (cls_ptr->lib_vers ? cls_ptr->lib_vers : "(null)"));
@@ -381,22 +381,22 @@ H5E_walk2_cb(unsigned n, const H5E_error2_t *err_desc, void *client_data)
         {
             int mpi_rank, mpi_initialized, mpi_finalized;
 
-	    MPI_Initialized(&mpi_initialized);
+            MPI_Initialized(&mpi_initialized);
             MPI_Finalized(&mpi_finalized);
 
             if(mpi_initialized && !mpi_finalized) {
-	        MPI_Comm_rank(MPI_COMM_WORLD, &mpi_rank);
-	        fprintf(stream, "MPI-process %d", mpi_rank);
-	    } /* end if */
+                MPI_Comm_rank(MPI_COMM_WORLD, &mpi_rank);
+                HDfprintf(stream, "MPI-process %d", mpi_rank);
+            } /* end if */
             else
-	        fprintf(stream, "thread 0");
+                HDfprintf(stream, "thread 0");
         } /* end block */
 #elif defined(H5_HAVE_THREADSAFE)
-        fprintf(stream, "thread %lu", (unsigned long)HDpthread_self_ulong());
+        HDfprintf(stream, "thread %lu", (unsigned long)HDpthread_self_ulong());
 #else
-        fprintf(stream, "thread 0");
+        HDfprintf(stream, "thread 0");
 #endif
-        fprintf(stream, ":\n");
+        HDfprintf(stream, ":\n");
     } /* end if */
 
     /* Check for "real" error description - used to format output more nicely */
@@ -404,28 +404,28 @@ H5E_walk2_cb(unsigned n, const H5E_error2_t *err_desc, void *client_data)
         have_desc = 0;
 
     /* Print error message */
-    fprintf(stream, "%*s#%03u: %s line %u in %s()%s%s\n",
+    HDfprintf(stream, "%*s#%03u: %s line %u in %s()%s%s\n",
 	     H5E_INDENT, "", n, err_desc->file_name, err_desc->line,
 	     err_desc->func_name, (have_desc ? ": " : ""),
              (have_desc ? err_desc->desc : ""));
-    fprintf(stream, "%*smajor: %s\n", (H5E_INDENT * 2), "", maj_str);
-    fprintf(stream, "%*sminor: %s\n", (H5E_INDENT * 2), "", min_str);
+    HDfprintf(stream, "%*smajor: %s\n", (H5E_INDENT * 2), "", maj_str);
+    HDfprintf(stream, "%*sminor: %s\n", (H5E_INDENT * 2), "", min_str);
 
 done:
     FUNC_LEAVE_NOAPI(ret_value)
-} /* end H5E_walk2_cb() */
+} /* end H5E__walk2_cb() */
 
 
 /*-------------------------------------------------------------------------
- * Function:	H5E_print
+ * Function:    H5E__print
  *
- * Purpose:	Private function to print the error stack in some default
+ * Purpose:     Private function to print the error stack in some default
  *              way.  This is just a convenience function for H5Ewalk() and
  *              H5Ewalk2() with a function that prints error messages.
  *              Users are encouraged to write there own more specific error
  *              handlers.
  *
- * Return:	Non-negative on success/Negative on failure
+ * Return:      SUCCEED/FAIL
  *
  * Programmer:	Robb Matzke
  *              Friday, February 27, 1998
@@ -433,13 +433,13 @@ done:
  *-------------------------------------------------------------------------
  */
 herr_t
-H5E_print(const H5E_t *estack, FILE *stream, hbool_t bk_compatible)
+H5E__print(const H5E_t *estack, FILE *stream, hbool_t bk_compatible)
 {
     H5E_print_t eprint;         /* Callback information to pass to H5E_walk() */
     H5E_walk_op_t walk_op;      /* Error stack walking callback */
     herr_t ret_value = SUCCEED;
 
-    FUNC_ENTER_NOAPI_NOINIT
+    FUNC_ENTER_PACKAGE
 
     /* Sanity check */
     HDassert(estack);
@@ -457,8 +457,8 @@ H5E_print(const H5E_t *estack, FILE *stream, hbool_t bk_compatible)
     if(bk_compatible) {
 #ifndef H5_NO_DEPRECATED_SYMBOLS
         walk_op.vers = 1;
-        walk_op.u.func1 = H5E_walk1_cb;
-        if(H5E_walk(estack, H5E_WALK_DOWNWARD, &walk_op, (void*)&eprint) < 0)
+        walk_op.u.func1 = H5E__walk1_cb;
+        if(H5E__walk(estack, H5E_WALK_DOWNWARD, &walk_op, (void*)&eprint) < 0)
             HGOTO_ERROR(H5E_ERROR, H5E_CANTLIST, FAIL, "can't walk error stack")
 #else /* H5_NO_DEPRECATED_SYMBOLS */
         HDassert(0 && "version 1 error stack print without deprecated symbols!");
@@ -466,40 +466,40 @@ H5E_print(const H5E_t *estack, FILE *stream, hbool_t bk_compatible)
     } /* end if */
     else {
         walk_op.vers = 2;
-        walk_op.u.func2 = H5E_walk2_cb;
-        if(H5E_walk(estack, H5E_WALK_DOWNWARD, &walk_op, (void*)&eprint) < 0)
+        walk_op.u.func2 = H5E__walk2_cb;
+        if(H5E__walk(estack, H5E_WALK_DOWNWARD, &walk_op, (void*)&eprint) < 0)
             HGOTO_ERROR(H5E_ERROR, H5E_CANTLIST, FAIL, "can't walk error stack")
     } /* end else */
 
 done:
     FUNC_LEAVE_NOAPI(ret_value)
-} /* end H5E_print() */
+} /* end H5E__print() */
 
 
 /*-------------------------------------------------------------------------
- * Function:	H5E_walk
+ * Function:    H5E__walk
  *
- * Purpose:	Private function for H5Ewalk.
+ * Purpose:     Private function for H5Ewalk.
  *              Walks the error stack, calling the specified function for
- *		each error on the stack.  The DIRECTION argument determines
- *		whether the stack is walked from the inside out or the
- *		outside in.  The value H5E_WALK_UPWARD means begin with the
- *		most specific error and end at the API; H5E_WALK_DOWNWARD
- *		means to start at the API and end at the inner-most function
- *		where the error was first detected.
- *
- *		The function pointed to by STACK_FUNC will be called for
- *		each error record in the error stack. It's arguments will
- *		include an index number (beginning at zero regardless of
- *		stack traversal	direction), an error stack entry, and the
- *		CLIENT_DATA pointer passed to H5E_print.
- *
- *		The function FUNC is also provided for backward compatibility.
- *		When BK_COMPATIBLE is set to be TRUE, FUNC is used to be
- *		compatible with older library.  If BK_COMPATIBLE is FALSE,
- *		STACK_FUNC is used.
- *
- * Return:	Non-negative on success/Negative on failure
+ *              each error on the stack.  The DIRECTION argument determines
+ *              whether the stack is walked from the inside out or the
+ *              outside in.  The value H5E_WALK_UPWARD means begin with the
+ *              most specific error and end at the API; H5E_WALK_DOWNWARD
+ *              means to start at the API and end at the inner-most function
+ *              where the error was first detected.
+ *
+ *              The function pointed to by STACK_FUNC will be called for
+ *              each error record in the error stack. It's arguments will
+ *              include an index number (beginning at zero regardless of
+ *              stack traversal	direction), an error stack entry, and the
+ *              CLIENT_DATA pointer passed to H5E_print.
+ *
+ *              The function FUNC is also provided for backward compatibility.
+ *              When BK_COMPATIBLE is set to be TRUE, FUNC is used to be
+ *              compatible with older library.  If BK_COMPATIBLE is FALSE,
+ *              STACK_FUNC is used.
+ *
+ * Return:      SUCCEED/FAIL
  *
  * Programmer:	Robb Matzke
  *		Friday, December 12, 1997
@@ -507,14 +507,14 @@ done:
  *-------------------------------------------------------------------------
  */
 herr_t
-H5E_walk(const H5E_t *estack, H5E_direction_t direction, const H5E_walk_op_t *op,
+H5E__walk(const H5E_t *estack, H5E_direction_t direction, const H5E_walk_op_t *op,
     void *client_data)
 {
     int		i;              /* Local index variable */
     herr_t	status;         /* Status from callback function */
     herr_t ret_value = SUCCEED;   /* Return value */
 
-    FUNC_ENTER_NOAPI_NOINIT
+    FUNC_ENTER_PACKAGE
 
     /* Sanity check */
     HDassert(estack);
@@ -587,18 +587,18 @@ H5E_walk(const H5E_t *estack, H5E_direction_t direction, const H5E_walk_op_t *op
 
 done:
     FUNC_LEAVE_NOAPI(ret_value)
-} /* end H5E_walk() */
+} /* end H5E__walk() */
 
 
 /*-------------------------------------------------------------------------
- * Function:	H5E_get_auto
+ * Function:    H5E__get_auto
  *
- * Purpose:	Private function to return the current settings for the
+ * Purpose:     Private function to return the current settings for the
  *              automatic error stack traversal function and its data
  *              for specific error stack. Either (or both) arguments may
  *              be null in which case the value is not returned.
  *
- * Return:	Non-negative on success/Negative on failure
+ * Return:      SUCCEED/FAIL
  *
  * Programmer:	Raymond Lu
  *              July 18, 2003
@@ -606,9 +606,9 @@ done:
  *-------------------------------------------------------------------------
  */
 herr_t
-H5E_get_auto(const H5E_t *estack, H5E_auto_op_t *op, void **client_data)
+H5E__get_auto(const H5E_t *estack, H5E_auto_op_t *op, void **client_data)
 {
-    FUNC_ENTER_NOAPI_NOINIT_NOERR
+    FUNC_ENTER_PACKAGE_NOERR
 
     HDassert(estack);
 
@@ -619,26 +619,26 @@ H5E_get_auto(const H5E_t *estack, H5E_auto_op_t *op, void **client_data)
         *client_data = estack->auto_data;
 
     FUNC_LEAVE_NOAPI(SUCCEED)
-} /* end H5E_get_auto2() */
+} /* end H5E__get_auto() */
 
 
 /*-------------------------------------------------------------------------
- * Function:	H5E_set_auto
+ * Function:    H5E__set_auto
  *
- * Purpose:	Private function to turn on or off automatic printing of
+ * Purpose:     Private function to turn on or off automatic printing of
  *              errors for certain error stack.  When turned on (non-null
  *              FUNC pointer) any API function which returns an error
  *              indication will first call FUNC passing it CLIENT_DATA
  *              as an argument.
  *
- *		The default values before this function is called are
- *		H5Eprint2() with client data being the standard error stream,
- *		stderr.
+ *              The default values before this function is called are
+ *              H5Eprint2() with client data being the standard error stream,
+ *              stderr.
  *
- *		Automatic stack traversal is always in the H5E_WALK_DOWNWARD
- *		direction.
+ *              Automatic stack traversal is always in the H5E_WALK_DOWNWARD
+ *              direction.
  *
- * Return:	Non-negative on success/Negative on failure
+ * Return:      SUCCEED/FAIL
  *
  * Programmer:	Robb Matzke
  *              Friday, February 27, 1998
@@ -646,9 +646,9 @@ H5E_get_auto(const H5E_t *estack, H5E_auto_op_t *op, void **client_data)
  *-------------------------------------------------------------------------
  */
 herr_t
-H5E_set_auto(H5E_t *estack, const H5E_auto_op_t *op, void *client_data)
+H5E__set_auto(H5E_t *estack, const H5E_auto_op_t *op, void *client_data)
 {
-    FUNC_ENTER_NOAPI_NOINIT_NOERR
+    FUNC_ENTER_PACKAGE_NOERR
 
     HDassert(estack);
 
@@ -657,15 +657,15 @@ H5E_set_auto(H5E_t *estack, const H5E_auto_op_t *op, void *client_data)
     estack->auto_data = client_data;
 
     FUNC_LEAVE_NOAPI(SUCCEED)
-} /* end H5E_set_auto() */
+} /* end H5E__set_auto() */
 
 
 /*-------------------------------------------------------------------------
- * Function:	H5E_printf_stack
+ * Function:    H5E_printf_stack
  *
- * Purpose:	Printf-like wrapper around H5E__push_stack.
+ * Purpose:     Printf-like wrapper around H5E__push_stack.
  *
- * Return:	Non-negative on success/Negative on failure
+ * Return:      SUCCEED/FAIL
  *
  * Programmer:	Quincey Koziol
  *		Tuesday, August 12, 2008
@@ -758,19 +758,19 @@ done:
 
 
 /*-------------------------------------------------------------------------
- * Function:	H5E__push_stack
+ * Function:    H5E__push_stack
  *
- * Purpose:	Pushes a new error record onto error stack for the current
- *		thread.  The error has major and minor IDs MAJ_ID and
- *		MIN_ID, the name of a function where the error was detected,
- *		the name of the file where the error was detected, the
- *		line within that file, and an error description string.  The
- *		function name, file name, and error description strings must
- *		be statically allocated (the FUNC_ENTER() macro takes care of
- *		the function name and file name automatically, but the
- *		programmer is responsible for the description string).
+ * Purpose:     Pushes a new error record onto error stack for the current
+ *              thread.  The error has major and minor IDs MAJ_ID and
+ *              MIN_ID, the name of a function where the error was detected,
+ *              the name of the file where the error was detected, the
+ *              line within that file, and an error description string.  The
+ *              function name, file name, and error description strings must
+ *              be statically allocated (the FUNC_ENTER() macro takes care of
+ *              the function name and file name automatically, but the
+ *              programmer is responsible for the description string).
  *
- * Return:	Non-negative on success/Negative on failure
+ * Return:      SUCCEED/FAIL
  *
  * Programmer:	Robb Matzke
  *		Friday, December 12, 1997
@@ -799,7 +799,7 @@ H5E__push_stack(H5E_t *estack, const char *file, const char *func, unsigned line
 
     /* Check for 'default' error stack */
     if(estack == NULL)
-    	if(NULL == (estack = H5E_get_my_stack())) /*lint !e506 !e774 Make lint 'constant value Boolean' in non-threaded case */
+    	if(NULL == (estack = H5E__get_my_stack())) /*lint !e506 !e774 Make lint 'constant value Boolean' in non-threaded case */
             HGOTO_DONE(FAIL)
 
     /*
@@ -845,12 +845,12 @@ done:
 
 
 /*-------------------------------------------------------------------------
- * Function:	H5E_clear_entries
+ * Function:    H5E__clear_entries
  *
- * Purpose:	Private function to clear the error stack entries for the
+ * Purpose:     Private function to clear the error stack entries for the
  *              specified error stack.
  *
- * Return:	Non-negative on success/Negative on failure
+ * Return:      SUCCEED/FAIL
  *
  * Programmer:	Quincey Koziol
  *              Wednesday, August 6, 2003
@@ -858,13 +858,13 @@ done:
  *-------------------------------------------------------------------------
  */
 static herr_t
-H5E_clear_entries(H5E_t *estack, size_t nentries)
+H5E__clear_entries(H5E_t *estack, size_t nentries)
 {
     H5E_error2_t *error;        /* Pointer to error stack entry to clear */
     unsigned u;                 /* Local index variable */
-    herr_t ret_value=SUCCEED;   /* Return value */
+    herr_t ret_value = SUCCEED; /* Return value */
 
-    FUNC_ENTER_NOAPI_NOINIT
+    FUNC_ENTER_STATIC
 
     /* Sanity check */
     HDassert(estack);
@@ -897,16 +897,16 @@ H5E_clear_entries(H5E_t *estack, size_t nentries)
 
 done:
     FUNC_LEAVE_NOAPI(ret_value)
-} /* end H5E_clear_entries() */
+} /* end H5E__clear_entries() */
 
 
 /*-------------------------------------------------------------------------
- * Function:	H5E_clear_stack
+ * Function:    H5E_clear_stack
  *
- * Purpose:	Private function to clear the error stack for the
+ * Purpose:     Private function to clear the error stack for the
  *              specified error stack.
  *
- * Return:	Non-negative on success/Negative on failure
+ * Return:      SUCCEED/FAIL
  *
  * Programmer:	Raymond Lu
  *              Wednesday, July 16, 2003
@@ -922,13 +922,13 @@ H5E_clear_stack(H5E_t *estack)
 
     /* Check for 'default' error stack */
     if(estack == NULL)
-    	if(NULL == (estack = H5E_get_my_stack())) /*lint !e506 !e774 Make lint 'constant value Boolean' in non-threaded case */
+    	if(NULL == (estack = H5E__get_my_stack())) /*lint !e506 !e774 Make lint 'constant value Boolean' in non-threaded case */
             HGOTO_ERROR(H5E_ERROR, H5E_CANTGET, FAIL, "can't get current error stack")
 
     /* Empty the error stack */
     HDassert(estack);
     if(estack->nused)
-        if(H5E_clear_entries(estack, estack->nused) < 0)
+        if(H5E__clear_entries(estack, estack->nused) < 0)
             HGOTO_ERROR(H5E_ERROR, H5E_CANTSET, FAIL, "can't clear error stack")
 
 done:
@@ -937,12 +937,12 @@ done:
 
 
 /*-------------------------------------------------------------------------
- * Function:	H5E_pop
+ * Function:    H5E__pop
  *
- * Purpose:	Private function to delete some error messages from the top
+ * Purpose:     Private function to delete some error messages from the top
  *              of error stack.
  *
- * Return:	Non-negative value on success/Negative on failure
+ * Return:      SUCCEED/FAIL
  *
  * Programmer:	Raymond Lu
  *              Friday, July 16, 2003
@@ -950,33 +950,33 @@ done:
  *-------------------------------------------------------------------------
  */
 herr_t
-H5E_pop(H5E_t *estack, size_t count)
+H5E__pop(H5E_t *estack, size_t count)
 {
     herr_t      ret_value = SUCCEED;   /* Return value */
 
-    FUNC_ENTER_NOAPI_NOINIT
+    FUNC_ENTER_PACKAGE
 
     /* Sanity check */
     HDassert(estack);
     HDassert(estack->nused >= count);
 
     /* Remove the entries from the error stack */
-    if(H5E_clear_entries(estack, count) < 0)
+    if(H5E__clear_entries(estack, count) < 0)
         HGOTO_ERROR(H5E_ERROR, H5E_CANTRELEASE, FAIL, "can't remove errors from stack")
 
 done:
     FUNC_LEAVE_NOAPI(ret_value)
-} /* end H5E_pop() */
+} /* end H5E__pop() */
 
 
 /*-------------------------------------------------------------------------
- * Function:	H5E_dump_api_stack
+ * Function:    H5E_dump_api_stack
  *
- * Purpose:	Private function to dump the error stack during an error in
+ * Purpose:     Private function to dump the error stack during an error in
  *              an API function if a callback function is defined for the
  *              current error stack.
  *
- * Return:	Non-negative on success/Negative on failure
+ * Return:      SUCCEED/FAIL
  *
  * Programmer:	Quincey Koziol
  *              Wednesday, August 6, 2003
@@ -992,7 +992,7 @@ H5E_dump_api_stack(hbool_t is_api)
 
     /* Only dump the error stack during an API call */
     if(is_api) {
-        H5E_t *estack = H5E_get_my_stack();
+        H5E_t *estack = H5E__get_my_stack();
 
         HDassert(estack);
 
diff --git a/src/H5Epkg.h b/src/H5Epkg.h
index fcde1ca..ac98496 100644
--- a/src/H5Epkg.h
+++ b/src/H5Epkg.h
@@ -49,15 +49,15 @@
  * each thread individually. The association of stacks to threads will
  * be handled by the pthread library.
  *
- * In order for this macro to work, H5E_get_my_stack() must be preceeded
+ * In order for this macro to work, H5E__get_my_stack() must be preceeded
  * by "H5E_t *estack =".
  */
-#define H5E_get_my_stack()  H5E_get_stack()
+#define H5E__get_my_stack()  H5E__get_stack()
 #else /* H5_HAVE_THREADSAFE */
 /*
  * The current error stack.
  */
-#define H5E_get_my_stack() (H5E_stack_g + 0)
+#define H5E__get_my_stack() (H5E_stack_g + 0)
 #endif /* H5_HAVE_THREADSAFE */
 
 
@@ -132,20 +132,20 @@ H5_DLLVAR H5E_t	H5E_stack_g[1];
 /******************************/
 H5_DLL herr_t H5E__term_deprec_interface(void);
 #ifdef H5_HAVE_THREADSAFE
-H5_DLL H5E_t *H5E_get_stack(void);
+H5_DLL H5E_t *H5E__get_stack(void);
 #endif /* H5_HAVE_THREADSAFE */
 H5_DLL herr_t H5E__push_stack(H5E_t *estack, const char *file, const char *func,
     unsigned line, hid_t cls_id, hid_t maj_id, hid_t min_id, const char *desc);
-H5_DLL ssize_t H5E_get_msg(const H5E_msg_t *msg_ptr, H5E_type_t *type,
+H5_DLL ssize_t H5E__get_msg(const H5E_msg_t *msg_ptr, H5E_type_t *type,
     char *msg, size_t size);
-H5_DLL herr_t H5E_print(const H5E_t *estack, FILE *stream, hbool_t bk_compat);
-H5_DLL herr_t H5E_walk(const H5E_t *estack, H5E_direction_t direction,
+H5_DLL herr_t H5E__print(const H5E_t *estack, FILE *stream, hbool_t bk_compat);
+H5_DLL herr_t H5E__walk(const H5E_t *estack, H5E_direction_t direction,
     const H5E_walk_op_t *op, void *client_data);
-H5_DLL herr_t H5E_get_auto(const H5E_t *estack, H5E_auto_op_t *op,
+H5_DLL herr_t H5E__get_auto(const H5E_t *estack, H5E_auto_op_t *op,
     void **client_data);
-H5_DLL herr_t H5E_set_auto(H5E_t *estack, const H5E_auto_op_t *op,
+H5_DLL herr_t H5E__set_auto(H5E_t *estack, const H5E_auto_op_t *op,
     void *client_data);
-H5_DLL herr_t H5E_pop(H5E_t *err_stack, size_t count);
+H5_DLL herr_t H5E__pop(H5E_t *err_stack, size_t count);
 
 #endif /* _H5Epkg_H */
 
diff --git a/src/H5FDpkg.h b/src/H5FDpkg.h
index 6f47efb..e51050e 100644
--- a/src/H5FDpkg.h
+++ b/src/H5FDpkg.h
@@ -57,7 +57,7 @@ H5_DLL herr_t H5FD_free_real(H5FD_t *file, H5FD_mem_t type, haddr_t addr,
 
 /* Testing functions */
 #ifdef H5FD_TESTING
-H5_DLL hbool_t H5FD_supports_swmr_test(const char *vfd_name);
+H5_DLL hbool_t H5FD__supports_swmr_test(const char *vfd_name);
 #endif /* H5FD_TESTING */
 
 #endif /* _H5FDpkg_H */
diff --git a/src/H5FDtest.c b/src/H5FDtest.c
index f528dfb..080223c 100644
--- a/src/H5FDtest.c
+++ b/src/H5FDtest.c
@@ -71,7 +71,7 @@
 
 
 /*-------------------------------------------------------------------------
- * Function:	H5FD_supports_swmr_test()
+ * Function:	H5FD__supports_swmr_test()
  *
  * Purpose:	    Determines if a VFD supports SWMR.
  *
@@ -98,7 +98,7 @@
  *-------------------------------------------------------------------------
  */
 hbool_t
-H5FD_supports_swmr_test(const char *vfd_name)
+H5FD__supports_swmr_test(const char *vfd_name)
 {
     hbool_t ret_value = FALSE;
 
@@ -112,5 +112,5 @@ H5FD_supports_swmr_test(const char *vfd_name)
 
     FUNC_LEAVE_NOAPI(ret_value)
     
-} /* end H5FD_supports_swmr_test() */
+} /* end H5FD__supports_swmr_test() */
 
diff --git a/src/H5private.h b/src/H5private.h
index 196d001..2dff0f0 100644
--- a/src/H5private.h
+++ b/src/H5private.h
@@ -1992,7 +1992,6 @@ extern hbool_t H5_MPEinit_g;   /* Has the MPE Library been initialized? */
 H5_DLL herr_t H5CX_push(void);
 H5_DLL herr_t H5CX_pop(void);
 
-
 #ifndef NDEBUG
 #define FUNC_ENTER_CHECK_NAME(asrt)                                           \
     {                                                                         \
@@ -2031,7 +2030,7 @@ H5_DLL herr_t H5CX_pop(void);
 /* Local variables for API routines */
 #define FUNC_ENTER_API_VARS                                                   \
     MPE_LOG_VARS                                                              \
-    H5TRACE_DECL                                                              \
+    H5TRACE_DECL
 
 #define FUNC_ENTER_API_COMMON                                                 \
     FUNC_ENTER_API_VARS                                                       \
diff --git a/src/H5system.c b/src/H5system.c
index 186d8fa..2d29650 100644
--- a/src/H5system.c
+++ b/src/H5system.c
@@ -294,13 +294,13 @@ HDfprintf(FILE *stream, const char *fmt, ...)
                         unsigned short x = (unsigned short)va_arg(ap, unsigned int);
                         n = fprintf(stream, format_templ, x);
                     } else if(!*modifier) {
-                        unsigned int x = va_arg(ap, unsigned int); /*lint !e732 Loss of sign not really occurring */
+                        unsigned int x = va_arg(ap, unsigned int);
                         n = fprintf(stream, format_templ, x);
                     } else if(!HDstrcmp(modifier, "l")) {
-                        unsigned long x = va_arg(ap, unsigned long); /*lint !e732 Loss of sign not really occurring */
+                        unsigned long x = va_arg(ap, unsigned long);
                         n = fprintf(stream, format_templ, x);
                     } else {
-                        uint64_t x = va_arg(ap, uint64_t); /*lint !e732 Loss of sign not really occurring */
+                        uint64_t x = va_arg(ap, uint64_t);
                         n = fprintf(stream, format_templ, x);
                     }
                     break;
@@ -333,7 +333,7 @@ HDfprintf(FILE *stream, const char *fmt, ...)
 
                 case 'a':
                     {
-                        haddr_t x = va_arg(ap, haddr_t); /*lint !e732 Loss of sign not really occurring */
+                        haddr_t x = va_arg(ap, haddr_t);
 
                         if(H5F_addr_defined(x)) {
                             len = 0;
@@ -387,7 +387,7 @@ HDfprintf(FILE *stream, const char *fmt, ...)
                 case 's':
                 case 'p':
                     {
-                        char *x = va_arg(ap, char*); /*lint !e64 Type mismatch not really occurring */
+                        char *x = va_arg(ap, char*);
                         n = fprintf(stream, format_templ, x);
                     }
                     break;
diff --git a/test/accum.c b/test/accum.c
index 19006b6..91786a9 100644
--- a/test/accum.c
+++ b/test/accum.c
@@ -1846,11 +1846,11 @@ test_swmr_write_big(hbool_t newest_format)
      * by the environment variable.
      */
     driver = HDgetenv("HDF5_DRIVER");
-    if (!H5FD_supports_swmr_test(driver)) {
+    if(!H5FD__supports_swmr_test(driver)) {
         SKIPPED();
         HDputs("    Test skipped due to VFD not supporting SWMR I/O.");
         return 0;
-    } /* end if */
+    }
 
     /* File access property list */
     if((fapl = h5_fileaccess()) < 0)
@@ -1863,7 +1863,8 @@ test_swmr_write_big(hbool_t newest_format)
 
 	if((fid = H5Fcreate(SWMR_FILENAME, H5F_ACC_TRUNC, H5P_DEFAULT, fapl)) < 0)
 	    FAIL_STACK_ERROR
-    } else { /* non-latest-format */
+    }
+    else { /* non-latest-format */
         if((fid = H5Fcreate(SWMR_FILENAME, H5F_ACC_TRUNC|H5F_ACC_SWMR_WRITE, H5P_DEFAULT, fapl)) < 0)
             FAIL_STACK_ERROR
     } /* end if */
@@ -1951,10 +1952,11 @@ test_swmr_write_big(hbool_t newest_format)
     if((pid = HDfork()) < 0) {
         HDperror("fork");
         FAIL_STACK_ERROR;
-    } else if(0 == pid) { /* Child process */
+    }
+    else if(0 == pid) { /* Child process */
         /* Run the reader */
         status = HDexecv(SWMR_READER, new_argv);
-        printf("errno from execv = %s\n", strerror(errno));
+        HDprintf("errno from execv = %s\n", strerror(errno));
         FAIL_STACK_ERROR;
     } /* end if */
 
@@ -2030,18 +2032,19 @@ accum_printf(const H5F_t *f)
 {
     H5F_meta_accum_t * accum = &f->shared->accum;
 
-    printf("\n");
-    printf("Current contents of accumulator:\n");
-    if (accum->alloc_size == 0) {
-        printf("=====================================================\n");
-        printf(" No accumulator allocated.\n");
-        printf("=====================================================\n");
-    } else {
-        printf("=====================================================\n");
-        printf(" accumulator allocated size == %zu\n", accum->alloc_size);
-        printf(" accumulated data size      == %zu\n", accum->size);
+    HDprintf("\n");
+    HDprintf("Current contents of accumulator:\n");
+    if(accum->alloc_size == 0) {
+        HDprintf("=====================================================\n");
+        HDprintf(" No accumulator allocated.\n");
+        HDprintf("=====================================================\n");
+    }
+    else {
+        HDprintf("=====================================================\n");
+        HDprintf(" accumulator allocated size == %zu\n", accum->alloc_size);
+        HDprintf(" accumulated data size      == %zu\n", accum->size);
         HDfprintf(stdout, " accumulator dirty?         == %t\n", accum->dirty);
-        printf("=====================================================\n");
+        HDprintf("=====================================================\n");
         HDfprintf(stdout, " start of accumulated data, loc = %a\n", accum->loc);
         if(accum->dirty) {
             HDfprintf(stdout, " start of dirty region, loc = %a\n", (haddr_t)(accum->loc + accum->dirty_off));
@@ -2049,8 +2052,8 @@ accum_printf(const H5F_t *f)
         } /* end if */
         HDfprintf(stdout, " end of accumulated data,   loc = %a\n", (haddr_t)(accum->loc + accum->size));
         HDfprintf(stdout, " end of accumulator allocation,   loc = %a\n", (haddr_t)(accum->loc + accum->alloc_size));
-        printf("=====================================================\n");
+        HDprintf("=====================================================\n");
     }
-    printf("\n\n");
+    HDprintf("\n\n");
 } /* accum_printf() */
 
diff --git a/test/accum_swmr_reader.c b/test/accum_swmr_reader.c
index 5bda46a..cf2616e 100644
--- a/test/accum_swmr_reader.c
+++ b/test/accum_swmr_reader.c
@@ -56,9 +56,8 @@ main(void)
      * by the environment variable.
      */
     driver = HDgetenv("HDF5_DRIVER");
-    if(!H5FD_supports_swmr_test(driver)) {
+    if(!H5FD__supports_swmr_test(driver))
         return EXIT_SUCCESS;
-    }
 
     /* Initialize buffers */
     for(u = 0; u < 1024; u++) {
@@ -101,8 +100,11 @@ main(void)
 
     return EXIT_SUCCESS;
 
-error: 
-    H5Fclose(fid);
+error:
+    H5E_BEGIN_TRY {
+        H5Pclose(fapl);
+        H5Fclose(fid);
+    } H5E_END_TRY;
 
     if(api_ctx_pushed) H5CX_pop();
 
diff --git a/test/dsets.c b/test/dsets.c
index d23f438..faf2ad7 100644
--- a/test/dsets.c
+++ b/test/dsets.c
@@ -27,7 +27,6 @@
 #include "testhdf5.h"
 #include "H5srcdir.h"
 
-#include "H5Bprivate.h"
 #include "H5CXprivate.h"        /* API Contexts                         */
 #include "H5Iprivate.h"
 #include "H5Pprivate.h"
@@ -2517,8 +2516,7 @@ error:
  *
  * Purpose:   Tests library behavior when filter is missing
  *
- * Return:    Success:    0
- *            Failure:    -1
+ * Return:    SUCCEED/FAIL
  *-------------------------------------------------------------------------
  */
 static herr_t
@@ -2543,7 +2541,7 @@ test_missing_filter(hid_t file)
         /* Verify deflate filter is registered currently */
         if(H5Zfilter_avail(H5Z_FILTER_DEFLATE)!=TRUE) {
             H5_FAILED();
-            printf("    Line %d: Deflate filter not available\n",__LINE__);
+            HDprintf("    Line %d: Deflate filter not available\n",__LINE__);
             goto error;
         } /* end if */
 
@@ -2555,31 +2553,31 @@ test_missing_filter(hid_t file)
         /* (Use private routine, to avoid range checking on filter ID) */
         if(H5Z__unregister(H5Z_FILTER_DEFLATE) < 0) {
             H5_FAILED();
-            printf("    Line %d: Can't unregister deflate filter\n",__LINE__);
+            HDprintf("    Line %d: Can't unregister deflate filter\n",__LINE__);
             goto error;
         } /* end if */
 #endif /* H5_HAVE_FILTER_DEFLATE */
         /* Verify deflate filter is not registered currently */
         if(H5Zfilter_avail(H5Z_FILTER_DEFLATE)!=FALSE) {
             H5_FAILED();
-            printf("    Line %d: Deflate filter available\n",__LINE__);
+            HDprintf("    Line %d: Deflate filter available\n",__LINE__);
             goto error;
         } /* end if */
 
     /* Create dcpl with deflate filter */
     if((dcpl = H5Pcreate(H5P_DATASET_CREATE)) < 0) {
         H5_FAILED();
-        printf("    Line %d: Can't create dcpl\n",__LINE__);
+        HDprintf("    Line %d: Can't create dcpl\n",__LINE__);
         goto error;
     } /* end if */
     if(H5Pset_chunk(dcpl, 2, chunk_dims) < 0) {
         H5_FAILED();
-        printf("    Line %d: Can't set chunk sizes\n",__LINE__);
+        HDprintf("    Line %d: Can't set chunk sizes\n",__LINE__);
         goto error;
     } /* end if */
     if(H5Pset_deflate(dcpl, 9) < 0) {
         H5_FAILED();
-        printf("    Line %d: Can't set deflate filter\n",__LINE__);
+        HDprintf("    Line %d: Can't set deflate filter\n",__LINE__);
         goto error;
     } /* end if */
 
@@ -2587,47 +2585,47 @@ test_missing_filter(hid_t file)
     ret=H5Pall_filters_avail(dcpl);
     if(ret<0) {
         H5_FAILED();
-        printf("    Line %d: Can't check filter availability\n",__LINE__);
+        HDprintf("    Line %d: Can't check filter availability\n",__LINE__);
         goto error;
     } /* end if */
     if(ret!=FALSE) {
         H5_FAILED();
-        printf("    Line %d: Filter shouldn't be available\n",__LINE__);
+        HDprintf("    Line %d: Filter shouldn't be available\n",__LINE__);
         goto error;
     } /* end if */
 
     /* Create the data space */
     if((sid = H5Screate_simple(2, dims, NULL)) < 0) {
         H5_FAILED();
-        printf("    Line %d: Can't open dataspace\n",__LINE__);
+        HDprintf("    Line %d: Can't open dataspace\n",__LINE__);
         goto error;
     } /* end if */
 
     /* Create new dataset */
     if((dsid = H5Dcreate2(file, DSET_MISSING_NAME, H5T_NATIVE_INT, sid, H5P_DEFAULT, dcpl, H5P_DEFAULT)) < 0) {
         H5_FAILED();
-        printf("    Line %d: Can't create dataset\n",__LINE__);
+        HDprintf("    Line %d: Can't create dataset\n",__LINE__);
         goto error;
     } /* end if */
 
     /* Write data */
     if(H5Dwrite(dsid, H5T_NATIVE_INT, H5S_ALL, H5S_ALL, H5P_DEFAULT, points) < 0) {
         H5_FAILED();
-        printf("    Line %d: Error writing dataset data\n",__LINE__);
+        HDprintf("    Line %d: Error writing dataset data\n",__LINE__);
         goto error;
     } /* end if */
 
     /* Flush the file (to clear the cache) */
     if(H5Fflush(file, H5F_SCOPE_GLOBAL) < 0) {
         H5_FAILED();
-        printf("    Line %d: Error flushing file\n",__LINE__);
+        HDprintf("    Line %d: Error flushing file\n",__LINE__);
         goto error;
     } /* end if */
 
     /* Query the dataset's size on disk */
     if(0 == (dset_size = H5Dget_storage_size(dsid))) {
         H5_FAILED();
-        printf("    Line %d: Error querying dataset size, dset_size=%lu\n",__LINE__,(unsigned long)dset_size);
+        HDprintf("    Line %d: Error querying dataset size, dset_size=%lu\n",__LINE__,(unsigned long)dset_size);
         goto error;
     } /* end if */
 
@@ -2635,14 +2633,14 @@ test_missing_filter(hid_t file)
     /* (i.e. the deflation filter we asked for was silently ignored) */
     if((H5Tget_size(H5T_NATIVE_INT) * DSET_DIM1 * DSET_DIM2) != dset_size) {
         H5_FAILED();
-        printf("    Line %d: Incorrect dataset size: %lu\n",__LINE__,(unsigned long)dset_size);
+        HDprintf("    Line %d: Incorrect dataset size: %lu\n",__LINE__,(unsigned long)dset_size);
         goto error;
     } /* end if */
 
     /* Read data */
     if(H5Dread(dsid, H5T_NATIVE_INT, H5S_ALL, H5S_ALL, H5P_DEFAULT, check) < 0) {
         H5_FAILED();
-        printf("    Line %d: Error reading dataset data\n",__LINE__);
+        HDprintf("    Line %d: Error reading dataset data\n",__LINE__);
         goto error;
     } /* end if */
 
@@ -2652,10 +2650,10 @@ test_missing_filter(hid_t file)
         for(j=0; j<(size_t)dims[1]; j++) {
             if(points[i][j] != check[i][j]) {
                 H5_FAILED();
-                printf("    Line %d: Read different values than written.\n",__LINE__);
-                printf("    At index %lu,%lu\n", (unsigned long)(i), (unsigned long)(j));
-                printf("    At original: %d\n",points[i][j]);
-                printf("    At returned: %d\n",check[i][j]);
+                HDprintf("    Line %d: Read different values than written.\n",__LINE__);
+                HDprintf("    At index %lu,%lu\n", (unsigned long)(i), (unsigned long)(j));
+                HDprintf("    At original: %d\n",points[i][j]);
+                HDprintf("    At returned: %d\n",check[i][j]);
                 goto error;
             } /* end if */
         } /* end for */
@@ -2664,21 +2662,21 @@ test_missing_filter(hid_t file)
     /* Close dataset */
     if(H5Dclose(dsid) < 0) {
         H5_FAILED();
-        printf("    Line %d: Can't close dataset\n",__LINE__);
+        HDprintf("    Line %d: Can't close dataset\n",__LINE__);
         goto error;
     } /* end if */
 
     /* Close dataspace */
     if(H5Sclose(sid) < 0) {
         H5_FAILED();
-        printf("    Line %d: Can't close dataspace\n",__LINE__);
+        HDprintf("    Line %d: Can't close dataspace\n",__LINE__);
         goto error;
     } /* end if */
 
     /* Close dataset creation property list */
     if(H5Pclose(dcpl) < 0) {
         H5_FAILED();
-        printf("    Line %d: Can't close dcpl\n",__LINE__);
+        HDprintf("    Line %d: Can't close dcpl\n",__LINE__);
         goto error;
     } /* end if */
 
@@ -2688,14 +2686,14 @@ test_missing_filter(hid_t file)
     /* Open existing file */
     if((fid = H5Fopen(testfile, H5F_ACC_RDONLY, H5P_DEFAULT)) < 0) {
         H5_FAILED();
-        printf("    Line %d: Can't open existing deflated file\n", __LINE__);
+        HDprintf("    Line %d: Can't open existing deflated file\n", __LINE__);
         goto error;
     } /* end if */
 
     /* Open dataset */
     if((dsid = H5Dopen2(fid, "Dataset1", H5P_DEFAULT)) < 0) {
         H5_FAILED();
-        printf("    Line %d: Can't open dataset\n", __LINE__);
+        HDprintf("    Line %d: Can't open dataset\n", __LINE__);
         goto error;
     } /* end if */
 
@@ -2705,21 +2703,21 @@ test_missing_filter(hid_t file)
     } H5E_END_TRY;
     if(ret>=0) {
         H5_FAILED();
-        printf("    Line %d: Should not be able to read dataset data\n", __LINE__);
+        HDprintf("    Line %d: Should not be able to read dataset data\n", __LINE__);
         goto error;
     } /* end if */
 
     /* Close dataset */
     if(H5Dclose(dsid) < 0) {
         H5_FAILED();
-        printf("    Line %d: Can't close dataset\n", __LINE__);
+        HDprintf("    Line %d: Can't close dataset\n", __LINE__);
         goto error;
     } /* end if */
 
     /* Close existing file */
     if(H5Fclose(fid) < 0) {
         H5_FAILED();
-        printf("    Line %d: Can't close file\n", __LINE__);
+        HDprintf("    Line %d: Can't close file\n", __LINE__);
         goto error;
     } /* end if */
 
@@ -2727,21 +2725,21 @@ test_missing_filter(hid_t file)
         /* Verify deflate filter is not registered currently */
         if(H5Zfilter_avail(H5Z_FILTER_DEFLATE)!=FALSE) {
             H5_FAILED();
-            printf("    Line %d: Deflate filter available\n",__LINE__);
+            HDprintf("    Line %d: Deflate filter available\n",__LINE__);
             goto error;
         } /* end if */
 #ifdef H5_HAVE_FILTER_DEFLATE
         /* Register deflate filter (use internal function to avoid range checks) */
         if(H5Z_register(H5Z_DEFLATE) < 0) {
             H5_FAILED();
-            printf("    Line %d: Can't unregister deflate filter\n",__LINE__);
+            HDprintf("    Line %d: Can't unregister deflate filter\n",__LINE__);
             goto error;
         } /* end if */
 
         /* Verify deflate filter is registered currently */
         if(H5Zfilter_avail(H5Z_FILTER_DEFLATE)!=TRUE) {
             H5_FAILED();
-            printf("    Line %d: Deflate filter not available\n",__LINE__);
+            HDprintf("    Line %d: Deflate filter not available\n",__LINE__);
             goto error;
         } /* end if */
 #endif /* H5_HAVE_FILTER_DEFLATE */
@@ -2751,13 +2749,13 @@ test_missing_filter(hid_t file)
     api_ctx_pushed = FALSE;
 
     PASSED();
-    return 0;
+    return SUCCEED;
 
 error:
     if(api_ctx_pushed) H5CX_pop();
 
-    return -1;
-}
+    return FAIL;
+} /* end test_missing_filter() */
 
 
 /*-------------------------------------------------------------------------
@@ -8301,25 +8299,25 @@ test_chunk_fast(const char *env_h5_driver, hid_t fapl)
 
     /* Loop over using SWMR access to write */
     for(swmr = 0; swmr <= 1; swmr++) {
-    int     compress;       /* Whether chunks should be compressed */
+        int     compress;       /* Whether chunks should be compressed */
 
         /* SWMR is now supported with/without latest format:  */
-    /* (1) write+latest-format (2) SWMR-write+non-latest-format */
+        /* (1) write+latest-format (2) SWMR-write+non-latest-format */
 
         /* Skip this iteration if SWMR I/O is not supported for the VFD specified
          * by the environment variable.
          */
-        if(swmr && !H5FD_supports_swmr_test(env_h5_driver))
+        if(swmr && !H5FD__supports_swmr_test(env_h5_driver))
             continue;
 
 #ifdef H5_HAVE_FILTER_DEFLATE
         /* Loop over compressing chunks */
         for(compress = 0; compress <= 1; compress++)
 #else
-    /* Loop over without compression */
+        /* Loop over without compression */
         for(compress = 0; compress <= 0; compress++)
 #endif /* H5_HAVE_FILTER_DEFLATE */
-    {
+        {
             H5D_alloc_time_t alloc_time;        /* Storage allocation time */
 
             /* Loop over storage allocation time */
@@ -10412,11 +10410,11 @@ test_swmr_non_latest(const char *env_h5_driver, hid_t fapl)
     /* Skip this test if SWMR I/O is not supported for the VFD specified
      * by the environment variable.
      */
-    if(!H5FD_supports_swmr_test(env_h5_driver)) {
+    if(!H5FD__supports_swmr_test(env_h5_driver)) {
         SKIPPED();
         HDputs("    Test skipped due to VFD not supporting SWMR I/O.");
         return 0;
-    } /* end if */
+    }
 
     /* Check if we are using the latest version of the format */
     if(H5Pget_libver_bounds(fapl, &low, NULL) < 0)
@@ -10428,7 +10426,8 @@ test_swmr_non_latest(const char *env_h5_driver, hid_t fapl)
         /* Create file with write+latest-format */
         if((fid = H5Fcreate(filename, H5F_ACC_TRUNC, H5P_DEFAULT, fapl)) < 0)
             FAIL_STACK_ERROR
-    } else {
+    }
+    else {
         /* Create file with SWMR-write+non-latest-format */
         if((fid = H5Fcreate(filename, H5F_ACC_TRUNC|H5F_ACC_SWMR_WRITE, H5P_DEFAULT, fapl)) < 0)
             FAIL_STACK_ERROR
@@ -10661,11 +10660,11 @@ test_earray_hdr_fd(const char *env_h5_driver, hid_t fapl)
     /* Skip this test if SWMR I/O is not supported for the VFD specified
      * by the environment variable.
      */
-    if(!H5FD_supports_swmr_test(env_h5_driver)) {
+    if(!H5FD__supports_swmr_test(env_h5_driver)) {
         SKIPPED();
         HDputs("    Test skipped due to VFD not supporting SWMR I/O.");
         return 0;
-    } /* end if */
+    }
 
     if((fapl = H5Pcreate(H5P_FILE_ACCESS)) < 0)
         FAIL_STACK_ERROR;
@@ -10781,11 +10780,11 @@ test_farray_hdr_fd(const char *env_h5_driver, hid_t fapl)
     /* Skip this test if SWMR I/O is not supported for the VFD specified
      * by the environment variable.
      */
-    if(!H5FD_supports_swmr_test(env_h5_driver)) {
+    if(!H5FD__supports_swmr_test(env_h5_driver)) {
         SKIPPED();
         HDputs("    Test skipped due to VFD not supporting SWMR I/O.");
         return 0;
-    } /* end if */
+    }
 
     if((fapl = H5Pcreate(H5P_FILE_ACCESS)) < 0)
         FAIL_STACK_ERROR;
@@ -10901,11 +10900,11 @@ test_bt2_hdr_fd(const char *env_h5_driver, hid_t fapl)
     /* Skip this test if SWMR I/O is not supported for the VFD specified
      * by the environment variable.
      */
-    if(!H5FD_supports_swmr_test(env_h5_driver)) {
+    if(!H5FD__supports_swmr_test(env_h5_driver)) {
         SKIPPED();
         HDputs("    Test skipped due to VFD not supporting SWMR I/O.");
         return 0;
-    } /* end if */
+    }
 
     if((fapl = H5Pcreate(H5P_FILE_ACCESS)) < 0)
         FAIL_STACK_ERROR;
@@ -12904,7 +12903,7 @@ error:
 #define SRC_DSET    "src_dset"
 #define V_DSET      "v_dset"
 static herr_t
-test_versionbounds()
+test_versionbounds(void)
 {
     hid_t fapl = -1;
     hid_t srcfile = -1;   /* Files with source dsets */
diff --git a/test/flush1.c b/test/flush1.c
index bdbd731..fefa8d0 100644
--- a/test/flush1.c
+++ b/test/flush1.c
@@ -209,7 +209,7 @@ main(void)
 
     /* Check if the current VFD supports SWMR */
     driver = HDgetenv("HDF5_DRIVER");
-    vfd_supports_swmr = H5FD_supports_swmr_test(driver);
+    vfd_supports_swmr = H5FD__supports_swmr_test(driver);
 
     /*************************************************/
     /* NOTE: Not closing the file ID is intentional! */
diff --git a/test/flush2.c b/test/flush2.c
index 9fdf6c1..6e8aee7 100644
--- a/test/flush2.c
+++ b/test/flush2.c
@@ -258,7 +258,7 @@ main(void)
 
     /* Check if the current VFD supports SWMR */
     driver = HDgetenv("HDF5_DRIVER");
-    vfd_supports_swmr = H5FD_supports_swmr_test(driver);
+    vfd_supports_swmr = H5FD__supports_swmr_test(driver);
 
     /* TEST 1 */
     /* Check the case where the file was flushed */
diff --git a/test/flushrefresh.c b/test/flushrefresh.c
index 4196d85..42b5e43 100644
--- a/test/flushrefresh.c
+++ b/test/flushrefresh.c
@@ -130,7 +130,7 @@ herr_t end_verification(void);
  *              it will time out waiting for a signal from the test script
  *              which will never come.
  *
- * Return:      0 on Success, 1 on Failure
+ * Return:      EXIT_SUCCESS/EXIT_FAILURE
  *
  * Programmer:  Mike McGreevy
  *              July 1, 2010
@@ -155,7 +155,7 @@ int main(int argc, const char *argv[])
         /* Determine driver being used */
         envval = HDgetenv("HDF5_DRIVER");
 
-        if(envval == NULL || H5FD_supports_swmr_test(envval)) {
+        if(envval == NULL || H5FD__supports_swmr_test(envval)) {
             if(test_flush() != SUCCEED) TEST_ERROR;
             if(test_refresh() != SUCCEED) TEST_ERROR;
         } /* end if */
@@ -166,23 +166,26 @@ int main(int argc, const char *argv[])
             if(end_verification() < 0) TEST_ERROR;
             if(end_verification() < 0) TEST_ERROR;
         } /* end else */
-    } else if(argc == 3) {
+    }
+    else if(argc == 3) {
         /* Two arguments supplied. Pass them to flush verification routine. */
         if(flush_verification(argv[1], argv[2]) != 0) PROCESS_ERROR;
-    } else if(argc == 2) {
+    }
+    else if(argc == 2) {
         /* One argument supplied. Pass it to refresh verification routine. */
         if(refresh_verification(argv[1]) != 0) PROCESS_ERROR;
-    } else {
+    }
+    else {
         /* Illegal number of arguments supplied. Error. */
         HDfprintf(stderr, "Error. %d is an Invalid number of arguments to main().\n", argc);
         PROCESS_ERROR
     } /* end if */
 
-    return SUCCEED;
+    return EXIT_SUCCESS;
 
 error:
     /* Return */
-    return FAIL;
+    return EXIT_FAILURE;
 } /* main */
 
 
@@ -1027,55 +1030,57 @@ herr_t refresh_verification(const char * obj_pathname)
      * test cases is easy). */
     do {
 
-	if((HDstrcmp(obj_pathname, D1) == 0) || (HDstrcmp(obj_pathname, D2) == 0)) {
-	    if(H5Drefresh(oid) < 0) PROCESS_ERROR;
-	} /* end if */
-	else if((HDstrcmp(obj_pathname, G1) == 0) || (HDstrcmp(obj_pathname, G2) == 0)) {
-	    if(H5Grefresh(oid) < 0) PROCESS_ERROR;
-	} /* end if */
-	else if((HDstrcmp(obj_pathname, T1) == 0) || (HDstrcmp(obj_pathname, T2) == 0)) {
-	    if(H5Trefresh(oid) < 0) PROCESS_ERROR;
-	} /* end if */
-	else if((HDstrcmp(obj_pathname, D3) == 0) || (HDstrcmp(obj_pathname, G3) == 0) ||
+        if((HDstrcmp(obj_pathname, D1) == 0) || (HDstrcmp(obj_pathname, D2) == 0)) {
+            if(H5Drefresh(oid) < 0) PROCESS_ERROR;
+        } /* end if */
+        else if((HDstrcmp(obj_pathname, G1) == 0) || (HDstrcmp(obj_pathname, G2) == 0)) {
+            if(H5Grefresh(oid) < 0) PROCESS_ERROR;
+        } /* end if */
+        else if((HDstrcmp(obj_pathname, T1) == 0) || (HDstrcmp(obj_pathname, T2) == 0)) {
+            if(H5Trefresh(oid) < 0) PROCESS_ERROR;
+        } /* end if */
+        else if((HDstrcmp(obj_pathname, D3) == 0) || (HDstrcmp(obj_pathname, G3) == 0) ||
                 (HDstrcmp(obj_pathname, T3) == 0)) {
-	    if(H5Orefresh(oid) < 0) PROCESS_ERROR;
-	} /* end if */
-	else {
-	    HDfprintf(stdout, "Error. %s is an unrecognized object.\n", obj_pathname);
-	    PROCESS_ERROR;
-	} /* end else */
-
-	/* Get object info. This should now accurately reflect the refreshed object on disk. */
-	if((status = H5Oget_info2(oid, &refreshed_oinfo, H5O_INFO_BASIC|H5O_INFO_NUM_ATTRS|H5O_INFO_HDR)) < 0) PROCESS_ERROR;
-    
-	/* Confirm following (first 4) attributes are the same: */
-	/* Confirm following (last 4) attributes are different */
-	if( (flushed_oinfo.addr == refreshed_oinfo.addr) &&
-	    (flushed_oinfo.type == refreshed_oinfo.type) &&
-	    (flushed_oinfo.hdr.version == refreshed_oinfo.hdr.version) &&
-	    (flushed_oinfo.hdr.flags == refreshed_oinfo.hdr.flags) &&
-	    (flushed_oinfo.num_attrs != refreshed_oinfo.num_attrs) &&
-	    (flushed_oinfo.hdr.nmesgs != refreshed_oinfo.hdr.nmesgs) &&
-	    (flushed_oinfo.hdr.nchunks != refreshed_oinfo.hdr.nchunks) &&
-	    (flushed_oinfo.hdr.space.total != refreshed_oinfo.hdr.space.total) ) {
-		ok = TRUE;
-		break;
-	}
-	if(tries == sleep_tries)
-	    HDsleep(1);
+            if(H5Orefresh(oid) < 0) PROCESS_ERROR;
+        } /* end if */
+        else {
+            HDfprintf(stdout, "Error. %s is an unrecognized object.\n", obj_pathname);
+            PROCESS_ERROR;
+        } /* end else */
+
+        /* Get object info. This should now accurately reflect the refreshed object on disk. */
+        if((status = H5Oget_info2(oid, &refreshed_oinfo, H5O_INFO_BASIC|H5O_INFO_NUM_ATTRS|H5O_INFO_HDR)) < 0)
+            PROCESS_ERROR;
+
+        /* Confirm following (first 4) attributes are the same: */
+        /* Confirm following (last 4) attributes are different */
+        if( (flushed_oinfo.addr == refreshed_oinfo.addr) &&
+            (flushed_oinfo.type == refreshed_oinfo.type) &&
+            (flushed_oinfo.hdr.version == refreshed_oinfo.hdr.version) &&
+            (flushed_oinfo.hdr.flags == refreshed_oinfo.hdr.flags) &&
+            (flushed_oinfo.num_attrs != refreshed_oinfo.num_attrs) &&
+            (flushed_oinfo.hdr.nmesgs != refreshed_oinfo.hdr.nmesgs) &&
+            (flushed_oinfo.hdr.nchunks != refreshed_oinfo.hdr.nchunks) &&
+            (flushed_oinfo.hdr.space.total != refreshed_oinfo.hdr.space.total) ) {
+            ok = TRUE;
+            break;
+        }
+
+        if(tries == sleep_tries)
+            HDsleep(1);
 
     } while(--tries);
-    
+
     if(!ok) {
-	printf("FLUSHED: num_attrs=%d, nmesgs=%d, nchunks=%d, total=%d\n",
-	    (int)flushed_oinfo.num_attrs, (int)flushed_oinfo.hdr.nmesgs,
-	    (int)flushed_oinfo.hdr.nchunks, (int)flushed_oinfo.hdr.space.total);
-	printf("REFRESHED: num_attrs=%d, nmesgs=%d, nchunks=%d, total=%d\n",
-	    (int)refreshed_oinfo.num_attrs, (int)refreshed_oinfo.hdr.nmesgs,
-	    (int)refreshed_oinfo.hdr.nchunks, (int)refreshed_oinfo.hdr.space.total);
-	PROCESS_ERROR;
+        HDprintf("FLUSHED: num_attrs=%d, nmesgs=%d, nchunks=%d, total=%d\n",
+            (int)flushed_oinfo.num_attrs, (int)flushed_oinfo.hdr.nmesgs,
+            (int)flushed_oinfo.hdr.nchunks, (int)flushed_oinfo.hdr.space.total);
+        HDprintf("REFRESHED: num_attrs=%d, nmesgs=%d, nchunks=%d, total=%d\n",
+            (int)refreshed_oinfo.num_attrs, (int)refreshed_oinfo.hdr.nmesgs,
+            (int)refreshed_oinfo.hdr.nchunks, (int)refreshed_oinfo.hdr.space.total);
+        PROCESS_ERROR;
     }
-    
+
     /* Close objects */
     if(H5Oclose(oid) < 0) PROCESS_ERROR;
     if(H5Fclose(fid) < 0) PROCESS_ERROR;
diff --git a/test/links.c b/test/links.c
index fb2c75a..786aa8f 100644
--- a/test/links.c
+++ b/test/links.c
@@ -4052,7 +4052,7 @@ external_set_elink_acc_flags(const char *env_h5_drvr, hid_t fapl, hbool_t new_fo
     if(H5Fclose(file1) < 0) TEST_ERROR
 
     /* Only run this part with VFDs that support SWMR */
-    if(H5FD_supports_swmr_test(env_h5_drvr)) {
+    if(H5FD__supports_swmr_test(env_h5_drvr)) {
 
         /* Reopen file1, with read-write and SWMR-write access */
         /* Only supported under the latest file format */
@@ -8354,9 +8354,9 @@ ud_callbacks(hid_t fapl, hbool_t new_format)
     if (H5Lget_info(fid, UD_CB_LINK_NAME, &li, H5P_DEFAULT) < 0) TEST_ERROR
     if(li.u.val_size != 16) TEST_ERROR
     if (UD_CB_TYPE != li.type) {
-	H5_FAILED();
-	HDputs("    Unexpected link class - should have been a UD hard link");
-	goto error;
+        H5_FAILED();
+        HDputs("    Unexpected link class - should have been a UD hard link");
+        goto error;
     }
 
     /* Fill the query buffer */
@@ -9004,9 +9004,9 @@ lapl_nlinks(hid_t fapl, hbool_t new_format)
         gid = H5Oopen(fid, "soft5", plist);
     } H5E_END_TRY;
     if (gid >= 0) {
-	H5_FAILED();
-	HDputs("    Should have failed for sequence of too many nested links.");
-	goto error;
+        H5_FAILED();
+        HDputs("    Should have failed for sequence of too many nested links.");
+        goto error;
     }
 
     /* Open object through lesser soft link */
@@ -15003,7 +15003,7 @@ main(void)
             nerrors += external_copy_invalid_object(my_fapl, new_format) < 0 ? 1 : 0;
             nerrors += external_dont_fail_to_source(my_fapl, new_format) < 0 ? 1 : 0;
             nerrors += external_open_twice(my_fapl, new_format) < 0 ? 1 : 0;
-	    nerrors += external_link_with_committed_datatype(my_fapl, new_format) < 0 ? 1 : 0;
+            nerrors += external_link_with_committed_datatype(my_fapl, new_format) < 0 ? 1 : 0;
         } /* end for */
 
         /* These tests assume that external links are a form of UD links,
diff --git a/test/swmr.c b/test/swmr.c
index 0b352e2..b7e54e7 100644
--- a/test/swmr.c
+++ b/test/swmr.c
@@ -6484,106 +6484,106 @@ test_refresh_concur(hid_t in_fapl, hbool_t new_format)
     if(childpid == 0) { /* Child process */
         hid_t child_fid1 = -1;    /* File ID */
         hid_t child_fid2 = -1;    /* File ID */
-    hid_t child_did1 = -1, child_did2 = -1;
-    hid_t child_sid = -1;
-    hsize_t tdims[1];
-    int rbuf[2] = {0, 0};
-    int child_notify = 0;
+        hid_t child_did1 = -1, child_did2 = -1;
+        hid_t child_sid = -1;
+        hsize_t tdims[1];
+        int rbuf[2] = {0, 0};
+        int child_notify = 0;
 
-    /* Close unused write end for out_pdf */
-    if(HDclose(out_pdf[1]) < 0)
-        HDexit(EXIT_FAILURE);
+        /* Close unused write end for out_pdf */
+        if(HDclose(out_pdf[1]) < 0)
+            HDexit(EXIT_FAILURE);
 
-    /* close unused read end for in_pdf */
-    if(HDclose(in_pdf[0]) < 0)
-        HDexit(EXIT_FAILURE);
+        /* close unused read end for in_pdf */
+        if(HDclose(in_pdf[0]) < 0)
+            HDexit(EXIT_FAILURE);
 
-    /* Wait for notification from parent process */
-    while(child_notify != 1) {
-        if(HDread(out_pdf[0], &child_notify, sizeof(int)) < 0)
-        HDexit(EXIT_FAILURE);
-    }
+        /* Wait for notification from parent process */
+        while(child_notify != 1) {
+            if(HDread(out_pdf[0], &child_notify, sizeof(int)) < 0)
+                HDexit(EXIT_FAILURE);
+        }
 
-    /* Open the file 2 times */
-    if((child_fid1 = H5Fopen(filename, H5F_ACC_RDONLY|H5F_ACC_SWMR_READ, fapl)) < 0)
-        HDexit(EXIT_FAILURE);
+        /* Open the file 2 times */
+        if((child_fid1 = H5Fopen(filename, H5F_ACC_RDONLY|H5F_ACC_SWMR_READ, fapl)) < 0)
+            HDexit(EXIT_FAILURE);
 
-    if((child_fid2 = H5Fopen(filename, H5F_ACC_RDONLY|H5F_ACC_SWMR_READ, fapl)) < 0)
-        HDexit(EXIT_FAILURE);
+        if((child_fid2 = H5Fopen(filename, H5F_ACC_RDONLY|H5F_ACC_SWMR_READ, fapl)) < 0)
+            HDexit(EXIT_FAILURE);
 
-    /* Open the dataset 2 times */
-    if((child_did1 = H5Dopen2(child_fid1, "dataset", H5P_DEFAULT)) < 0)
-        HDexit(EXIT_FAILURE);
-    if((child_did2 = H5Dopen2(child_fid2, "dataset", H5P_DEFAULT)) < 0)
-        HDexit(EXIT_FAILURE);
+        /* Open the dataset 2 times */
+        if((child_did1 = H5Dopen2(child_fid1, "dataset", H5P_DEFAULT)) < 0)
+            HDexit(EXIT_FAILURE);
+        if((child_did2 = H5Dopen2(child_fid2, "dataset", H5P_DEFAULT)) < 0)
+            HDexit(EXIT_FAILURE);
 
-    /* Get the dataset's dataspace via did1 */
-    if((child_sid = H5Dget_space(child_did1)) < 0)
-        HDexit(EXIT_FAILURE);
-    if(H5Sget_simple_extent_dims(child_sid, tdims, NULL) < 0)
-        HDexit(EXIT_FAILURE);
-    if(tdims[0] != 1)
-        HDexit(EXIT_FAILURE);
+        /* Get the dataset's dataspace via did1 */
+        if((child_sid = H5Dget_space(child_did1)) < 0)
+            HDexit(EXIT_FAILURE);
+        if(H5Sget_simple_extent_dims(child_sid, tdims, NULL) < 0)
+            HDexit(EXIT_FAILURE);
+        if(tdims[0] != 1)
+            HDexit(EXIT_FAILURE);
 
-    /* Read from the dataset via did2 */
-    if(H5Dread(child_did2, H5T_NATIVE_INT, H5S_ALL, H5S_ALL, H5P_DEFAULT, rbuf) < 0)
-        HDexit(EXIT_FAILURE);
+        /* Read from the dataset via did2 */
+        if(H5Dread(child_did2, H5T_NATIVE_INT, H5S_ALL, H5S_ALL, H5P_DEFAULT, rbuf) < 0)
+            HDexit(EXIT_FAILURE);
 
-    /* Verify the data is correct */
-    if(rbuf[0] != 99)
-        HDexit(EXIT_FAILURE);
+        /* Verify the data is correct */
+        if(rbuf[0] != 99)
+            HDexit(EXIT_FAILURE);
 
-    /* Notify parent process */
-    child_notify = 2;
-    if(HDwrite(in_pdf[1], &child_notify, sizeof(int)) < 0)
-        HDexit(EXIT_FAILURE);
+        /* Notify parent process */
+        child_notify = 2;
+        if(HDwrite(in_pdf[1], &child_notify, sizeof(int)) < 0)
+            HDexit(EXIT_FAILURE);
 
-    /* Wait for notification from parent process */
-    while(child_notify != 3) {
-        if(HDread(out_pdf[0], &child_notify, sizeof(int)) < 0)
-        HDexit(EXIT_FAILURE);
-    }
+        /* Wait for notification from parent process */
+        while(child_notify != 3) {
+            if(HDread(out_pdf[0], &child_notify, sizeof(int)) < 0)
+                HDexit(EXIT_FAILURE);
+        }
 
-    /* Refresh dataset via did1 */
-    if(H5Drefresh(child_did1) < 0)
-        HDexit(EXIT_FAILURE);
+        /* Refresh dataset via did1 */
+        if(H5Drefresh(child_did1) < 0)
+            HDexit(EXIT_FAILURE);
 
-    /* Get the dataset's dataspace and verify */
-    if((child_sid = H5Dget_space(child_did1)) < 0)
-        HDexit(EXIT_FAILURE);
-    if(H5Sget_simple_extent_dims(child_sid, tdims, NULL) < 0)
-        HDexit(EXIT_FAILURE);
+        /* Get the dataset's dataspace and verify */
+        if((child_sid = H5Dget_space(child_did1)) < 0)
+            HDexit(EXIT_FAILURE);
+        if(H5Sget_simple_extent_dims(child_sid, tdims, NULL) < 0)
+            HDexit(EXIT_FAILURE);
 
-    if(tdims[0] != 2)
-        HDexit(EXIT_FAILURE);
+        if(tdims[0] != 2)
+            HDexit(EXIT_FAILURE);
 
-    /* Read from the dataset */
-    if(H5Dread(child_did2, H5T_NATIVE_INT, H5S_ALL, H5S_ALL, H5P_DEFAULT, rbuf) < 0)
-        HDexit(EXIT_FAILURE);
+        /* Read from the dataset */
+        if(H5Dread(child_did2, H5T_NATIVE_INT, H5S_ALL, H5S_ALL, H5P_DEFAULT, rbuf) < 0)
+            HDexit(EXIT_FAILURE);
 
-    /* Verify the data is correct */
-    if(rbuf[0] != 100 || rbuf[1] != 100)
-        HDexit(EXIT_FAILURE);
+        /* Verify the data is correct */
+        if(rbuf[0] != 100 || rbuf[1] != 100)
+            HDexit(EXIT_FAILURE);
 
-    /* Close the 2 datasets */
-    if(H5Dclose(child_did1) < 0)
-        HDexit(EXIT_FAILURE);
-    if(H5Dclose(child_did2) < 0)
-        HDexit(EXIT_FAILURE);
+        /* Close the 2 datasets */
+        if(H5Dclose(child_did1) < 0)
+            HDexit(EXIT_FAILURE);
+        if(H5Dclose(child_did2) < 0)
+            HDexit(EXIT_FAILURE);
 
-    /* Close the 2 files */
-    if(H5Fclose(child_fid1) < 0)
-        HDexit(EXIT_FAILURE);
-    if(H5Fclose(child_fid2) < 0)
-        HDexit(EXIT_FAILURE);
+        /* Close the 2 files */
+        if(H5Fclose(child_fid1) < 0)
+            HDexit(EXIT_FAILURE);
+        if(H5Fclose(child_fid2) < 0)
+            HDexit(EXIT_FAILURE);
 
-    /* Close the pipes */
-    if(HDclose(out_pdf[0]) < 0)
-        HDexit(EXIT_FAILURE);
-    if(HDclose(in_pdf[1]) < 0)
-        HDexit(EXIT_FAILURE);
+        /* Close the pipes */
+        if(HDclose(out_pdf[0]) < 0)
+            HDexit(EXIT_FAILURE);
+        if(HDclose(in_pdf[1]) < 0)
+            HDexit(EXIT_FAILURE);
 
-    HDexit(EXIT_SUCCESS);
+        HDexit(EXIT_SUCCESS);
     }
 
     /* Close unused read end for out_pdf */
@@ -7042,7 +7042,7 @@ main(void)
      * by the environment variable.
      */
     driver = HDgetenv("HDF5_DRIVER");
-    if(!H5FD_supports_swmr_test(driver)) {
+    if(!H5FD__supports_swmr_test(driver)) {
         printf("This VFD does not support SWMR I/O\n");
         return EXIT_SUCCESS;
     } /* end if */
diff --git a/test/swmr_check_compat_vfd.c b/test/swmr_check_compat_vfd.c
index 1589f6e..e249e09 100644
--- a/test/swmr_check_compat_vfd.c
+++ b/test/swmr_check_compat_vfd.c
@@ -46,7 +46,7 @@ main(void)
 
     driver = HDgetenv("HDF5_DRIVER");
 
-    if(H5FD_supports_swmr_test(driver))
+    if(H5FD__supports_swmr_test(driver))
         return EXIT_SUCCESS;
     else
         return EXIT_FAILURE;
diff --git a/tools/src/h5format_convert/h5format_convert.c b/tools/src/h5format_convert/h5format_convert.c
index 0fc0289..b9ed9ce 100644
--- a/tools/src/h5format_convert/h5format_convert.c
+++ b/tools/src/h5format_convert/h5format_convert.c
@@ -226,81 +226,84 @@ convert(hid_t fid, const char *dname)
 
     /* Open the dataset */
     if((did = H5Dopen2(fid, dname, H5P_DEFAULT)) < 0) {
-	error_msg("unable to open dataset \"%s\"\n", dname);
-	h5tools_setstatus(EXIT_FAILURE);
-	goto error;
-
-    } else if(verbose_g)
-	HDfprintf(stdout, "Open the dataset\n");
+        error_msg("unable to open dataset \"%s\"\n", dname);
+        h5tools_setstatus(EXIT_FAILURE);
+        goto error;
+    }
+    else if(verbose_g)
+        HDfprintf(stdout, "Open the dataset\n");
 
     /* Get the dataset's creation property list */
     if((dcpl = H5Dget_create_plist(did)) < 0) {
-	error_msg("unable to get the dataset creation property list\n");
-	h5tools_setstatus(EXIT_FAILURE);
-	goto error;
+        error_msg("unable to get the dataset creation property list\n");
+        h5tools_setstatus(EXIT_FAILURE);
+        goto error;
     }
 
     /* Get the dataset's layout */
     if((layout_type = H5Pget_layout(dcpl)) < 0) {
-	error_msg("unable to get the dataset layout type\n");
-	h5tools_setstatus(EXIT_FAILURE);
-	goto error;
-
-    } else if(verbose_g)
-	HDfprintf(stdout, "Retrieve the dataset's layout\n");
+        error_msg("unable to get the dataset layout type\n");
+        h5tools_setstatus(EXIT_FAILURE);
+        goto error;
+    }
+    else if(verbose_g)
+        HDfprintf(stdout, "Retrieve the dataset's layout\n");
 
     switch(layout_type) {
-	case H5D_CHUNKED:
-	    if(verbose_g)
-		HDfprintf(stdout, "Dataset is a chunked dataset\n");
-
-	    /* Get the dataset's chunk indexing type */
-	    if(H5Dget_chunk_index_type(did, &idx_type) < 0) {
-		error_msg("unable to get the chunk indexing type for \"%s\"\n", dname);
-		h5tools_setstatus(EXIT_FAILURE);
-		goto error;
-	    } else if(verbose_g)
-		HDfprintf(stdout, "Retrieve the dataset's chunk indexing type\n");
+    case H5D_CHUNKED:
+        if(verbose_g)
+            HDfprintf(stdout, "Dataset is a chunked dataset\n");
+
+        /* Get the dataset's chunk indexing type */
+        if(H5Dget_chunk_index_type(did, &idx_type) < 0) {
+            error_msg("unable to get the chunk indexing type for \"%s\"\n", dname);
+            h5tools_setstatus(EXIT_FAILURE);
+            goto error;
+	    }
+        else if(verbose_g)
+            HDfprintf(stdout, "Retrieve the dataset's chunk indexing type\n");
+
+        if(idx_type == H5D_CHUNK_IDX_BTREE) {
+            if(verbose_g)
+                HDfprintf(stdout, "Dataset's chunk indexing type is already version 1 B-tree: no further action\n");
+            h5tools_setstatus(EXIT_SUCCESS);
+            goto done;
+	    }
+        else if (verbose_g)
+            HDfprintf(stdout, "Dataset's chunk indexing type is not version 1 B-tree\n");
 
-	    if(idx_type == H5D_CHUNK_IDX_BTREE) {
-		if(verbose_g)
-		    HDfprintf(stdout, "Dataset's chunk indexing type is already version 1 B-tree: no further action\n");
-		h5tools_setstatus(EXIT_SUCCESS);
-		goto done;
-	    } else if (verbose_g)
-		HDfprintf(stdout, "Dataset's chunk indexing type is not version 1 B-tree\n");
 	    break;
 
-	case H5D_CONTIGUOUS:
-	    if(verbose_g)
-		HDfprintf(stdout, "Dataset is a contiguous dataset: downgrade layout version as needed\n");
-	    break;
+    case H5D_CONTIGUOUS:
+        if(verbose_g)
+            HDfprintf(stdout, "Dataset is a contiguous dataset: downgrade layout version as needed\n");
+        break;
 
-        case H5D_COMPACT:
-	    if(verbose_g)
-		HDfprintf(stdout, "Dataset is a compact dataset: downgrade layout version as needed\n");
-	    break;
+    case H5D_COMPACT:
+        if(verbose_g)
+            HDfprintf(stdout, "Dataset is a compact dataset: downgrade layout version as needed\n");
+        break;
 
-        case H5D_VIRTUAL:
-	    if(verbose_g)
-		HDfprintf(stdout, "No further action for virtual dataset\n");
-	    goto done;
+    case H5D_VIRTUAL:
+        if(verbose_g)
+            HDfprintf(stdout, "No further action for virtual dataset\n");
+        goto done;
 
-        case H5D_NLAYOUTS:
-        case H5D_LAYOUT_ERROR:
-	default:
-	    error_msg("unknown layout type for \"%s\"\n", dname);
-	    h5tools_setstatus(EXIT_FAILURE);
-	    goto error;
+    case H5D_NLAYOUTS:
+    case H5D_LAYOUT_ERROR:
+    default:
+        error_msg("unknown layout type for \"%s\"\n", dname);
+        h5tools_setstatus(EXIT_FAILURE);
+        goto error;
 
     } /* end switch */
 
     /* No further action if it is a noop */
     if(noop_g) {
-	if(verbose_g)
-	    HDfprintf(stdout, "Not converting the dataset\n");
-	h5tools_setstatus(EXIT_SUCCESS);
-	goto done;
+        if(verbose_g)
+            HDfprintf(stdout, "Not converting the dataset\n");
+            h5tools_setstatus(EXIT_SUCCESS);
+            goto done;
     }
 
     if(verbose_g)
@@ -308,51 +311,54 @@ convert(hid_t fid, const char *dname)
 
     /* Downgrade the dataset */
     if(H5Dformat_convert(did) < 0) {
-	error_msg("unable to downgrade dataset \"%s\"\n", dname);
-	h5tools_setstatus(EXIT_FAILURE);
-	goto error;
-    } else if(verbose_g)
-	HDfprintf(stdout, "Done\n");
+        error_msg("unable to downgrade dataset \"%s\"\n", dname);
+        h5tools_setstatus(EXIT_FAILURE);
+        goto error;
+    }
+    else if(verbose_g)
+        HDfprintf(stdout, "Done\n");
 
 done:
     /* Close the dataset */
     if(H5Dclose(did) < 0) {
         error_msg("unable to close dataset \"%s\"\n", dname);
         h5tools_setstatus(EXIT_FAILURE);
-	goto error;
-    } else if(verbose_g)
-	HDfprintf(stdout, "Close the dataset\n");
+        goto error;
+    }
+    else if(verbose_g)
+        HDfprintf(stdout, "Close the dataset\n");
     
     /* Close the dataset creation property list */
     if(H5Pclose(dcpl) < 0) {
         error_msg("unable to close dataset creation property list\n");
         h5tools_setstatus(EXIT_FAILURE);
-	goto error;
-    } else if(verbose_g)
-	printf("Close the dataset creation property list\n");
+        goto error;
+    }
+    else if(verbose_g)
+        HDprintf("Close the dataset creation property list\n");
 
-    return(0);
+    return 0;
 
 error:
     if(verbose_g)
-	HDfprintf(stdout, "Error encountered\n");
+        HDfprintf(stdout, "Error encountered\n");
 
     H5E_BEGIN_TRY {
         H5Pclose(dcpl);
         H5Dclose(did);
     } H5E_END_TRY;
 
-    return(-1);
+    return -1;
 } /* convert() */
 
 /*-------------------------------------------------------------------------
- * Function: convert_dsets_cb()
+ * Function:    convert_dsets_cb()
  *
- * Purpose:  The callback routine from the traversal to convert the
- *	     chunk indexing type of the dataset object.
+ * Purpose:     The callback routine from the traversal to convert the
+ *              chunk indexing type of the dataset object.
  *
- * Return: Success: 0
- *  	   Failure: 1
+ * Return:      Success:    0
+ *              Failure:    -1
  *-------------------------------------------------------------------------
  */
 static int
@@ -363,11 +369,11 @@ convert_dsets_cb(const char *path, const H5O_info_t *oi, const char *already_vis
     /* If the object has already been seen then just return */
     if(NULL == already_visited) {
         if(oi->type == H5O_TYPE_DATASET) {
-	    if(verbose_g)
-		HDfprintf(stdout, "Going to process dataset:%s...\n", path);
-	    if(convert(fid, path) < 0)
-		goto error;
-	} /* end if */
+            if(verbose_g)
+                HDfprintf(stdout, "Going to process dataset:%s...\n", path);
+            if(convert(fid, path) < 0)
+            goto error;
+        } /* end if */
     } /* end if */
 
     return 0;
diff --git a/tools/src/h5jam/h5jam.c b/tools/src/h5jam/h5jam.c
index 01ba4af..4f3e7a4 100644
--- a/tools/src/h5jam/h5jam.c
+++ b/tools/src/h5jam/h5jam.c
@@ -221,7 +221,7 @@ main (int argc, const char *argv[])
     /* Initialize h5tools lib */
     h5tools_init();
 
-    parse_command_line (argc, argv);
+    parse_command_line(argc, argv);
 
     if (ub_file == NULL) {
         /* no user block */
@@ -252,21 +252,21 @@ main (int argc, const char *argv[])
         leave (EXIT_FAILURE);
     }
 
-    ifile = H5Fopen (input_file, H5F_ACC_RDONLY, H5P_DEFAULT);
+    ifile = H5Fopen(input_file, H5F_ACC_RDONLY, H5P_DEFAULT);
 
     if (ifile < 0) {
         error_msg("Can't open input HDF5 file \"%s\"\n", input_file);
         leave (EXIT_FAILURE);
     }
 
-    plist = H5Fget_create_plist (ifile);
+    plist = H5Fget_create_plist(ifile);
     if (plist < 0) {
         error_msg("Can't get file creation plist for file \"%s\"\n", input_file);
         H5Fclose(ifile);
         leave (EXIT_FAILURE);
     }
 
-    status = H5Pget_userblock (plist, &usize);
+    status = H5Pget_userblock(plist, &usize);
     if (status < 0) {
         error_msg("Can't get user block for file \"%s\"\n", input_file);
         H5Pclose(plist);
@@ -330,7 +330,7 @@ main (int argc, const char *argv[])
         }
     }
 
-    newubsize = compute_user_block_size ((hsize_t) fsize);
+    newubsize = compute_user_block_size((hsize_t) fsize);
 
     startub = usize;
 
@@ -345,22 +345,22 @@ main (int argc, const char *argv[])
         else {
             /* add new ub to current ublock, pad to new offset */
             newubsize += usize;
-            newubsize = compute_user_block_size ((hsize_t) newubsize);
+            newubsize = compute_user_block_size((hsize_t) newubsize);
         }
     }
 
     /* copy the HDF5 from starting at usize to starting at newubsize:
      *  makes room at 'from' for new ub */
     /* if no current ub, usize is 0 */
-    copy_some_to_file (h5fid, ofid, usize, newubsize, (ssize_t) (h5fsize - usize));
+    copy_some_to_file(h5fid, ofid, usize, newubsize, (ssize_t) (h5fsize - usize));
 
     /* copy the old ub to the beginning of the new file */
     if (!do_clobber) {
-        where = copy_some_to_file (h5fid, ofid, (hsize_t) 0, (hsize_t) 0, (ssize_t) usize);
+        where = copy_some_to_file(h5fid, ofid, (hsize_t) 0, (hsize_t) 0, (ssize_t) usize);
     }
 
     /* copy the new ub to the end of the ub */
-    where = copy_some_to_file (ufid, ofid, (hsize_t) 0, startub, (ssize_t) - 1);
+    where = copy_some_to_file(ufid, ofid, (hsize_t) 0, startub, (ssize_t) - 1);
 
     /* pad the ub */
     if(write_pad(ofid, where, &where) < 0) {
@@ -372,18 +372,18 @@ main (int argc, const char *argv[])
     } /* end if */
 
     if(ub_file)
-        HDfree (ub_file);
+        HDfree(ub_file);
     if(input_file)
-        HDfree (input_file);
+        HDfree(input_file);
     if(output_file)
-        HDfree (output_file);
+        HDfree(output_file);
 
     if(ufid >= 0)
-        HDclose (ufid);
+        HDclose(ufid);
     if(h5fid >= 0)
-        HDclose (h5fid);
+        HDclose(h5fid);
     if(ofid >= 0)
-        HDclose (ofid);
+        HDclose(ofid);
 
     return h5tools_getstatus();
 }
diff --git a/tools/src/misc/h5debug.c b/tools/src/misc/h5debug.c
index b66e7ce..088e6e9 100644
--- a/tools/src/misc/h5debug.c
+++ b/tools/src/misc/h5debug.c
@@ -346,7 +346,7 @@ main(int argc, char *argv[])
 	/*
 	 * Debug a global heap collection.
 	 */
-	status = H5HG_debug (f, addr, stdout, 0, VCOL);
+	status = H5HG_debug(f, addr, stdout, 0, VCOL);
 
     } else if(!HDmemcmp(sig, H5G_NODE_MAGIC, (size_t)H5_SIZEOF_MAGIC)) {
         /*
diff --git a/tools/test/h5diff/h5diffgentest.c b/tools/test/h5diff/h5diffgentest.c
index 7321c66..4f92cae 100644
--- a/tools/test/h5diff/h5diffgentest.c
+++ b/tools/test/h5diff/h5diffgentest.c
@@ -11,8 +11,6 @@
  * help@hdfgroup.org.                                                        *
  * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
 
-#include <stdio.h>
-#include <stdlib.h>
 #include "hdf5.h"
 #include "H5private.h"
 
@@ -110,6 +108,10 @@ size_t H5TOOLS_MALLOCSIZE = (128 * 1024 * 1024);
 #define SPACE1_DIM1 0
 #define SPACE1_DIM2 0
 
+/* Error macros */
+#define AT()            HDprintf("ERROR at %s:%d in %s()...\n", __FILE__, __LINE__, FUNC);
+#define PROGRAM_ERROR   {AT(); goto error;}
+
 /* A UD link traversal function.  Shouldn't actually be called. */
 static hid_t
 UD_traverse(H5_ATTR_UNUSED const char * link_name, H5_ATTR_UNUSED hid_t cur_group,
@@ -178,7 +180,7 @@ static void write_dset_in(hid_t loc_id, const char* dset_name, hid_t fid, int ma
 static void gen_datareg(hid_t fid, int make_diffs);
 /* utilities */
 static int write_attr(hid_t loc_id, int rank, hsize_t *dims, const char *name, hid_t tid, void *buf);
-static int write_dset(hid_t loc_id, int rank, hsize_t *dims, const char *name, hid_t tid, void *buf);
+static herr_t write_dset(hid_t loc_id, int rank, hsize_t *dims, const char *name, hid_t tid, void *buf);
 static int gen_dataset_idx(const char *file, int format);
 
 /*-------------------------------------------------------------------------
@@ -286,7 +288,7 @@ int main(void)
     /* string dataset and attribute. HDFFV-10028 */
     test_objs_strings(DIFF_STRINGS1, DIFF_STRINGS2);
 
-    return 0;
+    return EXIT_SUCCESS;
 }
 
 /*-------------------------------------------------------------------------
@@ -4908,9 +4910,9 @@ out:
  *   types.
  *   h5diff should show non-comparable output from these common objects.
  *-------------------------------------------------------------------------*/
-static void test_objs_nocomparables(const char *fname1, const char *fname2)
+static void
+test_objs_nocomparables(const char *fname1, const char *fname2)
 {
-    herr_t status = SUCCEED;
     hid_t fid1 = -1;
     hid_t fid2 = -1;
     hid_t topgid1 = -1;
@@ -4927,110 +4929,90 @@ static void test_objs_nocomparables(const char *fname1, const char *fname2)
     * Open file(s) to add objects
     *------------------------------------------------------------------------*/
     /* file1 */
-    fid1 = H5Fopen(fname1, H5F_ACC_RDWR, H5P_DEFAULT);
-    if (fid1 < 0) {
-        fprintf(stderr, "Error: %s> H5Fopen failed.\n", fname1);
-        status = FAIL;
-        goto out;
-    }
+    if((fid1 = H5Fopen(fname1, H5F_ACC_RDWR, H5P_DEFAULT)) < 0)
+        PROGRAM_ERROR
 
     /* file2 */
-    fid2 = H5Fopen(fname2, H5F_ACC_RDWR, H5P_DEFAULT);
-    if (fid2 < 0) {
-        fprintf(stderr, "Error: %s> H5Fopen failed.\n", fname2);
-        status = FAIL;
-        goto out;
-    }
+    if((fid2 = H5Fopen(fname2, H5F_ACC_RDWR, H5P_DEFAULT)) < 0)
+        PROGRAM_ERROR
 
     /*-----------------------------------------------------------------------
     * in file1 : add member objects
     *------------------------------------------------------------------------*/
     /* parent group */
-    topgid1 = H5Gcreate2(fid1, "diffobjtypes", H5P_DEFAULT, H5P_DEFAULT, H5P_DEFAULT);
-    if (topgid1 < 0) {
-        fprintf(stderr, "Error: %s> H5Gcreate2 failed.\n", fname1);
-        status = FAIL;
-        goto out;
-    }
+    if((topgid1 = H5Gcreate2(fid1, "diffobjtypes", H5P_DEFAULT, H5P_DEFAULT, H5P_DEFAULT)) < 0)
+        PROGRAM_ERROR
 
     /* dataset */
-    status = write_dset(topgid1, 1, dims, "obj1", H5T_NATIVE_INT, data1);
-    if (status == FAIL) {
-        fprintf(stderr, "Error: %s> write_dset failed\n", fname1);
-        goto out;
-    }
+    if(write_dset(topgid1, 1, dims, "obj1", H5T_NATIVE_INT, data1) < 0)
+        PROGRAM_ERROR
 
     /* group */
-    gid1 = H5Gcreate2(topgid1, "obj2", H5P_DEFAULT, H5P_DEFAULT, H5P_DEFAULT);
-    if (gid1 < 0) {
-        fprintf(stderr, "Error: %s> H5Gcreate2 failed.\n", fname1);
-        status = FAIL;
-        goto out;
-    }
+    if((gid1 = H5Gcreate2(topgid1, "obj2", H5P_DEFAULT, H5P_DEFAULT, H5P_DEFAULT)) < 0)
+        PROGRAM_ERROR
 
     /* committed type */
-    tid1 = H5Tcopy(H5T_NATIVE_INT);
-    status = H5Tcommit2(topgid1, "obj3", tid1, H5P_DEFAULT, H5P_DEFAULT, H5P_DEFAULT);
-    if (status < 0) {
-        fprintf(stderr, "Error: %s> H5Tcommit2 failed.\n", fname1);
-        goto out;
-    }
+    if((tid1 = H5Tcopy(H5T_NATIVE_INT)) < 0)
+        PROGRAM_ERROR
+    if(H5Tcommit2(topgid1, "obj3", tid1, H5P_DEFAULT, H5P_DEFAULT, H5P_DEFAULT) < 0)
+        PROGRAM_ERROR
 
     /*-----------------------------------------------------------------------
     * in file2 : add member objects
     *------------------------------------------------------------------------*/
     /* parent group */
-    topgid2 = H5Gcreate2(fid2, "diffobjtypes", H5P_DEFAULT, H5P_DEFAULT, H5P_DEFAULT);
-    if (topgid2 < 0) {
-        fprintf(stderr, "Error: %s> H5Gcreate2 failed.\n", fname2);
-        status = FAIL;
-        goto out;
-    }
+    if((topgid2 = H5Gcreate2(fid2, "diffobjtypes", H5P_DEFAULT, H5P_DEFAULT, H5P_DEFAULT)) < 0)
+        PROGRAM_ERROR
 
     /* group */
-    gid2 = H5Gcreate2(topgid2, "obj1", H5P_DEFAULT, H5P_DEFAULT, H5P_DEFAULT);
-    if (gid2 < 0) {
-        fprintf(stderr, "Error: %s> H5Gcreate2 failed.\n", fname2);
-        status = FAIL;
-        goto out;
-    }
+    if((gid2 = H5Gcreate2(topgid2, "obj1", H5P_DEFAULT, H5P_DEFAULT, H5P_DEFAULT)) < 0)
+        PROGRAM_ERROR
 
     /* committed type */
-    tid2 = H5Tcopy(H5T_NATIVE_INT);
-    status = H5Tcommit2(topgid2, "obj2", tid2, H5P_DEFAULT, H5P_DEFAULT, H5P_DEFAULT);
-    if (status < 0) {
-        fprintf(stderr, "Error: %s> H5Tcommit2 failed.\n", fname2);
-        goto out;
-    }
+    if((tid2 = H5Tcopy(H5T_NATIVE_INT)) < 0)
+        PROGRAM_ERROR
+    if(H5Tcommit2(topgid2, "obj2", tid2, H5P_DEFAULT, H5P_DEFAULT, H5P_DEFAULT) < 0)
+        PROGRAM_ERROR
 
     /* dataset */
-    status = write_dset(topgid2, 1, dims, "obj3", H5T_NATIVE_INT, data2);
-    if (status == FAIL) {
-        fprintf(stderr, "Error: %s> write_dset failed\n", fname2);
-        goto out;
-    }
+    if(write_dset(topgid2, 1, dims, "obj3", H5T_NATIVE_INT, data2) < 0)
+        PROGRAM_ERROR
 
-out:
     /*-----------------------------------------------------------------------
     * Close IDs
     *-----------------------------------------------------------------------*/
-    if (fid1)
+    if(H5Fclose(fid1) < 0)
+        PROGRAM_ERROR
+    if(H5Fclose(fid2) < 0)
+        PROGRAM_ERROR
+    if(H5Gclose(topgid1) < 0)
+        PROGRAM_ERROR
+    if(H5Gclose(topgid2) < 0)
+        PROGRAM_ERROR
+    if(H5Gclose(gid1) < 0)
+        PROGRAM_ERROR
+    if(H5Gclose(gid2) < 0)
+        PROGRAM_ERROR
+    if(H5Tclose(tid1) < 0)
+        PROGRAM_ERROR
+    if(H5Tclose(tid2) < 0)
+        PROGRAM_ERROR
+
+    return;
+
+error:
+    H5E_BEGIN_TRY {
         H5Fclose(fid1);
-    if (fid2)
         H5Fclose(fid2);
-    if (topgid1)
         H5Gclose(topgid1);
-    if (topgid2)
         H5Gclose(topgid2);
-    if (gid1)
         H5Gclose(gid1);
-    if (gid2)
         H5Gclose(gid2);
-    if (tid1)
         H5Tclose(tid1);
-    if (tid2)
         H5Tclose(tid2);
+    } H5E_END_TRY;
 
+    return;
 }
 
 static hid_t mkstr(int size, H5T_str_t pad)
@@ -8085,36 +8067,40 @@ out:
  *
  *-------------------------------------------------------------------------
  */
-static
-int write_dset(hid_t loc_id, int rank, hsize_t *dims, const char *name, hid_t tid, void *buf)
+static herr_t
+write_dset(hid_t loc_id, int rank, hsize_t *dims, const char *name, hid_t tid, void *buf)
 {
     hid_t did = -1;
     hid_t sid = -1;
 
     /* create a space  */
-    if ((sid = H5Screate_simple(rank, dims, NULL)) < 0)
-        goto out;
+    if((sid = H5Screate_simple(rank, dims, NULL)) < 0)
+        PROGRAM_ERROR
 
     /* create the dataset */
-    if ((did = H5Dcreate2(loc_id, name, tid, sid, H5P_DEFAULT, H5P_DEFAULT, H5P_DEFAULT)) < 0)
-        goto out;
+    if((did = H5Dcreate2(loc_id, name, tid, sid, H5P_DEFAULT, H5P_DEFAULT, H5P_DEFAULT)) < 0)
+        PROGRAM_ERROR
 
     /* write */
-    if (buf) {
-        if (H5Dwrite(did, tid, H5S_ALL, H5S_ALL, H5P_DEFAULT, buf) < 0)
-            goto out;
-    }
+    if(buf)
+        if(H5Dwrite(did, tid, H5S_ALL, H5S_ALL, H5P_DEFAULT, buf) < 0)
+            PROGRAM_ERROR
 
     /* close */
-    H5Dclose(did);
-    H5Sclose(sid);
+    if(H5Dclose(did) < 0)
+        PROGRAM_ERROR
+    if(H5Sclose(sid) < 0)
+        PROGRAM_ERROR
 
     return SUCCEED;
 
-out:
+error:
+
+    H5E_BEGIN_TRY {
+        H5Dclose(did);
+        H5Sclose(sid);
+    } H5E_END_TRY;
 
-    H5Dclose(did);
-    H5Sclose(sid);
     return FAIL;
-}
+} /* end write_dset() */
 
diff --git a/tools/test/h5jam/tellub.c b/tools/test/h5jam/tellub.c
index 8e4b3ac..667f2d9 100644
--- a/tools/test/h5jam/tellub.c
+++ b/tools/test/h5jam/tellub.c
@@ -26,9 +26,9 @@
  */
 static const char *s_opts = "h";
 static struct long_options l_opts[] = {
-  {"help", no_arg, 'h'},
-  {"hel", no_arg, 'h'},
-  {NULL, 0, '\0'}
+    {"help", no_arg, 'h'},
+    {"hel", no_arg, 'h'},
+    {NULL, 0, '\0'}
 };
 
 /*-------------------------------------------------------------------------
@@ -37,152 +37,126 @@ static struct long_options l_opts[] = {
  * Purpose:     Print the usage message
  *
  * Return:      void
- *
- * Programmer:
- *
- * Modifications:
- *
  *-------------------------------------------------------------------------
  */
 static void
 usage (const char *prog)
 {
-  fflush (stdout);
-  fprintf (stdout, "usage: %s h5_file\n", prog);
-  fprintf (stdout,
-     "           Check that h5_fil is HDF5 file and print size of user block \n");
-  fprintf (stdout, "       %s -h\n", prog);
-  fprintf (stdout, "           Print a usage message and exit\n");
-}
+    HDfflush(stdout);
+    HDfprintf(stdout, "usage: %s h5_file\n", prog);
+    HDfprintf(stdout,
+        "           Check that h5_fil is HDF5 file and print size of user block \n");
+    HDfprintf(stdout, "       %s -h\n", prog);
+    HDfprintf(stdout, "           Print a usage message and exit\n");
+} /* end usage() */
 
 /*-------------------------------------------------------------------------
  * Function:    parse_command_line
  *
  * Purpose:     Parse the command line for the h5dumper.
  *
- * Return:      Success:
- *
+ * Return:      Success:    void
  *              Failure:    Exits program with EXIT_FAILURE value.
- *
- * Programmer:
- *
- * Modifications:
- *
  *-------------------------------------------------------------------------
  */
 
 static void
 parse_command_line (int argc, const char *argv[])
 {
-  int opt;
-
-  /* parse command line options */
-  while ((opt = get_option (argc, argv, s_opts, l_opts)) != EOF)
-    {
-      switch ((char) opt)
-      {
-      case 'h':
-        usage (h5tools_getprogname());
-        exit (EXIT_SUCCESS);
-      case '?':
-      default:
-        usage (h5tools_getprogname());
-        exit (EXIT_FAILURE);
-      }
+    int opt;
+
+    /* parse command line options */
+    while ((opt = get_option (argc, argv, s_opts, l_opts)) != EOF) {
+        switch ((char) opt) {
+            case 'h':
+                usage (h5tools_getprogname());
+                HDexit(EXIT_SUCCESS);
+            case '?':
+            default:
+                usage (h5tools_getprogname());
+                HDexit(EXIT_FAILURE);
+        }
     }
 
-  /* check for file name to be processed */
-  if (argc <= opt_ind)
-    {
-      error_msg("missing file name\n");
-      usage (h5tools_getprogname());
-      exit (EXIT_FAILURE);
+    /* check for file name to be processed */
+    if (argc <= opt_ind) {
+        error_msg("missing file name\n");
+        usage (h5tools_getprogname());
+        HDexit(EXIT_FAILURE);
     }
-}
+} /* end parse_command_line() */
 
 /*-------------------------------------------------------------------------
  * Function:    main
  *
  * Purpose:     HDF5 user block unjammer
  *
- * Return:      Success:    0
- *              Failure:    1
- *
- * Programmer:
- *
- * Modifications:
- *
+ * Return:      EXIT_SUCCESS/EXIT_FAILURE
  *-------------------------------------------------------------------------
  */
 int
 main (int argc, const char *argv[])
 {
-  char *ifname;
-  void *edata;
-  H5E_auto2_t func;
-  hid_t ifile;
-  hsize_t usize;
-  htri_t testval;
-  herr_t status;
-  hid_t plist;
-
-  h5tools_setprogname(PROGRAMNAME);
-  h5tools_setstatus(EXIT_SUCCESS);
-
-  /* Initialize h5tools lib */
-  h5tools_init();
-
-  /* Disable error reporting */
-  H5Eget_auto2(H5E_DEFAULT, &func, &edata);
-  H5Eset_auto2(H5E_DEFAULT, NULL, NULL);
-
-  parse_command_line (argc, argv);
-
-  if (argc <= (opt_ind))
-    {
-      error_msg("missing file name\n");
-      usage (h5tools_getprogname());
-      return (EXIT_FAILURE);
+    char *ifname;
+    void *edata;
+    H5E_auto2_t func;
+    hid_t ifile;
+    hsize_t usize;
+    htri_t testval;
+    herr_t status;
+    hid_t plist = -1;
+
+    h5tools_setprogname(PROGRAMNAME);
+    h5tools_setstatus(EXIT_SUCCESS);
+
+    /* Initialize h5tools lib */
+    h5tools_init();
+
+    /* Disable error reporting */
+    H5Eget_auto2(H5E_DEFAULT, &func, &edata);
+    H5Eset_auto2(H5E_DEFAULT, NULL, NULL);
+
+    parse_command_line(argc, argv);
+
+    if(argc <= (opt_ind)) {
+        error_msg("missing file name\n");
+        usage (h5tools_getprogname());
+        return EXIT_FAILURE;
     }
 
-  ifname = HDstrdup (argv[opt_ind]);
+    ifname = HDstrdup(argv[opt_ind]);
 
-  testval = H5Fis_hdf5 (ifname);
+    testval = H5Fis_hdf5(ifname);
 
-  if (testval <= 0)
-    {
-      error_msg("Input HDF5 file is not HDF \"%s\"\n", ifname);
-      return (EXIT_FAILURE);
+    if(testval <= 0) {
+        error_msg("Input HDF5 file is not HDF \"%s\"\n", ifname);
+        return EXIT_FAILURE;
     }
 
-  ifile = H5Fopen (ifname, H5F_ACC_RDONLY, H5P_DEFAULT);
+    ifile = H5Fopen(ifname, H5F_ACC_RDONLY, H5P_DEFAULT);
 
-  if (ifile < 0)
-    {
-      error_msg("Can't open input HDF5 file \"%s\"\n", ifname);
-      return (EXIT_FAILURE);
+    if(ifile < 0) {
+        error_msg("Can't open input HDF5 file \"%s\"\n", ifname);
+        return EXIT_FAILURE;
     }
 
-  plist = H5Fget_create_plist (ifile);
-  if (plist < 0)
-    {
-      error_msg("Can't get file creation plist for file \"%s\"\n",
-     ifname);
-      return (EXIT_FAILURE);
+    plist = H5Fget_create_plist(ifile);
+    if(plist < 0) {
+        error_msg("Can't get file creation plist for file \"%s\"\n", ifname);
+        return EXIT_FAILURE;
     }
 
-  status = H5Pget_userblock (plist, &usize);
-  if (status < 0)
-    {
-      error_msg("Can't get user block for file \"%s\"\n", ifname);
-      return (EXIT_FAILURE);
+    status = H5Pget_userblock(plist, &usize);
+    if(status < 0) {
+        error_msg("Can't get user block for file \"%s\"\n", ifname);
+        return EXIT_FAILURE;
     }
 
-  printf ("%ld\n", (long) usize);
+    HDprintf("%ld\n", (long) usize);
 
-  H5Pclose (plist);
-  H5Fclose (ifile);
+    H5Pclose (plist);
+    H5Fclose (ifile);
 
-  return (EXIT_SUCCESS);
-}
+    return EXIT_SUCCESS;
+} /* end main() */
 
diff --git a/tools/test/h5repack/h5repack.sh.in b/tools/test/h5repack/h5repack.sh.in
index b0a2f99..a36eb08 100644
--- a/tools/test/h5repack/h5repack.sh.in
+++ b/tools/test/h5repack/h5repack.sh.in
@@ -997,6 +997,7 @@ fi
 ##############################################################################
 ###              T H E   T E S T S
 ##############################################################################
+
 # prepare for test
 COPY_TESTFILES_TO_TESTDIR
 
diff --git a/tools/test/h5stat/testh5stat.sh.in b/tools/test/h5stat/testh5stat.sh.in
index 5082daf..0a5127f 100644
--- a/tools/test/h5stat/testh5stat.sh.in
+++ b/tools/test/h5stat/testh5stat.sh.in
@@ -249,7 +249,6 @@ TOOLTEST h5stat_help2.ddl --help
 TOOLTEST h5stat_notexist.ddl notexist.h5
 TOOLTEST h5stat_nofile.ddl ''
 
-
 # Test file with groups, compressed datasets, user-applied fileters, etc.
 # h5stat_filters.h5 is a copy of ../../testfiles/tfilters.h5 as of release 1.8.0-alpha4
 TOOLTEST h5stat_filters.ddl h5stat_filters.h5