Brought H5E package in line with develop.

6 files changed, 567 insertions, 580 deletions

diff --git a/src/H5.c b/src/H5.c
index 96b4a5b..cf1ad6b 100644
--- a/src/H5.c
+++ b/src/H5.c
@@ -139,7 +139,7 @@ H5_init_library(void)
             int key_val;
 
             if(MPI_SUCCESS != (mpi_code = MPI_Comm_create_keyval(MPI_COMM_NULL_COPY_FN,
-                                                                 (MPI_Comm_delete_attr_function *)H5_mpi_delete_cb, 
+                                                                 (MPI_Comm_delete_attr_function *)H5_mpi_delete_cb,
                                                                  &key_val, NULL)))
                 HMPI_GOTO_ERROR(FAIL, "MPI_Comm_create_keyval failed", mpi_code)
 
@@ -207,7 +207,7 @@ H5_init_library(void)
      * The link interface needs to be initialized so that link property lists
      * have their properties registered.
      * The FS module needs to be initialized as a result of the fix for HDFFV-10160:
-     *   It might not be initialized during normal file open. 
+     *   It might not be initialized during normal file open.
      *   When the application does not close the file, routines in the module might
      *   be called via H5_term_library() when shutting down the file.
      */
@@ -344,7 +344,9 @@ H5_term_library(void)
             pending += DOWN(AC);
             pending += DOWN(Z);
             pending += DOWN(FD);
-            pending += DOWN(PL);
+            /* Don't shut down the plugin code until all "pluggable" interfaces (Z, FD, PL) are shut down */
+            if(pending == 0)
+                pending += DOWN(PL);
             /* Don't shut down the error code until other APIs which use it are shut down */
             if(pending == 0)
                 pending += DOWN(E);
@@ -651,7 +653,7 @@ H5_debug_mask(const char *s)
 /*-------------------------------------------------------------------------
  * Function:	H5_mpi_delete_cb
  *
- * Purpose:	Callback attribute on MPI_COMM_SELF to terminate the HDF5 
+ * Purpose:	Callback attribute on MPI_COMM_SELF to terminate the HDF5
  *              library when the communicator is destroyed, i.e. on MPI_Finalize.
  *
  * Return:	MPI_SUCCESS
@@ -897,7 +899,7 @@ H5close(void)
  * Return:
  *
  *      Success:    A pointer to the allocated buffer.
- *  
+ *
  *      Failure:    NULL
  *
  *-------------------------------------------------------------------------
@@ -938,7 +940,7 @@ H5allocate_memory(size_t size, hbool_t clear)
  * Return:
  *
  *      Success:    A pointer to the resized buffer.
- *  
+ *
  *      Failure:    NULL (the input buffer will be unchanged)
  *
  *-------------------------------------------------------------------------
@@ -999,7 +1001,7 @@ H5is_library_threadsafe(hbool_t *is_ts)
     H5TRACE1("e", "*b", is_ts);
 
     HDassert(is_ts);
- 
+
     /* At this time, it is impossible for this to fail. */
 #ifdef H5_HAVE_THREADSAFE
     *is_ts = TRUE;
diff --git a/src/H5E.c b/src/H5E.c
index 84e4b1a..0ce5c88 100644
--- a/src/H5E.c
+++ b/src/H5E.c
@@ -49,11 +49,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 "H5Epkg.h"             /* Error handling                           */
+#include "H5FLprivate.h"        /* Free lists                               */
+#include "H5Iprivate.h"         /* IDs                                      */
+#include "H5MMprivate.h"        /* Memory management                        */
 
 /****************/
 /* Local Macros */
@@ -78,18 +78,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 +122,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 +130,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 +138,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 +173,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 +204,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 +224,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 +259,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 +268,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 +279,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 +297,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 +310,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 +331,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 +351,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);
 
@@ -366,7 +363,7 @@ H5E_get_stack(void)
         /* No associated value with current thread - create one */
 #ifdef H5_HAVE_WIN_THREADS
         /* Win32 has to use LocalAlloc to match the LocalFree in DllMain */
