[svn-r145] ./src/H5Osdtyp.c -> H5Odtype.c

./src/H5Osdim.c		-> H5Osdspace.c
./src/Makefile.in
	Changed the names of these files to better reflect what they
	actually do.

./src/H5.c
./src/H5AC.c
./src/H5B.c
./src/H5C.c
./src/H5D.c
./src/H5E.c
./src/H5Eprivate.h
./src/H5Epublic.h
./src/H5F.c
./src/H5Fcore.c
./src/H5Ffamily.c
./src/H5Fistore.c
./src/H5Flow.c
./src/H5Fsec2.c
./src/H5Fsplit.c
./src/H5Fstdio.c
./src/H5G.c
./src/H5Gent.c
./src/H5Gnode.c
./src/H5Gshad.c
./src/H5Gstab.c
./src/H5H.c
./src/H5M.c
./src/H5MF.c
./src/H5O.c
./src/H5Osdtyp.c (./src/H5Odtype.c)
./src/H5P.c
./src/H5T.c
./src/H5detect.c
./src/H5private.h
	Added an argument to the HRETURN_ERROR(), HGOTO_ERROR(), and
	HERROR() macros which is a string error message.  This allows
	us to give extra information which can't be represented by the
	major and minor error numbers.  This information was
	previously in comments just before or after the macro call.
	The string isn't currently used, but I'm planning to change
	the test files so they print an error trace when something
	fails.  This should make debugging a little faster since it's
	often obvious what's wrong if we could just see the error
	stack without even having to start a debugger.

34 files changed, 1044 insertions, 842 deletions

diff --git a/src/H5.c b/src/H5.c
index 757e99d..555645e 100644
--- a/src/H5.c
+++ b/src/H5.c
@@ -41,6 +41,7 @@ static char RcsId[] = "@(#)$Revision$";
 #include <H5ACprivate.h>		/*cache				*/
 #include <H5Bprivate.h>			/*B-link trees			*/
 #include <H5Eprivate.h>			/*error handling		*/
+#include <H5MMprivate.h>		/*memory management		*/
 #include <H5Tprivate.h>			/*data types			*/
 
 #define PABLO_MASK	H5_mask
@@ -83,14 +84,16 @@ herr_t H5_init_library(void)
    /* Install atexit() library cleanup routine */
    if(install_atexit_g==TRUE)
       if (HDatexit(&H5_term_library) != 0)
-	 HRETURN_ERROR(H5E_FUNC, H5E_CANTINIT, FAIL);
+	 HRETURN_ERROR(H5E_FUNC, H5E_CANTINIT, FAIL,
+		       "unable to register atexit function");
 
    /*
     * Initialize interfaces that might not be able to initialize themselves
     * soon enough.
     */
    if (H5T_init_interface ()<0) {
-      HRETURN_ERROR (H5E_FUNC, H5E_CANTINIT, FAIL);
+      HRETURN_ERROR (H5E_FUNC, H5E_CANTINIT, FAIL,
+		     "unable to initialize type interface");
    }
    
 
@@ -127,8 +130,7 @@ H5_add_exit (void (*func)(void))
 
     assert(func);
 
-    if((new=HDcalloc(1,sizeof(H5_exit_t)))==NULL)
-       HRETURN_ERROR (H5E_RESOURCE, H5E_NOSPACE, FAIL);
+    new = H5MM_xcalloc (1, sizeof(H5_exit_t));
 
     new->func=func;
     new->next=lib_exit_head;
@@ -188,11 +190,13 @@ herr_t H5_init_thread(void)
 
     /* Create/initialize this thread's error stack */
     if((thrderrid=H5Enew_err_stack(16))==FAIL)
-       HRETURN_ERROR (H5E_FUNC, H5E_CANTINIT, FAIL);
+       HRETURN_ERROR (H5E_FUNC, H5E_CANTINIT, FAIL,
+		      "unable to create thread error stack");
 
     /* Add the "thread termination" routine to the exit chain */
     if(H5_add_exit(&H5_term_thread)==FAIL)
-       HRETURN_ERROR (H5E_FUNC, H5E_CANTINIT, FAIL);
+       HRETURN_ERROR (H5E_FUNC, H5E_CANTINIT, FAIL,
+		      "unable to set thread atexit function");
 
     FUNC_LEAVE (SUCCEED);
 }	/* H5_init_thread */
@@ -301,7 +305,8 @@ herr_t H5version(uintn *majnum, uintn *minnum, uintn *relnum, uintn *patnum)
     /* Clear errors and check args and all the boring stuff. */
     H5ECLEAR;
     if (majnum==NULL || minnum==NULL || relnum==NULL || patnum==NULL)
-        HGOTO_ERROR(H5E_ARGS, H5E_BADRANGE, FAIL);
+        HGOTO_ERROR(H5E_ARGS, H5E_BADRANGE, FAIL,
+		    "null pointer argument");
 
     /* Set the version information */
     *majnum=HDF5_MAJOR_VERSION;
diff --git a/src/H5AC.c b/src/H5AC.c
index 19e177e..8a5f4ed 100644
--- a/src/H5AC.c
+++ b/src/H5AC.c
@@ -112,7 +112,8 @@ H5AC_dest (H5F_t *f)
    cache = f->shared->cache;
    
    if (H5AC_flush (f, NULL, NO_ADDR, TRUE)<0) {
-      HRETURN_ERROR (H5E_CACHE, H5E_CANTFLUSH, FAIL);
+      HRETURN_ERROR (H5E_CACHE, H5E_CANTFLUSH, FAIL,
+		     "unable to flush cache");
    }
 
 #ifdef H5AC_DEBUG
@@ -212,7 +213,8 @@ H5AC_find_f (H5F_t *f, const H5AC_class_t *type, const haddr_t *addr,
     * of the wrong type.
     */
    if (slot->type && slot->type!=type && H5F_addr_eq (&(slot->addr), addr)) {
-      HRETURN_ERROR (H5E_CACHE, H5E_BADTYPE, NULL);
+      HRETURN_ERROR (H5E_CACHE, H5E_BADTYPE, NULL,
+		     "internal error (correct address, wrong type)");
    }
 
 #ifdef H5AC_DEBUG
@@ -234,7 +236,7 @@ H5AC_find_f (H5F_t *f, const H5AC_class_t *type, const haddr_t *addr,
     * without preempting anything.
     */
    if (NULL==(thing=(type->load)(f, addr, udata1, udata2))) {
-      HRETURN_ERROR (H5E_CACHE, H5E_CANTLOAD, NULL);
+      HRETURN_ERROR (H5E_CACHE, H5E_CANTLOAD, NULL, "unable to load object");
    }
 
    /*
@@ -249,9 +251,11 @@ H5AC_find_f (H5F_t *f, const H5AC_class_t *type, const haddr_t *addr,
 	  * Release the new thing and fail.
 	  */
 	 if ((type->flush)(f, TRUE, addr, thing)<0) {
-	    HRETURN_ERROR (H5E_CACHE, H5E_CANTFLUSH, NULL);
+	    HRETURN_ERROR (H5E_CACHE, H5E_CANTFLUSH, NULL,
+			   "unable to flush just-loaded object");
 	 }
-	 HRETURN_ERROR (H5E_CACHE, H5E_CANTFLUSH, NULL);
+	 HRETURN_ERROR (H5E_CACHE, H5E_CANTFLUSH, NULL,
+			"unable to flush existing cached object");
       }
       cache->diagnostics[slot->type->id].nflushes++;
    }