-        estack = (H5E_t *)LocalAlloc(LPTR, sizeof(H5E_t)); 
+        estack = (H5E_t *)LocalAlloc(LPTR, sizeof(H5E_t));
 #else
         /* Use HDmalloc here since this has to match the HDfree in the
          * destructor and we want to avoid the codestack there.
@@ -377,7 +374,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 +385,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 +420,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 +436,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 +459,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 +472,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,13 +505,13 @@ 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
  *
@@ -546,11 +545,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 +557,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 +576,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 +596,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 +615,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 +628,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 +649,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 +667,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 +725,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 +737,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 +750,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 +771,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 +812,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 +839,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 +863,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_NOCLEAR((-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 +882,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 +898,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 +920,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 +937,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 +957,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 +970,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,25 +1031,20 @@ 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
  *
  * Programmer:	Raymond Lu
  *              Friday, July 15, 2003
  *
- * Modification:
- *              Raymond Lu
- *              7 September 2010
- *              Also closes the stack to avoid potential problem (bug 1799)
- * 
  *-------------------------------------------------------------------------
  */
 herr_t
@@ -1061,7 +1061,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 +1078,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 +1090,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,13 +1138,13 @@ 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
  *
@@ -1180,11 +1180,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 +1192,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 +1206,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 +1229,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 +1243,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 +1256,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,20 +1269,20 @@ 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
  *
@@ -1301,7 +1303,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 +1320,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 +1329,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
  *
  * 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.
  *
  *-------------------------------------------------------------------------
@@ -1383,7 +1385,7 @@ H5Epush2(hid_t err_stack, const char *file, const char *func, unsigned line,
  */
 
     /* Format the description */
-    va_start(ap, fmt);
+    HDva_start(ap, fmt);
     va_started = TRUE;
 
 #ifdef H5_HAVE_VASPRINTF
@@ -1399,8 +1401,8 @@ H5Epush2(hid_t err_stack, const char *file, const char *func, unsigned line,
     /* If the description doesn't fit into the initial buffer size, allocate more space and try again */
     while((desc_len = HDvsnprintf(tmp, (size_t)tmp_len, fmt, ap)) > (tmp_len - 1)) {
         /* shutdown & restart the va_list */
-        va_end(ap);
-        va_start(ap, fmt);
+        HDva_end(ap);
+        HDva_start(ap, fmt);
 
         /* Release the previous description, it's too small */
         H5MM_xfree(tmp);
@@ -1418,7 +1420,7 @@ H5Epush2(hid_t err_stack, const char *file, const char *func, unsigned line,
 
 done:
     if(va_started)
-        va_end(ap);
+        HDva_end(ap);
 #ifdef H5_HAVE_VASPRINTF
     /* Memory was allocated with HDvasprintf so it needs to be freed
      * with HDfree
@@ -1435,9 +1437,9 @@ 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
  *
@@ -1477,12 +1479,12 @@ 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 their
- *		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 their
+ *              own more specific error handlers.
  *
  * Return:	Non-negative on success/Negative on failure
  *
@@ -1503,7 +1505,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 +1517,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,10 +1526,10 @@ 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
  *
@@ -1549,7 +1551,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 +1565,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((ret_value = H5E_walk(estack, direction, &op, client_data)) < 0)
+    if((ret_value = H5E__walk(estack, direction, &op, client_data)) < 0)
         HERROR(H5E_ERROR, H5E_CANTLIST, "can't walk error stack");
 
 done:
@@ -1572,23 +1574,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
  *
  * 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 +1599,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 +1607,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 +1625,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
  *
  * 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 +1658,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 +1667,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 +1682,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,9 +1691,9 @@ 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.
@@ -1721,7 +1715,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..7655c33 100644
--- a/src/H5Edeprec.c
+++ b/src/H5Edeprec.c
@@ -35,11 +35,10 @@
 /***********/
 /* 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 "H5Epkg.h"             /* Error handling                           */
+#include "H5Iprivate.h"         /* IDs                                      */
+#include "H5MMprivate.h"        /* Memory management                        */
 
 
 /****************/
@@ -80,12 +79,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 +105,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 +132,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 +158,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,14 +185,14 @@ 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.
@@ -225,9 +224,9 @@ done:
 
 
 /*-------------------------------------------------------------------------
- * Function:	H5Eclear1
+ * Function:    H5Eclear1
  *
- * Purpose:	This function is for backward compatibility.
+ * Purpose:     This function is for backward compatibility.
  *              Clears the error stack for the specified error stack.
  *
  * Return:	Non-negative on success/Negative on failure
@@ -256,13 +255,13 @@ done:
 
 
 /*-------------------------------------------------------------------------
- * Function:	H5Eprint1
+ * Function:    H5Eprint1
  *
- * Purpose:	This function is for backward compatibility.
+ * Purpose:     This function is for backward compatibility.
  *              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
  *
@@ -281,11 +280,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,11 +293,11 @@ done:
 
 
 /*-------------------------------------------------------------------------
- * Function:	H5Ewalk1
+ * Function:    H5Ewalk1
  *
- * Purpose:	This function is for backward compatibility.
+ * Purpose:     This function is for backward compatibility.
  *              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
  *
@@ -318,13 +317,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 +332,19 @@ done:
 
 
 /*-------------------------------------------------------------------------
- * Function:	H5Eget_auto1
+ * Function:    H5Eget_auto1
  *
- * Purpose:	This function is for backward compatibility.
+ * Purpose:     This function is for backward compatibility.
  *              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
  *
  * 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 +358,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 +378,26 @@ done:
 
 
 /*-------------------------------------------------------------------------
- * Function:	H5Eset_auto1
+ * Function:    H5Eset_auto1
  *
- * Purpose:	This function is for backward compatibility.
+ * Purpose:     This function is for backward compatibility.
  *              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
  *
  * 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 +411,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 +426,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 ddd4eab..d0880f5 100644
--- a/src/H5Eint.c
+++ b/src/H5Eint.c
@@ -13,11 +13,11 @@
 
 /*-------------------------------------------------------------------------
  *
- * Created:    H5Eint.c
- *        April 11 2007
- *        Quincey Koziol <koziol@hdfgroup.org>
+ * Created:	H5Eint.c
+ *		April 11 2007
+ *		Quincey Koziol <koziol@hdfgroup.org>
  *
- * Purpose:    General use, "internal" routines for error handling.
+ * Purpose:	General use, "internal" routines for error handling.
  *
  *-------------------------------------------------------------------------
  */
@@ -32,11 +32,10 @@
 /***********/
 /* 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 "H5Epkg.h"             /* Error handling                           */
+#include "H5Iprivate.h"         /* IDs                                      */
+#include "H5MMprivate.h"        /* Memory management                        */
 
 
 /****************/
@@ -64,12 +63,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);
 
 
 /*********************/
@@ -107,31 +106,31 @@ 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;
+char	H5E_mpi_error_str[MPI_MAX_ERROR_STRING];
+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
+ * Programmer:	Raymond Lu
  *              Friday, July 14, 2003
  *
  *-------------------------------------------------------------------------
  */
 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,57 +151,57 @@ 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
+ *		Thursday, May 11, 2006
  *
  *-------------------------------------------------------------------------
  */
 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 */
+    FILE		*stream;        /* I/O stream to print output to */
     H5E_cls_t           *cls_ptr;       /* Pointer to error class */
     H5E_msg_t           *maj_ptr;       /* Pointer to major error info */
     H5E_msg_t           *min_ptr;       /* Pointer to minor error info */
-    const char        *maj_str = "No major description";      /* Major error description */
-    const char        *min_str = "No minor description";      /* Minor error description */
+    const char		*maj_str = "No major description";      /* Major error description */
+    const char		*min_str = "No minor description";      /* Minor error description */
     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);
@@ -249,15 +248,15 @@ 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);
-            HDfprintf(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
-            HDfprintf(stream, "thread 0");
+                HDfprintf(stream, "thread 0");
         } /* end block */
 #elif defined(H5_HAVE_THREADSAFE)
         HDfprintf(stream, "thread %lu", (unsigned long)HDpthread_self_ulong());
@@ -273,63 +272,63 @@ H5E_walk1_cb(int n, H5E_error1_t *err_desc, void *client_data)
 
     /* Print error message */
     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 ? ": " : ""),
+	     H5E_INDENT, "", n, err_desc->file_name, err_desc->line,
+	     err_desc->func_name, (have_desc ? ": " : ""),
              (have_desc ? err_desc->desc : ""));
     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
+ * Programmer:	Robb Matzke
+ *		Friday, December 12, 1997
  *
  *-------------------------------------------------------------------------
  */
 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 */
+    FILE		*stream;        /* I/O stream to print output to */
     H5E_cls_t           *cls_ptr;       /* Pointer to error class */
     H5E_msg_t           *maj_ptr;       /* Pointer to major error info */
     H5E_msg_t           *min_ptr;       /* Pointer to minor error info */