@@ -398,7 +402,8 @@ H5AC_flush (H5F_t *f, const H5AC_class_t *type, const haddr_t *addr,
 	    status = (flush)(f, destroy, &(slot->addr), slot->thing);
 	    if (status<0) {
 	       map = H5MM_xfree (map);
-	       HRETURN_ERROR (H5E_CACHE, H5E_CANTFLUSH, FAIL);
+	       HRETURN_ERROR (H5E_CACHE, H5E_CANTFLUSH, FAIL,
+			      "can't flush cache");
 	    }
 	    cache->diagnostics[slot->type->id].nflushes++;
 	    if (destroy) slot->type = NULL;
@@ -411,7 +416,8 @@ H5AC_flush (H5F_t *f, const H5AC_class_t *type, const haddr_t *addr,
        * else should have been flushed.
        */
       if (cache->nprots>0) {
-	 HRETURN_ERROR (H5E_CACHE, H5E_PROTECT, FAIL);
+	 HRETURN_ERROR (H5E_CACHE, H5E_PROTECT, FAIL,
+			"cache has protected items");
       }
       
    } else {
@@ -425,7 +431,8 @@ H5AC_flush (H5F_t *f, const H5AC_class_t *type, const haddr_t *addr,
 	 status =  (flush) (f, destroy, &(cache->slot[i].addr),
 			    cache->slot[i].thing);
 	 if (status<0) {
-	    HRETURN_ERROR (H5E_CACHE, H5E_CANTFLUSH, FAIL);
+	    HRETURN_ERROR (H5E_CACHE, H5E_CANTFLUSH, FAIL,
+			   "can't flush object");
 	 }
 	 cache->diagnostics[cache->slot[i].type->id].nflushes++;
 	 if (destroy) cache->slot[i].type = NULL;
@@ -492,7 +499,8 @@ H5AC_set (H5F_t *f, const H5AC_class_t *type, const haddr_t *addr, void *thing)
       flush = slot->type->flush;
       status = (flush)(f, TRUE, &(slot->addr), slot->thing);
       if (status<0) {
-	 HRETURN_ERROR (H5E_CACHE, H5E_CANTFLUSH, FAIL);
+	 HRETURN_ERROR (H5E_CACHE, H5E_CANTFLUSH, FAIL,
+			"can't flush object");
       }
       cache->diagnostics[slot->type->id].nflushes++;
    }
@@ -582,7 +590,8 @@ H5AC_rename (H5F_t *f, const H5AC_class_t *type,
       status = (flush)(f, TRUE, &(cache->slot[new_idx].addr),
 		       cache->slot[new_idx].thing);
       if (status<0) {
-	 HRETURN_ERROR (H5E_CACHE, H5E_CANTFLUSH, FAIL);
+	 HRETURN_ERROR (H5E_CACHE, H5E_CANTFLUSH, FAIL,
+			"can't flush object");
       }
       cache->diagnostics[cache->slot[new_idx].type->id].nflushes++;
    }
@@ -668,7 +677,8 @@ H5AC_protect (H5F_t *f, const H5AC_class_t *type, const haddr_t *addr,
       /*
        * Right address but wrong object type.
        */
-      HRETURN_ERROR (H5E_CACHE, H5E_BADTYPE, NULL);
+      HRETURN_ERROR (H5E_CACHE, H5E_BADTYPE, NULL,
+		     "internal error");
 	      
    } else {
 #ifdef H5AC_DEBUG
@@ -689,7 +699,8 @@ H5AC_protect (H5F_t *f, const H5AC_class_t *type, const haddr_t *addr,
        */
       cache->diagnostics[type->id].nmisses++;
       if (NULL==(thing=(type->load)(f, addr, udata1, udata2))) {
-	 HRETURN_ERROR (H5E_CACHE, H5E_CANTLOAD, NULL);
+	 HRETURN_ERROR (H5E_CACHE, H5E_CANTLOAD, NULL,
+			"can't load object");
       }
    }
 
@@ -770,7 +781,8 @@ H5AC_unprotect (H5F_t *f, const H5AC_class_t *type, const haddr_t *addr,
       flush = slot->type->flush;
       status = (flush)(f, TRUE, &(slot->addr), slot->thing);
       if (status<0) {
-	 HRETURN_ERROR (H5E_CACHE, H5E_CANTFLUSH, FAIL);
+	 HRETURN_ERROR (H5E_CACHE, H5E_CANTFLUSH, FAIL,
+			"can't flush object");
       }
       cache->diagnostics[slot->type->id].nflushes++;
    }
diff --git a/src/H5B.c b/src/H5B.c
index e38f482..be64ccf 100644
--- a/src/H5B.c
+++ b/src/H5B.c
@@ -179,7 +179,8 @@ H5B_create (H5F_t *f, const H5B_class_t *type, void *udata, haddr_t *retval)
    sizeof_rkey = (type->get_sizeof_rkey)(f, udata);
    size = H5B_nodesize (f, type, &total_native_keysize, sizeof_rkey);
    if (H5MF_alloc (f, H5MF_META, size, retval)<0) {
-      HRETURN_ERROR (H5E_RESOURCE, H5E_NOSPACE, FAIL);
+      HRETURN_ERROR (H5E_RESOURCE, H5E_NOSPACE, FAIL,
+		     "can't allocate file space for B-tree root node");
    }
    bt = H5MM_xmalloc (sizeof(H5B_t));
    bt->type = type;
@@ -222,7 +223,8 @@ H5B_create (H5F_t *f, const H5B_class_t *type, void *udata, haddr_t *retval)
     * Cache the new B-tree node.
     */
    if (H5AC_set (f, H5AC_BT, retval, bt)<0) {
-      HRETURN_ERROR (H5E_BTREE, H5E_CANTINIT, FAIL);
+      HRETURN_ERROR (H5E_BTREE, H5E_CANTINIT, FAIL,
+		     "can't add B-tree root node to cache");
    }
 
 #ifdef H5B_DEBUG
@@ -278,19 +280,22 @@ H5B_load (H5F_t *f, const haddr_t *addr, const void *_type, void *udata)
    bt->key = H5MM_xmalloc ((2*H5B_K(f,type)+1) * sizeof(H5B_key_t));
    bt->child = H5MM_xmalloc (2 * H5B_K(f,type) * sizeof(haddr_t));
    if (H5F_block_read (f, addr, size, bt->page)<0) {
-      HRETURN_ERROR (H5E_BTREE, H5E_READERROR, NULL);
+      HRETURN_ERROR (H5E_BTREE, H5E_READERROR, NULL,
+		     "can't read B-tree node");
    }
    p = bt->page;
 
    /* magic number */
    if (HDmemcmp (p, H5B_MAGIC, H5B_SIZEOF_MAGIC)) {
-      HGOTO_ERROR (H5E_BTREE,  H5E_CANTLOAD, NULL);
+      HGOTO_ERROR (H5E_BTREE,  H5E_CANTLOAD, NULL,
+		   "wrong B-tree signature");
    }
    p += 4;
 
    /* node type and level */
    if (*p++ != type->id) {
-      HGOTO_ERROR (H5E_BTREE,  H5E_CANTLOAD, NULL);
+      HGOTO_ERROR (H5E_BTREE,  H5E_CANTLOAD, NULL,
+		   "incorrect B-tree node level");
    }
    bt->level = *p++;
 
@@ -398,7 +403,8 @@ H5B_flush (H5F_t *f, hbool_t destroy, const haddr_t *addr, H5B_t *bt)
 	    if (bt->key[i].nkey) {
 	       if ((bt->type->encode)(f, bt, bt->key[i].rkey,
 				      bt->key[i].nkey)<0) {
-		  HRETURN_ERROR (H5E_BTREE, H5E_CANTENCODE, FAIL);
+		  HRETURN_ERROR (H5E_BTREE, H5E_CANTENCODE, FAIL,
+				 "unable to encode B-tree key");
 	       }
 	    }
 	    bt->key[i].dirty = FALSE;
@@ -419,7 +425,8 @@ H5B_flush (H5F_t *f, hbool_t destroy, const haddr_t *addr, H5B_t *bt)
        * for the final unchanged children.
        */
       if (H5F_block_write (f, addr, size, bt->page)<0) {
-	 HRETURN_ERROR (H5E_BTREE, H5E_CANTFLUSH, FAIL);
+	 HRETURN_ERROR (H5E_BTREE, H5E_CANTFLUSH, FAIL,
+			"unable to save B-tree node to disk");
       }
       bt->dirty = FALSE;
       bt->ndirty = 0;
@@ -487,14 +494,16 @@ H5B_find (H5F_t *f, const H5B_class_t *type, const haddr_t *addr, void *udata)
     * the thing for which we're searching.
     */
    if (NULL==(bt=H5AC_protect (f, H5AC_BT, addr, type, udata))) {
-      HGOTO_ERROR (H5E_BTREE, H5E_CANTLOAD, FAIL);
+      HGOTO_ERROR (H5E_BTREE, H5E_CANTLOAD, FAIL,
+		   "unable to load B-tree node");
    }
    rt = bt->nchildren;
 
    while (lt<rt && cmp) {
       idx = (lt + rt) / 2;
       if (H5B_decode_keys (f, bt, idx)<0) {
-	 HGOTO_ERROR (H5E_BTREE, H5E_CANTDECODE, FAIL);
+	 HGOTO_ERROR (H5E_BTREE, H5E_CANTDECODE, FAIL,
+		      "unable to decode B-tree key(s)");
       }
 
       /* compare */
@@ -506,7 +515,8 @@ H5B_find (H5F_t *f, const H5B_class_t *type, const haddr_t *addr, void *udata)
       }
    }
    if (cmp) {
-      HGOTO_ERROR (H5E_BTREE, H5E_NOTFOUND, FAIL);
+      HGOTO_ERROR (H5E_BTREE, H5E_NOTFOUND, FAIL,
+		   "B-tree key not found");
    }
 
    /*
@@ -515,19 +525,22 @@ H5B_find (H5F_t *f, const H5B_class_t *type, const haddr_t *addr, void *udata)
    assert (idx>=0 && idx<bt->nchildren);
    if (bt->level > 0) {
       if ((ret_value = H5B_find (f, type, bt->child+idx, udata))<0) {
-	 HGOTO_ERROR (H5E_BTREE, H5E_NOTFOUND, FAIL);
+	 HGOTO_ERROR (H5E_BTREE, H5E_NOTFOUND, FAIL,
+		      "key not found in subtree");
       }
    } else {
       ret_value = (type->found)(f, bt->child+idx, bt->key[idx].nkey,
 				udata, bt->key[idx+1].nkey);
       if (ret_value<0) {
-	 HGOTO_ERROR (H5E_BTREE, H5E_NOTFOUND, FAIL);
+	 HGOTO_ERROR (H5E_BTREE, H5E_NOTFOUND, FAIL,
+		      "key not found in leaf node");
       }
    }
 
 done:
    if (bt && H5AC_unprotect (f, H5AC_BT, addr, bt)<0) {
-      HRETURN_ERROR (H5E_BTREE, H5E_PROTECT, FAIL);
+      HRETURN_ERROR (H5E_BTREE, H5E_PROTECT, FAIL,
+		     "unable to release node");
    }
    FUNC_LEAVE (ret_value);
 }
@@ -588,10 +601,12 @@ H5B_split (H5F_t *f, const H5B_class_t *type, H5B_t *old_bt,
     * Create the new B-tree node.
     */
    if (H5B_create (f, type, udata, new_addr/*out*/)<0) {
-      HGOTO_ERROR (H5E_BTREE, H5E_CANTINIT, FAIL);
+      HGOTO_ERROR (H5E_BTREE, H5E_CANTINIT, FAIL,
+		   "unable to create B-tree");
    }
    if (NULL==(new_bt=H5AC_protect (f, H5AC_BT, new_addr, type, udata))) {
-      HGOTO_ERROR (H5E_BTREE, H5E_CANTLOAD, FAIL);
+      HGOTO_ERROR (H5E_BTREE, H5E_CANTLOAD, FAIL,
+		   "unable to protect B-tree");
    }
    new_bt->level = old_bt->level;
 
@@ -633,7 +648,8 @@ H5B_split (H5F_t *f, const H5B_class_t *type, H5B_t *old_bt,
    if (H5F_addr_defined (&(old_bt->right))) {
       if (NULL==(tmp_bt=H5AC_find (f, H5AC_BT, &(old_bt->right), type,
 				   udata))) {
-	 HGOTO_ERROR (H5E_BTREE, H5E_CANTLOAD, FAIL);
+	 HGOTO_ERROR (H5E_BTREE, H5E_CANTLOAD, FAIL,
+		      "unable to load right sibling");
       }
       tmp_bt->dirty = TRUE;
       tmp_bt->left = *new_addr;
@@ -645,7 +661,8 @@ H5B_split (H5F_t *f, const H5B_class_t *type, H5B_t *old_bt,
 done:
    {
       if (new_bt && H5AC_unprotect (f, H5AC_BT, new_addr, new_bt)<0) {
-	 HRETURN_ERROR (H5E_BTREE, H5E_PROTECT, FAIL);
+	 HRETURN_ERROR (H5E_BTREE, H5E_PROTECT, FAIL,
+			"unable to release B-tree node");
       }
    }
    FUNC_LEAVE (ret_value);
@@ -677,7 +694,8 @@ H5B_decode_key (H5F_t *f, H5B_t *bt, intn idx)
    bt->key[idx].nkey = bt->native + idx * bt->type->sizeof_nkey;
    if ((bt->type->decode)(f, bt, bt->key[idx].rkey,
 			  bt->key[idx].nkey)<0) {
-      HRETURN_ERROR (H5E_BTREE, H5E_CANTDECODE, FAIL);
+      HRETURN_ERROR (H5E_BTREE, H5E_CANTDECODE, FAIL,
+		     "unable to decode key");
    }
 
    FUNC_LEAVE (SUCCEED);
@@ -710,10 +728,12 @@ H5B_decode_keys (H5F_t *f, H5B_t *bt, intn idx)
    assert (idx>=0 && idx<bt->nchildren);
 
    if (!bt->key[idx].nkey && H5B_decode_key (f, bt, idx)<0) {
-      HRETURN_ERROR (H5E_BTREE, H5E_CANTDECODE, FAIL);
+      HRETURN_ERROR (H5E_BTREE, H5E_CANTDECODE, FAIL,
+		     "unable to decode key");
    }
    if (!bt->key[idx+1].nkey && H5B_decode_key (f, bt, idx+1)<0) {
-      HRETURN_ERROR (H5E_BTREE, H5E_CANTDECODE, FAIL);
+      HRETURN_ERROR (H5E_BTREE, H5E_CANTDECODE, FAIL,
+		     "unable to decode key");
    }
 
    FUNC_LEAVE (SUCCEED);
@@ -764,31 +784,36 @@ H5B_insert (H5F_t *f, const H5B_class_t *type, const haddr_t *addr,
    if ((my_ins=H5B_insert_helper (f, addr, type, lt_key, &lt_key_changed,
 				  md_key, udata, rt_key, &rt_key_changed,
 				  &child/*out*/))<0 || my_ins<0) {
-      HRETURN_ERROR (H5E_BTREE, H5E_CANTINIT, FAIL);
+      HRETURN_ERROR (H5E_BTREE, H5E_CANTINIT, FAIL,
+		     "unable to insert key");
    }
    if (H5B_INS_NOOP==my_ins) HRETURN (SUCCEED);
    assert (H5B_INS_RIGHT==my_ins);
 
    /* the current root */
    if (NULL==(bt = H5AC_find (f, H5AC_BT, addr, type, udata))) {
-      HRETURN_ERROR (H5E_BTREE, H5E_CANTLOAD, FAIL);
+      HRETURN_ERROR (H5E_BTREE, H5E_CANTLOAD, FAIL,
+		     "unable to locate root of B-tree");
    }
    level = bt->level;
    if (!lt_key_changed) {
       if (!bt->key[0].nkey && H5B_decode_key (f, bt, 0)<0) {
-	 HRETURN_ERROR (H5E_BTREE, H5E_CANTDECODE, FAIL);
+	 HRETURN_ERROR (H5E_BTREE, H5E_CANTDECODE, FAIL,
+			"unable to decode key");
       }
       HDmemcpy (lt_key, bt->key[0].nkey, type->sizeof_nkey);
    }
 
    /* the new node */
    if (NULL==(bt = H5AC_find (f, H5AC_BT, &child, type, udata))) {
-      HRETURN_ERROR (H5E_BTREE, H5E_CANTLOAD, FAIL);
+      HRETURN_ERROR (H5E_BTREE, H5E_CANTLOAD, FAIL,
+		     "unable to load new node");
    }
    if (!rt_key_changed) {
       if (!bt->key[bt->nchildren].nkey &&
 	  H5B_decode_key (f, bt, bt->nchildren)<0) {
-	 HRETURN_ERROR (H5E_BTREE, H5E_CANTDECODE, FAIL);
+	 HRETURN_ERROR (H5E_BTREE, H5E_CANTDECODE, FAIL,
+			"unable to decode key");
       }
       HDmemcpy (rt_key, bt->key[bt->nchildren].nkey, type->sizeof_nkey);
    }
@@ -801,33 +826,40 @@ H5B_insert (H5F_t *f, const H5B_class_t *type, const haddr_t *addr,
    size = H5B_nodesize (f, type, NULL, bt->sizeof_rkey);
    buf = H5MM_xmalloc (size);
    if (H5MF_alloc (f, H5MF_META, size, &old_root/*out*/)<0) {
-      HRETURN_ERROR (H5E_RESOURCE, H5E_NOSPACE, FAIL);
+      HRETURN_ERROR (H5E_RESOURCE, H5E_NOSPACE, FAIL,
+		     "unable to allocate file space to move root");
    }
    if (H5AC_flush (f, H5AC_BT, addr, FALSE)<0) {
-      HRETURN_ERROR (H5E_BTREE, H5E_CANTFLUSH, FAIL);
+      HRETURN_ERROR (H5E_BTREE, H5E_CANTFLUSH, FAIL,
+		     "unable to flush B-tree root node");
    }
    if (H5F_block_read (f, addr, size, buf)<0) {
-      HRETURN_ERROR (H5E_BTREE, H5E_READERROR, FAIL);
+      HRETURN_ERROR (H5E_BTREE, H5E_READERROR, FAIL,
+		     "unable to read B-tree root node");
    }
    if (H5F_block_write (f, &old_root, size, buf)<0) {
-      HRETURN_ERROR (H5E_BTREE, H5E_WRITEERROR, FAIL);
+      HRETURN_ERROR (H5E_BTREE, H5E_WRITEERROR, FAIL,
+		     "unable to move B-tree root node");
    }
    if (H5AC_rename (f, H5AC_BT, addr, &old_root)<0) {
-      HRETURN_ERROR (H5E_BTREE, H5E_CANTSPLIT, FAIL);
+      HRETURN_ERROR (H5E_BTREE, H5E_CANTSPLIT, FAIL,
+		     "unable to move B-tree root node");
    }
 
    buf = H5MM_xfree (buf);
 
    /* update the new child's left pointer */
    if (NULL==(bt=H5AC_find (f, H5AC_BT, &child, type, udata))) {
-      HRETURN_ERROR (H5E_BTREE, H5E_CANTLOAD, FAIL);
+      HRETURN_ERROR (H5E_BTREE, H5E_CANTLOAD, FAIL,
+		     "unable to load new child");
    }
    bt->dirty = TRUE;
    bt->left = old_root;
 
    /* clear the old root at the old address (we already copied it)*/
    if (NULL==(bt=H5AC_find (f, H5AC_BT, addr, type, udata))) {
-      HRETURN_ERROR (H5E_BTREE, H5E_CANTLOAD, FAIL);
+      HRETURN_ERROR (H5E_BTREE, H5E_CANTLOAD, FAIL,
+		     "unable to clear old root location");
    }
    bt->dirty = TRUE;
    bt->ndirty = 0;
@@ -837,7 +869,8 @@ H5B_insert (H5F_t *f, const H5B_class_t *type, const haddr_t *addr,
 
    /* the new root */
    if (NULL==(bt = H5AC_find (f, H5AC_BT, addr, type, udata))) {
-      HRETURN_ERROR (H5E_BTREE, H5E_CANTLOAD, FAIL);
+      HRETURN_ERROR (H5E_BTREE, H5E_CANTLOAD, FAIL,
+		     "unable to load new root");
    }
    bt->dirty = TRUE;
    bt->ndirty = 2;
@@ -1032,14 +1065,16 @@ H5B_insert_helper (H5F_t *f, const haddr_t *addr, const H5B_class_t *type,
     * should get the new data.
     */
    if (NULL==(bt=H5AC_protect (f, H5AC_BT, addr, type, udata))) {
-      HGOTO_ERROR (H5E_BTREE, H5E_CANTLOAD, H5B_INS_ERROR);
+      HGOTO_ERROR (H5E_BTREE, H5E_CANTLOAD, H5B_INS_ERROR,
+		   "unable to load node");
    }
    rt = bt->nchildren;
 
    while (lt<rt && cmp) {
       idx = (lt + rt) / 2;
       if (H5B_decode_keys (f, bt, idx)<0) {
-	 HRETURN_ERROR (H5E_BTREE, H5E_CANTDECODE, H5B_INS_ERROR);
+	 HRETURN_ERROR (H5E_BTREE, H5E_CANTDECODE, H5B_INS_ERROR,
+			"unable to decode key");
       }
       if ((cmp=(type->cmp3)(f, bt->key[idx].nkey, udata,
 			    bt->key[idx+1].nkey))<0) {
@@ -1060,7 +1095,8 @@ H5B_insert_helper (H5F_t *f, const haddr_t *addr, const H5B_class_t *type,
       if ((type->new)(f, H5B_INS_FIRST, bt->key[0].nkey, udata,
 		      bt->key[1].nkey, bt->child+0/*out*/)<0) {
 	 bt->key[0].nkey = bt->key[1].nkey = NULL;
-	 HGOTO_ERROR (H5E_BTREE, H5E_CANTINIT, H5B_INS_ERROR);
+	 HGOTO_ERROR (H5E_BTREE, H5E_CANTINIT, H5B_INS_ERROR,
+		      "unable to create leaf node");
       }
       bt->nchildren = 1;
       bt->dirty = TRUE;
@@ -1075,8 +1111,8 @@ H5B_insert_helper (H5F_t *f, const haddr_t *addr, const H5B_class_t *type,
 				    md_key, udata,
 				    bt->key[idx+1].nkey, rt_key_changed,
 				    &child_addr/*out*/))<0) {
-	    /* Can't insert first leaf node */
-	    HGOTO_ERROR (H5E_BTREE, H5E_CANTINSERT, H5B_INS_ERROR);
+	    HGOTO_ERROR (H5E_BTREE, H5E_CANTINSERT, H5B_INS_ERROR,
+			 "can't insert first leaf node");
 	 }
       } else {
 	 my_ins = H5B_INS_NOOP;
@@ -1089,15 +1125,16 @@ H5B_insert_helper (H5F_t *f, const haddr_t *addr, const H5B_class_t *type,
        */
       idx = 0;
       if (H5B_decode_keys (f, bt, idx)<0) {
-	 HGOTO_ERROR (H5E_BTREE, H5E_CANTDECODE, H5B_INS_ERROR);
+	 HGOTO_ERROR (H5E_BTREE, H5E_CANTDECODE, H5B_INS_ERROR,
+		      "unable to decode key");
       }
       if ((my_ins=H5B_insert_helper (f, bt->child+idx, type, 
 				     bt->key[idx].nkey, lt_key_changed,
 				     md_key, udata,
 				     bt->key[idx+1].nkey, rt_key_changed,
 				     &child_addr/*out*/))<0) {
-	 /* Can't insert minimum subtree */
-	 HGOTO_ERROR (H5E_BTREE, H5E_CANTINSERT, H5B_INS_ERROR);
+	 HGOTO_ERROR (H5E_BTREE, H5E_CANTINSERT, H5B_INS_ERROR,
+		      "can't insert minimum subtree");
       }
 
    } else if (cmp<0 && idx<=0 && type->follow_min) {
@@ -1108,15 +1145,16 @@ H5B_insert_helper (H5F_t *f, const haddr_t *addr, const H5B_class_t *type,
        */
       idx = 0;
       if (H5B_decode_keys (f, bt, idx)<0) {
-	 HGOTO_ERROR (H5E_BTREE, H5E_CANTDECODE, H5B_INS_ERROR);
+	 HGOTO_ERROR (H5E_BTREE, H5E_CANTDECODE, H5B_INS_ERROR,
+		      "unable to decode key");
       }
       if ((my_ins=(type->insert)(f, bt->child+idx,
 				 bt->key[idx].nkey, lt_key_changed,
 				 md_key, udata,
 				 bt->key[idx+1].nkey, rt_key_changed,
 				 &child_addr/*out*/))<0) {
-	 /* Can't insert minimum leaf node */
-	 HGOTO_ERROR (H5E_BTREE, H5E_CANTINSERT, H5B_INS_ERROR);
+	 HGOTO_ERROR (H5E_BTREE, H5E_CANTINSERT, H5B_INS_ERROR,
+		      "can't insert minimum leaf node");
       }
       
    } else if (cmp<0 && idx<=0) {
@@ -1127,14 +1165,15 @@ H5B_insert_helper (H5F_t *f, const haddr_t *addr, const H5B_class_t *type,
        */
       idx = 0;
       if (H5B_decode_keys (f, bt, idx)<0) {
-	 HGOTO_ERROR (H5E_BTREE, H5E_CANTDECODE, H5B_INS_ERROR);
+	 HGOTO_ERROR (H5E_BTREE, H5E_CANTDECODE, H5B_INS_ERROR,
+		      "unable to decode key");
       }
       my_ins = H5B_INS_LEFT;
       HDmemcpy (md_key, bt->key[idx].nkey, type->sizeof_nkey);
       if ((type->new)(f, H5B_INS_LEFT, bt->key[idx].nkey, udata, md_key,
 		      &child_addr/*out*/)<0) {
-	 /* Can't insert minimum leaf node */
-	 HGOTO_ERROR (H5E_BTREE, H5E_CANTINSERT, H5B_INS_ERROR);
+	 HGOTO_ERROR (H5E_BTREE, H5E_CANTINSERT, H5B_INS_ERROR,
+		      "can't insert minimum leaf node");
       }
       *lt_key_changed = TRUE;
       
@@ -1145,15 +1184,16 @@ H5B_insert_helper (H5F_t *f, const haddr_t *addr, const H5B_class_t *type,
        */
       idx = bt->nchildren - 1;
       if (H5B_decode_keys (f, bt, idx)<0) {
-	 HGOTO_ERROR (H5E_BTREE, H5E_CANTDECODE, H5B_INS_ERROR);
+	 HGOTO_ERROR (H5E_BTREE, H5E_CANTDECODE, H5B_INS_ERROR,
+		      "unable to decode key");
       }
       if ((my_ins=H5B_insert_helper (f, bt->child+idx, type, 
 				     bt->key[idx].nkey, lt_key_changed,
 				     md_key, udata,
 				     bt->key[idx+1].nkey, rt_key_changed,
 				     &child_addr/*out*/))<0) {
-	 /* Can't insert maximum subtree */
-	 HGOTO_ERROR (H5E_BTREE, H5E_CANTINSERT, H5B_INS_ERROR);
+	 HGOTO_ERROR (H5E_BTREE, H5E_CANTINSERT, H5B_INS_ERROR,
+		      "can't insert maximum subtree");
       }
       
    } else if (cmp>0 && idx+1>=bt->nchildren && type->follow_max) {
@@ -1164,15 +1204,16 @@ H5B_insert_helper (H5F_t *f, const haddr_t *addr, const H5B_class_t *type,
        */
       idx = bt->nchildren - 1;
       if (H5B_decode_keys (f, bt, idx)<0) {
-	 HGOTO_ERROR (H5E_BTREE, H5E_CANTDECODE, H5B_INS_ERROR);
+	 HGOTO_ERROR (H5E_BTREE, H5E_CANTDECODE, H5B_INS_ERROR,
+		      "unable to decode key");
       }
       if ((my_ins=(type->insert)(f, bt->child+idx,
 				 bt->key[idx].nkey, lt_key_changed,
 				 md_key, udata,
 				 bt->key[idx+1].nkey, rt_key_changed,
 				 &child_addr/*out*/))<0) {
-	 /* Can't insert maximum leaf node */
-	 HGOTO_ERROR (H5E_BTREE, H5E_CANTINSERT, H5B_INS_ERROR);
+	 HGOTO_ERROR (H5E_BTREE, H5E_CANTINSERT, H5B_INS_ERROR,
+		      "can't insert maximum leaf node");
       }
       
    } else if (cmp>0 && idx+1>=bt->nchildren) {
@@ -1183,14 +1224,15 @@ H5B_insert_helper (H5F_t *f, const haddr_t *addr, const H5B_class_t *type,
        */
       idx = bt->nchildren - 1;
       if (H5B_decode_keys (f, bt, idx)<0) {
-	 HGOTO_ERROR (H5E_BTREE, H5E_CANTDECODE, H5B_INS_ERROR);
+	 HGOTO_ERROR (H5E_BTREE, H5E_CANTDECODE, H5B_INS_ERROR,
+		      "unable to decode key");
       }
       my_ins = H5B_INS_RIGHT;
       HDmemcpy (md_key, bt->key[idx+1].nkey, type->sizeof_nkey);
       if ((type->new)(f, H5B_INS_RIGHT, md_key, udata, bt->key[idx+1].nkey,
 		      &child_addr/*out*/)<0) {
-	 /* Can't insert maximum leaf node */
-	 HGOTO_ERROR (H5E_BTREE, H5E_CANTINSERT, H5B_INS_ERROR);
+	 HGOTO_ERROR (H5E_BTREE, H5E_CANTINSERT, H5B_INS_ERROR,
+		      "can't insert maximum leaf node");
       }
       *rt_key_changed = TRUE;
       
@@ -1211,8 +1253,8 @@ H5B_insert_helper (H5F_t *f, const haddr_t *addr, const H5B_class_t *type,
 				     md_key, udata,
 				     bt->key[idx+1].nkey, rt_key_changed,
 				     &child_addr/*out*/))<0) {
-	 /* Can't insert subtree */
-	 HGOTO_ERROR (H5E_BTREE, H5E_CANTINSERT, H5B_INS_ERROR);
+	 HGOTO_ERROR (H5E_BTREE, H5E_CANTINSERT, H5B_INS_ERROR,
+		      "can't insert subtree");
       }
       
    } else {
@@ -1225,8 +1267,8 @@ H5B_insert_helper (H5F_t *f, const haddr_t *addr, const H5B_class_t *type,
 				 md_key, udata,
 				 bt->key[idx+1].nkey, rt_key_changed,
 				 &child_addr/*out*/))<0) {
-	 /* Can't insert leaf node */
-	 HGOTO_ERROR (H5E_BTREE, H5E_CANTINSERT, H5B_INS_ERROR);
+	 HGOTO_ERROR (H5E_BTREE, H5E_CANTINSERT, H5B_INS_ERROR,
+		      "can't insert leaf node");
       }
       
    }
@@ -1270,12 +1312,12 @@ H5B_insert_helper (H5F_t *f, const haddr_t *addr, const H5B_class_t *type,
       /* If this node is full then split it before inserting the new child. */
       if (bt->nchildren==2*H5B_K (f, type)) {
 	 if (H5B_split (f, type, bt, addr, udata, new_node/*out*/)<0) {
-	    /*can't split node*/
-	    HGOTO_ERROR (H5E_BTREE, H5E_CANTSPLIT, H5B_INS_ERROR);
+	    HGOTO_ERROR (H5E_BTREE, H5E_CANTSPLIT, H5B_INS_ERROR,
+			 "can't split node");
 	 }
 	 if (NULL==(twin=H5AC_protect (f, H5AC_BT, new_node, type, udata))) {
-	    /*can't load B-tree*/
-	    HGOTO_ERROR (H5E_BTREE, H5E_CANTLOAD, H5B_INS_ERROR);
+	    HGOTO_ERROR (H5E_BTREE, H5E_CANTLOAD, H5B_INS_ERROR,
+			 "can't load B-tree");
 	 }
 	 if (idx<=H5B_K (f, type)) {
 	    tmp_bt = bt;
@@ -1290,8 +1332,8 @@ H5B_insert_helper (H5F_t *f, const haddr_t *addr, const H5B_class_t *type,
       /* Insert the child */
       if (H5B_insert_child (f, type, tmp_bt, idx, &child_addr, my_ins,
 			    md_key)<0) {
-	 /*can't insert child*/
-	 HGOTO_ERROR (H5E_BTREE, H5E_CANTINSERT, H5B_INS_ERROR);
+	 HGOTO_ERROR (H5E_BTREE, H5E_CANTINSERT, H5B_INS_ERROR,
+		      "can't insert child");
       }
    }
 
@@ -1302,7 +1344,8 @@ H5B_insert_helper (H5F_t *f, const haddr_t *addr, const H5B_class_t *type,
     */
    if (twin) {
       if (!twin->key[0].nkey && H5B_decode_key (f, twin, 0)<0) {
-	 HGOTO_ERROR (H5E_BTREE, H5E_CANTDECODE, H5B_INS_ERROR);
+	 HGOTO_ERROR (H5E_BTREE, H5E_CANTDECODE, H5B_INS_ERROR,
+		      "unable to decode key");
       }
       HDmemcpy (md_key, twin->key[0].nkey, type->sizeof_nkey);
       ret_value = H5B_INS_RIGHT;
@@ -1328,7 +1371,8 @@ done:
       herr_t e1 = (bt && H5AC_unprotect (f, H5AC_BT, addr, bt)<0);
       herr_t e2 = (twin && H5AC_unprotect (f, H5AC_BT, new_node, twin)<0);
       if (e1 || e2) { /*use vars to prevent short-circuit of side effects*/
-	 HRETURN_ERROR (H5E_BTREE, H5E_PROTECT, H5B_INS_ERROR);
+	 HRETURN_ERROR (H5E_BTREE, H5E_PROTECT, H5B_INS_ERROR,
+			"unable to release node(s)");
       }
    }
 
@@ -1375,12 +1419,14 @@ H5B_list (H5F_t *f, const H5B_class_t *type, const haddr_t *addr, void *udata)
    assert (udata);
    
    if (NULL==(bt = H5AC_find (f, H5AC_BT, addr, type, udata))) {
-      HRETURN_ERROR (H5E_BTREE, H5E_CANTLOAD, FAIL);
+      HRETURN_ERROR (H5E_BTREE, H5E_CANTLOAD, FAIL,
+		     "unable to load B-tree node");
    }
    
    if (bt->level>0) {
       if (H5B_list (f, type, bt->child+0, udata)<0) {
-	 HRETURN_ERROR (H5E_BTREE, H5E_CANTLIST, FAIL);
+	 HRETURN_ERROR (H5E_BTREE, H5E_CANTLIST, FAIL,
+			"unable to list B-tree node");
       } else {
 	 HRETURN (SUCCEED);
       }
@@ -1388,18 +1434,21 @@ H5B_list (H5F_t *f, const H5B_class_t *type, const haddr_t *addr, void *udata)
 
       for (cur_addr=addr; !H5F_addr_defined (cur_addr); cur_addr=&next_addr) {
 	 if (NULL==(bt=H5AC_protect (f, H5AC_BT, cur_addr, type, udata))) {
-	    HGOTO_ERROR (H5E_BTREE, H5E_CANTLOAD, FAIL);
+	    HGOTO_ERROR (H5E_BTREE, H5E_CANTLOAD, FAIL,
+			 "unable to protect B-tree node");
 	 }
 	 
 	 for (i=0; i<bt->nchildren; i++) {
 	    if ((type->list)(f, bt->child+i, udata)<0) {
-	       HGOTO_ERROR (H5E_BTREE, H5E_CANTLOAD, FAIL);
+	       HGOTO_ERROR (H5E_BTREE, H5E_CANTLOAD, FAIL,
+			    "unable to list leaf node");
 	    }
 	 }
 
 	 next_addr = bt->right;
 	 if (H5AC_unprotect (f, H5AC_BT, addr, bt)<0) {
-	    HRETURN_ERROR (H5E_BTREE, H5E_PROTECT, FAIL);
+	    HRETURN_ERROR (H5E_BTREE, H5E_PROTECT, FAIL,
+			   "unable to release B-tree node");
 	 }
 	 bt = NULL;
       }
@@ -1408,7 +1457,8 @@ H5B_list (H5F_t *f, const H5B_class_t *type, const haddr_t *addr, void *udata)
 
 done:
    if (bt && H5AC_unprotect (f, H5AC_BT, cur_addr, bt)<0) {
-      HRETURN_ERROR (H5E_BTREE, H5E_PROTECT, FAIL);
+      HRETURN_ERROR (H5E_BTREE, H5E_PROTECT, FAIL,
+		     "unable to release B-tree node");
    }
    FUNC_LEAVE (ret_value);
 }
@@ -1511,7 +1561,8 @@ H5B_debug (H5F_t *f, const haddr_t *addr, FILE *stream, intn indent,
     * Load the tree node.
     */
    if (NULL==(bt=H5AC_find (f, H5AC_BT, addr, type, udata))) {
-      HRETURN_ERROR (H5E_BTREE, H5E_CANTLOAD, FAIL);
+      HRETURN_ERROR (H5E_BTREE, H5E_CANTLOAD, FAIL,
+		     "unable to load B-tree node");
    }
 
    /*
diff --git a/src/H5C.c b/src/H5C.c
index ad18406..2d5ebe5 100644
--- a/src/H5C.c
+++ b/src/H5C.c
@@ -69,13 +69,17 @@ H5C_init_interface (void)
       status = H5Ainit_group (H5_TEMPLATE_0+i, H5A_TEMPID_HASHSIZE, 0, NULL);
       if (status<0) ret_value = FAIL;
    }
-   if (ret_value<0) HRETURN_ERROR (H5E_ATOM, H5E_CANTINIT, FAIL);
+   if (ret_value<0) {
+      HRETURN_ERROR (H5E_ATOM, H5E_CANTINIT, FAIL,
+		     "unable to initialize atom group");
+   }
 
    /*
     * Register cleanup function.
     */
    if (H5_add_exit (H5C_term_interface)<0) {
-      HRETURN_ERROR (H5E_INTERNAL, H5E_CANTINIT, FAIL);
+      HRETURN_ERROR (H5E_INTERNAL, H5E_CANTINIT, FAIL,
+		     "unable to install atexit function");
    }
 
    FUNC_LEAVE(ret_value);
@@ -143,8 +147,8 @@ H5Ccreate (H5C_class_t type)
       break;
 
    case H5C_FILE_ACCESS:
-      /* Not implemented yet */
-      HRETURN_ERROR (H5E_INTERNAL, H5E_UNSUPPORTED, FAIL);
+      HRETURN_ERROR (H5E_INTERNAL, H5E_UNSUPPORTED, FAIL,
+		     "not implemented yet");
 
    case H5C_DATASET_CREATE:
       tmpl = H5MM_xmalloc (sizeof(H5D_create_t));
@@ -157,13 +161,14 @@ H5Ccreate (H5C_class_t type)
       break;
       
    default:
-      /* Unknown template class */
-      HRETURN_ERROR (H5E_ARGS, H5E_BADVALUE, FAIL);
+      HRETURN_ERROR (H5E_ARGS, H5E_BADVALUE, FAIL,
+		     "unknown template class");
    }
 
    /* Atomize the new template */
    if ((ret_value = H5C_create (type, tmpl))<0) {
-      HRETURN_ERROR (H5E_ATOM, H5E_CANTINIT, FAIL); /*can't register template*/
+      HRETURN_ERROR (H5E_ATOM, H5E_CANTINIT, FAIL,
+		     "can't register template");
    }
 
    FUNC_LEAVE (ret_value);
@@ -201,7 +206,8 @@ H5C_create (H5C_class_t type, void *tmpl)
 
    /* Atomize the new template */
    if ((ret_value = H5Aregister_atom (H5_TEMPLATE_0+type, tmpl))<0) {
-      HRETURN_ERROR (H5E_ATOM, H5E_CANTINIT, FAIL); /*can't register template*/
+      HRETURN_ERROR (H5E_ATOM, H5E_CANTINIT, FAIL,
+		     "can't register template");
    }
 
    FUNC_LEAVE (ret_value);
@@ -229,7 +235,7 @@ H5Cclose (hid_t template)
 
    /* Chuck the object! :-) */
    if (NULL==(tmpl=H5Aremove_atom (template))) {
-      HRETURN_ERROR(H5E_ATOM, H5E_BADATOM, FAIL);
+      HRETURN_ERROR(H5E_ATOM, H5E_BADATOM, FAIL, "unable to remove atom");
    }
    H5MM_xfree (tmpl);
 
@@ -264,8 +270,7 @@ H5Cget_class (hid_t template)
    
    if ((group = H5Aatom_group (template))<0 ||
        group<H5_TEMPLATE_0 || group>=H5_TEMPLATE_MAX) {
-      /* not a template */
-      HRETURN_ERROR (H5E_ATOM, H5E_BADATOM, H5C_NO_CLASS);
+      HRETURN_ERROR (H5E_ATOM, H5E_BADATOM, H5C_NO_CLASS, "not a template");
    }
 
    ret_value = group - H5_TEMPLATE_0;
@@ -425,7 +430,7 @@ H5Cget_prop (hid_t template, H5C_prop_t prop, void *buf/*out*/)
    /* check args */
    if ((type=H5Cget_class (template))<0 ||
        NULL==(tmpl=H5Aatom_object (template))) {
-      HRETURN_ERROR (H5E_ARGS, H5E_BADTYPE, FAIL); /*not a template*/
+      HRETURN_ERROR (H5E_ARGS, H5E_BADTYPE, FAIL, "not a template");
    }
 
    /* Handle each class of template */
@@ -479,14 +484,14 @@ H5Cget_prop (hid_t template, H5C_prop_t prop, void *buf/*out*/)
 	 break;
 
       default:
-	 /* Unknown property for file create template */
-	 HRETURN_ERROR (H5E_ARGS, H5E_BADRANGE, FAIL);
+	 HRETURN_ERROR (H5E_ARGS, H5E_BADRANGE, FAIL,
+			"unknown property for file create template");
       }
       break;
 
    case H5C_FILE_ACCESS:
-      /* Unknown property for file access template */
-      HRETURN_ERROR (H5E_ARGS, H5E_BADRANGE, FAIL);
+      HRETURN_ERROR (H5E_ARGS, H5E_BADRANGE, FAIL,
+		     "unknown property for file access template");
        
    case H5C_DATASET_CREATE:
       dset_create = (const H5D_create_t *)tmpl;
@@ -499,8 +504,8 @@ H5Cget_prop (hid_t template, H5C_prop_t prop, void *buf/*out*/)
 	 if (H5D_CHUNKED==dset_create->layout) {
 	    *(int*)buf = dset_create->chunk_ndims; 
 	 } else {
-	    /* Chunk dimensionality is not initialized */
-	    HRETURN_ERROR (H5E_TEMPLATE, H5E_UNINITIALIZED, FAIL);
+	    HRETURN_ERROR (H5E_TEMPLATE, H5E_UNINITIALIZED, FAIL,
+			   "chunk dimensionality is not initialized");
 	 }
 	 break;
 
@@ -510,30 +515,30 @@ H5Cget_prop (hid_t template, H5C_prop_t prop, void *buf/*out*/)
 	       ((size_t*)buf)[i] = dset_create->chunk_size[i];
 	    }
 	 } else {
-	    /* Chunk size is not initialized */
-	    HRETURN_ERROR (H5E_TEMPLATE, H5E_UNINITIALIZED, FAIL);
+	    HRETURN_ERROR (H5E_TEMPLATE, H5E_UNINITIALIZED, FAIL,
+			   "chunk size is not initialized");
 	 }
 	 break;
 
       case H5D_COMPRESS:
       case H5D_PRE_OFFSET:
       case H5D_PRE_SCALE:
-	 /* Not implemented yet */
-	 HRETURN_ERROR (H5E_INTERNAL, H5E_UNSUPPORTED, FAIL);
+	 HRETURN_ERROR (H5E_INTERNAL, H5E_UNSUPPORTED, FAIL,
+			"not implemented yet");
 
       default:
-	 /* Unknown property for dataset create template */
-	 HRETURN_ERROR (H5E_ARGS, H5E_BADRANGE, FAIL);
+	 HRETURN_ERROR (H5E_ARGS, H5E_BADRANGE, FAIL,
+			"unknown property for dataset create template");
       }
       break;
        
    case H5C_DATASET_XFER:
-      /* Unknown property for dataset transfer template */
-      HRETURN_ERROR (H5E_ARGS, H5E_BADRANGE, FAIL);
+      HRETURN_ERROR (H5E_ARGS, H5E_BADRANGE, FAIL,
+		     "unknown property for dataset transfer template");
 
    default:
-      /* Unknown template class */
-      HRETURN_ERROR (H5E_ARGS, H5E_BADRANGE, FAIL);
+      HRETURN_ERROR (H5E_ARGS, H5E_BADRANGE, FAIL,
+		     "unknown template class");
    }
    FUNC_LEAVE (SUCCEED);
 }
@@ -583,7 +588,7 @@ H5Cset_prop (hid_t template, H5C_prop_t prop, ...)
    
    if ((type=H5Cget_class (template))<0 ||
        NULL==(tmpl=H5Aatom_object (template))) {
-      HGOTO_ERROR (H5E_ARGS, H5E_BADTYPE, FAIL); /*not a template*/
+      HGOTO_ERROR (H5E_ARGS, H5E_BADTYPE, FAIL, "not a template");
    }
 
    /* Handle each class of template */
@@ -599,8 +604,8 @@ H5Cset_prop (hid_t template, H5C_prop_t prop, ...)
 	    if (size==p2) break;
 	 }
 	 if (i>=8*sizeof(int)) {
-	    /* Userblock size is not valid */
-	    HGOTO_ERROR (H5E_ARGS, H5E_BADVALUE, FAIL);
+	    HGOTO_ERROR (H5E_ARGS, H5E_BADVALUE, FAIL,
+			 "userblock size is not valid");
 	 }
 	 file_create->userblock_size = size;
 	 break;
@@ -608,8 +613,8 @@ H5Cset_prop (hid_t template, H5C_prop_t prop, ...)
       case H5F_SIZEOF_ADDR:
 	 size = va_arg (ap, size_t);
 	 if (size!=2 && size!=4 && size!=8 && size!=16) {
-	    /* file haddr_t size is not valid */
-	    HGOTO_ERROR (H5E_ARGS, H5E_BADVALUE, FAIL);
+	    HGOTO_ERROR (H5E_ARGS, H5E_BADVALUE, FAIL,
+			 "file haddr_t size is not valid");
 	 }
 	 file_create->sizeof_addr = size;
 	 break;
@@ -617,8 +622,8 @@ H5Cset_prop (hid_t template, H5C_prop_t prop, ...)
       case H5F_SIZEOF_SIZE:
 	 size = va_arg (ap, size_t);
 	 if (size!=2 && size!=4 && size!=8 && size!=16) {
-	    /* file size_t size is not valid */
-	    HGOTO_ERROR (H5E_ARGS, H5E_BADVALUE, FAIL);
+	    HGOTO_ERROR (H5E_ARGS, H5E_BADVALUE, FAIL,
+			 "file size_t size is not valid");
 	 }
 	 file_create->sizeof_size = size;
 	 break;
@@ -626,8 +631,8 @@ H5Cset_prop (hid_t template, H5C_prop_t prop, ...)
       case H5F_SYM_LEAF_K:
 	 n = va_arg (ap, int);
 	 if (n<2) {
-	    /* Symbol leaf node 1/2 rank is not valid */
-	    HGOTO_ERROR (H5E_ARGS, H5E_BADRANGE, FAIL);
+	    HGOTO_ERROR (H5E_ARGS, H5E_BADRANGE, FAIL,
+			 "symbol leaf node 1/2 rank is not valid");
 	 }
 	 file_create->sym_leaf_k = n;
 	 break;
@@ -635,8 +640,8 @@ H5Cset_prop (hid_t template, H5C_prop_t prop, ...)
       case H5F_SYM_INTERN_K:
 	 n = va_arg (ap, int);
 	 if (n<2) {
-	    /* Symbol internal node 1/2 rank is not valid */
-	    HGOTO_ERROR (H5E_ARGS, H5E_BADRANGE, FAIL);
+	    HGOTO_ERROR (H5E_ARGS, H5E_BADRANGE, FAIL,
+			 "symbol internal node 1/2 rank is not valid");
 	 }
 	 file_create->btree_k[H5B_SNODE_ID] = n;
 	 break;
@@ -644,8 +649,8 @@ H5Cset_prop (hid_t template, H5C_prop_t prop, ...)
       case H5F_ISTORE_K:
 	 n = va_arg (ap, int);
 	 if (n<2) {
-	    /* Indexed storage internal node 1/2 rank is not valid */
-	    HGOTO_ERROR (H5E_ARGS, H5E_BADRANGE, FAIL);
+	    HGOTO_ERROR (H5E_ARGS, H5E_BADRANGE, FAIL,
+			 "indexed storage internal node 1/2 rank not valid");
 	 }
 	 file_create->btree_k[H5B_ISTORE_ID] = n;
 	 break;
@@ -655,18 +660,18 @@ H5Cset_prop (hid_t template, H5C_prop_t prop, ...)
       case H5F_FREESPACE_VER:
       case H5F_OBJECTDIR_VER:
       case H5F_SHAREDHEADER_VER:
-	 /* This is a read-only property */
-	 HGOTO_ERROR (H5E_ARGS, H5E_BADRANGE, FAIL);
+	 HGOTO_ERROR (H5E_ARGS, H5E_BADRANGE, FAIL,
+		      "this is a read-only property");
 
       default:
-	 /* Unknown file creation property */
-	 HGOTO_ERROR(H5E_ARGS, H5E_BADRANGE, FAIL);
+	 HGOTO_ERROR(H5E_ARGS, H5E_BADRANGE, FAIL,
+		     "unknown file creation property");
       }
       break;
 
    case H5C_FILE_ACCESS:
-      /* Unknown property for file access template */
-      HGOTO_ERROR (H5E_ARGS, H5E_BADRANGE, FAIL);
+      HGOTO_ERROR (H5E_ARGS, H5E_BADRANGE, FAIL,
+		   "unknown property for file access template");
        
    case H5C_DATASET_CREATE:
       dset_create = (H5D_create_t *)tmpl;
@@ -675,8 +680,8 @@ H5Cset_prop (hid_t template, H5C_prop_t prop, ...)
       case H5D_LAYOUT:
 	 layout = va_arg (ap, H5D_layout_t);
 	 if (layout<0 || layout>=H5D_NLAYOUTS) {
-	    /* Raw data layout method is not valid */
-	    HGOTO_ERROR (H5E_ARGS, H5E_BADRANGE, FAIL);
+	    HGOTO_ERROR (H5E_ARGS, H5E_BADRANGE, FAIL,
+			 "raw data layout method is not valid");
 	 }
 	 dset_create->layout = layout;
 	 break;
@@ -684,12 +689,12 @@ H5Cset_prop (hid_t template, H5C_prop_t prop, ...)
       case H5D_CHUNK_NDIMS:
 	 n = va_arg (ap, int);
 	 if (H5D_CHUNKED!=dset_create->layout) {
-	    /* Not a chunked layout template */
-	    HGOTO_ERROR (H5E_ARGS, H5E_BADTYPE, FAIL);
+	    HGOTO_ERROR (H5E_ARGS, H5E_BADTYPE, FAIL,
+			 "not a chunked layout template");
 	 }
 	 if (n<=0 || n>NELMTS (dset_create->chunk_size)) {
-	    /* Invalid number of dimensions */
-	    HGOTO_ERROR (H5E_ARGS, H5E_BADVALUE, FAIL);
+	    HGOTO_ERROR (H5E_ARGS, H5E_BADVALUE, FAIL,
+			 "invalid number of dimensions");
 	 }
 	 dset_create->chunk_ndims = n;
 	 for (i=0; i<n; i++) dset_create->chunk_size[i] = 1;
@@ -698,16 +703,16 @@ H5Cset_prop (hid_t template, H5C_prop_t prop, ...)
       case H5D_CHUNK_SIZE:
 	 dims = va_arg (ap, size_t*);
 	 if (H5D_CHUNKED!=dset_create->layout) {
-	    /* Not a chunked layout template */
-	    HGOTO_ERROR (H5E_ARGS, H5E_BADTYPE, FAIL);
+	    HGOTO_ERROR (H5E_ARGS, H5E_BADTYPE, FAIL,
+			 "not a chunked layout template");
 	 }
 	 if (!dims) {
-	    HGOTO_ERROR (H5E_ARGS, H5E_BADVALUE, FAIL); /*no dims*/
+	    HGOTO_ERROR (H5E_ARGS, H5E_BADVALUE, FAIL, "no dims");
 	 }
 	 for (i=0; i<dset_create->chunk_ndims; i++) {
 	    if (dims[i]<=0) {
-	       /* Invalid dimension size */
-	       HGOTO_ERROR (H5E_ARGS, H5E_BADVALUE, FAIL);
+	       HGOTO_ERROR (H5E_ARGS, H5E_BADVALUE, FAIL,
+			    "invalid dimension size");
 	    }
 	 }
 	 for (i=0; i<dset_create->chunk_ndims; i++) {
@@ -718,22 +723,22 @@ H5Cset_prop (hid_t template, H5C_prop_t prop, ...)
       case H5D_COMPRESS:
       case H5D_PRE_OFFSET:
       case H5D_PRE_SCALE:
-	 /* Not implemented yet */
-	 HGOTO_ERROR (H5E_INTERNAL, H5E_UNSUPPORTED, FAIL);
+	 HGOTO_ERROR (H5E_INTERNAL, H5E_UNSUPPORTED, FAIL,
+		      "not implemented yet");
 
       default:
-	 /* Unknown property for dataset create template */
-	 HGOTO_ERROR (H5E_ARGS, H5E_BADRANGE, FAIL);
+	 HGOTO_ERROR (H5E_ARGS, H5E_BADRANGE, FAIL,
+		      "unknown property for dataset create template");
       }
       break;
        
    case H5C_DATASET_XFER:
-      /* Unknown property for dataset transfer template */
-      HGOTO_ERROR (H5E_ARGS, H5E_BADRANGE, FAIL);
+      HGOTO_ERROR (H5E_ARGS, H5E_BADRANGE, FAIL,
+		   "unknown property for dataset transfer template");
 
    default:
-      /* Unknown template class */
-      HGOTO_ERROR (H5E_ARGS, H5E_BADRANGE, FAIL);
+      HGOTO_ERROR (H5E_ARGS, H5E_BADRANGE, FAIL,
+		   "unknown template class");
    }
 
    ret_value = SUCCEED;
@@ -783,8 +788,8 @@ H5Ccopy (hid_t template)
    if (NULL==(tmpl=H5Aatom_object (template)) ||
        (type=H5Cget_class (template))<0 ||
        (group=H5Aatom_group (template))<0) {
-      /* Can't unatomize template */
-      HRETURN_ERROR (H5E_ATOM, H5E_BADATOM, FAIL);
+      HRETURN_ERROR (H5E_ATOM, H5E_BADATOM, FAIL,
+		     "can't unatomize template");
    }
 
    /* How big is the template */
@@ -794,8 +799,8 @@ H5Ccopy (hid_t template)
       break;
 
    case H5C_FILE_ACCESS:
-      /* File access properties are not implemented yet */
-      HRETURN_ERROR (H5E_INTERNAL, H5E_UNSUPPORTED, FAIL);
+      HRETURN_ERROR (H5E_INTERNAL, H5E_UNSUPPORTED, FAIL,
+		     "file access properties are not implemented yet");
 
    case H5C_DATASET_CREATE:
       size = sizeof(H5D_create_t);
@@ -806,8 +811,8 @@ H5Ccopy (hid_t template)
       break;
 
    default:
-      /* Unknown template class */
-      HRETURN_ERROR (H5E_ARGS, H5E_BADRANGE, FAIL);
+      HRETURN_ERROR (H5E_ARGS, H5E_BADRANGE, FAIL,
+		     "unknown template class");
    }
 
    /* Create the new template */
@@ -816,7 +821,8 @@ H5Ccopy (hid_t template)
 
    /* Register the atom for the new template */
    if ((ret_value=H5Aregister_atom (group, new_tmpl))<0) {
-      HRETURN_ERROR (H5E_ATOM, H5E_CANTREGISTER, FAIL);
+      HRETURN_ERROR (H5E_ATOM, H5E_CANTREGISTER, FAIL,
+		     "unable to atomize template pointer");
    }
 
    FUNC_LEAVE (ret_value);
diff --git a/src/H5D.c b/src/H5D.c
index 9aad6a4..87e16d9 100644
--- a/src/H5D.c
+++ b/src/H5D.c
@@ -179,24 +179,24 @@ H5Dcreate (hid_t file_id, const char *name, hid_t type_id, hid_t space_id,
    /* check arguments */
    if (H5_FILE!=H5Aatom_group (file_id) ||
        NULL==(f=H5Aatom_object (file_id))) {
-      HRETURN_ERROR (H5E_ARGS, H5E_BADTYPE, FAIL); /*not a file*/
+      HRETURN_ERROR (H5E_ARGS, H5E_BADTYPE, FAIL, "not a file");
    }
    if (!name || !*name) {
-      HRETURN_ERROR (H5E_ARGS, H5E_BADVALUE, FAIL); /*no name*/
+      HRETURN_ERROR (H5E_ARGS, H5E_BADVALUE, FAIL, "no name");
    }
    if (H5_DATATYPE!=H5Aatom_group (type_id) ||
        NULL==(type=H5Aatom_object (type_id))) {
-      HRETURN_ERROR (H5E_ARGS, H5E_BADTYPE, FAIL); /*not a type*/
+      HRETURN_ERROR (H5E_ARGS, H5E_BADTYPE, FAIL, "not a type");
    }
    if (H5_DATASPACE!=H5Aatom_group (space_id) ||
        NULL==(space=H5Aatom_object (space_id))) {
-      HRETURN_ERROR (H5E_ARGS, H5E_BADTYPE, FAIL); /*not a data space */
+      HRETURN_ERROR (H5E_ARGS, H5E_BADTYPE, FAIL, "not a data space");
    }
    if (create_parms_id>=0) {
       if (H5C_DATASET_CREATE!=H5Cget_class (create_parms_id) ||
 	  NULL==(create_parms=H5Aatom_object (create_parms_id))) {
-	 /* Not a dataset creation template */
-	 HRETURN_ERROR (H5E_ARGS, H5E_BADTYPE, FAIL);
+	 HRETURN_ERROR (H5E_ARGS, H5E_BADTYPE, FAIL,
+			"not a dataset creation template");
       }
    } else {
       create_parms = &H5D_create_dflt;
@@ -204,14 +204,14 @@ H5Dcreate (hid_t file_id, const char *name, hid_t type_id, hid_t space_id,
 
    /* build and open the new dataset */
    if (NULL==(new_dset=H5D_create (f, name, type, space, create_parms))) {
-      HRETURN_ERROR (H5E_DATASET, H5E_CANTINIT, FAIL); /*can't create dataset*/
+      HRETURN_ERROR (H5E_DATASET, H5E_CANTINIT, FAIL, "can't create dataset");
    }
 
    /* Register the new datatype and get an ID for it */
    if ((ret_value=H5Aregister_atom (H5_DATASET, new_dset))<0) {
       H5D_close (new_dset);
-      /* Can't register dataset */
-      HRETURN_ERROR (H5E_DATASET, H5E_CANTREGISTER, FAIL);
+      HRETURN_ERROR (H5E_DATASET, H5E_CANTREGISTER, FAIL,
+		     "can't register dataset");
    }
 
    FUNC_LEAVE (ret_value);
@@ -255,22 +255,22 @@ H5Dopen (hid_t file_id, const char *name)
    /* Check args */
    if (H5_FILE!=H5Aatom_group (file_id) ||
        NULL==(file=H5Aatom_object (file_id))) {
-      HRETURN_ERROR (H5E_ARGS, H5E_BADTYPE, FAIL); /*not a file*/
+      HRETURN_ERROR (H5E_ARGS, H5E_BADTYPE, FAIL, "not a file");
    }
    if (!name || !*name) {
-      HRETURN_ERROR (H5E_ARGS, H5E_BADVALUE, FAIL); /*no name*/
+      HRETURN_ERROR (H5E_ARGS, H5E_BADVALUE, FAIL, "no name");
    }
 
    /* Find the dataset */
    if (NULL==(dataset=H5D_open (file, name))) {
-      HRETURN_ERROR (H5E_DATASET, H5E_NOTFOUND, FAIL); /*dataset not found*/
+      HRETURN_ERROR (H5E_DATASET, H5E_NOTFOUND, FAIL, "dataset not found");
    }
 
    /* Create an atom for the dataset */
    if ((ret_value=H5Aregister_atom (H5_DATASET, dataset))<0) {
       H5D_close (dataset);
-      /* Can't register dataset */
-      HRETURN_ERROR (H5E_DATASET, H5E_CANTREGISTER, FAIL);
+      HRETURN_ERROR (H5E_DATASET, H5E_CANTREGISTER, FAIL,
+		     "can't register dataset");
    }
 
    FUNC_LEAVE (ret_value);
@@ -311,7 +311,7 @@ H5Dclose (hid_t dataset_id)
    if (H5_DATASET!=H5Aatom_group (dataset_id) ||
        NULL==(dataset=H5Aatom_object (dataset_id)) ||
        NULL==dataset->file) {
-      HRETURN_ERROR (H5E_ARGS, H5E_BADTYPE, FAIL); /*not a dataset*/
+      HRETURN_ERROR (H5E_ARGS, H5E_BADTYPE, FAIL, "not a dataset");
    }
 
    /*
@@ -319,7 +319,7 @@ H5Dclose (hid_t dataset_id)
     * reaches zero.
     */
    if (H5A_dec_ref (dataset_id)<0) {
-      HRETURN_ERROR (H5E_DATASET, H5E_CANTINIT, FAIL); /*can't free*/
+      HRETURN_ERROR (H5E_DATASET, H5E_CANTINIT, FAIL, "can't free");
    }
 
    FUNC_LEAVE (SUCCEED);
@@ -379,31 +379,31 @@ H5Dread (hid_t dataset_id, hid_t type_id, hid_t space_id,
    if (H5_DATASET!=H5Aatom_group (dataset_id) ||
        NULL==(dataset=H5Aatom_object (dataset_id)) ||
        NULL==dataset->file) {
-      HRETURN_ERROR (H5E_ARGS, H5E_BADTYPE, FAIL); /*not a dataset*/
+      HRETURN_ERROR (H5E_ARGS, H5E_BADTYPE, FAIL, "not a dataset");
    }
    if (H5_DATATYPE!=H5Aatom_group (type_id) ||
        NULL==(type=H5Aatom_object (type_id))) {
-      HRETURN_ERROR (H5E_ARGS, H5E_BADTYPE, FAIL); /*not a data type*/
+      HRETURN_ERROR (H5E_ARGS, H5E_BADTYPE, FAIL, "not a data type");
    }
    if (H5P_ALL!=space_id) {
       if (H5_DATASPACE!=H5Aatom_group (space_id) ||
 	  NULL==(space=H5Aatom_object (space_id))) {
-	 HRETURN_ERROR (H5E_ARGS, H5E_BADTYPE, FAIL); /*not a data space*/
+	 HRETURN_ERROR (H5E_ARGS, H5E_BADTYPE, FAIL, "not a data space");
       }
    }
    if (H5C_DEFAULT==xfer_parms_id) {
       xfer_parms = &H5D_xfer_dflt;
    } else if (H5C_DATASET_XFER!=H5Cget_class (xfer_parms_id) ||
 	      NULL==(xfer_parms=H5Aatom_object (xfer_parms_id))) {
-      HRETURN_ERROR (H5E_ARGS, H5E_BADTYPE, FAIL); /*not xfer parms*/
+      HRETURN_ERROR (H5E_ARGS, H5E_BADTYPE, FAIL, "not xfer parms");
    }
    if (!buf) {
-      HRETURN_ERROR (H5E_ARGS, H5E_BADVALUE, FAIL); /*no output buffer*/
+      HRETURN_ERROR (H5E_ARGS, H5E_BADVALUE, FAIL, "no output buffer");
    }
 
    /* read raw data */
    if (H5D_read (dataset, type, space, xfer_parms, buf/*out*/)<0) {
-      HRETURN_ERROR (H5E_DATASET, H5E_READERROR, FAIL); /*can't read data*/
+      HRETURN_ERROR (H5E_DATASET, H5E_READERROR, FAIL, "can't read data");
    }
    
    FUNC_LEAVE (SUCCEED);
@@ -459,31 +459,31 @@ H5Dwrite (hid_t dataset_id, hid_t type_id, hid_t space_id,
    if (H5_DATASET!=H5Aatom_group (dataset_id) ||
        NULL==(dataset=H5Aatom_object (dataset_id)) ||
        NULL==dataset->file) {
-      HRETURN_ERROR (H5E_ARGS, H5E_BADTYPE, FAIL); /*not a dataset*/
+      HRETURN_ERROR (H5E_ARGS, H5E_BADTYPE, FAIL, "not a dataset");
    }
    if (H5_DATATYPE!=H5Aatom_group (type_id) ||
        NULL==(type=H5Aatom_object (type_id))) {
-      HRETURN_ERROR (H5E_ARGS, H5E_BADTYPE, FAIL); /*not a data type*/
+      HRETURN_ERROR (H5E_ARGS, H5E_BADTYPE, FAIL, "not a data type");
    }
    if (H5P_ALL!=space_id) {
       if (H5_DATASPACE!=H5Aatom_group (space_id) ||
 	  NULL==(space=H5Aatom_object (space_id))) {
-	 HRETURN_ERROR (H5E_ARGS, H5E_BADTYPE, FAIL); /*not a data space*/
+	 HRETURN_ERROR (H5E_ARGS, H5E_BADTYPE, FAIL, "not a data space");
       }
    }
    if (H5C_DEFAULT==xfer_parms_id) {
       xfer_parms = &H5D_xfer_dflt;
    } else if (H5C_DATASET_XFER!=H5Cget_class (xfer_parms_id) ||
 	      NULL==(xfer_parms=H5Aatom_object (xfer_parms_id))) {
-      HRETURN_ERROR (H5E_ARGS, H5E_BADTYPE, FAIL); /*not xfer parms*/
+      HRETURN_ERROR (H5E_ARGS, H5E_BADTYPE, FAIL, "not xfer parms");
    }
    if (!buf) {
-      HRETURN_ERROR (H5E_ARGS, H5E_BADVALUE, FAIL); /*no output buffer*/
+      HRETURN_ERROR (H5E_ARGS, H5E_BADVALUE, FAIL, "no output buffer");
    }
 
    /* write raw data */
    if (H5D_write (dataset, type, space, xfer_parms, buf)<0) {
-      HRETURN_ERROR (H5E_DATASET, H5E_READERROR, FAIL); /*can't write data*/
+      HRETURN_ERROR (H5E_DATASET, H5E_READERROR, FAIL, "can't write data");
    }
    
    FUNC_LEAVE (SUCCEED);
@@ -588,16 +588,16 @@ H5D_create (H5F_t *f, const char *name, const H5T_t *type, const H5P_t *space,
     * is cached it shouldn't cause any disk activity.
     */
    if (NULL==(new_dset->ent = H5G_create (f, name, H5D_MINHDR_SIZE))) {
-      /* Problem with the dataset name */
-      HGOTO_ERROR (H5E_DATASET, H5E_CANTINIT, NULL);
+      HGOTO_ERROR (H5E_DATASET, H5E_CANTINIT, NULL,
+		   "problem with the dataset name");
    }
 
    /* Update the type and space header messages */
    if (H5O_modify (f, NO_ADDR, new_dset->ent, H5O_DTYPE, 0,
 		   new_dset->type)<0 ||
        H5P_modify (f, new_dset->ent, new_dset->space)<0) {
-      /* Can't update type or space header messages */
-      HGOTO_ERROR (H5E_DATASET, H5E_CANTINIT, NULL);
+      HGOTO_ERROR (H5E_DATASET, H5E_CANTINIT, NULL,
+		   "can't update type or space header messages");
    }
 
    /* Total raw data size */
@@ -609,13 +609,13 @@ H5D_create (H5F_t *f, const char *name, const H5T_t *type, const H5P_t *space,
       new_dset->storage.cstore.size = nbytes;
       if (H5MF_alloc (f, H5MF_RAW, nbytes,
 		      &(new_dset->storage.cstore.addr))<0) {
-	 /* Can't allocate raw file storage */
-	 HGOTO_ERROR (H5E_DATASET, H5E_NOSPACE, NULL);
+	 HGOTO_ERROR (H5E_DATASET, H5E_NOSPACE, NULL,
+		      "can't allocate raw file storage");
       }
       if (H5O_modify (f, NO_ADDR, new_dset->ent, H5O_CSTORE, 0,
 		      &(new_dset->storage.cstore))<0) {
-	 /* Can't update dataset object header */
-	 HGOTO_ERROR (H5E_DATASET, H5E_CANTINIT, NULL);
+	 HGOTO_ERROR (H5E_DATASET, H5E_CANTINIT, NULL,
+		      "can't update dataset object header");
       }
       break;
 
@@ -628,27 +628,27 @@ H5D_create (H5F_t *f, const char *name, const H5T_t *type, const H5P_t *space,
        */
       ndims = new_dset->create_parms.chunk_ndims;
       if (ndims != H5P_get_ndims (space)) {
-	 /* Dimensionality of chunks doesn't match the data space */
-	 HGOTO_ERROR (H5E_DATASET, H5E_BADVALUE, NULL);
+	 HGOTO_ERROR (H5E_DATASET, H5E_BADVALUE, NULL,
+		      "dimensionality of chunks doesn't match the data space");
       }
       assert (ndims<NELMTS (new_dset->create_parms.chunk_size));
       new_dset->create_parms.chunk_size[ndims] = H5T_get_size (type);
 
       if (H5F_istore_create (f, &(new_dset->storage.istore), ndims+1,
 			     new_dset->create_parms.chunk_size)<0) {
-	 /* Can't initialize chunked storage */
-	 HGOTO_ERROR (H5E_DATASET, H5E_CANTINIT, NULL);
+	 HGOTO_ERROR (H5E_DATASET, H5E_CANTINIT, NULL,
+		      "can't initialize chunked storage");
       }
       if (H5O_modify (f, NO_ADDR, new_dset->ent, H5O_ISTORE, 0,
 		      &(new_dset->storage.istore))<0) {
-	 /* Can't update dataset object header */
-	 HGOTO_ERROR (H5E_DATASET, H5E_CANTINIT, NULL);
+	 HGOTO_ERROR (H5E_DATASET, H5E_CANTINIT, NULL,
+		      "can't update dataset object header");
       }
       break;
       
    default:
       assert ("not implemented yet" && 0);
-      HGOTO_ERROR (H5E_DATASET, H5E_UNSUPPORTED, NULL);
+      HGOTO_ERROR (H5E_DATASET, H5E_UNSUPPORTED, NULL, "not implemented yet");
    }
 
    /* Success */
@@ -707,15 +707,15 @@ H5D_open (H5F_t *f, const char *name)
     
    /* Open the dataset object */
    if (NULL==(dataset->ent=H5G_open (f, name))) {
-      HGOTO_ERROR (H5E_DATASET, H5E_NOTFOUND, NULL); /*not found*/
+      HGOTO_ERROR (H5E_DATASET, H5E_NOTFOUND, NULL, "not found");
    }
 
    /* Get the type and space */
    if (NULL==(dataset->type = H5O_read (f, NO_ADDR, dataset->ent, H5O_DTYPE,
 					0, NULL)) ||
        NULL==(dataset->space = H5P_read (f, dataset->ent))) {
-      /* Can't load type of space info from dataset header */
-      HGOTO_ERROR (H5E_DATASET, H5E_CANTINIT, NULL);
+      HGOTO_ERROR (H5E_DATASET, H5E_CANTINIT, NULL,
+		   "can't load type of space info from dataset header");
    }
 
    /*
@@ -746,7 +746,7 @@ H5D_open (H5F_t *f, const char *name)
       
    } else {
       assert ("not implemented yet" && 0);
-      HGOTO_ERROR (H5E_DATASET, H5E_UNSUPPORTED, NULL);
+      HGOTO_ERROR (H5E_DATASET, H5E_UNSUPPORTED, NULL, "not implemented yet");
    }
 
    /* Success */
@@ -819,8 +819,9 @@ H5D_close (H5D_t *dataset)
    H5MM_xfree (dataset);
 
    if (free_failed) {
-      /* Couldn't free the type or space, but the dataset was freed anyway. */
-      HRETURN_ERROR (H5E_DATASET, H5E_CANTINIT, FAIL);
+      HRETURN_ERROR (H5E_DATASET, H5E_CANTINIT, FAIL,
+		     "couldn't free the type or space, but the dataset was "
+		     "freed anyway.");
    }
 
    FUNC_LEAVE (SUCCEED);
@@ -866,16 +867,16 @@ H5D_read (H5D_t *dataset, const H5T_t *type, const H5P_t *space,
    assert (buf);
 
    if (H5D_CONTIGUOUS!=dataset->create_parms.layout) {
-      /* Layout is not supported yet */
-      HRETURN_ERROR (H5E_DATASET, H5E_UNSUPPORTED, FAIL);
+      HRETURN_ERROR (H5E_DATASET, H5E_UNSUPPORTED, FAIL,
+		     "layout is not supported yet");
    }
    if (H5T_cmp (type, dataset->type)) {
-      /* Type conversion not supported yet */
-      HRETURN_ERROR (H5E_DATASET, H5E_UNSUPPORTED, FAIL);
+      HRETURN_ERROR (H5E_DATASET, H5E_UNSUPPORTED, FAIL,
+		     "type conversion not supported yet");
    }
    if (space && H5P_cmp (space, dataset->space)) {
-      /* Space conversion not supported yet */
-      HRETURN_ERROR (H5E_DATASET, H5E_UNSUPPORTED, FAIL);
+      HRETURN_ERROR (H5E_DATASET, H5E_UNSUPPORTED, FAIL,
+		     "space conversion not supported yet");
    }
 
    /* Compute the size of the request */
@@ -888,7 +889,7 @@ H5D_read (H5D_t *dataset, const H5T_t *type, const H5P_t *space,
        */
       if (H5F_block_read (dataset->file, &(dataset->storage.cstore.addr),
 			  nbytes, buf)<0) {
-	 HRETURN_ERROR (H5E_IO, H5E_READERROR, FAIL); /*read failed*/
+	 HRETURN_ERROR (H5E_IO, H5E_READERROR, FAIL, "read failed");
       }
       break;
 
@@ -901,13 +902,14 @@ H5D_read (H5D_t *dataset, const H5T_t *type, const H5P_t *space,
       size[dataset->storage.istore.ndims-1] = H5T_get_size (dataset->type);
       if (H5F_istore_read (dataset->file, &(dataset->storage.istore),
 			   offset, size, buf)<0) {
-	 HRETURN_ERROR (H5E_IO, H5E_READERROR, FAIL); /*read failed*/
+	 HRETURN_ERROR (H5E_IO, H5E_READERROR, FAIL, "read failed");
       }
       break;
 
    default:
       assert ("not implemented yet" && 0);
-      HRETURN_ERROR (H5E_INTERNAL, H5E_UNSUPPORTED, FAIL);
+      HRETURN_ERROR (H5E_INTERNAL, H5E_UNSUPPORTED, FAIL,
+		     "not implemented yet");
    }
 
    FUNC_LEAVE (SUCCEED);
@@ -954,16 +956,16 @@ H5D_write (H5D_t *dataset, const H5T_t *type, const H5P_t *space,
    assert (buf);
 
    if (H5D_CONTIGUOUS!=dataset->create_parms.layout) {
-      /* Layout is not supported yet */
-      HRETURN_ERROR (H5E_DATASET, H5E_UNSUPPORTED, FAIL);
+      HRETURN_ERROR (H5E_DATASET, H5E_UNSUPPORTED, FAIL,
+		     "layout is not supported yet");
    }
    if (H5T_cmp (type, dataset->type)) {
-      /* Type conversion not supported yet */
-      HRETURN_ERROR (H5E_DATASET, H5E_UNSUPPORTED, FAIL);
+      HRETURN_ERROR (H5E_DATASET, H5E_UNSUPPORTED, FAIL,
+		     "type conversion not supported yet");
    }
    if (space && H5P_cmp (space, dataset->space)) {
-      /* Space conversion not supported yet */
-      HRETURN_ERROR (H5E_DATASET, H5E_UNSUPPORTED, FAIL);
+      HRETURN_ERROR (H5E_DATASET, H5E_UNSUPPORTED, FAIL,
+		     "space conversion not supported yet");
    }
 
    /* Compute the size of the request */
@@ -977,7 +979,7 @@ H5D_write (H5D_t *dataset, const H5T_t *type, const H5P_t *space,
        */
       if (H5F_block_write (dataset->file, &(dataset->storage.cstore.addr),
 			   nbytes, buf)<0) {
-	 HRETURN_ERROR (H5E_IO, H5E_WRITEERROR, FAIL); /*write failed*/
+	 HRETURN_ERROR (H5E_IO, H5E_WRITEERROR, FAIL, "write failed");
       }
       break;
 
@@ -990,13 +992,14 @@ H5D_write (H5D_t *dataset, const H5T_t *type, const H5P_t *space,
       size[dataset->storage.istore.ndims-1] = H5T_get_size (dataset->type);
       if (H5F_istore_write (dataset->file, &(dataset->storage.istore),
 			    offset, size, buf)<0) {
-	 HRETURN_ERROR (H5E_IO, H5E_WRITEERROR, FAIL); /*write failed*/
+	 HRETURN_ERROR (H5E_IO, H5E_WRITEERROR, FAIL, "write failed");
       }
       break;
 
    default:
       assert ("not implemented yet" && 0);
-      HRETURN_ERROR (H5E_INTERNAL, H5E_UNSUPPORTED, FAIL);
+      HRETURN_ERROR (H5E_INTERNAL, H5E_UNSUPPORTED, FAIL,
+		     "not implemented yet");
    }
    
    FUNC_LEAVE (SUCCEED);
diff --git a/src/H5Dconv.c b/src/H5Dconv.c
index 25ff762..5f9ee36 100644
--- a/src/H5Dconv.c
+++ b/src/H5Dconv.c
@@ -117,7 +117,8 @@ herr_t H5D_convert_buf(void *dst, const void *src, uintn len, uintn size)
               break;
 
           default:
-              HGOTO_ERROR(H5E_INTERNAL, H5E_UNSUPPORTED, FAIL);
+              HGOTO_ERROR(H5E_INTERNAL, H5E_UNSUPPORTED, FAIL,
+			  "not implemented yet");
       } /* end switch */
 
 done:
diff --git a/src/H5Distore.c b/src/H5Distore.c
index 8684465..15c7d4d 100644
--- a/src/H5Distore.c
+++ b/src/H5Distore.c
@@ -370,8 +370,8 @@ H5F_istore_new_node (H5F_t *f, H5B_ins_t op,
    nbytes = H5V_vector_reduce_product (udata->mesg.ndims, udata->key.size);
    assert (nbytes>0);
    if (H5MF_alloc (f, H5MF_RAW, nbytes, addr/*out*/)<0) {
-      /* Couldn't allocate new file storage */
-      HRETURN_ERROR (H5E_IO, H5E_CANTINIT, FAIL);
+      HRETURN_ERROR (H5E_IO, H5E_CANTINIT, FAIL,
+		     "couldn't allocate new file storage");
    }
    udata->addr = *addr;
    udata->key.file_number = 0;
@@ -518,7 +518,7 @@ H5F_istore_insert (H5F_t *f, const haddr_t *addr,
    if (cmp<0) {
       /* Negative indices not supported yet */
       assert ("HDF5 INTERNAL ERROR -- see rpm" && 0);
-      HRETURN_ERROR (H5E_STORAGE, H5E_UNSUPPORTED, FAIL);
+      HRETURN_ERROR (H5E_STORAGE, H5E_UNSUPPORTED, FAIL, "internal error");
       
    } else if (H5V_hyper_eq (udata->mesg.ndims,
 			    udata->key.offset,  udata->key.size, 
@@ -554,7 +554,8 @@ H5F_istore_insert (H5F_t *f, const haddr_t *addr,
        * Allocate storage for the new chunk
        */
       if (H5MF_alloc (f, H5MF_RAW, nbytes, new_node/*out*/)<0) {
-	 HRETURN_ERROR (H5E_IO, H5E_CANTINIT, FAIL);
+	 HRETURN_ERROR (H5E_IO, H5E_CANTINIT, FAIL,
+			"file allocation failed");
       }
       udata->addr = *new_node;
       udata->key.file_number = 0;
@@ -562,7 +563,7 @@ H5F_istore_insert (H5F_t *f, const haddr_t *addr,
       
    } else {
       assert ("HDF5 INTERNAL ERROR -- see rpm" && 0);
-      HRETURN_ERROR (H5E_IO, H5E_UNSUPPORTED, FAIL);
+      HRETURN_ERROR (H5E_IO, H5E_UNSUPPORTED, FAIL, "internal error");
    }
    
    FUNC_LEAVE (ret_value);
@@ -704,7 +705,8 @@ H5F_istore_copy_hyperslab (H5F_t *f, const H5O_istore_t *istore, H5F_isop_t op,
 	 if (status>=0 && H5F_addr_defined (&(udata.addr))) {
 	    assert (0==udata.key.file_number);
 	    if (H5F_block_read (f, &(udata.addr), chunk_size, chunk)<0) {
-	       HGOTO_ERROR (H5E_IO, H5E_READERROR, FAIL);
+	       HGOTO_ERROR (H5E_IO, H5E_READERROR, FAIL,
+			    "unable to read raw storage chunk");
 	    }
 	 } else {
 	    HDmemset (chunk, 0, chunk_size);
@@ -718,7 +720,8 @@ H5F_istore_copy_hyperslab (H5F_t *f, const H5O_istore_t *istore, H5F_isop_t op,
 			 size_m, sub_offset_m, buf);
 	 assert (0==udata.key.file_number);
 	 if (H5F_block_write (f, &(udata.addr), chunk_size, chunk)<0) {
-	    HGOTO_ERROR (H5E_IO, H5E_WRITEERROR, FAIL);
+	    HGOTO_ERROR (H5E_IO, H5E_WRITEERROR, FAIL,
+			 "unable to write raw storage chunk");
 	 }
       } else {
 	 H5V_hyper_copy (istore->ndims, sub_size,
@@ -774,8 +777,8 @@ H5F_istore_read (H5F_t *f, const H5O_istore_t *istore,
 
    if (H5F_istore_copy_hyperslab (f, istore, H5F_ISTORE_READ,
 				  offset, size, H5V_ZERO, size, buf)<0) {
-      /* hyperslab output failure */
-      HRETURN_ERROR (H5E_IO, H5E_READERROR, FAIL);
+      HRETURN_ERROR (H5E_IO, H5E_READERROR, FAIL,
+		     "hyperslab output failure");
    }
 
    FUNC_LEAVE (SUCCEED);
@@ -815,8 +818,8 @@ H5F_istore_write (H5F_t *f, const H5O_istore_t *istore,
 
    if (H5F_istore_copy_hyperslab (f, istore, H5F_ISTORE_WRITE,
 				  offset, size, H5V_ZERO, size, buf)<0) {
-      /* hyperslab output failure */
-      HRETURN_ERROR (H5E_IO, H5E_WRITEERROR, FAIL);
+      HRETURN_ERROR (H5E_IO, H5E_WRITEERROR, FAIL,
+		     "hyperslab output failure");
    }
 
    FUNC_LEAVE (SUCCEED);
@@ -868,7 +871,7 @@ H5F_istore_create (H5F_t *f, struct H5O_istore_t *istore/*out*/,
 
    udata.mesg.ndims = istore->ndims = ndims;
    if (H5B_create (f, H5B_ISTORE, &udata, &(istore->btree_addr)/*out*/)<0) {
-      HRETURN_ERROR (H5E_IO, H5E_CANTINIT, FAIL); /* Can't create B-tree */
+      HRETURN_ERROR (H5E_IO, H5E_CANTINIT, FAIL, "can't create B-tree");
    }
 
    for (i=0; i<ndims; i++) {
diff --git a/src/H5E.c b/src/H5E.c
index f14195f..f738caa 100644
--- a/src/H5E.c
+++ b/src/H5E.c
@@ -239,11 +239,11 @@ intn H5Edelete_err_stack(int32 err_stack)
 
     /* Clear errors and check args and all the boring stuff. */
     if (H5Aatom_group(err_stack)!=H5_ERR)
-        HGOTO_ERROR(H5E_ARGS, H5E_BADTYPE, FAIL);
+        HGOTO_ERROR(H5E_ARGS, H5E_BADTYPE, FAIL, "not an error stack");
 
     /* Get the error stack to put the error on */
     if((old_stack=H5Aremove_atom(err_stack))==NULL)
-        HGOTO_ERROR(H5E_ATOM, H5E_BADATOM, FAIL);
+        HGOTO_ERROR(H5E_ATOM, H5E_BADATOM, FAIL, "can't remove atom");
 
     /* Clear the error descriptions and reset the stack top */
     for(; old_stack->stack_top>0; old_stack->stack_top--)
@@ -292,11 +292,11 @@ H5Eclear (int32 err_hand)
 
     /* Get the error stack for this error handler, initialized earlier in H5Enew_err_stack */
     if (H5Aatom_group(err_hand)!=H5_ERR)
-        HGOTO_ERROR(H5E_ARGS, H5E_BADTYPE, FAIL);
+        HGOTO_ERROR(H5E_ARGS, H5E_BADTYPE, FAIL, "not an error stack");
 
     /* Get the error stack to put the error on */
     if((err_stack=H5Aatom_object(err_hand))==NULL)
-        HGOTO_ERROR(H5E_BADATOM, H5E_BADATOM, FAIL);
+        HGOTO_ERROR(H5E_BADATOM, H5E_BADATOM, FAIL, "not an error stack");
 
     /* Clear the error descriptions and reset the stack top */
     for(; err_stack->stack_top>0; err_stack->stack_top--)
@@ -337,7 +337,7 @@ DESCRIPTION
 
 --------------------------------------------------------------------------*/
 herr_t
-H5E_store(int32 errid, hdf_maj_err_code_t maj, hdf_min_err_code_t min, const char *function_name, const char *file_name, intn line)
+H5E_store(int32 errid, H5E_major_t maj, H5E_minor_t min, const char *function_name, const char *file_name, intn line)
 {
     H5E_errstack_t *err_stack=NULL;     /* Pointer to the error stack to put value on */
     herr_t ret_value = SUCCEED;
@@ -349,7 +349,7 @@ H5E_store(int32 errid, hdf_maj_err_code_t maj, hdf_min_err_code_t min, const cha
 
     /* Get the error stack to put the error on */
     if((err_stack=H5Aatom_object(errid))==NULL)
-        HGOTO_ERROR(H5E_BADATOM, H5E_BADATOM, FAIL);
+        HGOTO_ERROR(H5E_BADATOM, H5E_BADATOM, FAIL, "not an error stack");
 
     /* Check if we need to expand the stack */
     if(err_stack->stack_top>=err_stack->stack_size)
@@ -403,7 +403,7 @@ DESCRIPTION
 
 --------------------------------------------------------------------------*/
 herr_t
-H5Epush(hdf_maj_err_code_t maj, hdf_min_err_code_t min, const char *function_name, const char *file_name, intn line)
+H5Epush(H5E_major_t maj, H5E_minor_t min, const char *function_name, const char *file_name, intn line)
 {
     H5E_errstack_t *err_stack=NULL;     /* Pointer to the error stack to put value on */
     herr_t ret_value = SUCCEED;
@@ -412,11 +412,11 @@ H5Epush(hdf_maj_err_code_t maj, hdf_min_err_code_t min, const char *function_nam
 
     /* Clear errors and check args and all the boring stuff. */
     if (function_name==NULL || file_name==NULL || H5Aatom_group(thrderrid)!=H5_ERR)
-        HGOTO_ERROR(H5E_ARGS, H5E_BADTYPE, FAIL);
+        HGOTO_ERROR(H5E_ARGS, H5E_BADTYPE, FAIL, "wrong arguments");
 
     /* Get the error stack to put the error on */
     if((err_stack=H5Aatom_object(thrderrid))==NULL)
-        HGOTO_ERROR(H5E_BADATOM, H5E_BADATOM, FAIL);
+        HGOTO_ERROR(H5E_BADATOM, H5E_BADATOM, FAIL, "not an error stack");
 
     (err_stack->push)(thrderrid, maj, min, function_name, file_name, line);
 
diff --git a/src/H5Eprivate.h b/src/H5Eprivate.h
index 50b8241..47d3631 100644
--- a/src/H5Eprivate.h
+++ b/src/H5Eprivate.h
@@ -36,14 +36,14 @@
    Assume that func and file are both stored in static space, or at
    least be not corrupted in the meanwhile. */
 
-#define HERROR(maj, min) H5Epush(maj, min, FUNC, __FILE__, __LINE__)
+#define HERROR(maj, min, str) H5Epush(maj, min, FUNC, __FILE__, __LINE__)
 
 /* HRETURN_ERROR macro, used to facilitate error reporting.  Makes
    same assumptions as HERROR.  IN ADDITION, this macro causes
    a return from the calling routine */
 
-#define HRETURN_ERROR(maj, min, ret_val) {				      \
-   HERROR (maj, min);							      \
+#define HRETURN_ERROR(maj, min, ret_val, str) {				      \
+   HERROR (maj, min, str);						      \
    PABLO_TRACE_OFF (PABLO_MASK, pablo_func_id);				      \
    return (ret_val);							      \
 }
@@ -60,8 +60,8 @@
    a jump to the label 'done' which should be in every fucntion
    Also there is an assumption of a variable 'ret_value' */
 
-#define HGOTO_ERROR(maj, min, ret_val) {				      \
-   HERROR (maj, min);							      \
+#define HGOTO_ERROR(maj, min, ret_val, str) {				      \
+   HERROR (maj, min,  str);						      \
    ret_value = ret_val;							      \
    goto done;								      \
 }
@@ -87,7 +87,7 @@
  */
 typedef struct 
   {
-      hdf_maj_err_code_t error_code;
+      H5E_major_t error_code;
       const char *str;
   }
 hdf_maj_error_messages_t;
@@ -95,7 +95,7 @@ hdf_maj_error_messages_t;
 
 typedef struct 
   {
-      hdf_min_err_code_t error_code;
+      H5E_minor_t error_code;
       const char *str;
   }
 hdf_min_error_messages_t;
@@ -107,8 +107,8 @@ hdf_min_error_messages_t;
 /* the structure of the error stack element */
 typedef struct error_t
   {
-      hdf_maj_err_code_t maj;    /* Major error number */
-      hdf_min_err_code_t min;    /* Minor error number */
+      H5E_major_t maj;    /* Major error number */
+      H5E_minor_t min;    /* Minor error number */
       char function_name[MAX_FUNC_NAME_LEN];    /* function where error occur */
       const char *file_name;    /* file where error occur */
       intn        line;         /* line in file where error occurs */
@@ -132,6 +132,6 @@ extern int32 thrderrid;     	/* Thread-specific "global" error-handler ID */
 extern hbool_t install_atexit;	/* Whether to install the atexit routine */
 
 /* Private functions in H5E.c */
-herr_t H5E_store(int32 errid, hdf_maj_err_code_t maj, hdf_min_err_code_t min, const char *function_name, const char *file_name, intn line);
+herr_t H5E_store(int32 errid, H5E_major_t maj, H5E_minor_t min, const char *function_name, const char *file_name, intn line);
 
 #endif
diff --git a/src/H5Epublic.h b/src/H5Epublic.h
index 8f85551..57f40e5 100644
--- a/src/H5Epublic.h
+++ b/src/H5Epublic.h
@@ -1,13 +1,13 @@
 /****************************************************************************
- * NCSA HDF                                                                 *
- * Software Development Group                                               *
- * National Center for Supercomputing Applications                          *
- * University of Illinois at Urbana-Champaign                               *
- * 605 E. Springfield, Champaign IL 61820                                   *
- *                                                                          *
- * For conditions of distribution and use, see the accompanying             *
- * hdf/COPYING file.                                                        *
- *                                                                          *
+ * NCSA HDF								    *
+ * Software Development Group						    *
+ * National Center for Supercomputing Applications			    *
+ * University of Illinois at Urbana-Champaign				    *
+ * 605 E. Springfield, Champaign IL 61820				    *
+ *									    *
+ * For conditions of distribution and use, see the accompanying		    *
+ * hdf/COPYING file.							    *
+ *									    *
  ****************************************************************************/
 
 /* $Id$ */
@@ -22,113 +22,115 @@
 /* Public headers needed by this file */
 #include <H5public.h>
 
-/* Declare an enumerated type which holds all the valid major HDF error codes */
-typedef enum
-  {
-      H5E_NONE_MAJOR = 0,       /* special zero, no error */
-      H5E_ARGS,                 /* Invalid arguments to routine */
-      H5E_RESOURCE,             /* Resource unavailable */
-      H5E_INTERNAL,             /* Internal error (too specific to document
+/*
+ * Declare an enumerated type which holds all the valid major HDF error codes.
+ */
+typedef enum H5E_major_t {
+   H5E_NONE_MAJOR = 0,		/* special zero, no error		*/
+   H5E_ARGS,			/* Invalid arguments to routine		*/
+   H5E_RESOURCE,		/* Resource unavailable			*/
+   H5E_INTERNAL,		/* Internal error (too specific to document
 				 * in detail)			
 				 */
-      H5E_FILE,                 /* File Accessability */
-      H5E_IO,                   /* Low-level I/O */
-      H5E_FUNC,                 /* Function Entry/Exit */
-      H5E_ATOM,                 /* Object Atom */
-      H5E_CACHE,	        /* Object Cache */
-      H5E_BTREE,	        /* B-Tree Node */
-      H5E_SYM,		        /* Symbol Table */
-      H5E_HEAP,		        /* Heap */
-      H5E_OHDR,		        /* Object Header */
-      H5E_DATATYPE,	        /* Datatype */
-      H5E_DATASPACE,            /* Dataspace */
-      H5E_DATASET,	        /* Dataset */
-      H5E_STORAGE,              /* Data storage */
-      H5E_TEMPLATE		/* Templates */
-  }
-hdf_maj_err_code_t;
+   H5E_FILE,			/* File Accessability			*/
+   H5E_IO,			/* Low-level I/O			*/
+   H5E_FUNC,			/* Function Entry/Exit			*/
+   H5E_ATOM,			/* Object Atom				*/
+   H5E_CACHE,			/* Object Cache				*/
+   H5E_BTREE,			/* B-Tree Node				*/
+   H5E_SYM,			/* Symbol Table				*/
+   H5E_HEAP,			/* Heap					*/
+   H5E_OHDR,			/* Object Header			*/
+   H5E_DATATYPE,		/* Datatype				*/
+   H5E_DATASPACE,		/* Dataspace				*/
+   H5E_DATASET,			/* Dataset				*/
+   H5E_STORAGE,			/* Data storage				*/
+   H5E_TEMPLATE			/* Templates				*/
+} H5E_major_t;
+
 
 /* Declare an enumerated type which holds all the valid minor HDF error codes */
-typedef enum
-  {
-      H5E_NONE_MINOR = 0,      /* special zero, no error */
-
-    /* Argument errors */
-      H5E_UNINITIALIZED,       /* Information is unitialized */
-      H5E_UNSUPPORTED,         /* Feature is unsupported */
-      H5E_BADTYPE,             /* Incorrect type found */
-      H5E_BADRANGE,            /* Argument out of range */
-      H5E_BADVALUE,            /* Bad value for argument */
-
-    /* Resource errors */
-      H5E_NOSPACE,             /* No space available for allocation */
-
-    /* File accessability errors */
-      H5E_FILEEXISTS,          /* File already exists */
-      H5E_FILEOPEN,            /* File already open */
-      H5E_CANTCREATE,          /* Can't create file */
-      H5E_CANTOPENFILE,        /* Can't open file */
-      H5E_NOTHDF5,             /* Not an HDF5 format file */
-      H5E_BADFILE,             /* Bad file ID accessed */
-      H5E_TRUNCATED,           /* File has been truncated */
-
-    /* Generic low-level file I/O errors */
-      H5E_SEEKERROR,           /* Seek failed */
-      H5E_READERROR,           /* Read failed */
-      H5E_WRITEERROR,          /* Write failed */
-      H5E_CLOSEERROR,          /* Close failed */
-
-    /* Function entry/exit interface errors */
-      H5E_CANTINIT,            /* Can't initialize interface */
-      H5E_ALREADYINIT,         /* Object already initialized */
-
-    /* Object atom related errors */
-      H5E_BADATOM,             /* Can't find atom information */
-      H5E_CANTREGISTER,        /* Can't register new atom */
-
-    /* Cache related errors */
-      H5E_CANTFLUSH,	       /* Can't flush object from cache */
-      H5E_CANTLOAD,	       /* Can't load object into cache */
-      H5E_PROTECT,	       /* Protected object error */
-      H5E_NOTCACHED,	       /* Object not currently cached */
+typedef enum H5E_minor_t {
+   H5E_NONE_MINOR = 0,		/* special zero, no error		*/
+
+   /* Argument errors */
+   H5E_UNINITIALIZED,		/* Information is unitialized		*/
+   H5E_UNSUPPORTED,		/* Feature is unsupported		*/
+   H5E_BADTYPE,			/* Incorrect type found			*/
+   H5E_BADRANGE,		/* Argument out of range		*/
+   H5E_BADVALUE,		/* Bad value for argument		*/
+
+   /* Resource errors */
+   H5E_NOSPACE,			/* No space available for allocation	*/
+
+   /* File accessability errors */
+   H5E_FILEEXISTS,		/* File already exists			*/
+   H5E_FILEOPEN,		/* File already open			*/
+   H5E_CANTCREATE,		/* Can't create file			*/
+   H5E_CANTOPENFILE,		/* Can't open file			*/
+   H5E_NOTHDF5,			/* Not an HDF5 format file		*/
+   H5E_BADFILE,			/* Bad file ID accessed			*/
+   H5E_TRUNCATED,		/* File has been truncated		*/
+
+   /* Generic low-level file I/O errors */
+   H5E_SEEKERROR,		/* Seek failed				*/
+   H5E_READERROR,		/* Read failed				*/
+   H5E_WRITEERROR,		/* Write failed				*/
+   H5E_CLOSEERROR,		/* Close failed				*/
+
+   /* Function entry/exit interface errors */
+   H5E_CANTINIT,		/* Can't initialize interface		*/
+   H5E_ALREADYINIT,		/* Object already initialized		*/
+
+   /* Object atom related errors */
+   H5E_BADATOM,			/* Can't find atom information		*/
+   H5E_CANTREGISTER,		/* Can't register new atom		*/
+
+   /* Cache related errors */
+   H5E_CANTFLUSH,		/* Can't flush object from cache	*/
+   H5E_CANTLOAD,		/* Can't load object into cache		*/
+   H5E_PROTECT,			/* Protected object error		*/
+   H5E_NOTCACHED,		/* Object not currently cached		*/
       
-    /* B-tree related errors */
-      H5E_NOTFOUND,	       /* Object not found */
-      H5E_EXISTS,	       /* Object already exists */
-      H5E_CANTENCODE,	       /* Can't encode value */
-      H5E_CANTDECODE,	       /* Can't decode value */
-      H5E_CANTSPLIT,	       /* Can't split node */
-      H5E_CANTINSERT,	       /* Can't insert object */
-      H5E_CANTLIST,	       /* Can't list node */
-
-    /* Object header related errors */
-      H5E_LINKCOUNT,	       /* Bad object header link count */
-      H5E_VERSION,	       /* Wrong version number */
-      H5E_ALIGNMENT,	       /* Alignment error */
-      H5E_BADMESG,	       /* Unrecognized message */
-
-    /* Group related errors */
-      H5E_CANTOPENOBJ,	       /* Can't open object */
-      H5E_COMPLEN,	       /* Name component is too long */
-      H5E_CWG,		       /* Problem with current working group */
-      H5E_LINK		       /* Link count failure */
-  }
-hdf_min_err_code_t;
+   /* B-tree related errors */
+   H5E_NOTFOUND,		/* Object not found			*/
+   H5E_EXISTS,			/* Object already exists		*/
+   H5E_CANTENCODE,		/* Can't encode value			*/
+   H5E_CANTDECODE,		/* Can't decode value			*/
+   H5E_CANTSPLIT,		/* Can't split node			*/
+   H5E_CANTINSERT,		/* Can't insert object			*/
+   H5E_CANTLIST,		/* Can't list node			*/
+
+   /* Object header related errors */
+   H5E_LINKCOUNT,		/* Bad object header link count		*/
+   H5E_VERSION,			/* Wrong version number			*/
+   H5E_ALIGNMENT,		/* Alignment error			*/
+   H5E_BADMESG,			/* Unrecognized message			*/
+
+   /* Group related errors */
+   H5E_CANTOPENOBJ,		/* Can't open object			*/
+   H5E_COMPLEN,			/* Name component is too long		*/
+   H5E_CWG,			/* Problem with current working group	*/
+   H5E_LINK			/* Link count failure			*/
+} H5E_minor_t;
 
 /* Function pointer to report errors through */
-typedef herr_t (*H5E_push_func_t)(int32 errid, hdf_maj_err_code_t maj, hdf_min_err_code_t min, const char *function_name, const char *file_name, intn line);
+typedef herr_t (*H5E_push_func_t)(int32 errid, H5E_major_t maj,
+				  H5E_minor_t min, const char *function_name,
+				  const char *file_name, intn line);
 
 #ifdef __cplusplus
 extern "C" {
 #endif
 
 /* Functions in H5E.c */
-int32 H5Enew_err_stack(uintn initial_stack_size);
-intn H5Edelete_err_stack(int32 err_hand);
+int32 H5Enew_err_stack (uintn initial_stack_size);
+intn H5Edelete_err_stack (int32 err_hand);
 #ifdef H5_ERROR_DEBUG
-H5E_push_func_t H5Eset_push(H5E_push_func_t func);
+H5E_push_func_t H5Eset_push (H5E_push_func_t func);
 #endif
-herr_t H5Epush(hdf_maj_err_code_t maj, hdf_min_err_code_t min, const char *function_name, const char *file_name, intn line);
+herr_t H5Epush (H5E_major_t maj, H5E_minor_t min, const char *function_name,
+		const char *file_name, intn line);
 herr_t H5Eclear(int32 err_hand);
 void H5E_term_interface(void);
 
diff --git a/src/H5F.c b/src/H5F.c
index 00543ad..fff101c 100644
--- a/src/H5F.c
+++ b/src/H5F.c
@@ -232,18 +232,18 @@ H5Fget_create_template (hid_t fid)
 
     /* check args */
     if (H5_FILE!=H5Aatom_group (fid)) {
-       HRETURN_ERROR (H5E_ATOM, H5E_BADATOM, FAIL); /*not a file*/
+       HRETURN_ERROR (H5E_ATOM, H5E_BADATOM, FAIL, "not a file");
     }
     if (NULL==(file=H5Aatom_object (fid))) {
-       HRETURN_ERROR (H5E_ATOM, H5E_BADATOM, FAIL); /*can't get file struct*/
+       HRETURN_ERROR (H5E_ATOM, H5E_BADATOM, FAIL, "can't get file struct");
     }
 
     /* Create the template object to return */
     tmpl = H5MM_xmalloc (sizeof(H5F_create_t));
     *tmpl = file->shared->create_parms;
     if ((ret_value=H5C_create (H5C_FILE_CREATE, tmpl))<0) {
-       /* Can't register template */
-       HRETURN_ERROR (H5E_ATOM, H5E_CANTREGISTER, FAIL);
+       HRETURN_ERROR (H5E_ATOM, H5E_CANTREGISTER, FAIL,
+		      "can't register template");
     }
 
     FUNC_LEAVE (ret_value);
@@ -313,7 +313,7 @@ H5F_locate_signature (H5F_low_t *f_handle, haddr_t *addr/*out*/)
    H5F_addr_reset (addr);
    while (H5F_addr_lt (addr, &max_addr)) {
       if (H5F_low_read (f_handle, addr, H5F_SIGNATURE_LEN, buf)<0) {
-	 HRETURN_ERROR (H5E_IO, H5E_READERROR, FAIL);
+	 HRETURN_ERROR (H5E_IO, H5E_READERROR, FAIL, "can't read file");
       }
       if (!HDmemcmp (buf, H5F_SIGNATURE, H5F_SIGNATURE_LEN)) break;
       H5F_addr_pow2 (n++, addr);
@@ -357,12 +357,12 @@ hbool_t H5Fis_hdf5(const char *filename)
     /* Clear errors and check args and all the boring stuff. */
     H5ECLEAR;
     if(filename==NULL)
-        HGOTO_ERROR(H5E_ARGS, H5E_BADRANGE, BFAIL); /*no filename specified*/
+        HGOTO_ERROR(H5E_ARGS, H5E_BADRANGE, BFAIL, "no filename specified");
 
     /* Open the file */
     if (NULL==(f_handle=H5F_low_open (H5F_LOW_DFLT, filename, 0, NULL))) {
-       /* Low-level file open failure */
-       HGOTO_ERROR(H5E_FILE, H5E_BADFILE, BFAIL);
+       HGOTO_ERROR(H5E_FILE, H5E_BADFILE, BFAIL,
+		   "low-level file open failure");
     }
 
     if (H5F_locate_signature (f_handle, &addr)>=0) {
@@ -616,8 +616,8 @@ H5F_open (const H5F_low_class_t *type, const char *name, uintn flags,
 #endif
       type = H5F_LOW_FAM;
    } else if (type==H5F_LOW_FAM) {
-      /* Invalid file family name */
-      HRETURN_ERROR (H5E_FILE, H5E_CANTOPENFILE, NULL);
+      HRETURN_ERROR (H5E_FILE, H5E_CANTOPENFILE, NULL,
+		     "invalid file family name");
    }
 
    /*
@@ -659,29 +659,29 @@ H5F_open (const H5F_low_class_t *type, const char *name, uintn flags,
     */
    if (file_exists) {
       if (flags & H5F_ACC_EXCL) {
-	 /* File already exists - CREAT EXCL failed */
-	 HRETURN_ERROR (H5E_FILE, H5E_FILEEXISTS, NULL);
+	 HRETURN_ERROR (H5E_FILE, H5E_FILEEXISTS, NULL,
+			"file already exists - CREAT EXCL failed");
       }
       if (!H5F_low_access (type, name, R_OK, NULL)) {
-	 /* File is not readable */
-	 HRETURN_ERROR (H5E_FILE, H5E_READERROR, NULL);
+	 HRETURN_ERROR (H5E_FILE, H5E_READERROR, NULL,
+			"file is not readable");
       }
       if ((flags & H5F_ACC_WRITE) &&
 	  !H5F_low_access (type, name,  W_OK, NULL)) {
-	 /* File is not writable */
-	 HRETURN_ERROR (H5E_FILE, H5E_WRITEERROR, NULL);
+	 HRETURN_ERROR (H5E_FILE, H5E_WRITEERROR, NULL,
+			"file is not writable");
       }
 
       if ((old=H5Asearch_atom (H5_FILE, H5F_compare_files, &search))) {
 	 if (flags & H5F_ACC_TRUNC) {
-	    /* File already open - TRUNC failed */
-	    HRETURN_ERROR (H5E_FILE, H5E_FILEOPEN, NULL);
+	    HRETURN_ERROR (H5E_FILE, H5E_FILEOPEN, NULL,
+			   "file already open - TRUNC failed");
 	 }
 	 if ((flags & H5F_ACC_WRITE) &&
 	     0==(old->shared->flags & H5F_ACC_WRITE)) {
 	    if (NULL==(fd=H5F_low_open (type, name, H5F_ACC_WRITE, NULL))) {
-	       /* File cannot be reopened with write access */
-	       HRETURN_ERROR (H5E_FILE, H5E_CANTOPENFILE, NULL);
+	       HRETURN_ERROR (H5E_FILE, H5E_CANTOPENFILE, NULL,
+			      "file cannot be reopened with write access");
 	    }
 	    H5F_low_close (old->shared->lf);
 	    old->shared->lf = fd;
@@ -693,13 +693,13 @@ H5F_open (const H5F_low_class_t *type, const char *name, uintn flags,
       } else if (flags & H5F_ACC_TRUNC) {
 	 /* Truncate existing file */
 	 if (0==(flags & H5F_ACC_WRITE)) {
-	    /* Can't truncate without write intent */
-	    HRETURN_ERROR (H5E_FILE, H5E_BADVALUE, NULL);
+	    HRETURN_ERROR (H5E_FILE, H5E_BADVALUE, NULL,
+			   "can't truncate without write intent");
 	 }
 	 fd = H5F_low_open (type, name, H5F_ACC_WRITE|H5F_ACC_TRUNC, NULL);
 	 if (!fd) {
-	    /* Can't truncate file */
-	    HRETURN_ERROR (H5E_FILE, H5E_CANTCREATE, NULL);
+	    HRETURN_ERROR (H5E_FILE, H5E_CANTCREATE, NULL,
+			   "can't truncate file");
 	 }
 	 f = H5F_new (NULL);
 	 f->shared->key = search;
@@ -710,8 +710,8 @@ H5F_open (const H5F_low_class_t *type, const char *name, uintn flags,
       } else {
 	 fd = H5F_low_open (type, name, (flags & H5F_ACC_WRITE), NULL);
 	 if (!fd) {
-	    /* Cannot open existing file */
-	    HRETURN_ERROR (H5E_FILE, H5E_CANTOPENFILE, NULL);
+	    HRETURN_ERROR (H5E_FILE, H5E_CANTOPENFILE, NULL,
+			   "cannot open existing file");
 	 }
 	 f = H5F_new (NULL);
 	 f->shared->key = search;
@@ -721,15 +721,15 @@ H5F_open (const H5F_low_class_t *type, const char *name, uintn flags,
       
    } else if (flags & H5F_ACC_CREAT) {
       if (0==(flags & H5F_ACC_WRITE)) {
-	 /* Can't create file without write intent */
-	 HRETURN_ERROR (H5E_FILE, H5E_BADVALUE, NULL);
+	 HRETURN_ERROR (H5E_FILE, H5E_BADVALUE, NULL,
+			"can't create file without write intent");
       }
       fd = H5F_low_open (type, name,
 			 H5F_ACC_WRITE|H5F_ACC_CREAT|H5F_ACC_EXCL,
 			 &search);
       if (!fd) {
-	 /* Can't create file */
-	 HRETURN_ERROR (H5E_FILE, H5E_CANTCREATE, NULL);
+	 HRETURN_ERROR (H5E_FILE, H5E_CANTCREATE, NULL,
+			"can't create file");
       }
       f = H5F_new (NULL);
       f->shared->key = search;
@@ -738,8 +738,8 @@ H5F_open (const H5F_low_class_t *type, const char *name, uintn flags,
       empty_file = TRUE;
 
    } else {
-      /* File does not exist */
-      HRETURN_ERROR (H5E_FILE, H5E_CANTOPENFILE, NULL);
+      HRETURN_ERROR (H5E_FILE, H5E_CANTOPENFILE, NULL,
+		     "file does not exist");
    }
    assert (f);
 
@@ -778,17 +778,17 @@ H5F_open (const H5F_low_class_t *type, const char *name, uintn flags,
       
       f->shared->consist_flags = 0x03;
       if (H5F_flush (f, FALSE)<0) {
-	 /* Can't write file boot block */
-	 HGOTO_ERROR (H5E_FILE, H5E_CANTINIT, NULL);
+	 HGOTO_ERROR (H5E_FILE, H5E_CANTINIT, NULL,
+		      "can't write file boot block");
       }
    } else if (1==f->shared->nrefs) {
       /* For existing files we must read the boot block. */
       if (H5F_locate_signature (f->shared->lf, &(f->shared->boot_addr))<0) {
-	 HGOTO_ERROR (H5E_FILE, H5E_NOTHDF5, NULL);/*Can't find signature*/
+	 HGOTO_ERROR (H5E_FILE, H5E_NOTHDF5, NULL, "can't find signature");
       }
       if (H5F_low_read (f->shared->lf, &(f->shared->boot_addr),
 			fixed_size, buf)<0) {
-	 HGOTO_ERROR (H5E_IO, H5E_READERROR, NULL);/*Can't read boot block*/
+	 HGOTO_ERROR (H5E_IO, H5E_READERROR, NULL, "can't read boot block");
       }
       
       /*
@@ -810,32 +810,32 @@ H5F_open (const H5F_low_class_t *type, const char *name, uintn flags,
 
       cp->bootblock_ver = *p++;
       if (cp->bootblock_ver != HDF5_BOOTBLOCK_VERSION) {
-	 /* Bad boot block version number */
-	 HGOTO_ERROR (H5E_FILE, H5E_CANTOPENFILE, NULL);
+	 HGOTO_ERROR (H5E_FILE, H5E_CANTOPENFILE, NULL,
+		      "bad boot block version number");
       }
 
       cp->smallobject_ver = *p++;
       if (cp->smallobject_ver != HDF5_SMALLOBJECT_VERSION) {
-	 /* Bad small object heap version number */
-	 HGOTO_ERROR (H5E_FILE, H5E_CANTOPENFILE, NULL);
+	 HGOTO_ERROR (H5E_FILE, H5E_CANTOPENFILE, NULL,
+		      "bad small object heap version number");
       }
 
       cp->freespace_ver = *p++;
       if (cp->freespace_ver != HDF5_FREESPACE_VERSION) {
-	 /* Bad free space version number */
-	 HGOTO_ERROR (H5E_FILE, H5E_CANTOPENFILE, NULL);
+	 HGOTO_ERROR (H5E_FILE, H5E_CANTOPENFILE, NULL,
+		      "bad free space version number");
       }
 
       cp->objectdir_ver = *p++;
       if (cp->objectdir_ver != HDF5_OBJECTDIR_VERSION) {
-	 /* Bad object dir version number */
-	 HGOTO_ERROR (H5E_FILE, H5E_CANTOPENFILE, NULL);
+	 HGOTO_ERROR (H5E_FILE, H5E_CANTOPENFILE, NULL,
+		      "bad object dir version number");
       }
 
       cp->sharedheader_ver = *p++;
       if (cp->sharedheader_ver != HDF5_SHAREDHEADER_VERSION) {
-	 /* Bad shared header version number */
-	 HGOTO_ERROR (H5E_FILE, H5E_CANTOPENFILE, NULL);
+	 HGOTO_ERROR (H5E_FILE, H5E_CANTOPENFILE, NULL,
+		      "bad shared header version number");
       }
 
       cp->sizeof_addr = *p++;
@@ -844,8 +844,8 @@ H5F_open (const H5F_low_class_t *type, const char *name, uintn flags,
 	  cp->sizeof_addr!=8 &&
 	  cp->sizeof_addr!=16 &&
 	  cp->sizeof_addr!=32) {
-	 /* Bad address size */
-	 HGOTO_ERROR (H5E_FILE, H5E_CANTOPENFILE, NULL);
+	 HGOTO_ERROR (H5E_FILE, H5E_CANTOPENFILE, NULL,
+		      "bad address size");
       }
 
       cp->sizeof_size = *p++;
@@ -854,8 +854,8 @@ H5F_open (const H5F_low_class_t *type, const char *name, uintn flags,
 	  cp->sizeof_size!=8 &&
 	  cp->sizeof_size!=16 &&
 	  cp->sizeof_size!=32) {
-	 /* Bad length size */
-	 HGOTO_ERROR (H5E_FILE, H5E_CANTOPENFILE, NULL);
+	 HGOTO_ERROR (H5E_FILE, H5E_CANTOPENFILE, NULL,
+		      "bad length size");
       }
 
       /* Reserved byte */
@@ -863,14 +863,14 @@ H5F_open (const H5F_low_class_t *type, const char *name, uintn flags,
 
       UINT16DECODE (p, cp->sym_leaf_k);
       if (cp->sym_leaf_k<1) {
-	 /* Bad symbol table leaf node 1/2 rank */
-	 HGOTO_ERROR (H5E_FILE, H5E_CANTOPENFILE, NULL);
+	 HGOTO_ERROR (H5E_FILE, H5E_CANTOPENFILE, NULL,
+		      "bad symbol table leaf node 1/2 rank");
       }
 	 
       UINT16DECODE (p, cp->btree_k[H5B_SNODE_ID]);
       if (cp->btree_k[H5B_SNODE_ID]<1) {
-	 /* Bad symbol table internal node 1/2 rank */
-	 HGOTO_ERROR (H5E_FILE, H5E_CANTOPENFILE, NULL);
+	 HGOTO_ERROR (H5E_FILE, H5E_CANTOPENFILE, NULL,
+		      "bad symbol table internal node 1/2 rank");
       }
 
       UINT32DECODE (p, f->shared->consist_flags);
@@ -887,8 +887,8 @@ H5F_open (const H5F_low_class_t *type, const char *name, uintn flags,
       addr1 = f->shared->boot_addr;
       H5F_addr_inc (&addr1, fixed_size);
       if (H5F_low_read (f->shared->lf, &addr1, variable_size, buf)<0) {
-	 /*can't read boot block*/
-	 HGOTO_ERROR (H5E_FILE, H5E_NOTHDF5, NULL);
+	 HGOTO_ERROR (H5E_FILE, H5E_NOTHDF5, NULL,
+		      "can't read boot block");
       }
 	 
       p = buf;
@@ -896,8 +896,8 @@ H5F_open (const H5F_low_class_t *type, const char *name, uintn flags,
       H5F_addr_decode (f, &p, &(f->shared->freespace_addr));
       H5F_addr_decode (f, &p, &(f->shared->hdf5_eof));
       if (H5G_ent_decode (f, &p, f->shared->root_sym)<0) {
-	 /*can't read root symbol entry*/
-	 HGOTO_ERROR (H5E_FILE, H5E_CANTOPENFILE, NULL);
+	 HGOTO_ERROR (H5E_FILE, H5E_CANTOPENFILE, NULL,
+		      "can't read root symbol entry");
       }
    }
 
@@ -913,7 +913,7 @@ H5F_open (const H5F_low_class_t *type, const char *name, uintn flags,
        * Truncated file? This might happen if one tries to open the first
        * member of a file family.
        */
-      HGOTO_ERROR (H5E_FILE, H5E_TRUNCATED, NULL);
+      HGOTO_ERROR (H5E_FILE, H5E_TRUNCATED, NULL, "truncated file");
    } else if (H5F_addr_gt (&addr1, &addr2)) {
       /*
        * The file is larger than the hdf5 data.  It either has extra junk at
@@ -1013,16 +1013,16 @@ hid_t H5Fcreate(const char *filename, uintn flags, hid_t create_temp,
 
     /* Check/fix arguments */
     if (!filename || !*filename)
-        HGOTO_ERROR (H5E_ARGS, H5E_BADVALUE, FAIL); /*invalid file name*/
+        HGOTO_ERROR (H5E_ARGS, H5E_BADVALUE, FAIL, "invalid file name");
     if (flags & ~H5ACC_OVERWRITE)
-        HGOTO_ERROR (H5E_ARGS, H5E_BADVALUE, FAIL); /*invalid flags*/
+        HGOTO_ERROR (H5E_ARGS, H5E_BADVALUE, FAIL, "invalid flags");
     flags = (H5F_ACC_WRITE | H5F_ACC_CREAT) |
             (H5ACC_OVERWRITE==flags ? H5F_ACC_TRUNC : H5F_ACC_EXCL);
     
     if (create_temp<=0) {
        create_parms = &H5F_create_dflt;
     } else if (NULL==(create_parms=H5Aatom_object (create_temp))) {
-       HGOTO_ERROR (H5E_ATOM, H5E_BADATOM, FAIL); /*can't unatomize template*/
+       HGOTO_ERROR (H5E_ATOM, H5E_BADATOM, FAIL, "can't unatomize template");
     }
     
 #ifdef LATER
@@ -1038,12 +1038,12 @@ hid_t H5Fcreate(const char *filename, uintn flags, hid_t create_temp,
      */
     if (NULL==(new_file = H5F_open (H5F_LOW_DFLT, filename, flags,
 				    create_parms))) {
-       HGOTO_ERROR (H5E_FILE, H5E_CANTOPENFILE, FAIL); /*can't create file */
+       HGOTO_ERROR (H5E_FILE, H5E_CANTOPENFILE, FAIL, "can't create file");
     }
 
     /* Get an atom for the file */
     if ((ret_value=H5Aregister_atom (H5_FILE, new_file))<0)
-        HGOTO_ERROR(H5E_ATOM, H5E_CANTREGISTER, FAIL); /*can't atomize file*/
+        HGOTO_ERROR(H5E_ATOM, H5E_CANTREGISTER, FAIL, "can't atomize file");
 
  done:
     if (ret_value<0 && new_file) {
@@ -1108,7 +1108,7 @@ hid_t H5Fopen(const char *filename, uintn flags, hid_t access_temp)
 
     /* Check/fix arguments. */
     if (!filename || !*filename)
-        HGOTO_ERROR (H5E_ARGS, H5E_BADRANGE, FAIL);/*invalid file name*/
+        HGOTO_ERROR (H5E_ARGS, H5E_BADRANGE, FAIL, "invalid file name");
     flags = flags & H5ACC_WRITE ? H5F_ACC_WRITE : 0;
 
 #ifdef LATER
@@ -1120,12 +1120,12 @@ hid_t H5Fopen(const char *filename, uintn flags, hid_t access_temp)
 
     /* Open the file */
     if (NULL==(new_file=H5F_open (H5F_LOW_DFLT, filename, flags, NULL))) {
-       HGOTO_ERROR (H5E_FILE, H5E_CANTOPENFILE, FAIL); /*cant open file*/
+       HGOTO_ERROR (H5E_FILE, H5E_CANTOPENFILE, FAIL, "cant open file");
     }
 
     /* Get an atom for the file */
     if ((ret_value = H5Aregister_atom (H5_FILE, new_file))<0)
-        HGOTO_ERROR(H5E_ATOM, H5E_CANTREGISTER, FAIL);/*can't atomize file*/
+        HGOTO_ERROR(H5E_ATOM, H5E_CANTREGISTER, FAIL, "can't atomize file");
 
  done:
     if (ret_value<0 && new_file) {
@@ -1187,7 +1187,7 @@ H5F_flush (H5F_t *f, hbool_t invalidate)
       
    /* flush (and invalidate) the entire cache */
    if (H5AC_flush (f, NULL, 0, invalidate)<0) {
-      HRETURN_ERROR (H5E_CACHE, H5E_CANTFLUSH, FAIL); /*can't flush cache*/
+      HRETURN_ERROR (H5E_CACHE, H5E_CANTFLUSH, FAIL, "can't flush cache");
    }
 
    /* encode the file boot block */
@@ -1219,17 +1219,17 @@ H5F_flush (H5F_t *f, hbool_t invalidate)
 
    /* write the boot block to disk */
    if (H5F_low_write (f->shared->lf, &(f->shared->boot_addr), p-buf, buf)<0) {
-      HRETURN_ERROR (H5E_IO, H5E_WRITEERROR, FAIL); /*can't write header*/
+      HRETURN_ERROR (H5E_IO, H5E_WRITEERROR, FAIL, "can't write header");
    }
 
    /* Flush file buffers to disk */
    if (H5F_low_flush (f->shared->lf)<0) {
-      HRETURN_ERROR (H5E_IO, H5E_WRITEERROR, FAIL); /*low level flush failed*/
+      HRETURN_ERROR (H5E_IO, H5E_WRITEERROR, FAIL, "low level flush failed");
    }
 
    /* Did shadow flush fail above? */
    if (shadow_flush<0) {
-      HRETURN_ERROR (H5E_CACHE, H5E_CANTFLUSH, -2);/*object are still open*/
+      HRETURN_ERROR (H5E_CACHE, H5E_CANTFLUSH, -2, "object are still open");
    }
    
    FUNC_LEAVE (SUCCEED);
@@ -1263,8 +1263,8 @@ H5F_close (H5F_t *f)
    if (-2==(ret_value=H5F_flush (f, TRUE))) {
       /*objects are still open, but don't fail yet*/
    } else if (ret_value<0) {
-      /*can't flush cache*/
-      HRETURN_ERROR (H5E_CACHE, H5E_CANTFLUSH, FAIL);
+      HRETURN_ERROR (H5E_CACHE, H5E_CANTFLUSH, FAIL,
+		     "can't flush cache");
    }
    if (f->intent & H5F_ACC_DEBUG) H5AC_debug (f);
 
@@ -1273,7 +1273,7 @@ H5F_close (H5F_t *f)
 
    /* Did the H5F_flush() fail because of open objects? */
    if (ret_value<0) {
-      HRETURN_ERROR (H5E_SYM, H5E_CANTFLUSH, ret_value);
+      HRETURN_ERROR (H5E_SYM, H5E_CANTFLUSH, ret_value, "objects are open");
    }
 
    FUNC_LEAVE (ret_value);
@@ -1322,16 +1322,16 @@ herr_t H5Fclose(hid_t fid)
 
     /* Check/fix arguments. */
     if (H5_FILE!=H5Aatom_group (fid))
-       HGOTO_ERROR(H5E_ARGS, H5E_BADTYPE, FAIL);/*not a file atom*/
+       HGOTO_ERROR(H5E_ARGS, H5E_BADTYPE, FAIL, "not a file atom");
     if (NULL==(file=H5Aatom_object (fid)))
-       HGOTO_ERROR(H5E_ATOM, H5E_BADATOM, FAIL);/*can't unatomize file*/
+       HGOTO_ERROR(H5E_ATOM, H5E_BADATOM, FAIL, "can't unatomize file");
 
     /* Close the file */
     ret_value = H5F_close (file);
     
     /* Remove the file atom */
     if (NULL==H5Aremove_atom(fid)) {
-       HGOTO_ERROR(H5E_ATOM, H5E_BADATOM, FAIL);/*can't remove atom*/
+       HGOTO_ERROR(H5E_ATOM, H5E_BADATOM, FAIL, "can't remove atom");
     }
 
 done:
@@ -1376,7 +1376,7 @@ H5F_block_read (H5F_t *f, const haddr_t *addr, size_t size, void *buf)
 
    /* Read the data */
    if (H5F_low_read (f->shared->lf, &abs_addr, size, buf)<0) {
-      HRETURN_ERROR (H5E_IO, H5E_READERROR, FAIL); /*low-level read failed*/
+      HRETURN_ERROR (H5E_IO, H5E_READERROR, FAIL, "low-level read failed");
    }
 
    FUNC_LEAVE (SUCCEED);
@@ -1416,8 +1416,7 @@ H5F_block_write (H5F_t *f, const haddr_t *addr, size_t size, const void *buf)
    if (0==size) return 0;
 
    if (0==(f->intent & H5F_ACC_WRITE)) {
-      /* no write intent */
-      HRETURN_ERROR (H5E_IO, H5E_WRITEERROR, FAIL);
+      HRETURN_ERROR (H5E_IO, H5E_WRITEERROR, FAIL, "no write intent");
    }
 
    /* Convert the relative address to an absolute address */
@@ -1426,7 +1425,7 @@ H5F_block_write (H5F_t *f, const haddr_t *addr, size_t size, const void *buf)
 
    /* Write the data */
    if (H5F_low_write (f->shared->lf, &abs_addr, size, buf)) {
-      HRETURN_ERROR (H5E_IO, H5E_WRITEERROR, FAIL);/*low-level write failed*/
+      HRETURN_ERROR (H5E_IO, H5E_WRITEERROR, FAIL, "low-level write failed");
    }
 
    FUNC_LEAVE (SUCCEED);
diff --git a/src/H5Fcore.c b/src/H5Fcore.c
index a024e20..0a8797f 100644
--- a/src/H5Fcore.c
+++ b/src/H5Fcore.c
@@ -102,8 +102,8 @@ H5F_core_open (const char *name, uintn flags, H5F_search_t *key)
    FUNC_ENTER (H5F_core_open, NULL);
 
    if (0==(flags & H5F_ACC_WRITE) || 0==(flags & H5F_ACC_CREAT)) {
-      /* must creat file with write access */
-      HRETURN_ERROR (H5E_IO, H5E_CANTOPENFILE, NULL);
+      HRETURN_ERROR (H5E_IO, H5E_CANTOPENFILE, NULL,
+		     "must creat file with write access");
    }
       
    lf = H5MM_xcalloc (1, sizeof(H5F_low_t));
diff --git a/src/H5Ffamily.c b/src/H5Ffamily.c
index bf0431f..3c4c35b 100644
--- a/src/H5Ffamily.c
+++ b/src/H5Ffamily.c
@@ -110,7 +110,7 @@ H5F_fam_open (const char *name, uintn flags, H5F_search_t *key/*out*/)
 	 if (!H5F_low_access (H5F_LOW_DFLT, member_name, F_OK, NULL)) {
 	    break;
 	 } else if (unlink (member_name)<0) {
-	    HGOTO_ERROR (H5E_IO, H5E_CANTINIT, NULL);/*can't delete member*/
+	    HGOTO_ERROR (H5E_IO, H5E_CANTINIT, NULL, "can't delete member");
 	 }
       }
    }
@@ -133,8 +133,8 @@ H5F_fam_open (const char *name, uintn flags, H5F_search_t *key/*out*/)
 			     0==membno?key:NULL);
       if (!member) {
 	 if (0==membno) {
-	    /* Can't open first family member */
-	    HGOTO_ERROR (H5E_IO, H5E_CANTOPENFILE, NULL);
+	    HGOTO_ERROR (H5E_IO, H5E_CANTOPENFILE, NULL,
+			 "can't open first family member");
 	 }
 	 break;
       }
@@ -294,8 +294,8 @@ H5F_fam_read (H5F_low_t *lf, const haddr_t *addr, size_t size, uint8 *buf)
 	 cur_addr.offset = offset;
 	 if (H5F_low_read (lf->u.fam.memb[membno], &cur_addr,
 			   nbytes, buf)<0) {
-	    /* Can't read from family member */
-	    HRETURN_ERROR (H5E_IO, H5E_READERROR, FAIL);
+	    HRETURN_ERROR (H5E_IO, H5E_READERROR, FAIL,
+			   "can't read from family member");
 	 }
 	 buf += nbytes;
 	 size -= nbytes;
@@ -366,8 +366,8 @@ H5F_fam_write (H5F_low_t *lf, const haddr_t *addr, size_t size,
 				   lf->u.fam.flags|H5F_ACC_CREAT,
 				   NULL);
 	    if (!member) {
-	       /* Can't create a new member */
-	       HRETURN_ERROR (H5E_IO, H5E_CANTOPENFILE, FAIL);
+	       HRETURN_ERROR (H5E_IO, H5E_CANTOPENFILE, FAIL,
+			      "can't create a new member");
 	    }
 
 	    /*
@@ -401,8 +401,8 @@ H5F_fam_write (H5F_low_t *lf, const haddr_t *addr, size_t size,
       /* Write the data to the member */
       if (H5F_low_write (lf->u.fam.memb[membno], &cur_addr,
 			 nbytes, buf)<0) {
-	 /* Can't write to family member */
-	 HRETURN_ERROR (H5E_IO, H5E_WRITEERROR, FAIL);
+	 HRETURN_ERROR (H5E_IO, H5E_WRITEERROR, FAIL,
+			"can't write to family member");
       }
       buf += nbytes;
       size -= nbytes;
@@ -458,12 +458,12 @@ H5F_fam_flush (H5F_low_t *lf)
    H5F_addr_inc (&addr3, (size_t)1);
    H5F_low_seteof (lf->u.fam.memb[0], &addr3); /*prevent a warning*/
    if (H5F_low_read (lf->u.fam.memb[0], &addr1, 1, buf)<0) {
-      /* Can't read from first family member */
-      HRETURN_ERROR (H5E_IO, H5E_READERROR, FAIL);
+      HRETURN_ERROR (H5E_IO, H5E_READERROR, FAIL,
+		     "can't read from first family member");
    }
    if (H5F_low_write (lf->u.fam.memb[0], &addr1, 1, buf)<0) {
-      /* Can't write to first family member */
-      HRETURN_ERROR (H5E_IO, H5E_WRITEERROR, FAIL);
+      HRETURN_ERROR (H5E_IO, H5E_WRITEERROR, FAIL,
+		     "can't write to first family member");
    }
    H5F_low_seteof (lf->u.fam.memb[0], &addr2); /*reset old eof*/
    
@@ -477,8 +477,8 @@ H5F_fam_flush (H5F_low_t *lf)
       }
    }
    if (nerrors) {
-      /* Can't flush family member */
-      HRETURN_ERROR (H5E_IO, H5E_WRITEERROR, FAIL);
+      HRETURN_ERROR (H5E_IO, H5E_WRITEERROR, FAIL,
+		     "can't flush family member");
    }
 
    FUNC_LEAVE (SUCCEED);
@@ -539,8 +539,8 @@ H5F_fam_access (const char *name, int mode, H5F_search_t *key/*out*/)
       }
 				    
       if (status<0) {
-	 /* Access method failed for a member file */
-	 HRETURN_ERROR (H5E_IO, H5E_CANTOPENFILE, FAIL);
+	 HRETURN_ERROR (H5E_IO, H5E_CANTOPENFILE, FAIL,
+			"access method failed for a member file");
       }
    }
 
diff --git a/src/H5Fistore.c b/src/H5Fistore.c
index 8684465..15c7d4d 100644
--- a/src/H5Fistore.c
+++ b/src/H5Fistore.c
@@ -370,8 +370,8 @@ H5F_istore_new_node (H5F_t *f, H5B_ins_t op,
    nbytes = H5V_vector_reduce_product (udata->mesg.ndims, udata->key.size);
    assert (nbytes>0);
    if (H5MF_alloc (f, H5MF_RAW, nbytes, addr/*out*/)<0) {
-      /* Couldn't allocate new file storage */
-      HRETURN_ERROR (H5E_IO, H5E_CANTINIT, FAIL);
+      HRETURN_ERROR (H5E_IO, H5E_CANTINIT, FAIL,
+		     "couldn't allocate new file storage");
    }
    udata->addr = *addr;
    udata->key.file_number = 0;
@@ -518,7 +518,7 @@ H5F_istore_insert (H5F_t *f, const haddr_t *addr,
    if (cmp<0) {
       /* Negative indices not supported yet */
       assert ("HDF5 INTERNAL ERROR -- see rpm" && 0);
-      HRETURN_ERROR (H5E_STORAGE, H5E_UNSUPPORTED, FAIL);
+      HRETURN_ERROR (H5E_STORAGE, H5E_UNSUPPORTED, FAIL, "internal error");
       
    } else if (H5V_hyper_eq (udata->mesg.ndims,
 			    udata->key.offset,  udata->key.size, 
@@ -554,7 +554,8 @@ H5F_istore_insert (H5F_t *f, const haddr_t *addr,
        * Allocate storage for the new chunk
        */
       if (H5MF_alloc (f, H5MF_RAW, nbytes, new_node/*out*/)<0) {
-	 HRETURN_ERROR (H5E_IO, H5E_CANTINIT, FAIL);
+	 HRETURN_ERROR (H5E_IO, H5E_CANTINIT, FAIL,
+			"file allocation failed");
       }
       udata->addr = *new_node;
       udata->key.file_number = 0;
@@ -562,7 +563,7 @@ H5F_istore_insert (H5F_t *f, const haddr_t *addr,
       
    } else {
       assert ("HDF5 INTERNAL ERROR -- see rpm" && 0);
-      HRETURN_ERROR (H5E_IO, H5E_UNSUPPORTED, FAIL);
+      HRETURN_ERROR (H5E_IO, H5E_UNSUPPORTED, FAIL, "internal error");
    }
    
    FUNC_LEAVE (ret_value);
@@ -704,7 +705,8 @@ H5F_istore_copy_hyperslab (H5F_t *f, const H5O_istore_t *istore, H5F_isop_t op,
 	 if (status>=0 && H5F_addr_defined (&(udata.addr))) {
 	    assert (0==udata.key.file_number);
 	    if (H5F_block_read (f, &(udata.addr), chunk_size, chunk)<0) {
-	       HGOTO_ERROR (H5E_IO, H5E_READERROR, FAIL);
+	       HGOTO_ERROR (H5E_IO, H5E_READERROR, FAIL,
+			    "unable to read raw storage chunk");
 	    }
 	 } else {
 	    HDmemset (chunk, 0, chunk_size);
@@ -718,7 +720,8 @@ H5F_istore_copy_hyperslab (H5F_t *f, const H5O_istore_t *istore, H5F_isop_t op,
 			 size_m, sub_offset_m, buf);
 	 assert (0==udata.key.file_number);
 	 if (H5F_block_write (f, &(udata.addr), chunk_size, chunk)<0) {
-	    HGOTO_ERROR (H5E_IO, H5E_WRITEERROR, FAIL);
+	    HGOTO_ERROR (H5E_IO, H5E_WRITEERROR, FAIL,
+			 "unable to write raw storage chunk");
 	 }
       } else {
 	 H5V_hyper_copy (istore->ndims, sub_size,
@@ -774,8 +777,8 @@ H5F_istore_read (H5F_t *f, const H5O_istore_t *istore,
 
    if (H5F_istore_copy_hyperslab (f, istore, H5F_ISTORE_READ,
 				  offset, size, H5V_ZERO, size, buf)<0) {
-      /* hyperslab output failure */
-      HRETURN_ERROR (H5E_IO, H5E_READERROR, FAIL);
+      HRETURN_ERROR (H5E_IO, H5E_READERROR, FAIL,
+		     "hyperslab output failure");
    }
 
    FUNC_LEAVE (SUCCEED);
@@ -815,8 +818,8 @@ H5F_istore_write (H5F_t *f, const H5O_istore_t *istore,
 
    if (H5F_istore_copy_hyperslab (f, istore, H5F_ISTORE_WRITE,
 				  offset, size, H5V_ZERO, size, buf)<0) {
-      /* hyperslab output failure */
-      HRETURN_ERROR (H5E_IO, H5E_WRITEERROR, FAIL);
+      HRETURN_ERROR (H5E_IO, H5E_WRITEERROR, FAIL,
+		     "hyperslab output failure");
    }
 
    FUNC_LEAVE (SUCCEED);
@@ -868,7 +871,7 @@ H5F_istore_create (H5F_t *f, struct H5O_istore_t *istore/*out*/,
 
    udata.mesg.ndims = istore->ndims = ndims;
    if (H5B_create (f, H5B_ISTORE, &udata, &(istore->btree_addr)/*out*/)<0) {
-      HRETURN_ERROR (H5E_IO, H5E_CANTINIT, FAIL); /* Can't create B-tree */
+      HRETURN_ERROR (H5E_IO, H5E_CANTINIT, FAIL, "can't create B-tree");
    }
 
    for (i=0; i<ndims; i++) {
diff --git a/src/H5Flow.c b/src/H5Flow.c
index 0dfd11c..9cfb51f 100644
--- a/src/H5Flow.c
+++ b/src/H5Flow.c
@@ -79,7 +79,7 @@ H5F_low_open (const H5F_low_class_t *type, const char *name, uintn flags,
    assert (name && *name);
 
    if (NULL==(lf=(type->open)(name, flags, key))) {
-      HRETURN_ERROR (H5E_IO, H5E_CANTOPENFILE, NULL);/*open failed*/
+      HRETURN_ERROR (H5E_IO, H5E_CANTOPENFILE, NULL, "open failed");
    }
    lf->type = type;
 
@@ -123,7 +123,7 @@ H5F_low_close (H5F_low_t *lf)
    if (lf) {
       if ((lf->type->close)(lf)<0) {
 	 H5MM_xfree (lf);
-	 HRETURN_ERROR (H5E_IO, H5E_CLOSEERROR, NULL); /*close failed*/
+	 HRETURN_ERROR (H5E_IO, H5E_CLOSEERROR, NULL, "close failed");
       }
       H5MM_xfree (lf);
    }
@@ -172,10 +172,10 @@ H5F_low_read (H5F_low_t *lf, const haddr_t *addr, size_t size,
 
    if (lf->type->read) {
       if ((ret_value = (lf->type->read)(lf, addr, size, buf))<0) {
-	 HRETURN_ERROR (H5E_IO, H5E_READERROR, ret_value);/*read failed*/
+	 HRETURN_ERROR (H5E_IO, H5E_READERROR, ret_value, "read failed");
       }
    } else {
-      HRETURN_ERROR (H5E_IO, H5E_UNSUPPORTED, FAIL);/*no read method*/
+      HRETURN_ERROR (H5E_IO, H5E_UNSUPPORTED, FAIL, "no read method");
    }
 
    FUNC_LEAVE (ret_value);
@@ -231,10 +231,10 @@ H5F_low_write (H5F_low_t *lf, const haddr_t *addr, size_t size,
    /* Write the data */
    if (lf->type->write) {
       if ((ret_value = (lf->type->write)(lf, addr, size, buf))<0) {
-	 HRETURN_ERROR (H5E_IO, H5E_WRITEERROR, ret_value);/*write failed*/
+	 HRETURN_ERROR (H5E_IO, H5E_WRITEERROR, ret_value, "write failed");
       }
    } else {
-      HRETURN_ERROR (H5E_IO, H5E_UNSUPPORTED, FAIL);/*no write method*/
+      HRETURN_ERROR (H5E_IO, H5E_UNSUPPORTED, FAIL, "no write method");
    }
 
    FUNC_LEAVE (ret_value);
@@ -288,8 +288,8 @@ H5F_low_flush (H5F_low_t *lf)
    /* Invoke the subclass the flush method */
    if (lf->type->flush) {
       if ((lf->type->flush)(lf)<0) {
-	 /* Low level flush failed */
-	 HRETURN_ERROR (H5E_IO, H5E_WRITEERROR, FAIL);
+	 HRETURN_ERROR (H5E_IO, H5E_WRITEERROR, FAIL,
+			"low level flush failed");
       }
    }
 
@@ -438,8 +438,8 @@ H5F_low_extend (H5F_low_t *lf, intn op, size_t size, haddr_t *addr/*out*/)
 
    if (lf->type->extend) {
       if ((lf->type->extend)(lf, op, size, addr/*out*/)<0) {
-	 /* Unable to extend file */
-	 HRETURN_ERROR (H5E_RESOURCE, H5E_NOSPACE, FAIL);
+	 HRETURN_ERROR (H5E_RESOURCE, H5E_NOSPACE, FAIL,
+			"unable to extend file");
       }
    } else {
       *addr = lf->eof;
diff --git a/src/H5Fsec2.c b/src/H5Fsec2.c
index 4d82d11..03cd240 100644
--- a/src/H5Fsec2.c
+++ b/src/H5Fsec2.c
@@ -82,7 +82,7 @@ H5F_sec2_open (const char *name, uintn flags, H5F_search_t *key/*out*/)
    oflags |= (flags & H5F_ACC_TRUNC) ? O_TRUNC : 0;
 
    if ((fd=open (name, oflags, 0666))<0) {
-      HRETURN_ERROR (H5E_IO, H5E_CANTOPENFILE, NULL);/*open failed*/
+      HRETURN_ERROR (H5E_IO, H5E_CANTOPENFILE, NULL, "open failed");
    }
       
    lf = H5MM_xcalloc (1, sizeof(H5F_low_t));
@@ -126,7 +126,7 @@ H5F_sec2_close (H5F_low_t *lf)
    FUNC_ENTER (H5F_sec2_close, FAIL);
 
    if (close (lf->u.sec2.fd)<0) {
-      HRETURN_ERROR (H5E_IO, H5E_CLOSEERROR, FAIL); /*close failed*/
+      HRETURN_ERROR (H5E_IO, H5E_CLOSEERROR, FAIL, "close failed");
    }
    lf->u.sec2.fd = -1;
 
@@ -185,7 +185,7 @@ H5F_sec2_read (H5F_low_t *lf, const haddr_t *addr, size_t size, uint8 *buf)
        lf->u.sec2.op==H5F_OP_UNKNOWN ||
        lf->u.sec2.cur!=offset) {
       if (lseek (lf->u.sec2.fd, offset, SEEK_SET)<0) {
-	 HRETURN_ERROR (H5E_IO, H5E_SEEKERROR, FAIL); /*lseek failed*/
+	 HRETURN_ERROR (H5E_IO, H5E_SEEKERROR, FAIL, "lseek failed");
       }
       lf->u.sec2.cur = offset;
    }
@@ -205,7 +205,7 @@ H5F_sec2_read (H5F_low_t *lf, const haddr_t *addr, size_t size, uint8 *buf)
     */
    if ((n=read (lf->u.sec2.fd, buf, size))<0) {
       lf->u.sec2.op = H5F_OP_UNKNOWN;
-      HRETURN_ERROR (H5E_IO, H5E_READERROR, FAIL); /*read failed*/
+      HRETURN_ERROR (H5E_IO, H5E_READERROR, FAIL, "read failed");
    } else if (n<size) {
       HDmemset (buf+n, 0, size-n);
    }
@@ -264,7 +264,7 @@ H5F_sec2_write (H5F_low_t *lf, const haddr_t *addr, size_t size,
        lf->u.sec2.op==H5F_OP_UNKNOWN ||
        lf->u.sec2.cur!=offset) {
       if (lseek (lf->u.sec2.fd, offset, SEEK_SET)<0) {
-	 HRETURN_ERROR (H5E_IO, H5E_SEEKERROR, FAIL); /*lseek failed*/
+	 HRETURN_ERROR (H5E_IO, H5E_SEEKERROR, FAIL, "lseek failed");
       }
       lf->u.sec2.cur = offset;
    }
@@ -275,7 +275,7 @@ H5F_sec2_write (H5F_low_t *lf, const haddr_t *addr, size_t size,
     */
    if (size != write (lf->u.sec2.fd, buf, size)) {
       lf->u.sec2.op = H5F_OP_UNKNOWN;
-      HRETURN_ERROR (H5E_IO, H5E_WRITEERROR, FAIL); /*write failed*/
+      HRETURN_ERROR (H5E_IO, H5E_WRITEERROR, FAIL, "write failed");
    }
 
    /*
diff --git a/src/H5Fstdio.c b/src/H5Fstdio.c
index 46c63b5..b610a7a 100644
--- a/src/H5Fstdio.c
+++ b/src/H5Fstdio.c
@@ -80,13 +80,13 @@ H5F_stdio_open (const char *name, uintn flags, H5F_search_t *key/*out*/)
       if ((flags & H5F_ACC_CREAT) && (flags & H5F_ACC_WRITE)) {
 	 f = fopen (name, "wb+");
       } else {
-	 /* File doesn't exist and CREAT wasn't specified */
-	 HRETURN_ERROR (H5E_IO, H5E_CANTOPENFILE, NULL);
+	 HRETURN_ERROR (H5E_IO, H5E_CANTOPENFILE, NULL,
+			"file doesn't exist and CREAT wasn't specified");
       }
       
    } else if ((flags & H5F_ACC_CREAT) && (flags & H5F_ACC_EXCL)) {
-      /* File exists but CREAT and EXCL were specified */
-      HRETURN_ERROR (H5E_IO, H5E_FILEEXISTS, NULL);
+      HRETURN_ERROR (H5E_IO, H5E_FILEEXISTS, NULL,
+		     "file exists but CREAT and EXCL were specified");
       
    } else if (flags & H5F_ACC_WRITE) {
       if (flags & H5F_ACC_TRUNC) f = fopen (name, "wb+");
@@ -95,7 +95,7 @@ H5F_stdio_open (const char *name, uintn flags, H5F_search_t *key/*out*/)
    } else {
       f = fopen (name, "rb");
    }
-   if (!f) HRETURN_ERROR (H5E_IO, H5E_CANTOPENFILE, NULL); /*fopen failed*/
+   if (!f) HRETURN_ERROR (H5E_IO, H5E_CANTOPENFILE, NULL, "fopen failed");
 
    /* Build the return value */
    lf = H5MM_xcalloc (1, sizeof(H5F_low_t));
@@ -126,7 +126,7 @@ H5F_stdio_open (const char *name, uintn flags, H5F_search_t *key/*out*/)
  * Purpose:	Closes a file.
  *
  * Errors:
- *		IO        CLOSEERROR    Close failed. 
+ *		IO        CLOSEERROR    Fclose failed. 
  *
  * Return:	Success:	SUCCEED
  *
@@ -145,7 +145,7 @@ H5F_stdio_close (H5F_low_t *lf)
    FUNC_ENTER (H5F_stdio_close, FAIL);
 
    if (fclose (lf->u.stdio.f)<0) {
-      HRETURN_ERROR (H5E_IO, H5E_CLOSEERROR, FAIL); /*close failed*/
+      HRETURN_ERROR (H5E_IO, H5E_CLOSEERROR, FAIL, "fclose failed");
    }
    lf->u.stdio.f = NULL;
 
@@ -202,7 +202,7 @@ H5F_stdio_read (H5F_low_t *lf, const haddr_t *addr, size_t size, uint8 *buf)
        lf->u.stdio.op!=H5F_OP_READ ||
        lf->u.stdio.cur!=offset) {
       if (fseek (lf->u.stdio.f, offset, SEEK_SET)<0) {
-	 HRETURN_ERROR (H5E_IO, H5E_SEEKERROR, FAIL); /*fseek failed*/
+	 HRETURN_ERROR (H5E_IO, H5E_SEEKERROR, FAIL, "fseek failed");
       }
       lf->u.stdio.cur = offset;
    }
@@ -224,7 +224,7 @@ H5F_stdio_read (H5F_low_t *lf, const haddr_t *addr, size_t size, uint8 *buf)
    n = fread (buf, 1, size, lf->u.stdio.f);
    if (n<=0 && ferror (lf->u.stdio.f)) {
       lf->u.stdio.op = H5F_OP_UNKNOWN;
-      HRETURN_ERROR (H5E_IO, H5E_READERROR, FAIL); /*fread failed*/
+      HRETURN_ERROR (H5E_IO, H5E_READERROR, FAIL, "fread failed");
    } else if (n<size) {
       HDmemset (buf+n, 0, size-n);
    }
@@ -279,7 +279,7 @@ H5F_stdio_write (H5F_low_t *lf, const haddr_t *addr, size_t size,
        lf->u.stdio.op!=H5F_OP_WRITE ||
        lf->u.stdio.cur!=offset) {
       if (fseek (lf->u.stdio.f, offset, SEEK_SET)<0) {
-	 HRETURN_ERROR (H5E_IO, H5E_SEEKERROR, FAIL); /*fseek failed*/
+	 HRETURN_ERROR (H5E_IO, H5E_SEEKERROR, FAIL, "fseek failed");
       }
       lf->u.stdio.cur = offset;
    }
@@ -291,7 +291,7 @@ H5F_stdio_write (H5F_low_t *lf, const haddr_t *addr, size_t size,
     */
    if (size != fwrite (buf, 1, size, lf->u.stdio.f)) {
       lf->u.stdio.op = H5F_OP_UNKNOWN;
-      HRETURN_ERROR (H5E_IO, H5E_WRITEERROR, FAIL); /*fwrite failed*/
+      HRETURN_ERROR (H5E_IO, H5E_WRITEERROR, FAIL, "fwrite failed");
    }
 
    /*
@@ -337,7 +337,7 @@ H5F_stdio_flush (H5F_low_t *lf)
     * Flush
     */
    if (fflush (lf->u.stdio.f)<0) {
-      HRETURN_ERROR (H5E_IO, H5E_WRITEERROR, FAIL); /*fflush failed*/
+      HRETURN_ERROR (H5E_IO, H5E_WRITEERROR, FAIL, "fflush failed");
    }
    
    FUNC_LEAVE (SUCCEED);
diff --git a/src/H5G.c b/src/H5G.c
index a45ab02..25c5fc4 100644
--- a/src/H5G.c
+++ b/src/H5G.c
@@ -96,24 +96,24 @@ H5Gnew (hid_t file, const char *name, size_t size_hint)
 
    /* Check/fix arguments */
    if (!name || !*name) {
-      HRETURN_ERROR (H5E_ARGS, H5E_BADVALUE, FAIL);/*no name given*/
+      HRETURN_ERROR (H5E_ARGS, H5E_BADVALUE, FAIL, "no name given");
    }
    if (H5_FILE!=H5Aatom_group (file)) {
-      HRETURN_ERROR (H5E_ARGS, H5E_BADTYPE, FAIL);/*not a file atom*/
+      HRETURN_ERROR (H5E_ARGS, H5E_BADTYPE, FAIL, "not a file atom");
    }
    if (NULL==(f=H5Aatom_object (file))) {
-      HRETURN_ERROR (H5E_ATOM, H5E_BADATOM, FAIL);/*can't unatomize file*/
+      HRETURN_ERROR (H5E_ATOM, H5E_BADATOM, FAIL, "can't unatomize file");
    }
    
    /* Create the group */
    if (NULL==(grp_handle=H5G_new (f, name, size_hint))) {
-      /*can't create group*/
-      HRETURN_ERROR (H5E_SYM, H5E_CANTINIT, FAIL);
+      HRETURN_ERROR (H5E_SYM, H5E_CANTINIT, FAIL,
+		     "can't create group");
    }
 
    /* Close the group handle */
    if (H5G_close (f, grp_handle)<0) {
-      HRETURN_ERROR (H5E_SYM, H5E_CANTINIT, FAIL);/*can't close handle*/
+      HRETURN_ERROR (H5E_SYM, H5E_CANTINIT, FAIL, "can't close handle");
    }
 
    FUNC_LEAVE (SUCCEED);
@@ -162,18 +162,18 @@ H5Gset (hid_t file, const char *name)
 
    /* Check/fix arguments */
    if (!name || !*name) {
-      HRETURN_ERROR (H5E_ARGS, H5E_BADVALUE, FAIL);/*no name given*/
+      HRETURN_ERROR (H5E_ARGS, H5E_BADVALUE, FAIL, "no name given");
    }
    if (H5_FILE!=H5Aatom_group (file)) {
-      HRETURN_ERROR (H5E_ARGS, H5E_BADTYPE, FAIL);/*not a file atom*/
+      HRETURN_ERROR (H5E_ARGS, H5E_BADTYPE, FAIL, "not a file atom");
    }
    if (NULL==(f=H5Aatom_object (file))) {
-      HRETURN_ERROR (H5E_ATOM, H5E_BADATOM, FAIL);/*can't unatomize file*/
+      HRETURN_ERROR (H5E_ATOM, H5E_BADATOM, FAIL, "can't unatomize file");
    }
 
    if (H5G_set (f, name)<0) {
-      /* Can't change current working group */
-      HRETURN_ERROR (H5E_SYM, H5E_CANTINIT, FAIL);
+      HRETURN_ERROR (H5E_SYM, H5E_CANTINIT, FAIL,
+		     "can't change current working group");
    }
 
    FUNC_LEAVE (SUCCEED);
@@ -221,18 +221,18 @@ H5Gpush (hid_t file, const char *name)
 
    /* Check/fix arguments */
    if (!name || !*name) {
-      HRETURN_ERROR (H5E_ARGS, H5E_BADVALUE, FAIL);/*no name given*/
+      HRETURN_ERROR (H5E_ARGS, H5E_BADVALUE, FAIL, "no name given");
    }
    if (H5_FILE!=H5Aatom_group (file)) {
-      HRETURN_ERROR (H5E_ARGS, H5E_BADTYPE, FAIL);/*not a file atom*/
+      HRETURN_ERROR (H5E_ARGS, H5E_BADTYPE, FAIL, "not a file atom");
    }
    if (NULL==(f=H5Aatom_object (file))) {
-      HRETURN_ERROR (H5E_ATOM, H5E_BADATOM, FAIL);/*can't unatomize file*/
+      HRETURN_ERROR (H5E_ATOM, H5E_BADATOM, FAIL, "can't unatomize file");
    }
 
    if (H5G_push (f, name)<0) {
-      /* Can't change current working group */
-      HRETURN_ERROR (H5E_SYM, H5E_CANTINIT, FAIL);
+      HRETURN_ERROR (H5E_SYM, H5E_CANTINIT, FAIL,
+		     "can't change current working group");
    }
 
    FUNC_LEAVE (SUCCEED);
@@ -281,15 +281,15 @@ H5Gpop (hid_t file)
 
    /* Check/fix arguments */
    if (H5_FILE!=H5Aatom_group (file)) {
-      HRETURN_ERROR (H5E_ARGS, H5E_BADTYPE, FAIL);/*not a file atom*/
+      HRETURN_ERROR (H5E_ARGS, H5E_BADTYPE, FAIL, "not a file atom");
    }
    if (NULL==(f=H5Aatom_object (file))) {
-      HRETURN_ERROR (H5E_ATOM, H5E_BADATOM, FAIL);/*can't unatomize file*/
+      HRETURN_ERROR (H5E_ATOM, H5E_BADATOM, FAIL, "can't unatomize file");
    }
 
    if (H5G_pop (f)<0) {
-      /* Stack is empty */
-      HRETURN_ERROR (H5E_SYM, H5E_CANTINIT, FAIL);
+      HRETURN_ERROR (H5E_SYM, H5E_CANTINIT, FAIL,
+		     "stack is empty");
    }
 
    FUNC_LEAVE (SUCCEED);
@@ -436,8 +436,8 @@ H5G_namei (H5F_t *f, H5G_entry_t *cwg, const char *name,
    /* starting point */
    if ('/'==*name) {
       if (!H5F_addr_defined (&(f->shared->root_sym->header))) {
-	 /* No root group */
-	 HRETURN_ERROR (H5E_SYM, H5E_NOTFOUND, NULL);
+	 HRETURN_ERROR (H5E_SYM, H5E_NOTFOUND, NULL,
+			"no root group");
       }
       ret_value = f->shared->root_sym;
       grp = *(f->shared->root_sym);
@@ -466,9 +466,8 @@ H5G_namei (H5F_t *f, H5G_entry_t *cwg, const char *name,
        * we can pass it down to the other symbol table functions.
        */
       if (nchars+1 > sizeof(comp)) {
-	 /* component is too long */
 	 if (grp_ent) *grp_ent = grp;
-	 HRETURN_ERROR (H5E_SYM, H5E_COMPLEN, NULL);
+	 HRETURN_ERROR (H5E_SYM, H5E_COMPLEN, NULL, "component is too long");
       }
       HDmemcpy (comp, name, nchars);
       comp[nchars] = '\0';
@@ -492,10 +491,9 @@ H5G_namei (H5F_t *f, H5G_entry_t *cwg, const char *name,
 	    ret_value = f->shared->root_sym;
 	    aside = TRUE;
 	 } else {
-	    /* component not found */
 	    H5O_reset (H5O_NAME, &mesg);
 	    if (grp_ent) *grp_ent = grp;
-	    HRETURN_ERROR (H5E_SYM, H5E_NOTFOUND, NULL);
+	    HRETURN_ERROR (H5E_SYM, H5E_NOTFOUND, NULL, "component not found");
 	 }
       }
 
@@ -516,7 +514,7 @@ H5G_namei (H5F_t *f, H5G_entry_t *cwg, const char *name,
 
    /* Perhaps the root object doesn't even exist! */
    if (!H5F_addr_defined (&(ret_value->header))) {
-      HRETURN_ERROR (H5E_SYM, H5E_NOTFOUND, NULL); /*root not found*/
+      HRETURN_ERROR (H5E_SYM, H5E_NOTFOUND, NULL, "root not found");
    }
    
    FUNC_LEAVE (ret_value);
@@ -587,12 +585,12 @@ H5G_mkroot (H5F_t *f, size_t size_hint)
     */
    if (H5F_addr_defined (&(f->shared->root_sym->header))) {
       if (H5O_read (f, NO_ADDR, f->shared->root_sym, H5O_STAB, 0, &stab)) {
-	 /* root group already exists */
-	 HGOTO_ERROR (H5E_SYM, H5E_EXISTS, -2);
+	 HGOTO_ERROR (H5E_SYM, H5E_EXISTS, -2,
+		      "root group already exists");
       } else if (NULL==(handle=H5G_shadow_open (f, NULL,
 						f->shared->root_sym))) {
-	 /* can't open root object */
-	 HGOTO_ERROR (H5E_SYM, H5E_CANTINIT, FAIL);
+	 HGOTO_ERROR (H5E_SYM, H5E_CANTINIT, FAIL,
+		      "can't open root object");
       } else if (NULL==H5O_read (f, NO_ADDR, handle, H5O_NAME, 0, &name)) {
 	 obj_name = "Root Object";
       } else {
@@ -607,10 +605,11 @@ H5G_mkroot (H5F_t *f, size_t size_hint)
     * info back into f->root_sym because we set the dirty bit.
     */
    if (H5G_stab_create (f, f->shared->root_sym, size_hint)<0) {
-      HGOTO_ERROR (H5E_SYM, H5E_CANTINIT, FAIL); /*cant create root*/
+      HGOTO_ERROR (H5E_SYM, H5E_CANTINIT, FAIL, "cant create root");
    }
    if (1!=H5O_link (f, f->shared->root_sym, 1)) {
-      HGOTO_ERROR (H5E_SYM, H5E_LINK, FAIL);
+      HGOTO_ERROR (H5E_SYM, H5E_LINK, FAIL,
+		   "internal error (wrong link count)");
    }
 
    /*
@@ -620,13 +619,13 @@ H5G_mkroot (H5F_t *f, size_t size_hint)
     */
    if (obj_name) {
       if (1!=H5O_link (f, handle, 0)) {
-	 /* Bad link count on old root object */
-	 HGOTO_ERROR (H5E_SYM, H5E_LINK, FAIL);
+	 HGOTO_ERROR (H5E_SYM, H5E_LINK, FAIL,
+		      "bad link count on old root object");
       }
       if (NULL==(ent_ptr=H5G_stab_insert (f, f->shared->root_sym, obj_name,
 					  handle))) {
-	 /* Can't reinsert old root object */
-	 HGOTO_ERROR (H5E_SYM, H5E_CANTINIT, FAIL);
+	 HGOTO_ERROR (H5E_SYM, H5E_CANTINIT, FAIL,
+		      "can't reinsert old root object");
       }
       
       /*
@@ -719,14 +718,14 @@ H5G_new (H5F_t *f, const char *name, size_t size_hint)
     * fails because the root group already exists.
     */
    if ((status=H5G_mkroot (f, H5G_SIZE_HINT))<0 && -2!=status) {
-      /* Can't create root group */
-      HRETURN_ERROR (H5E_SYM, H5E_CANTINIT, NULL);
+      HRETURN_ERROR (H5E_SYM, H5E_CANTINIT, NULL,
+		     "can't create root group");
    }
    H5ECLEAR;
 
    /* lookup name */
    if (H5G_namei (f, cwg, name, &rest, &grp_ent)) {
-      HRETURN_ERROR (H5E_SYM, H5E_EXISTS, NULL); /*already exists*/
+      HRETURN_ERROR (H5E_SYM, H5E_EXISTS, NULL, "already exists");
    }
    H5ECLEAR; /*it's OK that we didn't find it*/
 
@@ -735,11 +734,11 @@ H5G_new (H5F_t *f, const char *name, size_t size_hint)
    assert (rest && *rest);
    if (rest[nchars]) {
       if (H5G_component (rest+nchars, NULL)) {
-	 /* missing component */
-	 HRETURN_ERROR (H5E_SYM, H5E_NOTFOUND, NULL);
+	 HRETURN_ERROR (H5E_SYM, H5E_NOTFOUND, NULL,
+			"missing component");
       } else if (nchars+1 > sizeof _comp) {
-	 /* component is too long */
-	 HRETURN_ERROR (H5E_SYM, H5E_COMPLEN, NULL);
+	 HRETURN_ERROR (H5E_SYM, H5E_COMPLEN, NULL,
+			"component is too long");
       } else {
 	 /* null terminate */
 	 HDmemcpy (_comp, rest, nchars);
@@ -750,17 +749,17 @@ H5G_new (H5F_t *f, const char *name, size_t size_hint)
    
    /* create group */
    if (H5G_stab_create (f, &ent, size_hint)<0) {
-      HRETURN_ERROR (H5E_SYM, H5E_CANTINIT, NULL); /*can't create grp*/
+      HRETURN_ERROR (H5E_SYM, H5E_CANTINIT, NULL, "can't create grp");
    }
 
    /* insert child name into parent */
    if (NULL==(ent_ptr=H5G_stab_insert (f, &grp_ent, rest, &ent))) {
-      HRETURN_ERROR (H5E_SYM, H5E_CANTINIT, NULL); /*can't insert*/
+      HRETURN_ERROR (H5E_SYM, H5E_CANTINIT, NULL, "can't insert");
    }
 
    /* open the group */
    if (NULL==(ret_value=H5G_shadow_open (f, &grp_ent, ent_ptr))) {
-      HRETURN_ERROR (H5E_SYM, H5E_CANTINIT, NULL); /*can't open*/
+      HRETURN_ERROR (H5E_SYM, H5E_CANTINIT, NULL, "can't open");
    }
 
    FUNC_LEAVE (ret_value);
@@ -803,12 +802,10 @@ H5G_set (H5F_t *f, const char *name)
    FUNC_ENTER (H5G_set, FAIL);
 
    if (NULL==(handle=H5G_open (f, name))) {
-      /* Can't open group */
-      HGOTO_ERROR (H5E_SYM, H5E_CWG, FAIL);
+      HGOTO_ERROR (H5E_SYM, H5E_CWG, FAIL, "can't open group");
    }
    if (NULL==H5O_read (f, NO_ADDR, handle, H5O_NAME, 0, &stab_mesg)) {
-      /* Not a group */
-      HGOTO_ERROR (H5E_SYM, H5E_CWG, FAIL);
+      HGOTO_ERROR (H5E_SYM, H5E_CWG, FAIL, "not a group");
    }
 
    /*
@@ -820,8 +817,8 @@ H5G_set (H5F_t *f, const char *name)
       f->cwg_stack->handle = handle;
    } else {
       if (H5G_close (f, f->cwg_stack->handle)<0) {
-	 /* Couldn't close previous c.w.g. */
-	 HGOTO_ERROR (H5E_SYM, H5E_CWG, FAIL);
+	 HGOTO_ERROR (H5E_SYM, H5E_CWG, FAIL,
+		      "couldn't close previous c.w.g.");
       }
       f->cwg_stack->handle = handle;
    }
@@ -907,12 +904,10 @@ H5G_push (H5F_t *f, const char *name)
    FUNC_ENTER (H5G_push, FAIL);
 
    if (NULL==(handle=H5G_open (f, name))) {
-      /* Can't open group */
-      HGOTO_ERROR (H5E_SYM, H5E_CWG, FAIL);
+      HGOTO_ERROR (H5E_SYM, H5E_CWG, FAIL, "can't open group");
    }
    if (NULL==H5O_read (f, NO_ADDR, handle, H5O_NAME, 0, &stab_mesg)) {
-      /* Not a group */
-      HGOTO_ERROR (H5E_SYM, H5E_CWG, FAIL);
+      HGOTO_ERROR (H5E_SYM, H5E_CWG, FAIL, "not a group");
    }
 
    /*
@@ -962,15 +957,14 @@ H5G_pop (H5F_t *f)
 
    if ((stack=f->cwg_stack)) {
       if (H5G_close (f, stack->handle)<0) {
-	 /* Can't close current working group */
-	 HRETURN_ERROR (H5E_SYM, H5E_CWG, FAIL);
+	 HRETURN_ERROR (H5E_SYM, H5E_CWG, FAIL,
+			"can't close current working group");
       }
       f->cwg_stack = stack->next;
       stack->handle = NULL;
       H5MM_xfree (stack);
    } else {
-      /* Stack is empty */
-      HRETURN_ERROR (H5E_SYM, H5E_CWG, FAIL);
+      HRETURN_ERROR (H5E_SYM, H5E_CWG, FAIL, "stack is empty");
    }
 
    FUNC_LEAVE (SUCCEED);
@@ -1040,7 +1034,7 @@ H5G_create (H5F_t *f, const char *name, size_t ohdr_hint)
     * Look up the name -- it shouldn't exist yet.
     */
    if (H5G_namei (f, cwg, name, &rest, &grp)) {
-      HRETURN_ERROR (H5E_SYM, H5E_EXISTS, NULL); /*already exists*/
+      HRETURN_ERROR (H5E_SYM, H5E_EXISTS, NULL, "already exists");
    }
    H5ECLEAR; /*it's OK that we didn't find it*/
    rest = H5G_component (rest, &nchars);
@@ -1052,18 +1046,19 @@ H5G_create (H5F_t *f, const char *name, size_t ohdr_hint)
        * it already has as a message.
        */
       if (H5F_addr_defined (&(f->shared->root_sym->header))) {
-	 HRETURN_ERROR (H5E_SYM, H5E_EXISTS, NULL); /*root exists*/
+	 HRETURN_ERROR (H5E_SYM, H5E_EXISTS, NULL, "root exists");
       }
       if (H5O_create (f, 0, ohdr_hint, &(ent.header)/*out*/)<0) {
-	 /* can't create header */
-	 HRETURN_ERROR (H5E_SYM, H5E_CANTINIT, NULL);
+	 HRETURN_ERROR (H5E_SYM, H5E_CANTINIT, NULL,
+			"can't create header");
       }
       if (1!=H5O_link (f, &ent, 1)) {
-	 HRETURN_ERROR (H5E_SYM, H5E_LINK, NULL); /*bad link count*/
+	 HRETURN_ERROR (H5E_SYM, H5E_LINK, NULL, "bad link count");
       }
       *(f->shared->root_sym) = ent;
       if (NULL==(ret_value=H5G_shadow_open (f, NULL, f->shared->root_sym))) {
-	 HRETURN_ERROR (H5E_SYM, H5E_CANTINIT, NULL);
+	 HRETURN_ERROR (H5E_SYM, H5E_CANTINIT, NULL,
+			"can't open root object");
       }
       HRETURN (ret_value);
    }
@@ -1074,11 +1069,11 @@ H5G_create (H5F_t *f, const char *name, size_t ohdr_hint)
     */
    if (rest[nchars]) {
       if (H5G_component (rest+nchars, NULL)) {
-	 /* component not found */
-	 HRETURN_ERROR (H5E_SYM, H5E_NOTFOUND, NULL);
+	 HRETURN_ERROR (H5E_SYM, H5E_NOTFOUND, NULL,
+			"component not found");
       } else if (nchars+1 > sizeof _comp) {
-	 /* component is too long */
-	 HRETURN_ERROR (H5E_SYM, H5E_COMPLEN, NULL);
+	 HRETURN_ERROR (H5E_SYM, H5E_COMPLEN, NULL,
+			"component is too long");
       } else {
 	 /* null terminate */
 	 HDmemcpy (_comp, rest, nchars);
@@ -1091,7 +1086,8 @@ H5G_create (H5F_t *f, const char *name, size_t ohdr_hint)
     * Create the object header.
     */
    if (H5O_create (f, 0, ohdr_hint, &(ent.header)/*out*/)<0) {
-      HRETURN_ERROR (H5E_SYM, H5E_CANTINIT, NULL);
+      HRETURN_ERROR (H5E_SYM, H5E_CANTINIT, NULL,
+		     "can't create object header");
    }
    
 
@@ -1105,15 +1101,16 @@ H5G_create (H5F_t *f, const char *name, size_t ohdr_hint)
       H5O_name_t name_mesg;
       name_mesg.s = rest;
       if (H5O_modify (f, NO_ADDR, &ent, H5O_NAME, 0, &name_mesg)<0) {
-	 /* cannot add/change name message */
-	 HRETURN_ERROR (H5E_SYM, H5E_CANTINIT, NULL);
+	 HRETURN_ERROR (H5E_SYM, H5E_CANTINIT, NULL,
+			"cannot add/change name message");
       }
       if (1!=H5O_link (f, &ent, 1)) {
-	 HRETURN_ERROR (H5E_SYM, H5E_LINK, NULL); /*bad link count*/
+	 HRETURN_ERROR (H5E_SYM, H5E_LINK, NULL, "bad link count");
       }
       *(f->shared->root_sym) = ent;
       if (NULL==(ret_value=H5G_shadow_open (f, &grp, f->shared->root_sym))) {
-	 HRETURN_ERROR (H5E_SYM, H5E_CANTINIT, NULL);
+	 HRETURN_ERROR (H5E_SYM, H5E_CANTINIT, NULL,
+			"can't open root object");
       }
       HRETURN (ret_value);
    } else {
@@ -1125,8 +1122,8 @@ H5G_create (H5F_t *f, const char *name, size_t ohdr_hint)
 					&(f->shared->root_sym->header));
       herr_t status = H5G_mkroot (f, H5G_SIZE_HINT);
       if (status<0 && -2!=status) {
-	 /* Can't create root group */
-	 HRETURN_ERROR (H5E_SYM, H5E_CANTINIT, NULL);
+	 HRETURN_ERROR (H5E_SYM, H5E_CANTINIT, NULL,
+			"can't create root group");
       }
       H5ECLEAR;
       if (update_grp) grp = *(f->shared->root_sym);
@@ -1137,13 +1134,13 @@ H5G_create (H5F_t *f, const char *name, size_t ohdr_hint)
     * entry into a symbol table.
     */
    if (H5O_link (f, &ent, 1)<0) {
-      HRETURN_ERROR (H5E_SYM, H5E_LINK, NULL); /*link inc failure*/
+      HRETURN_ERROR (H5E_SYM, H5E_LINK, NULL, "link inc failure");
    }
    if (NULL==(ent_ptr=H5G_stab_insert (f, &grp, rest, &ent))) {
-      HRETURN_ERROR (H5E_SYM, H5E_CANTINIT, NULL); /*can't insert*/
+      HRETURN_ERROR (H5E_SYM, H5E_CANTINIT, NULL, "can't insert");
    }
    if (NULL==(ret_value=H5G_shadow_open (f, &grp, ent_ptr))) {
-      HRETURN_ERROR (H5E_SYM, H5E_CANTINIT, NULL); /*can't open object*/
+      HRETURN_ERROR (H5E_SYM, H5E_CANTINIT, NULL, "can't open object");
    }
    FUNC_LEAVE (ret_value);
 }
@@ -1192,7 +1189,7 @@ H5G_open (H5F_t *f, const char *name)
    /* check args */
    assert (f);
    if (!name || !*name) {
-      HRETURN_ERROR (H5E_SYM, H5E_BADVALUE, NULL);
+      HRETURN_ERROR (H5E_SYM, H5E_BADVALUE, NULL, "no name");
    }
 
    /* Get CWG */
@@ -1200,13 +1197,13 @@ H5G_open (H5F_t *f, const char *name)
    assert (cwg || '/'==*name);
 
    if (!H5F_addr_defined (&(f->shared->root_sym->header))) {
-      HRETURN_ERROR (H5E_SYM, H5E_NOTFOUND, NULL); /*object not found*/
+      HRETURN_ERROR (H5E_SYM, H5E_NOTFOUND, NULL, "object not found");
    }
    if (NULL==(ent=H5G_namei (f, cwg, name, NULL, &grp))) {
-      HRETURN_ERROR (H5E_SYM, H5E_NOTFOUND, NULL); /*object not found*/
+      HRETURN_ERROR (H5E_SYM, H5E_NOTFOUND, NULL, "object not found");
    }
    if (NULL==(ret_value=H5G_shadow_open (f, &grp, ent))) {
-      HRETURN_ERROR (H5E_SYM, H5E_CANTOPENOBJ, NULL); /*can't open obj*/
+      HRETURN_ERROR (H5E_SYM, H5E_CANTOPENOBJ, NULL, "can't open obj");
    }
 
    FUNC_LEAVE (ret_value);
@@ -1241,8 +1238,8 @@ H5G_close (H5F_t *f, H5G_entry_t *ent)
    assert (f);
 
    if (ent && H5G_shadow_close (f,  ent)<0) {
-      /* Can't close object */
-      HRETURN_ERROR (H5E_SYM, H5E_CANTFLUSH, FAIL);
+      HRETURN_ERROR (H5E_SYM, H5E_CANTFLUSH, FAIL,
+		     "can't close object");
    }
    
    FUNC_LEAVE (SUCCEED);
@@ -1303,11 +1300,11 @@ H5G_find (H5F_t *f, const char *name,
    assert (cwg || '/'==*name);
 
    if (!H5F_addr_defined (&(f->shared->root_sym->header))) {
-      HRETURN_ERROR (H5E_SYM, H5E_NOTFOUND, FAIL); /*object not found*/
+      HRETURN_ERROR (H5E_SYM, H5E_NOTFOUND, FAIL, "object not found");
    }
 
    if (NULL==(ent_p=H5G_namei (f, cwg, name, NULL, grp_ent))) {
-      HRETURN_ERROR (H5E_SYM, H5E_NOTFOUND, FAIL); /*object not found*/
+      HRETURN_ERROR (H5E_SYM, H5E_NOTFOUND, FAIL, "object not found");
    }
 
    if (ent) *ent = *ent_p;
diff --git a/src/H5Gent.c b/src/H5Gent.c
index 29860e0..b8510f7 100644
--- a/src/H5Gent.c
+++ b/src/H5Gent.c
@@ -130,7 +130,7 @@ H5G_ent_cache (H5G_entry_t *ent, H5G_type_t *cache_type)
 {
    FUNC_ENTER (H5G_ent_cache, NULL);
    if (!ent) {
-      HRETURN_ERROR (H5E_SYM, H5E_BADVALUE, NULL);
+      HRETURN_ERROR (H5E_SYM, H5E_BADVALUE, NULL, "no entry");
    }
    if (cache_type) *cache_type = ent->type;
    
@@ -208,7 +208,7 @@ H5G_ent_decode_vec (H5F_t *f, const uint8 **pp, H5G_entry_t *ent, intn n)
    /* decode entries */
    for (i=0; i<n; i++) {
       if (H5G_ent_decode (f, pp, ent+i)<0) {
-	 HRETURN_ERROR (H5E_SYM, H5E_CANTDECODE, FAIL); /*can't decode*/
+	 HRETURN_ERROR (H5E_SYM, H5E_CANTDECODE, FAIL, "can't decode");
       }
    }
 
@@ -320,7 +320,7 @@ H5G_ent_encode_vec (H5F_t *f, uint8 **pp, H5G_entry_t *ent, intn n)
    /* encode entries */
    for (i=0; i<n; i++) {
       if (H5G_ent_encode (f, pp, ent+i)<0) {
-	 HRETURN_ERROR (H5E_SYM, H5E_CANTENCODE, FAIL); /*can't encode*/
+	 HRETURN_ERROR (H5E_SYM, H5E_CANTENCODE, FAIL, "can't encode");
       }
    }
 
diff --git a/src/H5Gnode.c b/src/H5Gnode.c
index f912c55..c4349a5 100644
--- a/src/H5Gnode.c
+++ b/src/H5Gnode.c
@@ -256,7 +256,8 @@ H5G_node_create (H5F_t *f, H5B_ins_t op,
    size = H5G_node_size (f);
    if (H5MF_alloc (f, H5MF_META, size, addr/*out*/)<0) {
       H5MM_xfree (sym);
-      HRETURN_ERROR (H5E_SYM, H5E_CANTINIT, FAIL);
+      HRETURN_ERROR (H5E_SYM, H5E_CANTINIT, FAIL,
+		     "unable to allocate file space");
    }
 
    sym->dirty = TRUE;
@@ -264,7 +265,8 @@ H5G_node_create (H5F_t *f, H5B_ins_t op,
    if (H5AC_set (f, H5AC_SNODE, addr, sym)<0) {
       H5MM_xfree (sym->entry);
       H5MM_xfree (sym);
-      HRETURN_ERROR (H5E_SYM, H5E_CANTINIT, FAIL);
+      HRETURN_ERROR (H5E_SYM, H5E_CANTINIT, FAIL,
+		     "unable to cache symbol table leaf node");
    }
 
    /*
@@ -324,7 +326,9 @@ H5G_node_flush (H5F_t *f, hbool_t destroy, const haddr_t *addr,
     */
    for (i=0; i<sym->nsyms; i++) {
       if (H5G_shadow_sync (sym->entry+i)<0) {
-	 HRETURN_ERROR (H5E_SYM, H5E_CANTFLUSH, FAIL);
+	 HRETURN_ERROR (H5E_SYM, H5E_CANTFLUSH, FAIL,
+			"unable to synchronize symbol table node with open "
+			"objects");
       }
       if (sym->entry[i].dirty) sym->dirty = TRUE;
    }
@@ -355,7 +359,9 @@ H5G_node_flush (H5F_t *f, hbool_t destroy, const haddr_t *addr,
       
       status = H5F_block_write (f, addr, size, buf);
       buf = H5MM_xfree (buf);
-      if (status<0) HRETURN_ERROR (H5E_SYM, H5E_WRITEERROR, FAIL);
+      if (status<0) HRETURN_ERROR (H5E_SYM, H5E_WRITEERROR, FAIL,
+				   "unable to write symbol table node to "
+				   "the file");
    }
 
    /*
@@ -423,18 +429,21 @@ H5G_node_load (H5F_t *f, const haddr_t *addr, const void *_udata1,
    sym->entry = H5MM_xcalloc (2*H5G_NODE_K(f), sizeof(H5G_entry_t));
    
    if (H5F_block_read (f, addr, size, buf)<0) {
-      HGOTO_ERROR (H5E_SYM, H5E_READERROR, NULL);
+      HGOTO_ERROR (H5E_SYM, H5E_READERROR, NULL,
+		   "unabel to read symbol table node");
    }
 
    /* magic */
    if (HDmemcmp (p, H5G_NODE_MAGIC, H5G_NODE_SIZEOF_MAGIC)) {
-      HGOTO_ERROR (H5E_SYM, H5E_CANTLOAD, NULL);
+      HGOTO_ERROR (H5E_SYM, H5E_CANTLOAD, NULL,
+		   "bad symbol table node signature");
    }
    p += 4;
 
    /* version */
    if (H5G_NODE_VERS!=*p++) {
-      HGOTO_ERROR (H5E_SYM, H5E_CANTLOAD, NULL);
+      HGOTO_ERROR (H5E_SYM, H5E_CANTLOAD, NULL,
+		   "bad symbol table node version");
    }
 
    /* reserved */
@@ -445,7 +454,8 @@ H5G_node_load (H5F_t *f, const haddr_t *addr, const void *_udata1,
 
    /* entries */
    if (H5G_ent_decode_vec (f, &p, sym->entry, sym->nsyms)<0) {
-      HGOTO_ERROR (H5E_SYM, H5E_CANTLOAD, NULL);
+      HGOTO_ERROR (H5E_SYM, H5E_CANTLOAD, NULL,
+		   "unable to decode symbol table entries");
    }
    buf = H5MM_xfree (buf);
 
@@ -456,7 +466,9 @@ H5G_node_load (H5F_t *f, const haddr_t *addr, const void *_udata1,
     */
    if (H5F_addr_defined (&(ac_udata->grp_addr)) &&
        H5G_shadow_assoc_node (f, sym, ac_udata)<0) {
-      HGOTO_ERROR (H5E_SYM, H5E_CANTLOAD, NULL);
+      HGOTO_ERROR (H5E_SYM, H5E_CANTLOAD, NULL,
+		   "unable to associate symbol table node with open "
+		   "objects");
    }
    
    ret_value = sym;
@@ -513,10 +525,12 @@ H5G_node_cmp2 (H5F_t *f, void *_lt_key, void *_udata, void *_rt_key)
    assert (rt_key);
 
    if (NULL==(s1=H5H_peek (f, &(udata->heap_addr), lt_key->offset))) {
-      HRETURN_ERROR (H5E_SYM, H5E_NOTFOUND, FAIL);
+      HRETURN_ERROR (H5E_SYM, H5E_NOTFOUND, FAIL,
+		     "unable to read symbol name");
    }
    if (NULL==(s2=H5H_peek (f, &(udata->heap_addr), rt_key->offset))) {
-      HRETURN_ERROR (H5E_SYM, H5E_NOTFOUND, FAIL);
+      HRETURN_ERROR (H5E_SYM, H5E_NOTFOUND, FAIL,
+		     "unable to read symbol name");
    }
 
    cmp = HDstrcmp (s1, s2);
@@ -564,13 +578,15 @@ H5G_node_cmp3 (H5F_t *f, void *_lt_key, void *_udata, void *_rt_key)
 
    /* left side */
    if (NULL==(s=H5H_peek (f, &(udata->heap_addr), lt_key->offset))) {
-      HRETURN_ERROR (H5E_SYM, H5E_NOTFOUND, FAIL);
+      HRETURN_ERROR (H5E_SYM, H5E_NOTFOUND, FAIL,
+		     "unable to read symbol name");
    }
    if (HDstrcmp (udata->name, s)<=0) HRETURN (-1);
 
    /* right side */
    if (NULL==(s=H5H_peek (f, &(udata->heap_addr), rt_key->offset))) {
-      HRETURN_ERROR (H5E_SYM, H5E_NOTFOUND, FAIL);
+      HRETURN_ERROR (H5E_SYM, H5E_NOTFOUND, FAIL,
+		     "unable to read symbol name");
    }
    if (HDstrcmp (udata->name, s)>0) HRETURN(1);
 
@@ -633,7 +649,8 @@ H5G_node_found (H5F_t *f, const haddr_t *addr, const void *_lt_key,
     * Load the symbol table node for exclusive access.
     */
    if (NULL==(sn=H5AC_protect (f, H5AC_SNODE, addr, &ac_udata, NULL))) {
-      HGOTO_ERROR (H5E_SYM, H5E_CANTLOAD, FAIL);
+      HGOTO_ERROR (H5E_SYM, H5E_CANTLOAD, FAIL,
+		   "unable to protect symbol table node");
    }
 
    /*
@@ -644,7 +661,8 @@ H5G_node_found (H5F_t *f, const haddr_t *addr, const void *_lt_key,
       idx = (lt + rt) / 2;
       if (NULL==(s=H5H_peek (f, &(bt_udata->heap_addr),
 			     sn->entry[idx].name_off))) {
-	 HGOTO_ERROR (H5E_SYM, H5E_NOTFOUND, FAIL);
+	 HGOTO_ERROR (H5E_SYM, H5E_NOTFOUND, FAIL,
+		      "unable to read symbol name");
       }
       cmp = HDstrcmp (bt_udata->name, s);
       
@@ -654,7 +672,7 @@ H5G_node_found (H5F_t *f, const haddr_t *addr, const void *_lt_key,
 	 lt = idx+1;
       }
    }
-   if (cmp) HGOTO_ERROR (H5E_SYM, H5E_NOTFOUND, FAIL);
+   if (cmp) HGOTO_ERROR (H5E_SYM, H5E_NOTFOUND, FAIL, "not found");
 
    switch (bt_udata->operation) {
    case H5G_OPER_FIND:
@@ -669,7 +687,8 @@ H5G_node_found (H5F_t *f, const haddr_t *addr, const void *_lt_key,
       break;
 
    default:
-      HRETURN_ERROR (H5E_SYM, H5E_UNSUPPORTED, FAIL);
+      HRETURN_ERROR (H5E_SYM, H5E_UNSUPPORTED, FAIL,
+		     "internal erorr (unknown symbol find operation)");
       break;
    }
    ret_value = SUCCEED;
@@ -682,7 +701,8 @@ done:
     */
    if (ret_value<0) {
       if (sn && H5AC_unprotect (f, H5AC_SNODE, addr, sn)<0) {
-	 HRETURN_ERROR (H5E_SYM, H5E_PROTECT, FAIL);
+	 HRETURN_ERROR (H5E_SYM, H5E_PROTECT, FAIL,
+			"unable to release symbol table node");
       }
    }
 
@@ -776,7 +796,8 @@ H5G_node_insert (H5F_t *f, const haddr_t *addr,
    ac_udata.grp_addr = bt_udata->grp_addr;
    ac_udata.heap_addr = bt_udata->heap_addr;
    if (NULL==(sn=H5AC_protect (f, H5AC_SNODE, addr, &ac_udata, NULL))) {
-      HGOTO_ERROR (H5E_SYM, H5E_CANTLOAD, H5B_INS_ERROR);
+      HGOTO_ERROR (H5E_SYM, H5E_CANTLOAD, H5B_INS_ERROR,
+		   "unable to protect symbol table node");
    }
 
    /*
@@ -787,11 +808,13 @@ H5G_node_insert (H5F_t *f, const haddr_t *addr,
       idx = (lt + rt) / 2;
       if (NULL==(s=H5H_peek (f, &(bt_udata->heap_addr),
 			     sn->entry[idx].name_off))) {
-	 HGOTO_ERROR (H5E_SYM, H5E_NOTFOUND, H5B_INS_ERROR);
+	 HGOTO_ERROR (H5E_SYM, H5E_NOTFOUND, H5B_INS_ERROR,
+		      "unable to read symbol name");
       }
       if (0==(cmp=HDstrcmp (bt_udata->name, s))) {
 	 /*already present*/
-	 HGOTO_ERROR (H5E_SYM, H5E_CANTINSERT, H5B_INS_ERROR);
+	 HGOTO_ERROR (H5E_SYM, H5E_CANTINSERT, H5B_INS_ERROR,
+		      "symbol is already present in symbol table");
       }
       if (cmp<0) {
 	 rt = idx;
@@ -809,8 +832,11 @@ H5G_node_insert (H5F_t *f, const haddr_t *addr,
    offset = H5H_insert (f, &(bt_udata->heap_addr), HDstrlen(bt_udata->name)+1,
 			bt_udata->name);
    bt_udata->entry.name_off = offset;
-   if (offset<=0) HGOTO_ERROR (H5E_SYM, H5E_CANTINSERT, H5B_INS_ERROR);
-
+   if (offset<=0) {
+      HGOTO_ERROR (H5E_SYM, H5E_CANTINSERT, H5B_INS_ERROR,
+		   "unable to insert symbol name into heap");
+   }
+   
    if (sn->nsyms>=2*H5G_NODE_K(f)) {
       /*
        * The node is full.  Split it into a left and right
@@ -822,10 +848,12 @@ H5G_node_insert (H5F_t *f, const haddr_t *addr,
       /* The right node */
       if (H5G_node_create (f, H5B_INS_FIRST, NULL, NULL, NULL,
 			   new_node/*out*/)<0) {
-	 HGOTO_ERROR (H5E_SYM, H5E_CANTINIT, H5B_INS_ERROR);
+	 HGOTO_ERROR (H5E_SYM, H5E_CANTINIT, H5B_INS_ERROR,
+		      "unable to split symbol table node");
       }
       if (NULL==(snrt=H5AC_find (f, H5AC_SNODE, new_node, &ac_udata, NULL))) {
-	 HGOTO_ERROR (H5E_SYM, H5E_CANTLOAD, H5B_INS_ERROR);
+	 HGOTO_ERROR (H5E_SYM, H5E_CANTLOAD, H5B_INS_ERROR,
+		      "unable to split symbol table node");
       }
       HDmemcpy (snrt->entry, sn->entry + H5G_NODE_K(f),
 		H5G_NODE_K(f) * sizeof(H5G_entry_t));
@@ -902,16 +930,19 @@ done:
    if (ret_value<0) {
       /* failing... */
       if (sn && H5AC_unprotect (f, H5AC_SNODE, addr, sn)<0) {
-	 HRETURN_ERROR (H5E_SYM, H5E_PROTECT, H5B_INS_ERROR);
+	 HRETURN_ERROR (H5E_SYM, H5E_PROTECT, H5B_INS_ERROR,
+			"unable to release symbol table node");
       }
    } else if (insert_into!=sn) {
       /* unprotect the first node and protect the return value */
       if (H5AC_unprotect (f, H5AC_SNODE, addr, sn)<0) {
-	 HRETURN_ERROR (H5E_SYM, H5E_PROTECT, H5B_INS_ERROR);
+	 HRETURN_ERROR (H5E_SYM, H5E_PROTECT, H5B_INS_ERROR,
+			"unable to release symbol table node");
       }
       if (NULL==(sn=H5AC_protect (f, H5AC_SNODE, &insert_addr, &ac_udata,
 				  NULL))) {
-	 HGOTO_ERROR (H5E_SYM, H5E_CANTLOAD, H5B_INS_ERROR);
+	 HGOTO_ERROR (H5E_SYM, H5E_CANTLOAD, H5B_INS_ERROR,
+		      "unable to protect symbol table node");
       }
       bt_udata->node_ptr = sn;
       bt_udata->entry_ptr = sn->entry + idx;
@@ -963,7 +994,8 @@ H5G_node_list (H5F_t *f, const haddr_t *addr, void *_udata)
    ac_udata.grp_addr = bt_udata->grp_addr;
    ac_udata.heap_addr = bt_udata->heap_addr;
    if (NULL==(sn=H5AC_protect (f, H5AC_SNODE, addr, &ac_udata, NULL))) {
-      HGOTO_ERROR (H5E_SYM, H5E_CANTLOAD, FAIL);
+      HGOTO_ERROR (H5E_SYM, H5E_CANTLOAD, FAIL,
+		   "unable to protect symbol table node");
    }
 
    /*
@@ -989,7 +1021,8 @@ H5G_node_list (H5F_t *f, const haddr_t *addr, void *_udata)
       for (i=0; i<sn->nsyms && bt_udata->nsyms+i<bt_udata->maxentries; i++) {
 	 if (NULL==(s=H5H_peek (f, &(bt_udata->heap_addr),
 				sn->entry[i].name_off))) {
-	    HGOTO_ERROR (H5E_SYM, H5E_NOTFOUND, FAIL);
+	    HGOTO_ERROR (H5E_SYM, H5E_NOTFOUND, FAIL,
+			 "unable to read symbol name");
 	 }
 	 bt_udata->name[bt_udata->nsyms+i] = H5MM_xstrdup (s);
       }
@@ -1003,7 +1036,8 @@ H5G_node_list (H5F_t *f, const haddr_t *addr, void *_udata)
 
 done:
    if (sn && H5AC_unprotect (f, H5AC_SNODE, addr, sn)<0) {
-      HRETURN_ERROR (H5E_CACHE, H5E_PROTECT, FAIL);
+      HRETURN_ERROR (H5E_CACHE, H5E_PROTECT, FAIL,
+		     "unable to release symbol table node");
    }
    FUNC_LEAVE (ret_value);
 }
@@ -1067,7 +1101,10 @@ H5G_node_debug (H5F_t *f, const haddr_t *addr, FILE *stream, intn indent,
    if (NULL==(sn=H5AC_protect(f, H5AC_SNODE, addr, &ac_udata, NULL))) {
       H5ECLEAR; /*discard that error*/
       status = H5B_debug (f, addr, stream, indent, fwidth, H5B_SNODE, NULL);
-      if (status<0) HRETURN_ERROR (H5E_SYM, H5E_CANTLOAD, FAIL);
+      if (status<0) {
+	 HRETURN_ERROR (H5E_SYM, H5E_CANTLOAD, FAIL,
+			"unable to debug B-tree node");
+      }
       HRETURN (SUCCEED);
    }
 
diff --git a/src/H5Gshad.c b/src/H5Gshad.c
index f7941ef..861f7e5 100644
--- a/src/H5Gshad.c
+++ b/src/H5Gshad.c
@@ -255,8 +255,8 @@ H5G_shadow_sync (H5G_entry_t *ent)
 
    if (shadow && shadow->entry.dirty) {
       if (!ent) {
-	 /* Main entry is not cached */
-	 HRETURN_ERROR (H5E_SYM, H5E_NOTCACHED, FAIL);
+	 HRETURN_ERROR (H5E_SYM, H5E_NOTCACHED, FAIL,
+			"main entry is not cached");
       }
       *ent = shadow->entry;
       shadow->entry.dirty = FALSE;
@@ -466,10 +466,12 @@ H5G_shadow_open (H5F_t *f, H5G_entry_t *grp, H5G_entry_t *ent)
        * Some entry other than the root.
        */
       if (NULL==H5O_read (f, NO_ADDR, grp, H5O_STAB, 0, &stab)) {
-	 HGOTO_ERROR (H5E_SYM, H5E_NOTFOUND, NULL);
+	 HGOTO_ERROR (H5E_SYM, H5E_NOTFOUND, NULL,
+		      "unable to read symbol table object header message");
       }
       if (NULL==(s=H5H_peek (f, &(stab.heap_addr), ent->name_off))) {
-	 HGOTO_ERROR (H5E_SYM, H5E_NOTFOUND, NULL);
+	 HGOTO_ERROR (H5E_SYM, H5E_NOTFOUND, NULL,
+		      "unable to read symbol name");
       }
       shadow->name = H5MM_xstrdup (s);
    }
@@ -576,7 +578,8 @@ H5G_shadow_close (H5F_t *f, H5G_entry_t *ent)
    if (1==shadow->nrefs && ent->dirty) {
       if (!shadow->main &&
 	  NULL==H5G_stab_find (f, &(shadow->grp_addr), NULL, shadow->name)) {
-	 HRETURN_ERROR (H5E_SYM, H5E_NOTFOUND, FAIL);
+	 HRETURN_ERROR (H5E_SYM, H5E_NOTFOUND, FAIL,
+			"unable to find shadow name in symbol table");
       }
       assert (shadow->main);
       *(shadow->main) = *ent;
@@ -760,7 +763,9 @@ H5G_shadow_flush (H5F_t *f, hbool_t invalidate)
 		  if (!shadow->main &&
 		      NULL==H5G_stab_find (f, &(shadow->grp_addr), NULL,
 					   shadow->name)) {
-		     HRETURN_ERROR (H5E_SYM, H5E_NOTFOUND, FAIL);
+		     HRETURN_ERROR (H5E_SYM, H5E_NOTFOUND, FAIL,
+				    "unable to find shadow name in symbol "
+				    "table");
 		  }
 		  assert (shadow->main);
 		  *(shadow->main) = shadow->entry;
@@ -797,7 +802,8 @@ H5G_shadow_flush (H5F_t *f, hbool_t invalidate)
        * shadow and then something else tries to access it (perhaps to close
        * it) then they trample on freed memory.
        */
-      HRETURN_ERROR (H5E_SYM, H5E_UNSUPPORTED, FAIL);
+      HRETURN_ERROR (H5E_SYM, H5E_UNSUPPORTED, FAIL,
+		     "leaking memory due to shadow errors");
    }
 
    FUNC_LEAVE (SUCCEED);
diff --git a/src/H5Gstab.c b/src/H5Gstab.c
index 30bca74..a607e5e 100644
--- a/src/H5Gstab.c
+++ b/src/H5Gstab.c
@@ -72,22 +72,23 @@ H5G_stab_create (H5F_t *f, H5G_entry_t *self, size_t init)
 
    /* Create symbol table private heap */
    if (H5H_create (f, H5H_LOCAL, init, &(stab.heap_addr)/*out*/)<0) {
-      HRETURN_ERROR (H5E_SYM, H5E_CANTINIT, FAIL); /*can't create heap*/
+      HRETURN_ERROR (H5E_SYM, H5E_CANTINIT, FAIL, "can't create heap");
    }
    if ((name = H5H_insert (f, &(stab.heap_addr), 1, "")<0)) {
-      HRETURN_ERROR (H5E_SYM, H5E_CANTINIT, FAIL); /*can't initialize heap*/
+      HRETURN_ERROR (H5E_SYM, H5E_CANTINIT, FAIL, "can't initialize heap");
    }
    if (0!=name) {
       /*
        * B-tree's won't work if the first name isn't at the beginning
        * of the heap.
        */
-      HRETURN_ERROR (H5E_INTERNAL, H5E_CANTINIT, FAIL);
+      HRETURN_ERROR (H5E_INTERNAL, H5E_CANTINIT, FAIL,
+		     "internal error (heap doesn't begin at zero)");
    }
 
    /* Create the B-tree */
    if (H5B_create (f, H5B_SNODE, NULL, &(stab.btree_addr)/*out*/)<0) {
-      HRETURN_ERROR (H5E_SYM, H5E_CANTINIT, FAIL); /*can't create B-tree*/
+      HRETURN_ERROR (H5E_SYM, H5E_CANTINIT, FAIL, "can't create B-tree");
    }
 
    /*
@@ -96,14 +97,14 @@ H5G_stab_create (H5F_t *f, H5G_entry_t *self, size_t init)
     * incremented if the object is added to the group directed graph.
     */
    if (H5O_create (f, 0, 4+2*H5F_SIZEOF_ADDR(f), &addr/*out*/)<0) {
-      HRETURN_ERROR (H5E_SYM, H5E_CANTINIT, FAIL); /*can't create header*/
+      HRETURN_ERROR (H5E_SYM, H5E_CANTINIT, FAIL, "can't create header");
    }
    
    /* insert the symbol table message */
    memset (self, 0, sizeof(H5G_entry_t));
    self->header = addr;
    if (H5O_modify(f, NO_ADDR, self, H5O_STAB, H5O_NEW_MESG, &stab)<0) {
-      HRETURN_ERROR (H5E_SYM, H5E_CANTINIT, FAIL); /*can't create message*/
+      HRETURN_ERROR (H5E_SYM, H5E_CANTINIT, FAIL, "can't create message");
    }
 
    FUNC_LEAVE (SUCCEED);
@@ -153,16 +154,16 @@ H5G_stab_find (H5F_t *f, const haddr_t *addr, H5G_entry_t *self,
    assert (f);
    assert (!addr || H5F_addr_defined (addr));
    if (!addr && (!self || !H5F_addr_defined (&(self->header)))) {
-      HRETURN_ERROR (H5E_SYM, H5E_NOTFOUND, NULL);
+      HRETURN_ERROR (H5E_SYM, H5E_NOTFOUND, NULL, "bad address");
    }
    if (!name || !*name) {
-      HRETURN_ERROR (H5E_SYM, H5E_NOTFOUND, NULL);
+      HRETURN_ERROR (H5E_SYM, H5E_NOTFOUND, NULL, "no name");
    }
    if (!addr) addr = &(self->header);
 
    /* set up the udata */
    if (NULL==H5O_read (f, addr, self, H5O_STAB, 0, &stab)) {
-      HRETURN_ERROR (H5E_SYM, H5E_BADMESG, NULL); /*can't read message*/
+      HRETURN_ERROR (H5E_SYM, H5E_BADMESG, NULL, "can't read message");
    }
    udata.operation = H5G_OPER_FIND;
    udata.name = name;
@@ -175,14 +176,15 @@ H5G_stab_find (H5F_t *f, const haddr_t *addr, H5G_entry_t *self,
       if (udata.node_ptr) {
 	 H5AC_unprotect (f, H5AC_SNODE, &(udata.node_addr), udata.node_ptr);
       }
-      HRETURN_ERROR (H5E_SYM, H5E_NOTFOUND, NULL); /*not found*/
+      HRETURN_ERROR (H5E_SYM, H5E_NOTFOUND, NULL, "not found");
    }
 
    /* Unprotect the symbol table node */
    if (udata.node_ptr) {
       if (H5AC_unprotect (f, H5AC_SNODE, &(udata.node_addr),
 			  udata.node_ptr)<0) {
-	 HRETURN_ERROR (H5E_SYM, H5E_PROTECT, NULL);
+	 HRETURN_ERROR (H5E_SYM, H5E_PROTECT, NULL,
+			"unable to release symbol table node");
       }
    }
 
@@ -238,7 +240,7 @@ H5G_stab_insert (H5F_t *f, H5G_entry_t *self, const char *name,
    
    /* initialize data to pass through B-tree */
    if (NULL==H5O_read (f, &(self->header), self, H5O_STAB, 0, &stab)) {
-      HRETURN_ERROR (H5E_SYM, H5E_BADMESG, NULL); /*can't read message*/
+      HRETURN_ERROR (H5E_SYM, H5E_BADMESG, NULL, "can't read message");
    }
 
    udata.operation = H5G_OPER_INSERT;
@@ -254,7 +256,7 @@ H5G_stab_insert (H5F_t *f, H5G_entry_t *self, const char *name,
       if (udata.node_ptr) {
 	 H5AC_unprotect (f, H5AC_SNODE, &(udata.node_addr), udata.node_ptr);
       }
-      HRETURN_ERROR (H5E_SYM, H5E_CANTINSERT, NULL); /*can't insert entry*/
+      HRETURN_ERROR (H5E_SYM, H5E_CANTINSERT, NULL, "can't insert entry");
    }
 
    /*
@@ -264,7 +266,7 @@ H5G_stab_insert (H5F_t *f, H5G_entry_t *self, const char *name,
     * until the next call to H5AC.
     */
    if (H5AC_unprotect (f, H5AC_SNODE, &(udata.node_addr), udata.node_ptr)<0) {
-      HRETURN_ERROR (H5E_SYM, H5E_PROTECT, NULL); /*can't unprotect*/
+      HRETURN_ERROR (H5E_SYM, H5E_PROTECT, NULL, "can't unprotect");
    }
       
    /* update the name offset in the entry */
@@ -321,7 +323,7 @@ H5G_stab_list (H5F_t *f, H5G_entry_t *self, intn maxentries,
 
    /* initialize data to pass through B-tree */
    if (NULL==H5O_read (f, &(self->header), self, H5O_STAB, 0, &stab)) {
-      HRETURN_ERROR (H5E_SYM, H5E_BADMESG, FAIL); /*not a symbol table*/
+      HRETURN_ERROR (H5E_SYM, H5E_BADMESG, FAIL, "not a symbol table");
    }
    udata.entry = entries;
    udata.name = names;
@@ -336,7 +338,7 @@ H5G_stab_list (H5F_t *f, H5G_entry_t *self, intn maxentries,
       if (names) {
 	 for (i=0; i<maxentries; i++) H5MM_xfree (names[i]);
       }
-      HRETURN_ERROR (H5E_SYM, H5E_CANTLIST, FAIL); /*B-tree list failure*/
+      HRETURN_ERROR (H5E_SYM, H5E_CANTLIST, FAIL, "b-tree list failure");
    }
 
    FUNC_LEAVE (udata.nsyms);
diff --git a/src/H5H.c b/src/H5H.c
index 3fed8e9..62aedc3 100644
--- a/src/H5H.c
+++ b/src/H5H.c
@@ -117,7 +117,8 @@ H5H_create (H5F_t *f, H5H_type_t heap_type, size_t size_hint,
    /* allocate file version */
    total_size = H5H_SIZEOF_HDR(f) + size_hint;
    if (H5MF_alloc (f, H5MF_META, total_size, addr/*out*/)<0) {
-      HRETURN_ERROR (H5E_RESOURCE, H5E_NOSPACE, FAIL);
+      HRETURN_ERROR (H5E_RESOURCE, H5E_NOSPACE, FAIL,
+		     "unable to allocate file memory");
    }
 
    /* allocate memory version */
@@ -143,7 +144,8 @@ H5H_create (H5F_t *f, H5H_type_t heap_type, size_t size_hint,
    if (H5AC_set (f, H5AC_HEAP, addr, heap)<0) {
       heap->chunk = H5MM_xfree (heap->chunk);
       heap->freelist = H5MM_xfree (heap->freelist);
-      HRETURN_ERROR (H5E_HEAP, H5E_CANTINIT, FAIL);
+      HRETURN_ERROR (H5E_HEAP, H5E_CANTINIT, FAIL,
+		     "unable to cache heap");
    }
 
    FUNC_LEAVE (SUCCEED);
@@ -187,14 +189,16 @@ H5H_load (H5F_t *f, const haddr_t *addr, const void *udata1, void *udata2)
    assert (!udata2);
 
    if (H5F_block_read (f, addr, H5H_SIZEOF_HDR(f), hdr)<0) {
-      HRETURN_ERROR (H5E_HEAP, H5E_READERROR, NULL);
+      HRETURN_ERROR (H5E_HEAP, H5E_READERROR, NULL,
+		     "unable to read heap header");
    }
    p = hdr;
    heap = H5MM_xcalloc (1, sizeof(H5H_t));
 
    /* magic number */
    if (HDmemcmp (hdr, H5H_MAGIC, H5H_SIZEOF_MAGIC)) {
-      HGOTO_ERROR (H5E_HEAP, H5E_CANTLOAD, NULL);
+      HGOTO_ERROR (H5E_HEAP, H5E_CANTLOAD, NULL,
+		   "bad heap signature");
    }
    p += H5H_SIZEOF_MAGIC;
 
@@ -205,7 +209,8 @@ H5H_load (H5F_t *f, const haddr_t *addr, const void *udata1, void *udata2)
    /* free list head */
    H5F_decode_length (f, p, free_block);
    if (free_block!=H5H_FREE_NULL && free_block>=heap->disk_alloc) {
-      HGOTO_ERROR (H5E_HEAP, H5E_CANTLOAD, NULL);
+      HGOTO_ERROR (H5E_HEAP, H5E_CANTLOAD, NULL,
+		   "bad heap free list");
    }
 
    /* data */
@@ -214,13 +219,15 @@ H5H_load (H5F_t *f, const haddr_t *addr, const void *udata1, void *udata2)
    if (heap->disk_alloc &&
        H5F_block_read (f, &(heap->addr), heap->disk_alloc,
 		       heap->chunk + H5H_SIZEOF_HDR(f))<0) {
-      HGOTO_ERROR (H5E_HEAP, H5E_CANTLOAD, NULL);
+      HGOTO_ERROR (H5E_HEAP, H5E_CANTLOAD, NULL,
+		   "unable to read heap data");
    }
 
    /* free list */
    while (H5H_FREE_NULL!=free_block) {
       if (free_block>=heap->disk_alloc) {
-	 HGOTO_ERROR (H5E_HEAP, H5E_CANTLOAD, NULL);
+	 HGOTO_ERROR (H5E_HEAP, H5E_CANTLOAD, NULL,
+		      "bad heap free list");
       }
       fl = H5MM_xmalloc (sizeof (H5H_free_t));
       fl->offset = free_block;
@@ -235,7 +242,8 @@ H5H_load (H5F_t *f, const haddr_t *addr, const void *udata1, void *udata2)
       H5F_decode_length (f, p, fl->size);
 
       if (fl->offset + fl->size > heap->disk_alloc) {
-	 HGOTO_ERROR (H5E_HEAP, H5E_CANTLOAD, NULL);
+	 HGOTO_ERROR (H5E_HEAP, H5E_CANTLOAD, NULL,
+		      "bad heap free list");
       }
    }
 
@@ -297,7 +305,8 @@ H5H_flush (H5F_t *f, hbool_t destroy, const haddr_t *addr, H5H_t *heap)
       if (heap->mem_alloc > heap->disk_alloc) {
 	 haddr_t old_addr = heap->addr, new_addr;
 	 if (H5MF_alloc (f, H5MF_META, heap->mem_alloc, &new_addr/*out*/)<0) {
-	    HRETURN_ERROR (H5E_RESOURCE, H5E_NOSPACE, FAIL);
+	    HRETURN_ERROR (H5E_RESOURCE, H5E_NOSPACE, FAIL,
+			   "unable to allocate file space for heap");
 	 }
 	 heap->addr = new_addr;
 	 H5MF_free (f, &old_addr, heap->disk_alloc);
@@ -336,15 +345,18 @@ H5H_flush (H5F_t *f, hbool_t destroy, const haddr_t *addr, H5H_t *heap)
 	 /* The header and data are contiguous */
 	 if (H5F_block_write (f, addr, H5H_SIZEOF_HDR(f)+heap->disk_alloc,
 			      heap->chunk)<0) {
-	    HRETURN_ERROR (H5E_HEAP, H5E_WRITEERROR, FAIL);
+	    HRETURN_ERROR (H5E_HEAP, H5E_WRITEERROR, FAIL,
+			   "unable to write heap header and data to disk");
 	 }
       } else {
 	 if (H5F_block_write (f, addr, H5H_SIZEOF_HDR(f), heap->chunk)<0) {
-	    HRETURN_ERROR (H5E_HEAP, H5E_WRITEERROR, FAIL);
+	    HRETURN_ERROR (H5E_HEAP, H5E_WRITEERROR, FAIL,
+			   "unable to write heap header to disk");
 	 }
 	 if (H5F_block_write (f, &(heap->addr), heap->disk_alloc,
 			      heap->chunk + H5H_SIZEOF_HDR(f))<0) {
-	    HRETURN_ERROR (H5E_HEAP, H5E_WRITEERROR, FAIL);
+	    HRETURN_ERROR (H5E_HEAP, H5E_WRITEERROR, FAIL,
+			   "unable to write heap data to disk");
 	 }
       }
 
@@ -411,7 +423,8 @@ H5H_read (H5F_t *f, const haddr_t *addr, size_t offset, size_t size, void *buf)
    assert (offset>=0);
 
    if (NULL==(heap=H5AC_find (f, H5AC_HEAP, addr, NULL, NULL))) {
-      HRETURN_ERROR (H5E_HEAP, H5E_CANTLOAD, NULL);
+      HRETURN_ERROR (H5E_HEAP, H5E_CANTLOAD, NULL,
+		     "unable to load heap");
    }
    assert (offset<heap->mem_alloc);
    assert (offset+size<=heap->mem_alloc);
@@ -471,7 +484,8 @@ H5H_peek (H5F_t *f, const haddr_t *addr, size_t offset)
    assert (offset>=0);
 
    if (NULL==(heap=H5AC_find (f, H5AC_HEAP, addr, NULL, NULL))) {
-      HRETURN_ERROR (H5E_HEAP, H5E_CANTLOAD, NULL);
+      HRETURN_ERROR (H5E_HEAP, H5E_CANTLOAD, NULL,
+		     "unable to load heap");
    }
    assert (offset<heap->mem_alloc);
    
@@ -549,7 +563,8 @@ H5H_insert (H5F_t *f, const haddr_t *addr, size_t buf_size, const void *buf)
    assert (buf);
 
    if (NULL==(heap=H5AC_find (f, H5AC_HEAP, addr, NULL, NULL))) {
-      HRETURN_ERROR (H5E_HEAP, H5E_CANTLOAD, FAIL);
+      HRETURN_ERROR (H5E_HEAP, H5E_CANTLOAD, FAIL,
+		     "unable to load heap");
    }
    heap->dirty += 1;
 
@@ -704,7 +719,8 @@ H5H_write (H5F_t *f, const haddr_t *addr, size_t offset, size_t size,
    assert (buf);
 
    if (NULL==(heap=H5AC_find (f, H5AC_HEAP, addr, NULL, NULL))) {
-      HRETURN_ERROR (H5E_HEAP, H5E_CANTLOAD, FAIL);
+      HRETURN_ERROR (H5E_HEAP, H5E_CANTLOAD, FAIL,
+		     "unable to load heap");
    }
    assert (offset<heap->mem_alloc);
    assert (offset+size<=heap->mem_alloc);
@@ -766,7 +782,8 @@ H5H_remove (H5F_t *f, const haddr_t *addr, size_t offset, size_t size)
    assert (size>0);
 
    if (NULL==(heap=H5AC_find (f, H5AC_HEAP, addr, NULL, NULL))) {
-      HRETURN_ERROR (H5E_HEAP, H5E_CANTLOAD, FAIL);
+      HRETURN_ERROR (H5E_HEAP, H5E_CANTLOAD, FAIL,
+		     "unable to load heap");
    }
    assert (offset<heap->mem_alloc);
    assert (offset+size<=heap->mem_alloc);
@@ -882,7 +899,8 @@ H5H_debug (H5F_t *f, const haddr_t *addr, FILE *stream, intn indent, intn fwidth
    assert (fwidth>=0);
 
    if (NULL==(h=H5AC_find (f, H5AC_HEAP, addr, NULL, NULL))) {
-      HRETURN_ERROR (H5E_HEAP, H5E_CANTLOAD, FAIL);
+      HRETURN_ERROR (H5E_HEAP, H5E_CANTLOAD, FAIL,
+		     "unable to load heap");
    }
 
    fprintf (stream, "%*sHeap...\n", indent, "");
diff --git a/src/H5M.c b/src/H5M.c
index d1911bd..31a5bd4 100644
--- a/src/H5M.c
+++ b/src/H5M.c
@@ -229,11 +229,12 @@ hid_t H5Maccess(hid_t oid)
     /* Clear errors and check args and all the boring stuff. */
     H5ECLEAR;
     if(group<=BADGROUP || group>=MAXGROUP)
-	HGOTO_ERROR(H5E_ARGS, H5E_BADRANGE, FAIL);
+	HGOTO_ERROR(H5E_ARGS, H5E_BADRANGE, FAIL, "bad group");
 
     i=H5M_find_type(group);
     if(meta_func_arr[i].access==NULL)
-	HGOTO_ERROR(H5E_INTERNAL, H5E_UNSUPPORTED, FAIL);
+	HGOTO_ERROR(H5E_INTERNAL, H5E_UNSUPPORTED, FAIL,
+		    "no access method");
     ret_value=(meta_func_arr[i].access)(oid);
 
 done:
@@ -272,11 +273,11 @@ hid_t H5Mcopy(hid_t oid)
     /* Clear errors and check args and all the boring stuff. */
     H5ECLEAR;
     if(group<=BADGROUP || group>=MAXGROUP)
-	HGOTO_ERROR(H5E_ARGS, H5E_BADRANGE, FAIL);
+	HGOTO_ERROR(H5E_ARGS, H5E_BADRANGE, FAIL, "bad group");
 
     i=H5M_find_type(group);
     if(meta_func_arr[i].copy==NULL)
-	HGOTO_ERROR(H5E_INTERNAL, H5E_UNSUPPORTED, FAIL);
+	HGOTO_ERROR(H5E_INTERNAL, H5E_UNSUPPORTED, FAIL, "no copy method");
     ret_value=(meta_func_arr[i].copy)(oid);
 
 done:
@@ -326,12 +327,12 @@ H5Mfind_name (hid_t owner_id, group_t type, const char *name)
     i=H5M_find_type(group);
 #else /* OLD_WAY */
     if(type<=BADGROUP || type>=MAXGROUP)
-	HGOTO_ERROR(H5E_ARGS, H5E_BADRANGE, FAIL);
+	HGOTO_ERROR(H5E_ARGS, H5E_BADRANGE, FAIL, "bad group");
 
     i=H5M_find_type(type);
 #endif /* OLD_WAY */
     if(meta_func_arr[i].find_name==NULL)
-	HGOTO_ERROR(H5E_INTERNAL, H5E_UNSUPPORTED, FAIL);
+	HGOTO_ERROR(H5E_INTERNAL, H5E_UNSUPPORTED, FAIL, "no open method");
     ret_value=(meta_func_arr[i].find_name)(owner_id,type,name);
 
 done:
@@ -370,11 +371,11 @@ uint32 H5Mname_len(hid_t oid)
     /* Clear errors and check args and all the boring stuff. */
     H5ECLEAR;
     if(group<=BADGROUP || group>=MAXGROUP)
-	HGOTO_ERROR(H5E_ARGS, H5E_BADRANGE, FAIL);
+	HGOTO_ERROR(H5E_ARGS, H5E_BADRANGE, FAIL, "bad group");
 
     i=H5M_find_type(group);
     if(meta_func_arr[i].name_len==NULL)
-	HGOTO_ERROR(H5E_INTERNAL, H5E_UNSUPPORTED, FAIL);
+	HGOTO_ERROR(H5E_INTERNAL, H5E_UNSUPPORTED, FAIL, "no name_len method");
     ret_value=(meta_func_arr[i].name_len)(oid);
 
 done:
@@ -414,11 +415,12 @@ herr_t H5Mget_name(hid_t oid, char *name)
     /* Clear errors and check args and all the boring stuff. */
     H5ECLEAR;
     if(group<=BADGROUP || group>=MAXGROUP)
-	HGOTO_ERROR(H5E_ARGS, H5E_BADRANGE, FAIL);
+	HGOTO_ERROR(H5E_ARGS, H5E_BADRANGE, FAIL, "bad group");
 
     i=H5M_find_type(group);
     if(meta_func_arr[i].get_name==NULL)
-	HGOTO_ERROR(H5E_INTERNAL, H5E_UNSUPPORTED, FAIL);
+	HGOTO_ERROR(H5E_INTERNAL, H5E_UNSUPPORTED, FAIL,
+		    "no get_name method");
     ret_value=(meta_func_arr[i].get_name)(oid,name);
 
 done:
@@ -458,11 +460,12 @@ herr_t H5Mset_name(hid_t oid, const char *name)
     /* Clear errors and check args and all the boring stuff. */
     H5ECLEAR;
     if(group<=BADGROUP || group>=MAXGROUP)
-	HGOTO_ERROR(H5E_ARGS, H5E_BADRANGE, FAIL);
+	HGOTO_ERROR(H5E_ARGS, H5E_BADRANGE, FAIL, "bad group");
 
     i=H5M_find_type(group);
     if(meta_func_arr[i].set_name==NULL)
-	HGOTO_ERROR(H5E_INTERNAL, H5E_UNSUPPORTED, FAIL);
+	HGOTO_ERROR(H5E_INTERNAL, H5E_UNSUPPORTED, FAIL,
+		    "no set_name method");
     ret_value=(meta_func_arr[i].set_name)(oid,name);
 
 done:
@@ -504,11 +507,11 @@ H5Msearch (hid_t oid, group_t type, const char *name)
     /* Clear errors and check args and all the boring stuff. */
     H5ECLEAR;
     if(group<=BADGROUP || group>=MAXGROUP)
-	HGOTO_ERROR(H5E_ARGS, H5E_BADRANGE, FAIL);
+	HGOTO_ERROR(H5E_ARGS, H5E_BADRANGE, FAIL, "bad group");
 
     i=H5M_find_type(group);
     if(meta_func_arr[i].search==NULL)
-	HGOTO_ERROR(H5E_INTERNAL, H5E_UNSUPPORTED, FAIL);
+	HGOTO_ERROR(H5E_INTERNAL, H5E_UNSUPPORTED, FAIL, "no search method");
     ret_value=(meta_func_arr[i].search)(oid,type,name);
 
 done:
@@ -550,11 +553,11 @@ H5Mindex (hid_t oid, group_t type, uint32 idx)
     /* Clear errors and check args and all the boring stuff. */
     H5ECLEAR;
     if(group<=BADGROUP || group>=MAXGROUP)
-	HGOTO_ERROR(H5E_ARGS, H5E_BADRANGE, FAIL);
+	HGOTO_ERROR(H5E_ARGS, H5E_BADRANGE, FAIL,  "bad group");
 
     i=H5M_find_type(group);
     if(meta_func_arr[i].index==NULL)
-	HGOTO_ERROR(H5E_INTERNAL, H5E_UNSUPPORTED, FAIL);
+	HGOTO_ERROR(H5E_INTERNAL, H5E_UNSUPPORTED, FAIL, "no index method");
     ret_value=(meta_func_arr[i].index)(oid,type,idx);
 
 done:
@@ -594,12 +597,12 @@ hid_t H5Mflush(hid_t oid)
     H5ECLEAR;
     group=H5Aatom_group(oid);	/* look up group for incoming object */
     if(group<=BADGROUP || group>=MAXGROUP)
-	HGOTO_ERROR(H5E_ARGS, H5E_BADRANGE, FAIL);
+	HGOTO_ERROR(H5E_ARGS, H5E_BADRANGE, FAIL, "bad group");
 
     /* Find correct function pointer set from static array */
     i=H5M_find_type(group);
     if(meta_func_arr[i].flush==NULL)
-	HGOTO_ERROR(H5E_INTERNAL, H5E_UNSUPPORTED, FAIL);
+	HGOTO_ERROR(H5E_INTERNAL, H5E_UNSUPPORTED, FAIL, "no flush method");
     ret_value=(meta_func_arr[i].flush)(oid);
 
 done:
@@ -639,11 +642,11 @@ herr_t H5Mdelete(hid_t oid)
     /* Clear errors and check args and all the boring stuff. */
     H5ECLEAR;
     if(group<=BADGROUP || group>=MAXGROUP)
-	HGOTO_ERROR(H5E_ARGS, H5E_BADRANGE, FAIL);
+	HGOTO_ERROR(H5E_ARGS, H5E_BADRANGE, FAIL, "bad group");
 
     i=H5M_find_type(group);
     if(meta_func_arr[i].delete==NULL)
-	HGOTO_ERROR(H5E_INTERNAL, H5E_UNSUPPORTED, FAIL);
+	HGOTO_ERROR(H5E_INTERNAL, H5E_UNSUPPORTED, FAIL, "no delete method");
     ret_value=(meta_func_arr[i].delete)(oid);
 
 done:
@@ -682,11 +685,12 @@ hid_t H5Mget_parent(hid_t oid)
     /* Clear errors and check args and all the boring stuff. */
     H5ECLEAR;
     if(group<=BADGROUP || group>=MAXGROUP)
-	HGOTO_ERROR(H5E_ARGS, H5E_BADRANGE, FAIL);
+	HGOTO_ERROR(H5E_ARGS, H5E_BADRANGE, FAIL, "bad group");
 
     i=H5M_find_type(group);
     if(meta_func_arr[i].get_parent==NULL)
-	HGOTO_ERROR(H5E_INTERNAL, H5E_UNSUPPORTED, FAIL);
+	HGOTO_ERROR(H5E_INTERNAL, H5E_UNSUPPORTED, FAIL,
+		    "no get_parent method");
     ret_value=(meta_func_arr[i].get_parent)(oid);
 
 done:
@@ -725,11 +729,12 @@ hid_t H5Mget_file(hid_t oid)
     /* Clear errors and check args and all the boring stuff. */
     H5ECLEAR;
     if(group<=BADGROUP || group>=MAXGROUP)
-	HGOTO_ERROR(H5E_ARGS, H5E_BADRANGE, FAIL);
+	HGOTO_ERROR(H5E_ARGS, H5E_BADRANGE, FAIL, "bad group");
 
     i=H5M_find_type(group);
     if(meta_func_arr[i].get_file==NULL)
-	HGOTO_ERROR(H5E_INTERNAL, H5E_UNSUPPORTED, FAIL);
+	HGOTO_ERROR(H5E_INTERNAL, H5E_UNSUPPORTED, FAIL,
+		    "no get_file method");
     ret_value=(meta_func_arr[i].get_file)(oid);
 
 done:
@@ -768,11 +773,11 @@ herr_t H5Mclose(hid_t oid)
     /* Clear errors and check args and all the boring stuff. */
     H5ECLEAR;
     if(group<=BADGROUP || group>=MAXGROUP)
-	HGOTO_ERROR(H5E_ARGS, H5E_BADRANGE, FAIL);
+	HGOTO_ERROR(H5E_ARGS, H5E_BADRANGE, FAIL, "bad group");
 
     i=H5M_find_type(group);
     if(meta_func_arr[i].close==NULL)
-	HGOTO_ERROR(H5E_INTERNAL, H5E_UNSUPPORTED, FAIL);
+	HGOTO_ERROR(H5E_INTERNAL, H5E_UNSUPPORTED, FAIL, "no close method");
     ret_value=(meta_func_arr[i].close)(oid);
 
 done:
diff --git a/src/H5MF.c b/src/H5MF.c
index e8d1fda..036e929 100644
--- a/src/H5MF.c
+++ b/src/H5MF.c
@@ -70,8 +70,8 @@ H5MF_alloc (H5F_t *f, intn op, size_t size, haddr_t *addr/*out*/)
     * the file.
     */
    if (H5F_low_extend (f->shared->lf, op, size, addr/*out*/)<0) {
-      /* Low level mem management failed */
-      HRETURN_ERROR (H5E_RESOURCE, H5E_NOSPACE, FAIL);
+      HRETURN_ERROR (H5E_RESOURCE, H5E_NOSPACE, FAIL,
+		     "low level mem management failed");
    }
    /* Convert from absolute to relative */
    addr->offset -= f->shared->base_addr.offset;
diff --git a/src/H5O.c b/src/H5O.c
index 2eb177d..5ba5c22 100644
--- a/src/H5O.c
+++ b/src/H5O.c
@@ -108,7 +108,8 @@ H5O_create (H5F_t *f, intn nlink, size_t size_hint, haddr_t *addr/*out*/)
    /* allocate disk space for header and first chunk */
    size = H5O_SIZEOF_HDR(f) + size_hint;
    if (H5MF_alloc (f, H5MF_META, size, addr/*out*/)<0) {
-      HRETURN_ERROR (H5E_RESOURCE, H5E_NOSPACE, FAIL);
+      HRETURN_ERROR (H5E_RESOURCE, H5E_NOSPACE, FAIL,
+		     "unable to allocate file space for object header hdr");
    }
 
    /* allocate the object header and fill in header fields */
@@ -145,7 +146,8 @@ H5O_create (H5F_t *f, intn nlink, size_t size_hint, haddr_t *addr/*out*/)
    /* cache it */
    if (H5AC_set (f, H5AC_OHDR, addr, oh)<0) {
       H5MM_xfree (oh);
-      HRETURN_ERROR (H5E_OHDR, H5E_CANTINIT, FAIL);
+      HRETURN_ERROR (H5E_OHDR, H5E_CANTINIT, FAIL,
+		     "unable to cache object header");
    }
 
    FUNC_LEAVE (SUCCEED);
@@ -199,20 +201,23 @@ H5O_load (H5F_t *f, const haddr_t *addr, const void *_udata1, void *_udata2)
    /* read fixed-lenth part of object header */
    hdr_size = H5O_SIZEOF_HDR (f);
    if (H5F_block_read (f, addr, hdr_size, buf)<0) {
-      HGOTO_ERROR (H5E_OHDR, H5E_READERROR, NULL);
+      HGOTO_ERROR (H5E_OHDR, H5E_READERROR, NULL,
+		   "unable to read object header");
    }
    p = buf;
 
    /* decode version */
    oh->version = *p++;
    if (H5O_VERSION!=oh->version) {
-      HGOTO_ERROR (H5E_OHDR, H5E_VERSION, NULL);
+      HGOTO_ERROR (H5E_OHDR, H5E_VERSION, NULL,
+		   "bad object header version number");
    }
 
    /* decode alignment */
    oh->alignment = *p++;
    if (4!=oh->alignment) {
-      HGOTO_ERROR (H5E_OHDR, H5E_ALIGNMENT, NULL);
+      HGOTO_ERROR (H5E_OHDR, H5E_ALIGNMENT, NULL,
+		   "unsupported object header alignment");
    }
 
    /* decode number of messages */
@@ -248,7 +253,8 @@ H5O_load (H5F_t *f, const haddr_t *addr, const void *_udata1, void *_udata2)
       oh->chunk[chunkno].image = H5MM_xmalloc (chunk_size);
       if (H5F_block_read (f, &chunk_addr, chunk_size,
 			  oh->chunk[chunkno].image)<0) {
-	 HGOTO_ERROR (H5E_OHDR, H5E_READERROR, NULL);
+	 HGOTO_ERROR (H5E_OHDR, H5E_READERROR, NULL,
+		      "unable to read object header data");
       }
       
 
@@ -260,10 +266,12 @@ H5O_load (H5F_t *f, const haddr_t *addr, const void *_udata1, void *_udata2)
 	 UINT16DECODE (p, mesg_size);
       
 	 if (id>=NELMTS(message_type_g) || NULL==message_type_g[id]) {
-	    HGOTO_ERROR (H5E_OHDR, H5E_BADMESG, NULL);
+	    HGOTO_ERROR (H5E_OHDR, H5E_BADMESG, NULL,
+			 "corrupt object header");
 	 }
 	 if (p + mesg_size > oh->chunk[chunkno].image + chunk_size) {
-	    HGOTO_ERROR (H5E_OHDR, H5E_CANTINIT, NULL);
+	    HGOTO_ERROR (H5E_OHDR, H5E_CANTINIT, NULL,
+			 "corrupt object header");
 	 }
 
 	 if (H5O_NULL_ID==id && oh->nmesgs>0 &&
@@ -275,7 +283,8 @@ H5O_load (H5F_t *f, const haddr_t *addr, const void *_udata1, void *_udata2)
 	 } else {
 	    /* new message */
 	    if (oh->nmesgs>=nmesgs) {
-	       HGOTO_ERROR (H5E_OHDR, H5E_CANTLOAD, NULL);
+	       HGOTO_ERROR (H5E_OHDR, H5E_CANTLOAD, NULL,
+			    "corrupt object header");
 	    }
 	    mesgno = oh->nmesgs++;
 	    oh->mesg[mesgno].type = message_type_g[id];
@@ -373,7 +382,8 @@ H5O_flush (H5F_t *f, hbool_t destroy, const haddr_t *addr, H5O_t *oh)
 
       /* write the object header header */
       if (H5F_block_write (f, addr, H5O_SIZEOF_HDR(f), buf)<0) {
-	 HRETURN_ERROR (H5E_OHDR, H5E_WRITEERROR, FAIL);
+	 HRETURN_ERROR (H5E_OHDR, H5E_WRITEERROR, FAIL,
+			"unable to write object header hdr to disk");
       }
 
       /* encode messages */
@@ -396,7 +406,9 @@ H5O_flush (H5F_t *f, hbool_t destroy, const haddr_t *addr, H5O_t *oh)
 		  cont->size = oh->chunk[cont->chunkno].size;
 		  if (H5MF_alloc (f, H5MF_META, cont->size,
 				  &(cont->addr)/*out*/)<0) {
-		     HRETURN_ERROR (H5E_RESOURCE, H5E_NOSPACE, FAIL);
+		     HRETURN_ERROR (H5E_RESOURCE, H5E_NOSPACE, FAIL,
+				    "unable to allocate space for object "
+				    "header data");
 		  }
 		  oh->chunk[cont->chunkno].addr = cont->addr;
 	       }
@@ -410,7 +422,8 @@ H5O_flush (H5F_t *f, hbool_t destroy, const haddr_t *addr, H5O_t *oh)
 	       if ((oh->mesg[i].type->encode)(f, oh->mesg[i].raw_size,
 					      oh->mesg[i].raw,
 					      oh->mesg[i].native)<0) {
-		  HRETURN_ERROR (H5E_OHDR, H5E_CANTENCODE, FAIL);
+		  HRETURN_ERROR (H5E_OHDR, H5E_CANTENCODE, FAIL,
+				 "unable to encode object header message");
 	       }
 	    }
 	    oh->mesg[i].dirty = FALSE;
@@ -424,7 +437,8 @@ H5O_flush (H5F_t *f, hbool_t destroy, const haddr_t *addr, H5O_t *oh)
 	    assert (H5F_addr_defined (&(oh->chunk[i].addr)));
 	    if (H5F_block_write (f, &(oh->chunk[i].addr), oh->chunk[i].size,
 				 oh->chunk[i].image)<0) {
-	       HRETURN_ERROR (H5E_OHDR, H5E_WRITEERROR, FAIL);
+	       HRETURN_ERROR (H5E_OHDR, H5E_WRITEERROR, FAIL,
+			      "unable to write object header data to disk");
 	    }
 	    oh->chunk[i].dirty = FALSE;
 	 }
@@ -483,7 +497,8 @@ H5O_reset (const H5O_class_t *type, void *native)
       if (type->reset) {
 	 if ((type->reset)(native)<0) {
 	    /* reset class method failed */
-	    HRETURN_ERROR (H5E_OHDR, H5E_CANTINIT, FAIL);
+	    HRETURN_ERROR (H5E_OHDR, H5E_CANTINIT, FAIL,
+			   "reset method failed");
 	 }
       } else {
 	 HDmemset (native, 0, type->native_size);
@@ -528,13 +543,15 @@ H5O_link (H5F_t *f, H5G_entry_t *ent, intn adjust)
    
    /* get header */
    if (NULL==(oh=H5AC_find (f, H5AC_OHDR, &addr, NULL, NULL))) {
-      HRETURN_ERROR (H5E_OHDR, H5E_CANTLOAD, FAIL);
+      HRETURN_ERROR (H5E_OHDR, H5E_CANTLOAD, FAIL,
+		     "unable to load object header");
    }
 
    /* adjust link count */
    if (adjust<0) {
       if (oh->nlink + adjust < 0) {
-	 HRETURN_ERROR (H5E_OHDR, H5E_LINKCOUNT, FAIL);
+	 HRETURN_ERROR (H5E_OHDR, H5E_LINKCOUNT, FAIL,
+			"link could would be negative");
       }
       oh->nlink += adjust;
       if (1==oh->nlink && ent) {
@@ -589,7 +606,8 @@ H5O_read (H5F_t *f, const haddr_t *addr, H5G_entry_t *ent,
    assert (f);
    if (!addr) {
       if (!ent || H5G_ent_addr (ent, &_addr/*out*/)) {
-	 HRETURN_ERROR (H5E_OHDR, H5E_NOTFOUND, NULL);
+	 HRETURN_ERROR (H5E_OHDR, H5E_NOTFOUND, NULL,
+			"invalid symbol table entry");
       }
       addr = &_addr;
    }
@@ -608,7 +626,8 @@ H5O_read (H5F_t *f, const haddr_t *addr, H5G_entry_t *ent,
 
    /* can we get it from the object header? */
    if ((idx = H5O_find_in_ohdr (f, addr, &type, sequence))<0) {
-      HRETURN_ERROR (H5E_OHDR, H5E_NOTFOUND, NULL);
+      HRETURN_ERROR (H5E_OHDR, H5E_NOTFOUND, NULL,
+		     "unable to find message in object header");
    }
 
 #ifdef LATER
@@ -617,11 +636,15 @@ H5O_read (H5F_t *f, const haddr_t *addr, H5G_entry_t *ent,
 
    /* copy the message to the user-supplied buffer */
    if (NULL==(oh=H5AC_find (f, H5AC_OHDR, addr, NULL, NULL))) {
-      HRETURN_ERROR (H5E_OHDR, H5E_CANTLOAD, NULL);
+      HRETURN_ERROR (H5E_OHDR, H5E_CANTLOAD, NULL,
+		     "unable to load object header");
    }
    retval = (type->copy)(oh->mesg[idx].native, mesg);
-   if (!retval) HRETURN_ERROR (H5E_OHDR, H5E_CANTINIT, NULL);
-
+   if (!retval) {
+      HRETURN_ERROR (H5E_OHDR, H5E_CANTINIT, NULL,
+		     "unable to copy object header message to user space");
+   }
+   
    FUNC_LEAVE (retval);
 }
 
@@ -660,7 +683,8 @@ H5O_find_in_ohdr (H5F_t *f, const haddr_t *addr, const H5O_class_t **type_p,
 
    /* load the object header */
    if (NULL==(oh=H5AC_find (f, H5AC_OHDR, addr, NULL, NULL))) {
-      HRETURN_ERROR (H5E_OHDR, H5E_CANTLOAD, FAIL);
+      HRETURN_ERROR (H5E_OHDR, H5E_CANTLOAD, FAIL,
+		     "unable to load object header");
    }
 
    /* scan through the messages looking for the right one */
@@ -668,7 +692,10 @@ H5O_find_in_ohdr (H5F_t *f, const haddr_t *addr, const H5O_class_t **type_p,
       if (*type_p && (*type_p)->id!=oh->mesg[i].type->id) continue;
       if (--sequence<0) break;
    }
-   if (sequence>=0) HRETURN_ERROR (H5E_OHDR, H5E_NOTFOUND, FAIL);
+   if (sequence>=0) {
+      HRETURN_ERROR (H5E_OHDR, H5E_NOTFOUND, FAIL,
+		     "unable to find object header message");
+   }
    
    /* decode the message if necessary */
    if (NULL==oh->mesg[i].native) {
@@ -677,7 +704,8 @@ H5O_find_in_ohdr (H5F_t *f, const haddr_t *addr, const H5O_class_t **type_p,
 						      oh->mesg[i].raw_size,
 						      oh->mesg[i].raw);
       if (NULL==oh->mesg[i].native) {
-	 HRETURN_ERROR (H5E_OHDR, H5E_CANTDECODE, FAIL);
+	 HRETURN_ERROR (H5E_OHDR, H5E_CANTDECODE, FAIL,
+			"unable to decode message");
       }
    }
 
@@ -725,10 +753,12 @@ H5O_peek (H5F_t *f, const haddr_t *addr, const H5O_class_t *type,
    assert (addr && H5F_addr_defined (addr));
 
    if ((idx = H5O_find_in_ohdr (f, addr, &type, sequence))<0) {
-      HRETURN_ERROR (H5E_OHDR, H5E_NOTFOUND, NULL);
+      HRETURN_ERROR (H5E_OHDR, H5E_NOTFOUND, NULL,
+		     "unable to find object header message");
    }
    if (NULL==(oh=H5AC_find (f, H5AC_OHDR, addr, NULL, NULL))) {
-      HRETURN_ERROR (H5E_OHDR, H5E_CANTLOAD, NULL);
+      HRETURN_ERROR (H5E_OHDR, H5E_CANTLOAD, NULL,
+		     "unable to load object header");
    }
 
    FUNC_LEAVE (oh->mesg[idx].native);
@@ -784,14 +814,16 @@ H5O_modify (H5F_t *f, const haddr_t *addr, H5G_entry_t *ent,
    assert (mesg);
    if (!addr) {
       if (!ent || H5G_ent_addr (ent, &_addr)<0) {
-	 HRETURN_ERROR (H5E_OHDR, H5E_CANTINIT, FAIL);
+	 HRETURN_ERROR (H5E_OHDR, H5E_CANTINIT, FAIL,
+			"invalid object header address");
       }
       addr = &_addr;
    }
    assert (H5F_addr_defined (addr));
    
    if (NULL==(oh=H5AC_find (f, H5AC_OHDR, addr, NULL, NULL))) {
-      HRETURN_ERROR (H5E_OHDR, H5E_CANTLOAD, FAIL);
+      HRETURN_ERROR (H5E_OHDR, H5E_CANTLOAD, FAIL,
+		     "unable to load object header");
    }
 
    /* Count similar messages */
@@ -808,7 +840,7 @@ H5O_modify (H5F_t *f, const haddr_t *addr, H5G_entry_t *ent,
       if (overwrite==sequence+1) {
 	 overwrite = -1;
       } else {
-	 HRETURN_ERROR (H5E_OHDR, H5E_NOTFOUND, FAIL); /*message not found*/
+	 HRETURN_ERROR (H5E_OHDR, H5E_NOTFOUND, FAIL, "message not found");
       }
    }
 
@@ -817,14 +849,18 @@ H5O_modify (H5F_t *f, const haddr_t *addr, H5G_entry_t *ent,
       size = (type->raw_size)(f, mesg);
       H5O_ALIGN (size, oh->alignment);
       idx = H5O_alloc (f, oh, type, size);
-      if (idx<0) HRETURN_ERROR (H5E_OHDR, H5E_CANTINIT, FAIL);
+      if (idx<0) {
+	 HRETURN_ERROR (H5E_OHDR, H5E_CANTINIT, FAIL,
+			"unable to allocate object header space for message");
+      }
       sequence++;
    }
 
    /* Copy the native value into the object header */
    oh->mesg[idx].native = (type->copy)(mesg, oh->mesg[idx].native);
    if (NULL==oh->mesg[idx].native) {
-      HRETURN_ERROR (H5E_OHDR, H5E_CANTINIT, FAIL);
+      HRETURN_ERROR (H5E_OHDR, H5E_CANTINIT, FAIL,
+		     "unable to copy message to object header");
    }
    oh->mesg[idx].dirty = TRUE;
    oh->dirty = TRUE;
@@ -887,7 +923,8 @@ H5O_remove (H5F_t *f, const haddr_t *addr, H5G_entry_t *ent,
    assert (type);
    if (!addr) {
       if (!ent || H5G_ent_addr (ent, &_addr)<0) {
-	 HRETURN_ERROR (H5E_OHDR, H5E_CANTINIT, FAIL);
+	 HRETURN_ERROR (H5E_OHDR, H5E_CANTINIT, FAIL,
+			"invalid object header address");
       }
       addr = &_addr;
    }
@@ -895,7 +932,8 @@ H5O_remove (H5F_t *f, const haddr_t *addr, H5G_entry_t *ent,
 
    /* load the object header */
    if (NULL==(oh=H5AC_find (f, H5AC_OHDR, addr, NULL, NULL))) {
-      HRETURN_ERROR (H5E_OHDR, H5E_CANTLOAD, FAIL);
+      HRETURN_ERROR (H5E_OHDR, H5E_CANTLOAD, FAIL,
+		     "unable to load object header");
    }
 
    for (i=seq=0; i<oh->nmesgs; i++) {
@@ -963,7 +1001,7 @@ H5O_alloc_extend_chunk (H5O_t *oh, intn chunkno, size_t size)
    assert (size>0);
 
    if (H5F_addr_defined (&(oh->chunk[chunkno].addr))) {
-      HRETURN_ERROR (H5E_OHDR, H5E_NOSPACE, FAIL); /*chunk is on disk*/
+      HRETURN_ERROR (H5E_OHDR, H5E_NOSPACE, FAIL, "chunk is on disk");
    }
 
    /* try to extend a null message */
@@ -1269,7 +1307,8 @@ H5O_alloc (H5F_t *f, H5O_t *oh, const H5O_class_t *type, size_t size)
        */
       if (idx<0) {
 	 if ((idx=H5O_alloc_new_chunk (f, oh, size))<0) {
-	    HRETURN_ERROR (H5E_OHDR, H5E_NOSPACE, FAIL);
+	    HRETURN_ERROR (H5E_OHDR, H5E_NOSPACE, FAIL,
+			   "unable to create a new object header data chunk");
 	 }
       }
    }
@@ -1341,7 +1380,8 @@ H5O_debug (H5F_t *f, const haddr_t *addr, FILE *stream, intn indent,
    assert (fwidth>=0);
 
    if (NULL==(oh=H5AC_find (f, H5AC_OHDR, addr, NULL, NULL))) {
-      HRETURN_ERROR (H5E_OHDR, H5E_CANTLOAD, FAIL);
+      HRETURN_ERROR (H5E_OHDR, H5E_CANTLOAD, FAIL,
+		     "unable to load object header");
    }
 
    /* debug */
diff --git a/src/H5Osdtyp.c b/src/H5Odtype.c
index edc4c82..e6f4c03 100644
--- a/src/H5Osdtyp.c
+++ b/src/H5Odtype.c
@@ -124,8 +124,8 @@ H5O_dtype_decode_helper (const uint8 **pp, H5T_t *dt)
 	 dt->u.atomic.u.f.norm = H5T_NORM_IMPLIED;
 	 break;
       default:
-	 /* unknown floating-point normalization */
-	 HRETURN_ERROR (H5E_DATATYPE, H5E_UNSUPPORTED, FAIL);
+	 HRETURN_ERROR (H5E_DATATYPE, H5E_UNSUPPORTED, FAIL,
+			"unknown floating-point normalization");
       }
       dt->u.atomic.u.f.sign = (flags>>8) & 0xff;
       UINT16DECODE (*pp, dt->u.atomic.offset);
@@ -167,16 +167,16 @@ H5O_dtype_decode_helper (const uint8 **pp, H5T_t *dt)
 	     H5T_COMPOUND==dt->u.compnd.memb[i].type.type) {
 	    for (j=0; j<=i; j++) H5MM_xfree (dt->u.compnd.memb[i].name);
 	    H5MM_xfree (dt->u.compnd.memb);
-	    /* Can't decode member type */
-	    HRETURN_ERROR (H5E_DATATYPE, H5E_CANTDECODE, FAIL);
+	    HRETURN_ERROR (H5E_DATATYPE, H5E_CANTDECODE, FAIL,
+			   "can't decode member type");
 	 }
       }
       break;
       
    default:
       if (flags) {
-	 /* class flags are non-zero */
-	 HRETURN_ERROR (H5E_DATATYPE, H5E_UNSUPPORTED, FAIL);
+	 HRETURN_ERROR (H5E_DATATYPE, H5E_UNSUPPORTED, FAIL,
+			"class flags are non-zero");
       }
       break;
    }
@@ -231,8 +231,8 @@ H5O_dtype_encode_helper (uint8 **pp, const H5T_t *dt)
 	 flags |= 0x01;
 	 break;
       default:
-	 /* Byte order is not supported in file format yet */
-	 HRETURN_ERROR (H5E_DATATYPE, H5E_UNSUPPORTED, FAIL);
+	 HRETURN_ERROR (H5E_DATATYPE, H5E_UNSUPPORTED, FAIL,
+			"byte order is not supported in file format yet");
       }
 
       switch (dt->u.atomic.lo_pad) {
@@ -242,8 +242,8 @@ H5O_dtype_encode_helper (uint8 **pp, const H5T_t *dt)
 	 flags |= 0x02;
 	 break;
       default:
-	 /* Bit padding is not supported in file format yet */
-	 HRETURN_ERROR (H5E_DATATYPE, H5E_UNSUPPORTED, FAIL);
+	 HRETURN_ERROR (H5E_DATATYPE, H5E_UNSUPPORTED, FAIL,
+			"bit padding is not supported in file format yet");
       }
       
       switch (dt->u.atomic.hi_pad) {
@@ -253,8 +253,8 @@ H5O_dtype_encode_helper (uint8 **pp, const H5T_t *dt)
 	 flags |= 0x04;
 	 break;
       default:
-	 /* Bit padding is not supported in file format yet */
-	 HRETURN_ERROR (H5E_DATATYPE, H5E_UNSUPPORTED, FAIL);
+	 HRETURN_ERROR (H5E_DATATYPE, H5E_UNSUPPORTED, FAIL,
+			"bit padding is not supported in file format yet");
       }
 
       switch (dt->u.atomic.u.i.sign) {
@@ -264,8 +264,8 @@ H5O_dtype_encode_helper (uint8 **pp, const H5T_t *dt)
 	 flags |= 0x08;
 	 break;
       default:
-	 /* Sign scheme is not supported in file format yet */
-	 HRETURN_ERROR (H5E_DATATYPE, H5E_UNSUPPORTED, FAIL);
+	 HRETURN_ERROR (H5E_DATATYPE, H5E_UNSUPPORTED, FAIL,
+			"sign scheme is not supported in file format yet");
       }
       
       UINT16ENCODE (*pp, dt->u.atomic.offset);
@@ -283,8 +283,8 @@ H5O_dtype_encode_helper (uint8 **pp, const H5T_t *dt)
 	 flags |= 0x01;
 	 break;
       default:
-	 /* Byte order is not supported in file format yet */
-	 HRETURN_ERROR (H5E_DATATYPE, H5E_UNSUPPORTED, FAIL);
+	 HRETURN_ERROR (H5E_DATATYPE, H5E_UNSUPPORTED, FAIL,
+			"byte order is not supported in file format yet");
       }
 
       switch (dt->u.atomic.lo_pad) {
@@ -294,8 +294,8 @@ H5O_dtype_encode_helper (uint8 **pp, const H5T_t *dt)
 	 flags |= 0x02;
 	 break;
       default:
-	 /* Bit padding is not supported in file format yet */
-	 HRETURN_ERROR (H5E_DATATYPE, H5E_UNSUPPORTED, FAIL);
+	 HRETURN_ERROR (H5E_DATATYPE, H5E_UNSUPPORTED, FAIL,
+			"bit padding is not supported in file format yet");
       }
       
       switch (dt->u.atomic.hi_pad) {
@@ -305,8 +305,8 @@ H5O_dtype_encode_helper (uint8 **pp, const H5T_t *dt)
 	 flags |= 0x04;
 	 break;
       default:
-	 /* Bit padding is not supported in file format yet */
-	 HRETURN_ERROR (H5E_DATATYPE, H5E_UNSUPPORTED, FAIL);
+	 HRETURN_ERROR (H5E_DATATYPE, H5E_UNSUPPORTED, FAIL,
+			"bit padding is not supported in file format yet");
       }
       
       switch (dt->u.atomic.u.f.pad) {
@@ -316,8 +316,8 @@ H5O_dtype_encode_helper (uint8 **pp, const H5T_t *dt)
 	 flags |= 0x08;
 	 break;
       default:
-	 /* Bit padding is not supported in file format yet */
-	 HRETURN_ERROR (H5E_DATATYPE, H5E_UNSUPPORTED, FAIL);
+	 HRETURN_ERROR (H5E_DATATYPE, H5E_UNSUPPORTED, FAIL,
+			"bit padding is not supported in file format yet");
       }
 
       switch (dt->u.atomic.u.f.norm) {
@@ -330,8 +330,9 @@ H5O_dtype_encode_helper (uint8 **pp, const H5T_t *dt)
 	 flags |= 0x20;
 	 break;
       default:
-	 /* Normalization scheme is not supported in file format yet */
-	 HRETURN_ERROR (H5E_DATATYPE, H5E_UNSUPPORTED, FAIL);
+	 HRETURN_ERROR (H5E_DATATYPE, H5E_UNSUPPORTED, FAIL,
+			"normalization scheme is not supported in file "
+			"format yet");
       }
 
       flags |= (dt->u.atomic.u.f.sign << 8) & 0xff00;
@@ -369,8 +370,8 @@ H5O_dtype_encode_helper (uint8 **pp, const H5T_t *dt)
 	 }
 	 UINT32ENCODE (*pp, perm_word);
 	 if (H5O_dtype_encode_helper (pp, &(dt->u.compnd.memb[i].type))<0) {
-	    /* Can't encode member type */
-	    HRETURN_ERROR (H5E_DATATYPE, H5E_CANTENCODE, FAIL);
+	    HRETURN_ERROR (H5E_DATATYPE, H5E_CANTENCODE, FAIL,
+			   "can't encode member type");
 	 }
       }
       break;
@@ -422,8 +423,8 @@ H5O_dtype_decode (H5F_t *f, size_t raw_size, const uint8 *p)
 
    if (H5O_dtype_decode_helper (&p, dt)<0) {
       H5MM_xfree (dt);
-      /* can't decode type */
-      HRETURN_ERROR (H5E_DATATYPE, H5E_CANTDECODE, NULL);
+      HRETURN_ERROR (H5E_DATATYPE, H5E_CANTDECODE, NULL,
+		     "can't decode type");
    }
    assert (raw_size==H5O_dtype_size (f, (void*)dt));
    
@@ -462,8 +463,8 @@ H5O_dtype_encode (H5F_t *f, size_t raw_size, uint8 *p, const void *mesg)
 
    /* encode */
    if (H5O_dtype_encode_helper (&p, dt)<0) {
-      /* can't encode type */
-      HRETURN_ERROR (H5E_DATATYPE, H5E_CANTENCODE, FAIL);
+      HRETURN_ERROR (H5E_DATATYPE, H5E_CANTENCODE, FAIL,
+		     "can't encode type");
    }
 
    FUNC_LEAVE (SUCCEED);
@@ -499,7 +500,7 @@ H5O_dtype_copy (const void *_src, void *_dst)
 
    /* copy */
    if (NULL==(dst=H5T_copy (src))) {
-      HRETURN_ERROR (H5E_DATATYPE, H5E_CANTINIT, NULL); /*can't copy type*/
+      HRETURN_ERROR (H5E_DATATYPE, H5E_CANTINIT, NULL, "can't copy type");
    }
    
    /* was result already allocated? */
diff --git a/src/H5Oprivate.h b/src/H5Oprivate.h
index 23086e8..8d00117 100644
--- a/src/H5Oprivate.h
+++ b/src/H5Oprivate.h
@@ -93,7 +93,7 @@ typedef struct H5O_t {
 extern const H5O_class_t H5O_NULL[1];
 
 /*
- * Simple Dimensionality Message.
+ * Simple Data Space Message.
  */
 #define H5O_SDSPACE_ID	0x0001
 extern const H5O_class_t H5O_SDSPACE[1];
diff --git a/src/H5Osdim.c b/src/H5Osdspace.c
index 3bc1e04..3bc1e04 100644
--- a/src/H5Osdim.c
+++ b/src/H5Osdspace.c
diff --git a/src/H5P.c b/src/H5P.c
index 243cff1..5171c01 100644
--- a/src/H5P.c
+++ b/src/H5P.c
@@ -124,17 +124,18 @@ H5Pcreate (H5P_class_t type)
       break;
 
    case H5P_COMPLEX:
-      /* Complex types are not supported yet */
-      HGOTO_ERROR (H5E_DATASPACE, H5E_UNSUPPORTED, FAIL);
+      HGOTO_ERROR (H5E_DATASPACE, H5E_UNSUPPORTED, FAIL,
+		   "complex types are not supported yet");
 
    default:
-      /* Unknown data space type */
-      HGOTO_ERROR (H5E_ARGS, H5E_BADTYPE, FAIL);
+      HGOTO_ERROR (H5E_ARGS, H5E_BADTYPE, FAIL,
+		   "unknown data space type");
    }
 
    /* Register the new data space and get an ID for it */
    if ((ret_value = H5Aregister_atom (H5_DATASPACE, ds))<0) {
-      HGOTO_ERROR (H5E_ATOM, H5E_CANTREGISTER, FAIL);
+      HGOTO_ERROR (H5E_ATOM, H5E_CANTREGISTER, FAIL,
+		   "unable to register data space for ID");
    }
 
  done:
@@ -173,12 +174,12 @@ H5Pclose (hid_t space_id)
    /* check args */
    if (H5_DATASPACE!=H5Aatom_group (space_id) ||
        NULL==H5Aatom_object (space_id)) {
-      HRETURN_ERROR (H5E_ARGS, H5E_BADTYPE, FAIL); /*not a data space*/
+      HRETURN_ERROR (H5E_ARGS, H5E_BADTYPE, FAIL, "not a data space");
    }
    
    /* When the reference count reaches zero the resources are freed */
    if (H5A_dec_ref (space_id)<0) {
-      HRETURN_ERROR (H5E_ATOM, H5E_BADATOM, FAIL); /*problem freeing id*/
+      HRETURN_ERROR (H5E_ATOM, H5E_BADATOM, FAIL, "problem freeing id");
    }
 
    FUNC_LEAVE (SUCCEED);
@@ -327,7 +328,7 @@ H5Pget_npoints (hid_t space_id)
    /* check args */
    if (H5_DATASPACE!=H5Aatom_group (space_id) ||
        NULL==(ds=H5Aatom_object (space_id))) {
-      HRETURN_ERROR (H5E_ARGS, H5E_BADTYPE, 0); /*not a data space*/
+      HRETURN_ERROR (H5E_ARGS, H5E_BADTYPE, 0, "not a data space");
    }
 
    ret_value = H5P_get_npoints (ds);
@@ -375,12 +376,13 @@ H5P_get_npoints (const H5P_t *ds)
       break;
 
    case H5P_COMPLEX:
-      /* complex data spaces are not supported yet */
-      HRETURN_ERROR (H5E_DATASPACE, H5E_UNSUPPORTED, 0);
+      HRETURN_ERROR (H5E_DATASPACE, H5E_UNSUPPORTED, 0,
+		     "complex data spaces are not supported yet");
 
    default:
       assert ("unknown data space class" && 0);
-      HRETURN_ERROR (H5E_DATASPACE, H5E_UNSUPPORTED, 0);
+      HRETURN_ERROR (H5E_DATASPACE, H5E_UNSUPPORTED, 0,
+		     "internal error (unknown data space class)");
    }
 
    FUNC_LEAVE (ret_value);
@@ -415,7 +417,7 @@ H5Pget_ndims (hid_t space_id)
    /* check args */
    if (H5_DATASPACE!=H5Aatom_group (space_id) ||
        NULL==(ds=H5Aatom_object (space_id))) {
-      HRETURN_ERROR (H5E_ARGS, H5E_BADTYPE, FAIL); /*not a data space*/
+      HRETURN_ERROR (H5E_ARGS, H5E_BADTYPE, FAIL, "not a data space");
    }
 
    ret_value = H5P_get_ndims (ds);
@@ -461,12 +463,13 @@ H5P_get_ndims (const H5P_t *ds)
       break;
 
    case H5P_COMPLEX:
-      /* complex data spaces are not supported yet */
-      HRETURN_ERROR (H5E_DATASPACE, H5E_UNSUPPORTED, FAIL);
+      HRETURN_ERROR (H5E_DATASPACE, H5E_UNSUPPORTED, FAIL,
+		     "complex data spaces are not supported yet");
 
    default:
       assert ("unknown data space class" && 0);
-      HRETURN_ERROR (H5E_DATASPACE, H5E_UNSUPPORTED, FAIL);
+      HRETURN_ERROR (H5E_DATASPACE, H5E_UNSUPPORTED, FAIL,
+		     "internal error (unknown data space class)");
    }
 
    FUNC_LEAVE (ret_value);
@@ -504,10 +507,10 @@ H5Pget_dims (hid_t space_id, size_t dims[]/*out*/)
    /* check args */
    if (H5_DATASPACE!=H5Aatom_group (space_id) ||
        NULL==(ds=H5Aatom_object (space_id))) {
-      HRETURN_ERROR (H5E_ARGS, H5E_BADTYPE, FAIL); /*not a data space*/
+      HRETURN_ERROR (H5E_ARGS, H5E_BADTYPE, FAIL, "not a data space");
    }
    if (!dims) {
-      HRETURN_ERROR (H5E_ARGS, H5E_BADVALUE, FAIL); /*no output buffer*/
+      HRETURN_ERROR (H5E_ARGS, H5E_BADVALUE, FAIL, "no output buffer");
    }
    
 
@@ -559,12 +562,13 @@ H5P_get_dims (const H5P_t *ds, size_t dims[])
       break;
 
    case H5P_COMPLEX:
-      /* complex data spaces are not supported yet */
-      HRETURN_ERROR (H5E_DATASPACE, H5E_UNSUPPORTED, FAIL);
+      HRETURN_ERROR (H5E_DATASPACE, H5E_UNSUPPORTED, FAIL,
+		     "complex data spaces are not supported yet");
 
    default:
       assert ("unknown data space class" && 0);
-      HRETURN_ERROR (H5E_DATASPACE, H5E_UNSUPPORTED, FAIL);
+      HRETURN_ERROR (H5E_DATASPACE, H5E_UNSUPPORTED, FAIL,
+		     "internal error (unknown data space class)");
    }
 
    FUNC_LEAVE (ret_value);
@@ -599,19 +603,19 @@ H5P_modify (H5F_t *f, H5G_entry_t *ent, const H5P_t *ds)
 
    switch (ds->type) {
    case H5P_SCALAR:
-      /* Scalar data spaces are not implemented yet */
-      HRETURN_ERROR (H5E_DATASPACE, H5E_UNSUPPORTED, FAIL);
+      HRETURN_ERROR (H5E_DATASPACE, H5E_UNSUPPORTED, FAIL,
+		     "scalar data spaces are not implemented yet");
 
    case H5P_SIMPLE:
       if (H5O_modify (f, NO_ADDR, ent, H5O_SDSPACE, 0, &(ds->u.simple))<0) {
-	 /* Can't update simple data space message */
-	 HRETURN_ERROR (H5E_DATASPACE, H5E_CANTINIT, FAIL);
+	 HRETURN_ERROR (H5E_DATASPACE, H5E_CANTINIT, FAIL,
+			"can't update simple data space message");
       }
       break;
 
    case H5P_COMPLEX:
-      /* Complex data spaces are not implemented yet */
-      HRETURN_ERROR (H5E_DATASPACE, H5E_UNSUPPORTED, FAIL);
+      HRETURN_ERROR (H5E_DATASPACE, H5E_UNSUPPORTED, FAIL,
+		     "complex data spaces are not implemented yet");
 
    default:
       assert ("unknown data space class" && 0);
@@ -783,7 +787,7 @@ hbool_t H5Pis_simple(hid_t sid)
     H5ECLEAR;
 
     if((space=H5Aatom_object(sid))==NULL)
-        HGOTO_ERROR(H5E_ATOM, H5E_BADATOM, FAIL);
+        HGOTO_ERROR(H5E_ATOM, H5E_BADATOM, FAIL, "not a data space");
 
     ret_value=H5P_is_simple(space);
 
@@ -832,9 +836,9 @@ herr_t H5Pset_space(hid_t sid, intn rank, const intn *dims)
 
     /* Get the object */
     if((space=H5Aatom_object(sid))==NULL)
-        HGOTO_ERROR(H5E_ATOM, H5E_BADATOM, FAIL);
+        HGOTO_ERROR(H5E_ATOM, H5E_BADATOM, FAIL, "not a data space");
     if(rank>0 && dims==NULL)
-        HGOTO_ERROR(H5E_ARGS, H5E_BADVALUE, FAIL);
+        HGOTO_ERROR(H5E_ARGS, H5E_BADVALUE, FAIL, "invalid rank");
 
     /* shift out of the previous state to a "simple" dataspace */
     switch(space->type)
@@ -851,7 +855,8 @@ herr_t H5Pset_space(hid_t sid, intn rank, const intn *dims)
             /* Fall through to report error */
 
         default:
-            HGOTO_ERROR(H5E_DATASPACE, H5E_BADVALUE, FAIL);
+            HGOTO_ERROR(H5E_DATASPACE, H5E_BADVALUE, FAIL,
+			"unknown data space class");
       } /* end switch */
     space->type=H5P_SIMPLE;
 
@@ -881,18 +886,18 @@ herr_t H5Pset_space(hid_t sid, intn rank, const intn *dims)
 
         /* Set the rank and copy the dims */
         space->u.simple.rank=rank;
-        if((space->u.simple.size=HDcalloc(sizeof(intn),rank))==NULL)
-            HGOTO_ERROR(H5E_RESOURCE, H5E_NOSPACE, FAIL);
+        space->u.simple.size = H5MM_xcalloc (sizeof(intn), rank);
         HDmemcpy(space->u.simple.size,dims,sizeof(intn)*rank);
 
         /* check if there are unlimited dimensions and create the maximum dims array */
         for(u=0; u<rank; u++)
             if(dims[u]==0)
               {
-                if(u>0) /* sanity check for unlimited dimensions not in the lowest dimensionality */
-                    HGOTO_ERROR(H5E_DATASPACE, H5E_UNSUPPORTED, FAIL);
-                if((space->u.simple.max=HDcalloc(sizeof(intn),rank))==NULL)
-                    HGOTO_ERROR(H5E_RESOURCE, H5E_NOSPACE, FAIL);
+                if(u>0)
+		   HGOTO_ERROR(H5E_DATASPACE, H5E_UNSUPPORTED, FAIL, 
+			       "unlimited dimensions not in the lowest "
+			       "dimensionality");
+                space->u.simple.max = H5MM_xcalloc (sizeof(intn),rank);
                 HDmemcpy(space->u.simple.max,dims,sizeof(intn)*rank);
                 space->u.simple.dim_flags|=H5P_VALID_MAX;
                 break;
diff --git a/src/H5T.c b/src/H5T.c
index cc19d1a..2618f14 100644
--- a/src/H5T.c
+++ b/src/H5T.c
@@ -120,18 +120,18 @@ H5Tcreate (H5T_class_t type, size_t size)
 
    /* check args */
    if (size<=0) {
-      HRETURN_ERROR (H5E_ARGS, H5E_BADVALUE, FAIL); /*invalid size*/
+      HRETURN_ERROR (H5E_ARGS, H5E_BADVALUE, FAIL, "invalid size");
    }
    
    /* create the type */
    if (NULL==(dt=H5T_create (type, size))) {
-      HRETURN_ERROR (H5E_DATATYPE, H5E_CANTINIT, FAIL);/*can't create type*/
+      HRETURN_ERROR (H5E_DATATYPE, H5E_CANTINIT, FAIL, "can't create type");
    }
    
    /* Make it an atom */
    if ((ret_value=H5Aregister_atom (H5_DATATYPE, dt))<0) {
-      /* Can't register data type atom */
-      HRETURN_ERROR (H5E_DATATYPE, H5E_CANTREGISTER, FAIL);
+      HRETURN_ERROR (H5E_DATATYPE, H5E_CANTREGISTER, FAIL,
+		     "can't register data type atom");
    }
 
    FUNC_LEAVE (ret_value);
@@ -169,16 +169,16 @@ H5T_create (H5T_class_t type, size_t size)
    case H5T_FIXED:
       /* Default type is a native `int' */
       if (NULL==(dt=H5T_copy (H5Aatom_object (H5T_NATIVE_INT)))) {
-	 /* Can't derive type from native int */
-	 HRETURN_ERROR (H5E_DATATYPE, H5E_CANTINIT, NULL);
+	 HRETURN_ERROR (H5E_DATATYPE, H5E_CANTINIT, NULL,
+			"can't derive type from native int");
       }
       break;
 
    case H5T_FLOAT:
       /* Default type is a native `double' */
       if (NULL==(dt=H5T_copy (H5Aatom_object (H5T_NATIVE_DOUBLE)))) {
-	 /* Can't derive type from native double */
-	 HRETURN_ERROR (H5E_DATATYPE, H5E_CANTINIT, NULL);
+	 HRETURN_ERROR (H5E_DATATYPE, H5E_CANTINIT, NULL,
+			"can't derive type from native double");
       }
       break;
 
@@ -187,7 +187,8 @@ H5T_create (H5T_class_t type, size_t size)
    case H5T_BITFIELD:
    case H5T_OPAQUE:
       assert ("not implemented yet" && 0);
-      HRETURN_ERROR (H5E_DATATYPE, H5E_UNSUPPORTED, NULL);
+      HRETURN_ERROR (H5E_DATATYPE, H5E_UNSUPPORTED, NULL,
+		     "not implemented yet");
 
    case H5T_COMPOUND:
       dt = H5MM_xcalloc (1, sizeof(H5T_t));
@@ -195,8 +196,8 @@ H5T_create (H5T_class_t type, size_t size)
       break;
 
    default:
-      /* Unknown data type class */
-      HRETURN_ERROR (H5E_INTERNAL, H5E_UNSUPPORTED, NULL);
+      HRETURN_ERROR (H5E_INTERNAL, H5E_UNSUPPORTED, NULL,
+		     "unknown data type class");
    }
 
    dt->size = size;
@@ -236,7 +237,7 @@ H5Tget_num_members (hid_t type_id)
    if (H5_DATATYPE!=H5Aatom_group (type_id) ||
        NULL==(dt=H5Aatom_object (type_id)) ||
        H5T_COMPOUND!=dt->type) {
-      HRETURN_ERROR (H5E_ARGS, H5E_BADTYPE, FAIL); /*not a compound data type*/
+      HRETURN_ERROR (H5E_ARGS, H5E_BADTYPE, FAIL, "not a compound data type");
    }
 
    FUNC_LEAVE (dt->u.compnd.nmembs);
@@ -271,7 +272,7 @@ H5Tget_class (hid_t type_id)
    /* Check args */
    if (H5_DATATYPE!=H5Aatom_group (type_id) ||
        NULL==(dt=H5Aatom_object (type_id))) {
-      HRETURN_ERROR (H5E_ARGS, H5E_BADTYPE, FAIL); /*not a data type*/
+      HRETURN_ERROR (H5E_ARGS, H5E_BADTYPE, FAIL, "not a data type");
    }
 
    FUNC_LEAVE (dt->type);
@@ -309,7 +310,7 @@ H5Tget_size (hid_t type_id)
    /* Check args */
    if (H5_DATATYPE!=H5Aatom_group (type_id) ||
        NULL==(dt=H5Aatom_object (type_id))) {
-      HRETURN_ERROR (H5E_ARGS, H5E_BADTYPE, FAIL); /*not a data type*/
+      HRETURN_ERROR (H5E_ARGS, H5E_BADTYPE, FAIL, "not a data type");
    }
 
    /* size */
@@ -391,23 +392,23 @@ H5Tinsert_member (hid_t parent_id, const char *name, off_t offset,
    if (H5_DATATYPE!=H5Aatom_group (parent_id) ||
        NULL==(parent=H5Aatom_object (parent_id)) ||
        H5T_COMPOUND!=parent->type) {
-      HRETURN_ERROR (H5E_ARGS, H5E_BADTYPE, FAIL); /*not a compound data type*/
+      HRETURN_ERROR (H5E_ARGS, H5E_BADTYPE, FAIL, "not a compound data type");
    }
    if (parent->locked) {
-      HRETURN_ERROR (H5E_ARGS, H5E_BADVALUE, FAIL); /*parent is locked*/
+      HRETURN_ERROR (H5E_ARGS, H5E_BADVALUE, FAIL, "parent is locked");
    }
    if (!name || !*name) {
-      HRETURN_ERROR (H5E_ARGS, H5E_BADVALUE, FAIL); /*no member name*/
+      HRETURN_ERROR (H5E_ARGS, H5E_BADVALUE, FAIL, "no member name");
    }
    if (H5_DATATYPE!=H5Aatom_group (member_id) ||
        NULL==(member=H5Aatom_object (member_id)) ||
        H5T_COMPOUND==member->type) {
-      HRETURN_ERROR (H5E_ARGS, H5E_BADTYPE, FAIL); /*not an atomic data type*/
+      HRETURN_ERROR (H5E_ARGS, H5E_BADTYPE, FAIL, "not an atomic data type");
    }
 
    if (H5T_insert_member (parent, name, offset, member)<0) {
-      /* Can't insert member. */
-      HRETURN_ERROR (H5E_DATATYPE, H5E_CANTINSERT, FAIL);
+      HRETURN_ERROR (H5E_DATATYPE, H5E_CANTINSERT, FAIL,
+		     "can't insert member");
    }
 
    FUNC_LEAVE (SUCCEED);
@@ -451,8 +452,8 @@ H5T_insert_member (H5T_t *parent, const char *name, off_t offset,
    /* Does NAME already exist in PARENT? */
    for (i=0; i<parent->u.compnd.nmembs; i++) {
       if (!HDstrcmp (parent->u.compnd.memb[i].name, name)) {
-	 /* Member name is not unique */
-	 HRETURN_ERROR (H5E_DATATYPE, H5E_CANTINSERT, FAIL);
+	 HRETURN_ERROR (H5E_DATATYPE, H5E_CANTINSERT, FAIL,
+			"member name is not unique");
       }
    }
 
@@ -507,19 +508,19 @@ H5Tcopy (hid_t type_id)
    /* check args */
    if (H5_DATATYPE!=H5Aatom_group (type_id) ||
        NULL==(dt=H5Aatom_object (type_id))) {
-      HRETURN_ERROR (H5E_ARGS, H5E_BADTYPE, FAIL); /*not a data type*/
+      HRETURN_ERROR (H5E_ARGS, H5E_BADTYPE, FAIL, "not a data type");
    }
 
    /* copy */
    if (NULL==(new_dt = H5T_copy (dt))) {
-      HRETURN_ERROR (H5E_DATATYPE, H5E_CANTINIT, FAIL); /*can't copy*/
+      HRETURN_ERROR (H5E_DATATYPE, H5E_CANTINIT, FAIL, "can't copy");
    }
 
    /* atomize result */
    if ((ret_value=H5Aregister_atom (H5_DATATYPE, new_dt))<0) {
       H5T_close (new_dt);
-      /* Can't register data type atom */
-      HRETURN_ERROR (H5E_DATATYPE, H5E_CANTREGISTER, FAIL);
+      HRETURN_ERROR (H5E_DATATYPE, H5E_CANTREGISTER, FAIL,
+		     "can't register data type atom");
    }
 
    FUNC_LEAVE (ret_value);
@@ -602,15 +603,15 @@ H5Tclose (hid_t type_id)
    /* check args */
    if (H5_DATATYPE!=H5Aatom_group (type_id) ||
        NULL==(dt=H5Aatom_object (type_id))) {
-      HRETURN_ERROR (H5E_ARGS, H5E_BADTYPE, FAIL); /*not a data type*/
+      HRETURN_ERROR (H5E_ARGS, H5E_BADTYPE, FAIL, "not a data type");
    }
    if (dt->locked) {
-      HRETURN_ERROR (H5E_ARGS, H5E_BADVALUE, FAIL); /*predefined data type*/
+      HRETURN_ERROR (H5E_ARGS, H5E_BADVALUE, FAIL, "predefined data type");
    }
 
    /* When the reference count reaches zero the resources are freed */
    if (H5A_dec_ref (type_id)<0) {
-      HRETURN_ERROR (H5E_ATOM, H5E_BADATOM, FAIL); /*problem freeing id*/
+      HRETURN_ERROR (H5E_ATOM, H5E_BADATOM, FAIL, "problem freeing id");
    }
 
    FUNC_LEAVE (SUCCEED);
@@ -691,7 +692,7 @@ H5Tequal (hid_t type1_id, hid_t type2_id)
        NULL==(dt1=H5Aatom_object (type1_id)) ||
        H5_DATATYPE!=H5Aatom_group (type2_id) ||
        NULL==(dt2=H5Aatom_object (type2_id))) {
-      HRETURN_ERROR (H5E_ARGS, H5E_BADTYPE, FAIL); /*not a data type*/
+      HRETURN_ERROR (H5E_ARGS, H5E_BADTYPE, FAIL, "not a data type");
    }
 
    ret_value = (0==H5T_cmp (dt1, dt2));
diff --git a/src/H5detect.c b/src/H5detect.c
index 18a8d60..be77339 100644
--- a/src/H5detect.c
+++ b/src/H5detect.c
@@ -351,8 +351,9 @@ H5T_init (void)\n\
       /* Atomize the type */
       printf ("\
    if ((H5T_NATIVE_%s = H5Aregister_atom (H5_DATATYPE, dt))<0) {\n\
-      /* Can't initialize type system - atom registration failure */\n\
-      HRETURN_ERROR (H5E_DATATYPE, H5E_CANTINIT, FAIL);\n\
+      HRETURN_ERROR (H5E_DATATYPE, H5E_CANTINIT, FAIL,\n\
+                     \"can't initialize type system (atom registration \"\n\
+                     \"failure\");\n\
    }\n", 
 	      d[i].varname);
       
diff --git a/src/H5private.h b/src/H5private.h
index aaf2bf9..6972ebf 100644
--- a/src/H5private.h
+++ b/src/H5private.h
@@ -424,14 +424,16 @@ extern hbool_t thread_initialize_g; /*don't decl interface_initialize_g */
    if (!library_initialize_g) {						      \
       library_initialize_g = TRUE;					      \
       if (H5_init_library()<0) {					      \
-	 HRETURN_ERROR (H5E_FUNC, H5E_CANTINIT, err);			      \
+	 HRETURN_ERROR (H5E_FUNC, H5E_CANTINIT, err,			      \
+			"library initialization failed");		      \
       }									      \
    }									      \
 									      \
    if (!thread_initialize_g) {						      \
       thread_initialize_g = TRUE;					      \
       if (H5_init_thread()<0) {						      \
-	 HRETURN_ERROR (H5E_FUNC, H5E_CANTINIT, err);			      \
+	 HRETURN_ERROR (H5E_FUNC, H5E_CANTINIT, err, 			      \
+			"thread initialization failed");		      \
       }									      \
    }									      \
       									      \
@@ -439,7 +441,8 @@ extern hbool_t thread_initialize_g; /*don't decl interface_initialize_g */
       interface_initialize_g = TRUE;					      \
       if (interface_init_func &&					      \
 	  ((herr_t(*)(void))interface_init_func)()<0) {			      \
-	 HRETURN_ERROR (H5E_FUNC, H5E_CANTINIT, err);			      \
+	 HRETURN_ERROR (H5E_FUNC, H5E_CANTINIT, err, 			      \
+			"interface initialization failed");		      \
       }									      \
    }									      \
    {
diff --git a/src/Makefile.in b/src/Makefile.in
index 33485cd..16086f2 100644
--- a/src/Makefile.in
+++ b/src/Makefile.in
@@ -17,8 +17,9 @@ PROGS=debug
 LIB_SRC=H5.c H5A.c H5AC.c H5B.c H5C.c H5D.c H5Dconv.c H5E.c H5F.c H5Fcore.c   \
         H5Ffamily.c H5Fistore.c H5Flow.c H5Fsec2.c H5Fsplit.c H5Fstdio.c      \
         H5G.c H5Gent.c H5Gnode.c H5Gshad.c H5Gstab.c H5H.c H5M.c H5MF.c       \
-        H5MM.c H5O.c H5Ocont.c H5Ocstore.c H5Oefl.c H5Oistore.c H5Oname.c     \
-	H5Onull.c H5Osdtyp.c H5Osdim.c H5Ostab.c H5P.c H5T.c H5Tinit.c H5V.c
+        H5MM.c H5O.c H5Ocont.c H5Ocstore.c H5Odtype.c H5Oefl.c H5Oistore.c    \
+        H5Oname.c H5Onull.c H5Osdspace.c H5Ostab.c H5P.c H5T.c H5Tinit.c      \
+        H5V.c
 
 LIB_OBJ=$(LIB_SRC:.c=.o)