-    const char        *maj_str = "No major description";      /* Major error description */
-    const char        *min_str = "No minor description";      /* Minor error description */
+    const char		*maj_str = "No major description";      /* Major error description */
+    const char		*min_str = "No minor description";      /* Minor error description */
     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);
@@ -381,15 +380,15 @@ 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);
-            HDfprintf(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
-            HDfprintf(stream, "thread 0");
+                HDfprintf(stream, "thread 0");
         } /* end block */
 #elif defined(H5_HAVE_THREADSAFE)
         HDfprintf(stream, "thread %lu", (unsigned long)HDpthread_self_ulong());
@@ -405,19 +404,19 @@ H5E_walk2_cb(unsigned n, const H5E_error2_t *err_desc, void *client_data)
 
     /* Print error message */
     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 ? ": " : ""),
+	     H5E_INDENT, "", n, err_desc->file_name, err_desc->line,
+	     err_desc->func_name, (have_desc ? ": " : ""),
              (have_desc ? err_desc->desc : ""));
     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
  *              way.  This is just a convenience function for H5Ewalk() and
@@ -425,21 +424,21 @@ done:
  *              Users are encouraged to write their own more specific error
  *              handlers.
  *
- * Return:      Non-negative on success/Negative on failure
+ * Return:      SUCCEED/FAIL
  *
- * Programmer:    Robb Matzke
+ * Programmer:	Robb Matzke
  *              Friday, February 27, 1998
  *
  *-------------------------------------------------------------------------
  */
 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 +456,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,54 +465,54 @@ 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.
+ *              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 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.
+ *              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
+ * Return:      SUCCEED/FAIL
  *
- * Programmer:    Robb Matzke
- *        Friday, December 12, 1997
+ * Programmer:	Robb Matzke
+ *		Friday, December 12, 1997
  *
  *-------------------------------------------------------------------------
  */
 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 */
+    int		i;              /* Local index variable */
     herr_t ret_value = H5_ITER_CONT;   /* Return value */
 
-    FUNC_ENTER_NOAPI_NOINIT
+    FUNC_ENTER_PACKAGE_NOERR
 
     /* Sanity check */
     HDassert(estack);
@@ -521,7 +520,7 @@ H5E_walk(const H5E_t *estack, H5E_direction_t direction, const H5E_walk_op_t *op
 
     /* check args, but rather than failing use some default value */
     if(direction != H5E_WALK_UPWARD && direction != H5E_WALK_DOWNWARD)
-    direction = H5E_WALK_UPWARD;
+	direction = H5E_WALK_UPWARD;
 
     /* Walk the stack if a callback function was given */
     if(op->vers == 1) {
@@ -529,6 +528,7 @@ H5E_walk(const H5E_t *estack, H5E_direction_t direction, const H5E_walk_op_t *op
         if(op->u.func1) {
             H5E_error1_t old_err;
 
+            ret_value = SUCCEED;
             if(H5E_WALK_UPWARD == direction) {
                 for(i = 0; i < (int)estack->nused && ret_value == H5_ITER_CONT; i++) {
                     /* Point to each error record on the stack and pass it to callback function.*/
@@ -567,6 +567,7 @@ H5E_walk(const H5E_t *estack, H5E_direction_t direction, const H5E_walk_op_t *op
     else {
         HDassert(op->vers == 2);
         if(op->u.func2) {
+            ret_value = SUCCEED;
             if(H5E_WALK_UPWARD == direction) {
                 for(i = 0; i < (int)estack->nused && ret_value == H5_ITER_CONT; i++)
                     ret_value = (op->u.func2)((unsigned)i, estack->slot + i, client_data);
@@ -582,30 +583,29 @@ H5E_walk(const H5E_t *estack, H5E_direction_t direction, const H5E_walk_op_t *op
         } /* end if */
     } /* end else */
 
-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
+ * Programmer:	Raymond Lu
  *              July 18, 2003
  *
  *-------------------------------------------------------------------------
  */
 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);
 
@@ -616,36 +616,36 @@ 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
+ * Programmer:	Robb Matzke
  *              Friday, February 27, 1998
  *
  *-------------------------------------------------------------------------
  */
 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);
 
@@ -654,18 +654,18 @@ 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
  *
- * 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
+ * Programmer:	Quincey Koziol
+ *		Tuesday, August 12, 2008
  *
  *-------------------------------------------------------------------------
  */
@@ -680,14 +680,14 @@ H5E_printf_stack(H5E_t *estack, const char *file, const char *func, unsigned lin
 #endif /* H5_HAVE_VASPRINTF */
     char        *tmp = NULL;      /* Buffer to place formatted description in */
     hbool_t     va_started = FALSE; /* Whether the variable argument list is open */
-    herr_t    ret_value = SUCCEED;    /* Return value */
+    herr_t	ret_value = SUCCEED;    /* Return value */
 
     /*
      * WARNING: We cannot call HERROR() from within this function or else we
-     *        could enter infinite recursion.  Furthermore, we also cannot
-     *        call any other HDF5 macro or function which might call
-     *        HERROR().  HERROR() is called by HRETURN_ERROR() which could
-     *        be called by FUNC_ENTER().
+     *		could enter infinite recursion.  Furthermore, we also cannot
+     *		call any other HDF5 macro or function which might call
+     *		HERROR().  HERROR() is called by HRETURN_ERROR() which could
+     *		be called by FUNC_ENTER().
      */
     FUNC_ENTER_NOAPI_NOINIT_NOERR
 
@@ -703,7 +703,7 @@ H5E_printf_stack(H5E_t *estack, const char *file, const char *func, unsigned lin
  */
 
     /* Start the variable-argument parsing */
-    va_start(ap, fmt);
+    HDva_start(ap, fmt);
     va_started = TRUE;
 
 #ifdef H5_HAVE_VASPRINTF
@@ -719,8 +719,8 @@ H5E_printf_stack(H5E_t *estack, const char *file, const char *func, unsigned lin
     /* If the description doesn't fit into the initial buffer size, allocate more space and try again */
     while((desc_len = HDvsnprintf(tmp, (size_t)tmp_len, fmt, ap)) > (tmp_len - 1)) {
         /* shutdown & restart the va_list */
-        va_end(ap);
-        va_start(ap, fmt);
+        HDva_end(ap);
+        HDva_start(ap, fmt);
 
         /* Release the previous description, it's too small */
         H5MM_xfree(tmp);
@@ -738,7 +738,7 @@ H5E_printf_stack(H5E_t *estack, const char *file, const char *func, unsigned lin
 
 done:
     if(va_started)
-        va_end(ap);
+        HDva_end(ap);
 #ifdef H5_HAVE_VASPRINTF
     /* Memory was allocated with HDvasprintf so it needs to be freed
      * with HDfree
@@ -753,24 +753,24 @@ done:
     FUNC_LEAVE_NOAPI(ret_value)
 } /* end H5E_printf_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
+ * Programmer:	Robb Matzke
+ *		Friday, December 12, 1997
  *
  *-------------------------------------------------------------------------
  */
@@ -778,14 +778,14 @@ 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)
 {
-    herr_t    ret_value = SUCCEED;      /* Return value */
+    herr_t	ret_value = SUCCEED;      /* Return value */
 
     /*
      * WARNING: We cannot call HERROR() from within this function or else we
-     *        could enter infinite recursion.  Furthermore, we also cannot
-     *        call any other HDF5 macro or function which might call
-     *        HERROR().  HERROR() is called by HRETURN_ERROR() which could
-     *        be called by FUNC_ENTER().
+     *		could enter infinite recursion.  Furthermore, we also cannot
+     *		call any other HDF5 macro or function which might call
+     *		HERROR().  HERROR() is called by HRETURN_ERROR() which could
+     *		be called by FUNC_ENTER().
      */
     FUNC_ENTER_PACKAGE_NOERR
 
@@ -796,7 +796,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)
 
     /*
@@ -819,49 +819,49 @@ H5E__push_stack(H5E_t *estack, const char *file, const char *func, unsigned line
         /* Increment the IDs to indicate that they are used in this stack */
         if(H5I_inc_ref(cls_id, FALSE) < 0)
             HGOTO_DONE(FAIL)
-    estack->slot[estack->nused].cls_id = cls_id;
+	estack->slot[estack->nused].cls_id = cls_id;
         if(H5I_inc_ref(maj_id, FALSE) < 0)
             HGOTO_DONE(FAIL)
-    estack->slot[estack->nused].maj_num = maj_id;
+	estack->slot[estack->nused].maj_num = maj_id;
         if(H5I_inc_ref(min_id, FALSE) < 0)
             HGOTO_DONE(FAIL)
-    estack->slot[estack->nused].min_num = min_id;
-    if(NULL == (estack->slot[estack->nused].func_name = H5MM_xstrdup(func)))
+	estack->slot[estack->nused].min_num = min_id;
+	if(NULL == (estack->slot[estack->nused].func_name = H5MM_xstrdup(func)))
             HGOTO_DONE(FAIL)
-    if(NULL == (estack->slot[estack->nused].file_name = H5MM_xstrdup(file)))
+	if(NULL == (estack->slot[estack->nused].file_name = H5MM_xstrdup(file)))
             HGOTO_DONE(FAIL)
-    estack->slot[estack->nused].line = line;
-    if(NULL == (estack->slot[estack->nused].desc = H5MM_xstrdup(desc)))
+	estack->slot[estack->nused].line = line;
+	if(NULL == (estack->slot[estack->nused].desc = H5MM_xstrdup(desc)))
             HGOTO_DONE(FAIL)
-    estack->nused++;
+	estack->nused++;
     } /* end if */
 
 done:
     FUNC_LEAVE_NOAPI(ret_value)
 } /* end H5E__push_stack() */
 
-
+
 /*-------------------------------------------------------------------------
- * 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
+ * Programmer:	Quincey Koziol
  *              Wednesday, August 6, 2003
  *
  *-------------------------------------------------------------------------
  */
 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);
@@ -894,18 +894,18 @@ 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
  *
- * 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
+ * Programmer:	Raymond Lu
  *              Wednesday, July 16, 2003
  *
  *-------------------------------------------------------------------------
@@ -919,63 +919,63 @@ 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:
     FUNC_LEAVE_NOAPI(ret_value)
 } /* end H5E_clear_stack() */
 
-
+
 /*-------------------------------------------------------------------------
- * 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
+ * Programmer:	Raymond Lu
  *              Friday, July 16, 2003
  *
  *-------------------------------------------------------------------------
  */
 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
  *
- * 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
+ * Programmer:	Quincey Koziol
  *              Wednesday, August 6, 2003
  *
  *-------------------------------------------------------------------------
@@ -989,7 +989,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..83f3816 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 */
 
 
@@ -77,9 +77,9 @@ typedef struct {
 } H5E_auto_op_t;
 #else /* H5_NO_DEPRECATED_SYMBOLS */
 typedef struct {
-    H5E_auto_t  func2;      /* Only the new style callback function is available. */
+    H5E_auto2_t func2;      /* Only the new style callback function is available. */
 } H5E_auto_op_t;
-#endif /* H5_NO_DEPRECATED_SYMBOLS */ 
+#endif /* H5_NO_DEPRECATED_SYMBOLS */
 
 /* Some syntactic sugar to make the compiler happy with two different kinds of callbacks */
 typedef struct {
@@ -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/H5Epublic.h b/src/H5Epublic.h
index 3eae2da..ed14217 100644
--- a/src/H5Epublic.h
+++ b/src/H5Epublic.h
@@ -100,14 +100,14 @@ H5_DLLVAR hid_t H5E_ERR_CLS_g;
 }
 #else /* H5_NO_DEPRECATED_SYMBOLS */
 #define H5E_BEGIN_TRY {							      \
-    H5E_auto_t saved_efunc;						      \
+    H5E_auto2_t saved_efunc;						      \
     void *H5E_saved_edata;						      \
 								    	      \
-    (void)H5Eget_auto(H5E_DEFAULT, &saved_efunc, &H5E_saved_edata);	      \
-    (void)H5Eset_auto(H5E_DEFAULT, NULL, NULL);
+    (void)H5Eget_auto2(H5E_DEFAULT, &saved_efunc, &H5E_saved_edata);	      \
+    (void)H5Eset_auto2(H5E_DEFAULT, NULL, NULL);
 
 #define H5E_END_TRY							      \
-    (void)H5Eset_auto(H5E_DEFAULT, saved_efunc, H5E_saved_edata);	      \
+    (void)H5Eset_auto2(H5E_DEFAULT, saved_efunc, H5E_saved_edata);	      \
 }
 #endif /* H5_NO_DEPRECATED_SYMBOLS */