[svn-r28616] Normalization of H5HL package with revise_chunks.

NOTE: Flush dependency code was not moved.

Tested on:
    Ubuntu 15.10 (Linux 4.2.0 x86_64) gcc 5.2.1 w/ CMake 3.3.2
    serial only (Autotools and CMake since new files were added)
    (these changes have been in revise_chunks for a long time)

1 files changed, 358 insertions, 512 deletions

diff --git a/src/H5HL.c b/src/H5HL.c
index 80603dd..8c6fd3e 100644
--- a/src/H5HL.c
+++ b/src/H5HL.c
@@ -15,12 +15,12 @@
 
 /*-------------------------------------------------------------------------
  *
- * Created:		H5HL.c
- *			Jul 16 1997
- *			Robb Matzke <matzke@llnl.gov>
+ * Created:         H5HL.c
+ *                  Jul 16 1997
+ *                  Robb Matzke <matzke@llnl.gov>
  *
- * Purpose:		Heap functions for the local heaps used by symbol
- *			tables to store names (among other things).
+ * Purpose:         Heap functions for the local heaps used by symbol
+ *                  tables to store names (among other things).
  *
  *-------------------------------------------------------------------------
  */
@@ -35,18 +35,18 @@
 /***********/
 /* Headers */
 /***********/
-#include "H5private.h"		/* Generic Functions			*/
-#include "H5Eprivate.h"		/* Error handling		  	*/
-#include "H5Fprivate.h"         /* File access				*/
-#include "H5HLpkg.h"		/* Local Heaps				*/
-#include "H5MFprivate.h"	/* File memory management		*/
+#include "H5private.h"      /* Generic Functions        */
+#include "H5Eprivate.h"     /* Error handling           */
+#include "H5Fprivate.h"     /* File access              */
+#include "H5HLpkg.h"        /* Local Heaps              */
+#include "H5MFprivate.h"    /* File memory management   */
 
 
 /****************/
 /* Local Macros */
 /****************/
 
-#define H5HL_MIN_HEAP   128             /* Minimum size to reduce heap buffer to */
+#define H5HL_MIN_HEAP   128     /* Minimum size to reduce heap buffer to */
 
 
 /******************/
@@ -63,8 +63,9 @@
 /* Local Prototypes */
 /********************/
 
-static H5HL_free_t *H5HL_remove_free(H5HL_t *heap, H5HL_free_t *fl);
-static herr_t H5HL_minimize_heap_space(H5F_t *f, hid_t dxpl_id, H5HL_t *heap);
+static H5HL_free_t *H5HL__remove_free(H5HL_t *heap, H5HL_free_t *fl);
+static herr_t H5HL__minimize_heap_space(H5F_t *f, hid_t dxpl_id, H5HL_t *heap);
+static herr_t H5HL__dirty(H5HL_t *heap);
 
 
 /*********************/
@@ -93,7 +94,7 @@ H5FL_BLK_DEFINE(lheap_chunk);
 
 
 /*-------------------------------------------------------------------------
- * Function:	H5HL_create
+ * Function:    H5HL_create
  *
  * Purpose:	Creates a new heap data structure on disk and caches it
  *		in memory.  SIZE_HINT is a hint for the initial size of the
@@ -102,26 +103,22 @@ H5FL_BLK_DEFINE(lheap_chunk);
  *		If the heap ever has to grow, then REALLOC_HINT is the
  *		minimum amount by which the heap will grow.
  *
- * Return:	Success:	Non-negative. The file address of new heap is
- *				returned through the ADDR argument.
+ * Return:      Success:    SUCCEED. The file address of new heap is
+ *                          returned through the ADDR argument.
+ *              Failure:    FAIL.  addr_p will be HADDR_UNDEF.
  *
- *		Failure:	Negative
- *
- * Programmer:	Robb Matzke
- *		matzke@llnl.gov
- *		Jul 16 1997
+ * Programmer:  Robb Matzke
+ *              Jul 16 1997
  *
  *-------------------------------------------------------------------------
  */
-herr_t
-H5HL_create(H5F_t *f, hid_t dxpl_id, size_t size_hint, haddr_t *addr_p/*out*/)
-{
-    H5HL_t	*heap = NULL;           /* Heap created */
-    H5HL_prfx_t *prfx = NULL;           /* Heap prefix */
-    hsize_t	total_size = 0;		/* Total heap size on disk */
-    herr_t	ret_value = SUCCEED;    /* Return value */
+BEGIN_FUNC(PRIV, ERR,
+herr_t, SUCCEED, FAIL,
+H5HL_create(H5F_t *f, hid_t dxpl_id, size_t size_hint, haddr_t *addr_p/*out*/))
 
-    FUNC_ENTER_NOAPI(FAIL)
+    H5HL_t      *heap = NULL;           /* Heap created                 */
+    H5HL_prfx_t *prfx = NULL;           /* Heap prefix                  */
+    hsize_t     total_size = 0;         /* Total heap size on disk      */
 
     /* check arguments */
     HDassert(f);
@@ -129,17 +126,17 @@ H5HL_create(H5F_t *f, hid_t dxpl_id, size_t size_hint, haddr_t *addr_p/*out*/)
 
     /* Adjust size hint as necessary */
     if(size_hint && size_hint < H5HL_SIZEOF_FREE(f))
-	size_hint = H5HL_SIZEOF_FREE(f);
+        size_hint = H5HL_SIZEOF_FREE(f);
     size_hint = H5HL_ALIGN(size_hint);
 
     /* Allocate new heap structure */
-    if(NULL == (heap = H5HL_new(H5F_SIZEOF_SIZE(f), H5F_SIZEOF_ADDR(f), H5HL_SIZEOF_HDR(f))))
-	HGOTO_ERROR(H5E_HEAP, H5E_CANTALLOC, FAIL, "can't allocate new heap struct")
+    if(NULL == (heap = H5HL__new(H5F_SIZEOF_SIZE(f), H5F_SIZEOF_ADDR(f), H5HL_SIZEOF_HDR(f))))
+        H5E_THROW(H5E_CANTALLOC, "can't allocate new heap struct");
 
     /* Allocate file space */
     total_size = heap->prfx_size + size_hint;
     if(HADDR_UNDEF == (heap->prfx_addr = H5MF_alloc(f, H5FD_MEM_LHEAP, dxpl_id, total_size)))
-	HGOTO_ERROR(H5E_HEAP, H5E_CANTALLOC, FAIL, "unable to allocate file memory")
+        H5E_THROW(H5E_CANTALLOC, "unable to allocate file memory");
 
     /* Initialize info */
     heap->single_cache_obj = TRUE;
@@ -147,188 +144,72 @@ H5HL_create(H5F_t *f, hid_t dxpl_id, size_t size_hint, haddr_t *addr_p/*out*/)
     heap->dblk_size = size_hint;
     if(size_hint)
         if(NULL == (heap->dblk_image = H5FL_BLK_CALLOC(lheap_chunk, size_hint)))
-            HGOTO_ERROR(H5E_HEAP, H5E_CANTALLOC, FAIL, "memory allocation failed")
+            H5E_THROW(H5E_CANTALLOC, "memory allocation failed");
 
     /* free list */
     if(size_hint) {
-	if(NULL == (heap->freelist = H5FL_MALLOC(H5HL_free_t)))
-	    HGOTO_ERROR(H5E_HEAP, H5E_CANTALLOC, FAIL, "memory allocation failed")
-	heap->freelist->offset = 0;
-	heap->freelist->size = size_hint;
-	heap->freelist->prev = heap->freelist->next = NULL;
+        if(NULL == (heap->freelist = H5FL_MALLOC(H5HL_free_t)))
+            H5E_THROW(H5E_CANTALLOC, "memory allocation failed");
+        heap->freelist->offset = 0;
+        heap->freelist->size = size_hint;
+        heap->freelist->prev = heap->freelist->next = NULL;
         heap->free_block = 0;
     } /* end if */
     else {
-	heap->freelist = NULL;
+        heap->freelist = NULL;
         heap->free_block = H5HL_FREE_NULL;
     } /* end else */
 
     /* Allocate the heap prefix */
-    if(NULL == (prfx = H5HL_prfx_new(heap)))
-	HGOTO_ERROR(H5E_HEAP, H5E_CANTALLOC, FAIL, "memory allocation failed")
+    if(NULL == (prfx = H5HL__prfx_new(heap)))
+        H5E_THROW(H5E_CANTALLOC, "memory allocation failed");
 
     /* Add to cache */
-    if(H5AC_insert_entry(f, dxpl_id, H5AC_LHEAP_PRFX, heap->prfx_addr, prfx, H5AC__NO_FLAGS_SET) < 0)
-	HGOTO_ERROR(H5E_HEAP, H5E_CANTINIT, FAIL, "unable to cache local heap prefix")
+    if(FAIL == H5AC_insert_entry(f, dxpl_id, H5AC_LHEAP_PRFX, heap->prfx_addr, prfx, H5AC__NO_FLAGS_SET))
+        H5E_THROW(H5E_CANTINIT, "unable to cache local heap prefix");
 
     /* Set address to return */
     *addr_p = heap->prfx_addr;
 
-done:
+CATCH
     if(ret_value < 0) {
+        *addr_p = HADDR_UNDEF;
         if(prfx) {
-            if(H5HL_prfx_dest(prfx) < 0)
-                HDONE_ERROR(H5E_HEAP, H5E_CANTFREE, FAIL, "unable to destroy local heap prefix")
+            if(FAIL == H5HL__prfx_dest(prfx))
+                H5E_THROW(H5E_CANTFREE, "unable to destroy local heap prefix");
         } /* end if */
         else {
             if(heap) {
                 if(H5F_addr_defined(heap->prfx_addr))
-                    if(H5MF_xfree(f, H5FD_MEM_LHEAP, dxpl_id, heap->prfx_addr, total_size) < 0)
-                        HDONE_ERROR(H5E_HEAP, H5E_CANTFREE, FAIL, "can't release heap data?")
-                if(H5HL_dest(heap) < 0)
-                    HDONE_ERROR(H5E_HEAP, H5E_CANTFREE, FAIL, "unable to destroy local heap")
+                    if(FAIL == H5MF_xfree(f, H5FD_MEM_LHEAP, dxpl_id, heap->prfx_addr, total_size))
+                        H5E_THROW(H5E_CANTFREE, "can't release heap data?");
+                if(FAIL == H5HL__dest(heap))
+                    H5E_THROW(H5E_CANTFREE, "unable to destroy local heap");
             } /* end if */
         } /* end else */
     } /* end if */
 
-    FUNC_LEAVE_NOAPI(ret_value)
-} /* end H5HL_create() */
-
-
-/*-------------------------------------------------------------------------
- * Function:	H5HL_dblk_realloc
- *
- * Purpose:	Reallocate data block for heap
- *
- * Return:	Success:	Non-negative
- *		Failure:	Negative
- *
- * Programmer:	Quincey Koziol
- *		koziol@hdfgroup.org
- *		Oct 12 2008
- *
- *-------------------------------------------------------------------------
- */
-static herr_t
-H5HL_dblk_realloc(H5F_t *f, hid_t dxpl_id, H5HL_t *heap, size_t new_heap_size)
-{
-    H5HL_dblk_t *dblk;                  /* Local heap data block */
-    haddr_t old_addr;                   /* Old location of heap data block */
-    haddr_t new_addr;                   /* New location of heap data block */
-    size_t old_heap_size;               /* Old size of heap data block */
-    herr_t ret_value = SUCCEED;         /* Return value */
-
-    FUNC_ENTER_NOAPI_NOINIT
-
-    /* check arguments */
-    HDassert(heap);
-    HDassert(new_heap_size > 0);
-
-    /* Release old space on disk */
-    old_addr = heap->dblk_addr;
-    old_heap_size = heap->dblk_size;
-    H5_CHECK_OVERFLOW(old_heap_size, size_t, hsize_t);
-    if(H5MF_xfree(f, H5FD_MEM_LHEAP, dxpl_id, old_addr, (hsize_t)old_heap_size) < 0)
-        HGOTO_ERROR(H5E_HEAP, H5E_CANTFREE, FAIL, "can't release old heap data?")
-
-    /* Allocate new space on disk */
-    H5_CHECK_OVERFLOW(new_heap_size, size_t, hsize_t);
-    if(HADDR_UNDEF == (new_addr = H5MF_alloc(f, H5FD_MEM_LHEAP, dxpl_id, (hsize_t)new_heap_size)))
-        HGOTO_ERROR(H5E_HEAP, H5E_CANTALLOC, FAIL, "unable to allocate file space for heap")
-
-    /* Update heap info*/
-    heap->dblk_addr = new_addr;
-    heap->dblk_size = new_heap_size;
-
-    /* Check if heap data block actually moved in the file */
-    if(H5F_addr_eq(old_addr, new_addr)) {
-        /* Check if heap data block is contiguous w/prefix */
-        if(heap->single_cache_obj) {
-            /* Sanity check */
-            HDassert(H5F_addr_eq(heap->prfx_addr + heap->prfx_size, old_addr));
-            HDassert(heap->prfx);
-
-            /* Resize the heap prefix in the cache */
-            if(H5AC_resize_entry(heap->prfx, (size_t)(heap->prfx_size + new_heap_size)) < 0)
-                HGOTO_ERROR(H5E_HEAP, H5E_CANTRESIZE, FAIL, "unable to resize heap in cache")
-        } /* end if */
-        else {
-            /* Sanity check */
-            HDassert(H5F_addr_ne(heap->prfx_addr + heap->prfx_size, old_addr));
-            HDassert(heap->dblk);
-
-            /* Resize the heap data block in the cache */
-            if(H5AC_resize_entry(heap->dblk, (size_t)new_heap_size) < 0)
-                HGOTO_ERROR(H5E_HEAP, H5E_CANTRESIZE, FAIL, "unable to resize heap in cache")
-        } /* end else */
-    } /* end if */
-    else {
-        /* Check if heap data block was contiguous w/prefix previously */
-        if(heap->single_cache_obj) {
-            /* Create new heap data block */
-            if(NULL == (dblk = H5HL_dblk_new(heap)))
-                HGOTO_ERROR(H5E_HEAP, H5E_CANTALLOC, FAIL, "unable to allocate local heap data block")
-
-            /* Resize current heap prefix */
-            heap->prfx_size = H5HL_SIZEOF_HDR(f);
-            if(H5AC_resize_entry(heap->prfx, (size_t)heap->prfx_size) < 0)
-                HGOTO_ERROR(H5E_HEAP, H5E_CANTRESIZE, FAIL, "unable to resize heap prefix in cache")
-
-            /* Insert data block into cache (pinned) */
-            if(H5AC_insert_entry(f, dxpl_id, H5AC_LHEAP_DBLK, new_addr, dblk, H5AC__PIN_ENTRY_FLAG) < 0)
-                HGOTO_ERROR(H5E_HEAP, H5E_CANTINIT, FAIL, "unable to cache local heap data block")
-            dblk = NULL;
-
-            /* Reset 'single cache object' flag */
-            heap->single_cache_obj = FALSE;
-        } /* end if */
-        else {
-            /* Resize the heap data block in the cache */
-            /* (ignore [unlikely] case where heap data block ends up
-             *      contiguous w/heap prefix again.
-             */
-            if(H5AC_resize_entry(heap->dblk, (size_t)new_heap_size) < 0)
-                HGOTO_ERROR(H5E_HEAP, H5E_CANTRESIZE, FAIL, "unable to resize heap data block in cache")
-
-            /* Relocate the heap data block in the cache */
-            if(H5AC_move_entry(f, H5AC_LHEAP_DBLK, old_addr, new_addr) < 0)
-                HGOTO_ERROR(H5E_HEAP, H5E_CANTMOVE, FAIL, "unable to move heap data block in cache")
-        } /* end else */
-    } /* end else */
-
-done:
-    if(ret_value < 0) {
-        /* Restore old heap address & size */
-        heap->dblk_addr = old_addr;
-        heap->dblk_size = old_heap_size;
-    } /* end if */
-
-    FUNC_LEAVE_NOAPI(ret_value)
-} /* end H5HL_dblk_realloc() */
+END_FUNC(PRIV) /* end H5HL_create() */
 
 
 /*-------------------------------------------------------------------------
- * Function:    H5HL_minimize_heap_space
+ * Function:    H5HL__minimize_heap_space
  *
  * Purpose:     Go through the heap's freelist and determine if we can
  *              eliminate the free blocks at the tail of the buffer.
  *
- * Return:      Success:        SUCCEED
- *              Failure:        FAIL
+ * Return:      SUCCEED/FAIL
  *
  * Programmer:  Bill Wendling
- *              wendling@ncsa.uiuc.edu
  *              Sept. 16, 2003
  *
  *-------------------------------------------------------------------------
  */
-static herr_t
-H5HL_minimize_heap_space(H5F_t *f, hid_t dxpl_id, H5HL_t *heap)
-{
-    size_t new_heap_size = heap->dblk_size;     /* New size of heap */
-    herr_t ret_value = SUCCEED;                 /* Return value */
+BEGIN_FUNC(STATIC, ERR,
+herr_t, SUCCEED, FAIL,
+H5HL__minimize_heap_space(H5F_t *f, hid_t dxpl_id, H5HL_t *heap))
 
-    FUNC_ENTER_NOAPI(FAIL)
+    size_t new_heap_size = heap->dblk_size;     /* New size of heap */
 
     /* check args */
     HDassert(f);
@@ -393,7 +274,7 @@ H5HL_minimize_heap_space(H5F_t *f, hid_t dxpl_id, H5HL_t *heap)
                         new_heap_size = last_fl->offset;
 
                         /* Eliminate the free block from the list */
-                        last_fl = H5HL_remove_free(heap, last_fl);
+                        last_fl = H5HL__remove_free(heap, last_fl);
                     } /* end else */
                 } /* end if */
                 else {
@@ -413,20 +294,21 @@ H5HL_minimize_heap_space(H5F_t *f, hid_t dxpl_id, H5HL_t *heap)
      * storage.
      */
     if(new_heap_size != heap->dblk_size) {
-	HDassert(new_heap_size < heap->dblk_size);
+        HDassert(new_heap_size < heap->dblk_size);
 
         /* Resize the memory buffer */
         if(NULL == (heap->dblk_image = H5FL_BLK_REALLOC(lheap_chunk, heap->dblk_image, new_heap_size)))
-            HGOTO_ERROR(H5E_HEAP, H5E_CANTALLOC, FAIL, "memory allocation failed")
+            H5E_THROW(H5E_CANTALLOC, "memory allocation failed");
 
         /* Reallocate data block in file */
-        if(H5HL_dblk_realloc(f, dxpl_id, heap, new_heap_size) < 0)
-            HGOTO_ERROR(H5E_HEAP, H5E_CANTRESIZE, FAIL, "reallocating data block failed")
+        if(FAIL == H5HL__dblk_realloc(f, dxpl_id, heap, new_heap_size))
+            H5E_THROW(H5E_CANTRESIZE, "reallocating data block failed");
     } /* end if */
 
-done:
-    FUNC_LEAVE_NOAPI(ret_value)
-} /* H5HL_minimize_heap_space() */
+CATCH
+    /* No special processing on errors */
+
+END_FUNC(STATIC) /* H5HL__minimize_heap_space() */
 
 
 /*-------------------------------------------------------------------------
@@ -438,23 +320,20 @@ done:
  *              Failure:    NULL
  *
  * Programmer:  Bill Wendling
- *              wendling@ncsa.uiuc.edu
  *              Sept. 17, 2003
  *
  *-------------------------------------------------------------------------
  */
-H5HL_t *
-H5HL_protect(H5F_t *f, hid_t dxpl_id, haddr_t addr, unsigned flags)
-{
-    H5HL_cache_prfx_ud_t prfx_udata; /* User data for protecting local heap prefix */
-    H5HL_prfx_t *prfx = NULL;   /* Local heap prefix */
-    H5HL_dblk_t *dblk = NULL;   /* Local heap data block */
-    H5HL_t *heap = NULL;        /* Heap data structure */
-    unsigned prfx_cache_flags = H5AC__NO_FLAGS_SET;         /* Cache flags for unprotecting prefix entry */
-    unsigned dblk_cache_flags = H5AC__NO_FLAGS_SET;         /* Cache flags for unprotecting data block entry */
-    H5HL_t *ret_value = NULL;   /* Return value */
-
-    FUNC_ENTER_NOAPI(NULL)
+BEGIN_FUNC(PRIV, ERR,
+H5HL_t *, NULL, NULL,
+H5HL_protect(H5F_t *f, hid_t dxpl_id, haddr_t addr, unsigned flags))
+
+    H5HL_cache_prfx_ud_t prfx_udata;                    /* User data for protecting local heap prefix       */
+    H5HL_prfx_t *prfx = NULL;                           /* Local heap prefix                                */
+    H5HL_dblk_t *dblk = NULL;                           /* Local heap data block                            */
+    H5HL_t *heap = NULL;                                /* Heap data structure                              */
+    unsigned prfx_cache_flags = H5AC__NO_FLAGS_SET;     /* Cache flags for unprotecting prefix entry        */
+    unsigned dblk_cache_flags = H5AC__NO_FLAGS_SET;     /* Cache flags for unprotecting data block entry    */
 
     /* check arguments */
     HDassert(f);
@@ -473,7 +352,7 @@ H5HL_protect(H5F_t *f, hid_t dxpl_id, haddr_t addr, unsigned flags)
 
     /* Protect the local heap prefix */
     if(NULL == (prfx = (H5HL_prfx_t *)H5AC_protect(f, dxpl_id, H5AC_LHEAP_PRFX, addr, &prfx_udata, flags)))
-        HGOTO_ERROR(H5E_HEAP, H5E_CANTPROTECT, NULL, "unable to load heap prefix")
+        H5E_THROW(H5E_CANTPROTECT, "unable to load heap prefix");
 
     /* Get the pointer to the heap */
     heap = prfx->heap;
@@ -495,7 +374,7 @@ H5HL_protect(H5F_t *f, hid_t dxpl_id, haddr_t addr, unsigned flags)
 
             /* Protect the local heap data block */
             if(NULL == (dblk = (H5HL_dblk_t *)H5AC_protect(f, dxpl_id, H5AC_LHEAP_DBLK, heap->dblk_addr, &dblk_udata, flags)))
-                HGOTO_ERROR(H5E_HEAP, H5E_CANTPROTECT, NULL, "unable to load heap data block")
+                H5E_THROW(H5E_CANTPROTECT, "unable to load heap data block");
 
             /* Pin the prefix, if the data block was loaded from file */
             if(dblk_udata.loaded)
@@ -512,49 +391,43 @@ H5HL_protect(H5F_t *f, hid_t dxpl_id, haddr_t addr, unsigned flags)
     /* Set return value */
     ret_value = heap;
 
-done:
+CATCH
     /* Release the prefix from the cache, now pinned */
     if(prfx && heap && H5AC_unprotect(f, dxpl_id, H5AC_LHEAP_PRFX, heap->prfx_addr, prfx, prfx_cache_flags) < 0)
-        HDONE_ERROR(H5E_HEAP, H5E_CANTUNPROTECT, NULL, "unable to release local heap prefix")
+        H5E_THROW(H5E_CANTUNPROTECT, "unable to release local heap prefix");
 
     /* Release the data block from the cache, now pinned */
     if(dblk && heap && H5AC_unprotect(f, dxpl_id, H5AC_LHEAP_DBLK, heap->dblk_addr, dblk, dblk_cache_flags) < 0)
-        HDONE_ERROR(H5E_HEAP, H5E_CANTUNPROTECT, NULL, "unable to release local heap data block")
+        H5E_THROW(H5E_CANTUNPROTECT, "unable to release local heap data block");
 
-    FUNC_LEAVE_NOAPI(ret_value)
-} /* end H5HL_protect() */
+END_FUNC(PRIV) /* end H5HL_protect() */
 
 
 /*-------------------------------------------------------------------------
  * Function:    H5HL_offset_into
  *
  * Purpose:     Called directly after the call to H5HL_protect so that
- *              a pointer to the object in the heap can be got.
+ *              a pointer to the object in the heap can be obtained.
  *
  * Return:      Success:    Valid pointer.
- *              Failure:    NULL
+ *              Failure:    Can't fail
  *
  * Programmer:  Bill Wendling
- *              wendling@ncsa.uiuc.edu
  *              Sept. 17, 2003
  *
  *-------------------------------------------------------------------------
  */
-void *
-H5HL_offset_into(const H5HL_t *heap, size_t offset)
-{
-    /*
-     * We need to have called some other function before this to get a
-     * valid heap pointer. So, this can remain "FUNC_ENTER_NOAPI_NOINIT"
-     */
-    FUNC_ENTER_NOAPI_NOINIT_NOERR
+BEGIN_FUNC(PRIV, NOERR,
+void *, NULL, -,
+H5HL_offset_into(const H5HL_t *heap, size_t offset))
 
     /* Sanity check */
     HDassert(heap);
     HDassert(offset < heap->dblk_size);
 
-    FUNC_LEAVE_NOAPI(heap->dblk_image + offset)
-} /* end H5HL_offset_into() */
+    ret_value = heap->dblk_image + offset;
+
+END_FUNC(PRIV) /* end H5HL_offset_into() */
 
 
 /*-------------------------------------------------------------------------
@@ -562,21 +435,16 @@ H5HL_offset_into(const H5HL_t *heap, size_t offset)
  *
  * Purpose:     Unprotect the data retrieved by the H5HL_protect call.
  *
- * Return:      Success:    SUCCEED
- *              Failure:    FAIL
+ * Return:      SUCCEED/FAIL
  *
  * Programmer:  Bill Wendling
- *              wendling@ncsa.uiuc.edu
  *              Sept. 17, 2003
  *
  *-------------------------------------------------------------------------
  */
-herr_t
-H5HL_unprotect(H5HL_t *heap)
-{
-    herr_t  ret_value = SUCCEED;
-
-    FUNC_ENTER_NOAPI(FAIL)
+BEGIN_FUNC(PRIV, ERR,
+herr_t, SUCCEED, FAIL,
+H5HL_unprotect(H5HL_t *heap))
 
     /* check arguments */
     HDassert(heap);
@@ -589,8 +457,8 @@ H5HL_unprotect(H5HL_t *heap)
         /* Check for separate heap data block */
         if(heap->single_cache_obj) {
             /* Mark local heap prefix as evictable again */
-            if(H5AC_unpin_entry(heap->prfx) < 0)
-                HGOTO_ERROR(H5E_HEAP, H5E_CANTUNPIN, FAIL, "unable to unpin local heap data block")
+            if(FAIL == H5AC_unpin_entry(heap->prfx))
+                H5E_THROW(H5E_CANTUNPIN, "unable to unpin local heap data block");
         } /* end if */
         else {
             /* Sanity check */
@@ -598,34 +466,33 @@ H5HL_unprotect(H5HL_t *heap)
 
             /* Mark local heap data block as evictable again */
             /* (data block still pins prefix) */
-            if(H5AC_unpin_entry(heap->dblk) < 0)
-                HGOTO_ERROR(H5E_HEAP, H5E_CANTUNPIN, FAIL, "unable to unpin local heap data block")
+            if(FAIL == H5AC_unpin_entry(heap->dblk))
+                H5E_THROW(H5E_CANTUNPIN, "unable to unpin local heap data block");
         } /* end else */
     } /* end if */
 
-done:
-    FUNC_LEAVE_NOAPI(ret_value)
-} /* end H5HL_unprotect() */
+CATCH
+    /* No special processing on errors */
+
+END_FUNC(PRIV) /* end H5HL_unprotect() */
 
 
 /*-------------------------------------------------------------------------
- * Function:	H5HL_remove_free
+ * Function:    H5HL__remove_free
  *
- * Purpose:	Removes free list element FL from the specified heap and
- *		frees it.
+ * Purpose:     Removes free list element FL from the specified heap and
+ *              frees it.
  *
- * Return:	NULL
+ * Return:      NULL
  *
- * Programmer:	Robb Matzke
- *		matzke@llnl.gov
- *		Jul 17 1997
+ * Programmer:  Robb Matzke
+ *              Jul 17 1997
  *
  *-------------------------------------------------------------------------
  */
-static H5HL_free_t *
-H5HL_remove_free(H5HL_t *heap, H5HL_free_t *fl)
-{
-    FUNC_ENTER_NOAPI_NOINIT_NOERR
+BEGIN_FUNC(STATIC, NOERR,
+H5HL_free_t *, NULL, -,
+H5HL__remove_free(H5HL_t *heap, H5HL_free_t *fl))
 
     if(fl->prev)
         fl->prev->next = fl->next;
@@ -635,30 +502,27 @@ H5HL_remove_free(H5HL_t *heap, H5HL_free_t *fl)
     if(!fl->prev)
         heap->freelist = fl->next;
 
-    FUNC_LEAVE_NOAPI((H5HL_free_t *)H5FL_FREE(H5HL_free_t, fl))
-} /* end H5HL_remove_free() */
+    /* H5FL_FREE always returns NULL so we can't check for errors */
+    ret_value = (H5HL_free_t *)H5FL_FREE(H5HL_free_t, fl);
+
+END_FUNC(STATIC) /* end H5HL__remove_free() */
 
 
 /*-------------------------------------------------------------------------
- * Function:	H5HL_dirty
+ * Function:    H5HL__dirty
  *
- * Purpose:	Mark heap as dirty
+ * Purpose:     Mark heap as dirty
  *
- * Return:	Success:	Non-negative
- *		Failure:	Negative
+ * Return:      SUCCEED/FAIL
  *
- * Programmer:	Quincey Koziol
- *		koziol@hdfgroup.org
- *		Oct 12 2008
+ * Programmer:  Quincey Koziol
+ *              Oct 12 2008
  *
  *-------------------------------------------------------------------------
  */
-static herr_t
-H5HL_dirty(H5HL_t *heap)
-{
-    herr_t ret_value = SUCCEED;         /* Return value */
-
-    FUNC_ENTER_NOAPI_NOINIT
+BEGIN_FUNC(STATIC, ERR,
+herr_t, SUCCEED, FAIL,
+H5HL__dirty(H5HL_t *heap))
 
     /* check arguments */
     HDassert(heap);
@@ -669,43 +533,41 @@ H5HL_dirty(H5HL_t *heap)
         /* Sanity check */
         HDassert(heap->dblk);
 
-        if(H5AC_mark_entry_dirty(heap->dblk) < 0)
-            HGOTO_ERROR(H5E_HEAP, H5E_CANTMARKDIRTY, FAIL, "unable to mark heap data block as dirty")
+        if(FAIL == H5AC_mark_entry_dirty(heap->dblk))
+            H5E_THROW(H5E_CANTMARKDIRTY, "unable to mark heap data block as dirty");
     } /* end if */
 
     /* Mark heap prefix as dirty */
-    if(H5AC_mark_entry_dirty(heap->prfx) < 0)
-        HGOTO_ERROR(H5E_HEAP, H5E_CANTMARKDIRTY, FAIL, "unable to mark heap prefix as dirty")
+    if(FAIL == H5AC_mark_entry_dirty(heap->prfx))
+        H5E_THROW(H5E_CANTMARKDIRTY, "unable to mark heap prefix as dirty");
 
-done:
-    FUNC_LEAVE_NOAPI(ret_value)
-} /* end H5HL_dirty() */
+CATCH
+    /* No special processing on errors */
+
+END_FUNC(STATIC) /* end H5HL__dirty() */
 
 
 /*-------------------------------------------------------------------------
- * Function:	H5HL_insert
+ * Function:    H5HL_insert
  *
- * Purpose:	Inserts a new item into the heap.
+ * Purpose:     Inserts a new item into the heap.
  *
- * Return:	Success:	Offset of new item within heap.
- *		Failure:	UFAIL
+ * Return:      Success:    Offset of new item within heap.
+ *              Failure:    UFAIL
  *
- * Programmer:	Robb Matzke
- *		matzke@llnl.gov
- *		Jul 17 1997
+ * Programmer:  Robb Matzke
+ *              Jul 17 1997
  *
  *-------------------------------------------------------------------------
  */
-size_t
-H5HL_insert(H5F_t *f, hid_t dxpl_id, H5HL_t *heap, size_t buf_size, const void *buf)
-{
-    H5HL_free_t	*fl = NULL, *last_fl = NULL;
-    size_t	offset = 0;
-    size_t	need_size;
-    hbool_t	found;
-    size_t	ret_value = 0;          /* Return value */
+BEGIN_FUNC(PRIV, ERR,
+size_t, UFAIL, UFAIL,
+H5HL_insert(H5F_t *f, hid_t dxpl_id, H5HL_t *heap, size_t buf_size, const void *buf))
 
-    FUNC_ENTER_NOAPI(UFAIL)
+    H5HL_free_t     *fl = NULL, *last_fl = NULL;
+    size_t          offset = 0;
+    size_t          need_size;
+    hbool_t         found;
 
     /* check arguments */
     HDassert(f);
@@ -719,8 +581,8 @@ H5HL_insert(H5F_t *f, hid_t dxpl_id, H5HL_t *heap, size_t buf_size, const void *
      *  so we just accept that an extra flush of the heap info could occur
      *  if an error occurs -QAK)
      */
-    if(H5HL_dirty(heap) < 0)
-        HGOTO_ERROR(H5E_HEAP, H5E_CANTMARKDIRTY, UFAIL, "unable to mark heap as dirty")
+    if(FAIL == H5HL__dirty(heap))
+        H5E_THROW(H5E_CANTMARKDIRTY, "unable to mark heap as dirty");
 
     /*
      * In order to keep the free list descriptors aligned on word boundaries,
@@ -734,26 +596,25 @@ H5HL_insert(H5F_t *f, hid_t dxpl_id, H5HL_t *heap, size_t buf_size, const void *
      * leave zero or at least H5G_SIZEOF_FREE bytes left over.
      */
     for(fl = heap->freelist, found = FALSE; fl; fl = fl->next) {
-	if(fl->size > need_size &&
-                fl->size - need_size >= H5HL_SIZEOF_FREE(f)) {
-	    /* a big enough free block was found */
-	    offset = fl->offset;
-	    fl->offset += need_size;
-	    fl->size -= need_size;
-	    HDassert(fl->offset == H5HL_ALIGN(fl->offset));
-	    HDassert(fl->size == H5HL_ALIGN(fl->size));
-	    found = TRUE;
-	    break;
-	} else if(fl->size == need_size) {
-	    /* free block of exact size found */
-	    offset = fl->offset;
-	    fl = H5HL_remove_free(heap, fl);
-	    found = TRUE;
-	    break;
-	} else if(!last_fl || last_fl->offset < fl->offset) {
-	    /* track free space that's closest to end of heap */
-	    last_fl = fl;
-	}
+        if(fl->size > need_size && fl->size - need_size >= H5HL_SIZEOF_FREE(f)) {
+            /* a big enough free block was found */
+            offset = fl->offset;
+            fl->offset += need_size;
+            fl->size -= need_size;
+            HDassert(fl->offset == H5HL_ALIGN(fl->offset));
+            HDassert(fl->size == H5HL_ALIGN(fl->size));
+            found = TRUE;
+            break;
+        } else if(fl->size == need_size) {
+            /* free block of exact size found */
+            offset = fl->offset;
+            fl = H5HL__remove_free(heap, fl);
+            found = TRUE;
+            break;
+        } else if(!last_fl || last_fl->offset < fl->offset) {
+            /* track free space that's closest to end of heap */
+            last_fl = fl;
+        }
     } /* end for */
 
     /*
@@ -770,7 +631,7 @@ H5HL_insert(H5F_t *f, hid_t dxpl_id, H5HL_t *heap, size_t buf_size, const void *
 
         /* At least double the heap's size, making certain there's enough room
          * for the new object */
-	need_more = MAX(need_size, heap->dblk_size);
+        need_more = MAX(need_size, heap->dblk_size);
 
         /* If there is no last free block or it's not at the end of the heap,
          * and the amount of space to allocate is not big enough to include at
@@ -778,106 +639,104 @@ H5HL_insert(H5F_t *f, hid_t dxpl_id, H5HL_t *heap, size_t buf_size, const void *
          * space requested to just the amount of space needed.  (Generally
          * speaking, this only occurs when the heap is small -QAK)
          */
-	if(!(last_fl && last_fl->offset + last_fl->size == heap->dblk_size)
+        if(!(last_fl && last_fl->offset + last_fl->size == heap->dblk_size)
                 && (need_more < (need_size + H5HL_SIZEOF_FREE(f))))
             need_more = need_size;
 
-	new_dblk_size = heap->dblk_size + need_more;
-	HDassert(heap->dblk_size < new_dblk_size);
+        new_dblk_size = heap->dblk_size + need_more;
+        HDassert(heap->dblk_size < new_dblk_size);
         old_dblk_size = heap->dblk_size;
-	H5_CHECK_OVERFLOW(heap->dblk_size, size_t, hsize_t);
-	H5_CHECK_OVERFLOW(new_dblk_size, size_t, hsize_t);
+        H5_CHECK_OVERFLOW(heap->dblk_size, size_t, hsize_t);
+        H5_CHECK_OVERFLOW(new_dblk_size, size_t, hsize_t);
 
         /* Extend current heap if possible */
-	was_extended = H5MF_try_extend(f, dxpl_id, H5FD_MEM_LHEAP, heap->dblk_addr, (hsize_t)(heap->dblk_size), (hsize_t)need_more);
-        if(was_extended < 0)
-            HGOTO_ERROR(H5E_HEAP, H5E_CANTEXTEND, UFAIL, "error trying to extend heap")
+        was_extended = H5MF_try_extend(f, dxpl_id, H5FD_MEM_LHEAP, heap->dblk_addr, (hsize_t)(heap->dblk_size), (hsize_t)need_more);
+        if(FAIL == was_extended)
+            H5E_THROW(H5E_CANTEXTEND, "error trying to extend heap");
 
         /* Check if we extended the heap data block in file */
         if(was_extended == TRUE) {
             /* Check for prefix & data block contiguous */
             if(heap->single_cache_obj) {
                 /* Resize prefix+data block */
-                if(H5AC_resize_entry(heap->prfx, (size_t)(heap->prfx_size + new_dblk_size)) < 0)
-                    HGOTO_ERROR(H5E_HEAP, H5E_CANTRESIZE, UFAIL, "unable to resize heap prefix in cache")
+                if(FAIL == H5AC_resize_entry(heap->prfx, (size_t)(heap->prfx_size + new_dblk_size)))
+                    H5E_THROW(H5E_CANTRESIZE, "unable to resize heap prefix in cache");
             } /* end if */
             else {
                 /* Resize 'standalone' data block */
-                if(H5AC_resize_entry(heap->dblk, (size_t)new_dblk_size) < 0)
-                    HGOTO_ERROR(H5E_HEAP, H5E_CANTRESIZE, UFAIL, "unable to resize heap data block in cache")
+                if(FAIL == H5AC_resize_entry(heap->dblk, (size_t)new_dblk_size))
+                    H5E_THROW(H5E_CANTRESIZE, "unable to resize heap data block in cache");
             } /* end else */
 
             /* Note new size */
             heap->dblk_size = new_dblk_size;
-	} /* end if */
+        } /* end if */
         else { /* ...if we can't, allocate a new chunk & release the old */
             /* Reallocate data block in file */
-            if(H5HL_dblk_realloc(f, dxpl_id, heap, new_dblk_size) < 0)
-                HGOTO_ERROR(H5E_HEAP, H5E_CANTRESIZE, UFAIL, "reallocating data block failed")
-	} /* end if */
+            if(FAIL == H5HL__dblk_realloc(f, dxpl_id, heap, new_dblk_size))
+                H5E_THROW(H5E_CANTRESIZE, "reallocating data block failed");
+        } /* end if */
 
         /* If the last free list in the heap is at the end of the heap, extend it */
-	if(last_fl && last_fl->offset + last_fl->size == old_dblk_size) {
-	    /*
-	     * Increase the size of the last free block.
-	     */
-	    offset = last_fl->offset;
-	    last_fl->offset += need_size;
-	    last_fl->size += need_more - need_size;
-	    HDassert(last_fl->offset == H5HL_ALIGN(last_fl->offset));
-	    HDassert(last_fl->size == H5HL_ALIGN(last_fl->size));
-
-	    if (last_fl->size < H5HL_SIZEOF_FREE(f)) {
+        if(last_fl && last_fl->offset + last_fl->size == old_dblk_size) {
+            /*
+             * Increase the size of the last free block.
+             */
+            offset = last_fl->offset;
+            last_fl->offset += need_size;
+            last_fl->size += need_more - need_size;
+            HDassert(last_fl->offset == H5HL_ALIGN(last_fl->offset));
+            HDassert(last_fl->size == H5HL_ALIGN(last_fl->size));
+
+            if (last_fl->size < H5HL_SIZEOF_FREE(f)) {
 #ifdef H5HL_DEBUG
-		if (H5DEBUG(HL) && last_fl->size) {
-		    fprintf(H5DEBUG(HL), "H5HL: lost %lu bytes at line %d\n",
-			    (unsigned long)(last_fl->size), __LINE__);
-		}
+                if (H5DEBUG(HL) && last_fl->size) {
+                    HDfprintf(H5DEBUG(HL), "H5HL: lost %lu bytes at line %d\n",
+                        (unsigned long)(last_fl->size), __LINE__);
+                }
 #endif
-		last_fl = H5HL_remove_free(heap, last_fl);
-	    }
-	} /* end if */
+                last_fl = H5HL__remove_free(heap, last_fl);
+            }
+        } /* end if */
         else {
-	    /*
-	     * Create a new free list element large enough that we can
-	     * take some space out of it right away.
-	     */
-	    offset = old_dblk_size;
-	    if(need_more - need_size >= H5HL_SIZEOF_FREE(f)) {
-		if(NULL == (fl = H5FL_MALLOC(H5HL_free_t)))
-		    HGOTO_ERROR(H5E_HEAP, H5E_CANTALLOC, UFAIL, "memory allocation failed")
-		fl->offset = old_dblk_size + need_size;
-		fl->size = need_more - need_size;
-		HDassert(fl->offset == H5HL_ALIGN(fl->offset));
-		HDassert(fl->size == H5HL_ALIGN(fl->size));
-		fl->prev = NULL;
-		fl->next = heap->freelist;
-		if(heap->freelist)
+            /*
+             * Create a new free list element large enough that we can
+             * take some space out of it right away.
+             */
+            offset = old_dblk_size;
+            if(need_more - need_size >= H5HL_SIZEOF_FREE(f)) {
+                if(NULL == (fl = H5FL_MALLOC(H5HL_free_t)))
+                    H5E_THROW(H5E_CANTALLOC, "memory allocation failed");
+                fl->offset = old_dblk_size + need_size;
+                fl->size = need_more - need_size;
+                HDassert(fl->offset == H5HL_ALIGN(fl->offset));
+                HDassert(fl->size == H5HL_ALIGN(fl->size));
+                fl->prev = NULL;
+                fl->next = heap->freelist;
+                if(heap->freelist)
                     heap->freelist->prev = fl;
-		heap->freelist = fl;
+                heap->freelist = fl;
 #ifdef H5HL_DEBUG
-	    } else if (H5DEBUG(HL) && need_more > need_size) {
-		fprintf(H5DEBUG(HL),
-			"H5HL_insert: lost %lu bytes at line %d\n",
-			(unsigned long)(need_more - need_size), __LINE__);
+            } else if (H5DEBUG(HL) && need_more > need_size) {
+                HDfprintf(H5DEBUG(HL), "H5HL_insert: lost %lu bytes at line %d\n",
+                    (unsigned long)(need_more - need_size), __LINE__);
 #endif
-	    }
-	} /* end else */
+            }
+        } /* end else */
 
 #ifdef H5HL_DEBUG
-	if (H5DEBUG(HL)) {
-	    fprintf(H5DEBUG(HL),
-		    "H5HL: resize mem buf from %lu to %lu bytes\n",
-		    (unsigned long)(old_dblk_size),
-		    (unsigned long)(old_dblk_size + need_more));
-	}
+        if (H5DEBUG(HL)) {
+            HDfprintf(H5DEBUG(HL), "H5HL: resize mem buf from %lu to %lu bytes\n",
+                (unsigned long)(old_dblk_size),
+                (unsigned long)(old_dblk_size + need_more));
+        }
 #endif
-	if(NULL == (heap->dblk_image = H5FL_BLK_REALLOC(lheap_chunk, heap->dblk_image, heap->dblk_size)))
-	    HGOTO_ERROR(H5E_HEAP, H5E_CANTALLOC, UFAIL, "memory allocation failed")
+        if(NULL == (heap->dblk_image = H5FL_BLK_REALLOC(lheap_chunk, heap->dblk_image, heap->dblk_size)))
+            H5E_THROW(H5E_CANTALLOC, "memory allocation failed");
 
-	/* Clear new section so junk doesn't appear in the file */
+        /* Clear new section so junk doesn't appear in the file */
         /* (Avoid clearing section which will be overwritten with newly inserted data) */
-	HDmemset(heap->dblk_image + offset + buf_size, 0, (new_dblk_size - (offset + buf_size)));
+        HDmemset(heap->dblk_image + offset + buf_size, 0, (new_dblk_size - (offset + buf_size)));
     } /* end if */
 
     /* Copy the data into the heap */
@@ -886,42 +745,40 @@ H5HL_insert(H5F_t *f, hid_t dxpl_id, H5HL_t *heap, size_t buf_size, const void *
     /* Set return value */
     ret_value = offset;
 
-done:
-    FUNC_LEAVE_NOAPI(ret_value)
-} /* H5HL_insert() */
+CATCH
+    /* No special processing on errors */
+
+END_FUNC(PRIV) /* H5HL_insert() */
 
 
 /*-------------------------------------------------------------------------
- * Function:	H5HL_remove
+ * Function:    H5HL_remove
  *
- * Purpose:	Removes an object or part of an object from the heap at
- *		address ADDR of file F.	 The object (or part) to remove
- *		begins at byte OFFSET from the beginning of the heap and
- *		continues for SIZE bytes.
+ * Purpose:     Removes an object or part of an object from the heap at
+ *              address ADDR of file F.	 The object (or part) to remove
+ *              begins at byte OFFSET from the beginning of the heap and
+ *              continues for SIZE bytes.
  *
- *		Once part of an object is removed, one must not attempt
- *		to access that part.  Removing the beginning of an object
- *		results in the object OFFSET increasing by the amount
- *		truncated.  Removing the end of an object results in
- *		object truncation.  Removing the middle of an object results
- *		in two separate objects, one at the original offset and
- *		one at the first offset past the removed portion.
+ *              Once part of an object is removed, one must not attempt
+ *              to access that part.  Removing the beginning of an object
+ *              results in the object OFFSET increasing by the amount
+ *              truncated.  Removing the end of an object results in
+ *              object truncation.  Removing the middle of an object results
+ *              in two separate objects, one at the original offset and
+ *              one at the first offset past the removed portion.
  *
- * Return:	Non-negative on success/Negative on failure
+ * Return:      SUCCEED/FAIL
  *
- * Programmer:	Robb Matzke
- *		matzke@llnl.gov
- *		Jul 16 1997
+ * Programmer:  Robb Matzke
+ *              Jul 16 1997
  *
  *-------------------------------------------------------------------------
  */
-herr_t
-H5HL_remove(H5F_t *f, hid_t dxpl_id, H5HL_t *heap, size_t offset, size_t size)
-{
-    H5HL_free_t		*fl = NULL;
-    herr_t      	ret_value = SUCCEED;       /* Return value */
+BEGIN_FUNC(PRIV, ERR,
+herr_t, SUCCEED, FAIL,
+H5HL_remove(H5F_t *f, hid_t dxpl_id, H5HL_t *heap, size_t offset, size_t size))
 
-    FUNC_ENTER_NOAPI(FAIL)
+    H5HL_free_t *fl = NULL;
 
     /* check arguments */
     HDassert(f);
@@ -940,8 +797,8 @@ H5HL_remove(H5F_t *f, hid_t dxpl_id, H5HL_t *heap, size_t offset, size_t size)
      *  so we just accept that an extra flush of the heap info could occur
      *  if an error occurs -QAK)
      */
-    if(H5HL_dirty(heap) < 0)
-        HGOTO_ERROR(H5E_HEAP, H5E_CANTMARKDIRTY, FAIL, "unable to mark heap as dirty")
+    if(FAIL == H5HL__dirty(heap))
+        H5E_THROW(H5E_CANTMARKDIRTY, "unable to mark heap as dirty");
 
     /*
      * Check if this chunk can be prepended or appended to an already
@@ -952,60 +809,60 @@ H5HL_remove(H5F_t *f, hid_t dxpl_id, H5HL_t *heap, size_t offset, size_t size)
     while(fl) {
         H5HL_free_t *fl2 = NULL;
 
-	if((offset + size) == fl->offset) {
-	    fl->offset = offset;
-	    fl->size += size;
-	    HDassert(fl->offset == H5HL_ALIGN(fl->offset));
-	    HDassert(fl->size == H5HL_ALIGN(fl->size));
-	    fl2 = fl->next;
-	    while(fl2) {
-		if((fl2->offset + fl2->size) == fl->offset) {
-		    fl->offset = fl2->offset;
-		    fl->size += fl2->size;
-		    HDassert(fl->offset == H5HL_ALIGN(fl->offset));
-		    HDassert(fl->size == H5HL_ALIGN(fl->size));
-		    fl2 = H5HL_remove_free(heap, fl2);
-	            if(((fl->offset + fl->size) == heap->dblk_size) &&
+        if((offset + size) == fl->offset) {
+            fl->offset = offset;
+            fl->size += size;
+            HDassert(fl->offset == H5HL_ALIGN(fl->offset));
+            HDassert(fl->size == H5HL_ALIGN(fl->size));
+            fl2 = fl->next;
+            while(fl2) {
+                if((fl2->offset + fl2->size) == fl->offset) {
+                    fl->offset = fl2->offset;
+                    fl->size += fl2->size;
+                    HDassert(fl->offset == H5HL_ALIGN(fl->offset));
+                    HDassert(fl->size == H5HL_ALIGN(fl->size));
+                    fl2 = H5HL__remove_free(heap, fl2);
+                    if(((fl->offset + fl->size) == heap->dblk_size) &&
                              ((2 * fl->size) > heap->dblk_size)) {
-                        if(H5HL_minimize_heap_space(f, dxpl_id, heap) < 0)
-	                    HGOTO_ERROR(H5E_HEAP, H5E_CANTFREE, FAIL, "heap size minimization failed")
+                        if(FAIL == H5HL__minimize_heap_space(f, dxpl_id, heap))
+                            H5E_THROW(H5E_CANTFREE, "heap size minimization failed");
                     }
-		    HGOTO_DONE(SUCCEED);
-		}
-		fl2 = fl2->next;
-	    }
-	    if(((fl->offset + fl->size) == heap->dblk_size) &&
+                    H5_LEAVE(SUCCEED);
+                }
+                fl2 = fl2->next;
+            }
+            if(((fl->offset + fl->size) == heap->dblk_size) &&
                      ((2 * fl->size) > heap->dblk_size)) {
-                if(H5HL_minimize_heap_space(f, dxpl_id, heap) < 0)
-	            HGOTO_ERROR(H5E_HEAP, H5E_CANTFREE, FAIL, "heap size minimization failed")
+                if(FAIL == H5HL__minimize_heap_space(f, dxpl_id, heap))
+                    H5E_THROW(H5E_CANTFREE, "heap size minimization failed");
             }
-	    HGOTO_DONE(SUCCEED);
-	} else if(fl->offset + fl->size == offset) {
-	    fl->size += size;
-	    fl2 = fl->next;
-	    HDassert(fl->size == H5HL_ALIGN(fl->size));
-	    while(fl2) {
-		if(fl->offset + fl->size == fl2->offset) {
-		    fl->size += fl2->size;
-		    HDassert(fl->size == H5HL_ALIGN(fl->size));
-		    fl2 = H5HL_remove_free(heap, fl2);
-	            if(((fl->offset + fl->size) == heap->dblk_size) &&
-                            ((2 * fl->size) > heap->dblk_size)) {
-                        if(H5HL_minimize_heap_space(f, dxpl_id, heap) < 0)
-	                    HGOTO_ERROR(H5E_HEAP, H5E_CANTFREE, FAIL, "heap size minimization failed")
+            H5_LEAVE(SUCCEED);
+        } else if(fl->offset + fl->size == offset) {
+            fl->size += size;
+            fl2 = fl->next;
+            HDassert(fl->size == H5HL_ALIGN(fl->size));
+            while(fl2) {
+                if(fl->offset + fl->size == fl2->offset) {
+                    fl->size += fl2->size;
+                    HDassert(fl->size == H5HL_ALIGN(fl->size));
+                    fl2 = H5HL__remove_free(heap, fl2);
+                    if(((fl->offset + fl->size) == heap->dblk_size) &&
+                        ((2 * fl->size) > heap->dblk_size)) {
+                        if(FAIL == H5HL__minimize_heap_space(f, dxpl_id, heap))
+                            H5E_THROW(H5E_CANTFREE, "heap size minimization failed");
                     } /* end if */
-		    HGOTO_DONE(SUCCEED);
-		} /* end if */
-		fl2 = fl2->next;
-	    } /* end while */
-	    if(((fl->offset + fl->size) == heap->dblk_size) &&
+                    H5_LEAVE(SUCCEED);
+                } /* end if */
+                fl2 = fl2->next;
+            } /* end while */
+            if(((fl->offset + fl->size) == heap->dblk_size) &&
                     ((2 * fl->size) > heap->dblk_size)) {
-                if(H5HL_minimize_heap_space(f, dxpl_id, heap) < 0)
-	            HGOTO_ERROR(H5E_HEAP, H5E_CANTFREE, FAIL, "heap size minimization failed")
+                if(FAIL == H5HL__minimize_heap_space(f, dxpl_id, heap))
+                    H5E_THROW(H5E_CANTFREE, "heap size minimization failed");
             } /* end if */
-	    HGOTO_DONE(SUCCEED);
-	} /* end if */
-	fl = fl->next;
+            H5_LEAVE(SUCCEED);
+        } /* end if */
+        fl = fl->next;
     } /* end while */
 
     /*
@@ -1015,19 +872,18 @@ H5HL_remove(H5F_t *f, hid_t dxpl_id, H5HL_t *heap, size_t offset, size_t size)
      */
     if(size < H5HL_SIZEOF_FREE(f)) {
 #ifdef H5HL_DEBUG
-	if(H5DEBUG(HL)) {
-	    fprintf(H5DEBUG(HL), "H5HL: lost %lu bytes\n",
-		    (unsigned long) size);
-	}
+        if(H5DEBUG(HL)) {
+            HDfprintf(H5DEBUG(HL), "H5HL: lost %lu bytes\n", (unsigned long) size);
+        }
 #endif
-	HGOTO_DONE(SUCCEED);
+        H5_LEAVE(SUCCEED);
     } /* end if */
 
     /*
      * Add an entry to the free list.
      */
     if(NULL == (fl = H5FL_MALLOC(H5HL_free_t)))
-	HGOTO_ERROR(H5E_HEAP, H5E_CANTALLOC, FAIL, "memory allocation failed")
+        H5E_THROW(H5E_CANTALLOC, "memory allocation failed");
     fl->offset = offset;
     fl->size = size;
     HDassert(fl->offset == H5HL_ALIGN(fl->offset));
@@ -1040,39 +896,37 @@ H5HL_remove(H5F_t *f, hid_t dxpl_id, H5HL_t *heap, size_t offset, size_t size)
 
     if(((fl->offset + fl->size) == heap->dblk_size) &&
             ((2 * fl->size) > heap->dblk_size)) {
-        if(H5HL_minimize_heap_space(f, dxpl_id, heap) < 0)
-            HGOTO_ERROR(H5E_HEAP, H5E_CANTFREE, FAIL, "heap size minimization failed")
+        if(FAIL == H5HL__minimize_heap_space(f, dxpl_id, heap))
+            H5E_THROW(H5E_CANTFREE, "heap size minimization failed");
     } /* end if */
 
-done:
-    FUNC_LEAVE_NOAPI(ret_value)
-} /* end H5HL_remove() */
+CATCH
+    /* No special processing on exit */
+
+END_FUNC(PRIV) /* end H5HL_remove() */
 
 
 /*-------------------------------------------------------------------------
- * Function:	H5HL_delete
+ * Function:    H5HL_delete
  *
- * Purpose:	Deletes a local heap from disk, freeing disk space used.
+ * Purpose:     Deletes a local heap from disk, freeing disk space used.
  *
- * Return:	Non-negative on success/Negative on failure
+ * Return:      SUCCEED/FAIL
  *
- * Programmer:	Quincey Koziol
- *		koziol@ncsa.uiuc.edu
- *		Mar 22 2003
+ * Programmer:  Quincey Koziol
+ *              Mar 22 2003
  *
  *-------------------------------------------------------------------------
  */
-herr_t
-H5HL_delete(H5F_t *f, hid_t dxpl_id, haddr_t addr)
-{
-    H5HL_t	*heap = NULL;           /* Local heap to delete */
+BEGIN_FUNC(PRIV, ERR,
+herr_t, SUCCEED, FAIL,
+H5HL_delete(H5F_t *f, hid_t dxpl_id, haddr_t addr))
+
+    H5HL_t      *heap = NULL;           /* Local heap to delete */
     H5HL_cache_prfx_ud_t prfx_udata;    /* User data for protecting local heap prefix */
     H5HL_prfx_t *prfx = NULL;           /* Local heap prefix */
     H5HL_dblk_t *dblk = NULL;           /* Local heap data block */
     unsigned    cache_flags = H5AC__NO_FLAGS_SET;       /* Flags for unprotecting heap */
-    herr_t      ret_value = SUCCEED;    /* Return value */
-
-    FUNC_ENTER_NOAPI(FAIL)
 
     /* check arguments */
     HDassert(f);
@@ -1088,7 +942,7 @@ H5HL_delete(H5F_t *f, hid_t dxpl_id, haddr_t addr)
 
     /* Protect the local heap prefix */
     if(NULL == (prfx = (H5HL_prfx_t *)H5AC_protect(f, dxpl_id, H5AC_LHEAP_PRFX, addr, &prfx_udata, H5AC__NO_FLAGS_SET)))
-        HGOTO_ERROR(H5E_HEAP, H5E_CANTPROTECT, FAIL, "unable to load heap prefix")
+        H5E_THROW(H5E_CANTPROTECT, "unable to load heap prefix");
 
     /* Get the pointer to the heap */
     heap = prfx->heap;
@@ -1103,53 +957,49 @@ H5HL_delete(H5F_t *f, hid_t dxpl_id, haddr_t addr)
 
         /* Protect the local heap data block */
         if(NULL == (dblk = (H5HL_dblk_t *)H5AC_protect(f, dxpl_id, H5AC_LHEAP_DBLK, heap->dblk_addr, &dblk_udata, H5AC__NO_FLAGS_SET)))
-            HGOTO_ERROR(H5E_HEAP, H5E_CANTPROTECT, FAIL, "unable to load heap data block")
+            H5E_THROW(H5E_CANTPROTECT, "unable to load heap data block");
 
         /* Pin the prefix, if the data block was loaded from file */
         if(dblk_udata.loaded) {
-            if(H5AC_pin_protected_entry(prfx) < 0)
-                HGOTO_ERROR(H5E_HEAP, H5E_CANTPIN, FAIL, "unable to pin local heap prefix")
+            if(FAIL == H5AC_pin_protected_entry(prfx))
+                H5E_THROW(H5E_CANTPIN, "unable to pin local heap prefix");
         } /* end if */
     } /* end if */
 
     /* Set the flags for releasing the prefix and data block */
     cache_flags |= H5AC__DIRTIED_FLAG | H5AC__DELETED_FLAG | H5AC__FREE_FILE_SPACE_FLAG;
 
-done:
+CATCH
     /* Release the data block from the cache, now deleted */
     if(dblk && heap && H5AC_unprotect(f, dxpl_id, H5AC_LHEAP_DBLK, heap->dblk_addr, dblk, cache_flags) < 0)
-        HDONE_ERROR(H5E_HEAP, H5E_CANTUNPROTECT, FAIL, "unable to release local heap data block")
+        H5E_THROW(H5E_CANTUNPROTECT, "unable to release local heap data block");
 
     /* Release the prefix from the cache, now deleted */
     if(prfx && heap && H5AC_unprotect(f, dxpl_id, H5AC_LHEAP_PRFX, heap->prfx_addr, prfx, cache_flags) < 0)
-        HDONE_ERROR(H5E_HEAP, H5E_CANTUNPROTECT, FAIL, "unable to release local heap prefix")
+        H5E_THROW(H5E_CANTUNPROTECT, "unable to release local heap prefix");
 
-    FUNC_LEAVE_NOAPI(ret_value)
-} /* end H5HL_delete() */
+END_FUNC(PRIV) /* end H5HL_delete() */
 
 
 /*-------------------------------------------------------------------------
- * Function:	H5HL_get_size
+ * Function:    H5HL_get_size
  *
- * Purpose:	Retrieves the current size of a heap
+ * Purpose:     Retrieves the current size of a heap
  *
- * Return:	Non-negative on success/Negative on failure
+ * Return:      SUCCEED/FAIL
  *
- * Programmer:	Quincey Koziol
- *		koziol@ncsa.uiuc.edu
- *		Nov  7 2005
+ * Programmer:  Quincey Koziol
+ *              Nov  7 2005
  *
  *-------------------------------------------------------------------------
  */
-herr_t
-H5HL_get_size(H5F_t *f, hid_t dxpl_id, haddr_t addr, size_t *size)
-{
-    H5HL_cache_prfx_ud_t prfx_udata;      /* User data for protecting local heap prefix */
-    H5HL_prfx_t *prfx = NULL;   /* Local heap prefix */
-    H5HL_t *heap;               /* Heap data structure */
-    herr_t ret_value = SUCCEED; /* Return value */
+BEGIN_FUNC(PRIV, ERR,
+herr_t, SUCCEED, FAIL,
+H5HL_get_size(H5F_t *f, hid_t dxpl_id, haddr_t addr, size_t *size))
 
-    FUNC_ENTER_NOAPI(FAIL)
+    H5HL_cache_prfx_ud_t prfx_udata;    /* User data for protecting local heap prefix */
+    H5HL_prfx_t *prfx = NULL;           /* Local heap prefix */
+    H5HL_t *heap;                       /* Heap data structure */
 
     /* check arguments */
     HDassert(f);
@@ -1166,7 +1016,7 @@ H5HL_get_size(H5F_t *f, hid_t dxpl_id, haddr_t addr, size_t *size)
 
     /* Protect the local heap prefix */
     if(NULL == (prfx = (H5HL_prfx_t *)H5AC_protect(f, dxpl_id, H5AC_LHEAP_PRFX, addr, &prfx_udata, H5AC__READ_ONLY_FLAG)))
-        HGOTO_ERROR(H5E_HEAP, H5E_CANTPROTECT, FAIL, "unable to load heap prefix")
+        H5E_THROW(H5E_CANTPROTECT, "unable to load heap prefix");
 
     /* Get the pointer to the heap */
     heap = prfx->heap;
@@ -1174,12 +1024,11 @@ H5HL_get_size(H5F_t *f, hid_t dxpl_id, haddr_t addr, size_t *size)
     /* Set the size to return */
     *size = heap->dblk_size;
 
-done:
-    if(prfx && H5AC_unprotect(f, dxpl_id, H5AC_LHEAP_PRFX, heap->prfx_addr, prfx, H5AC__NO_FLAGS_SET) < 0)
-        HDONE_ERROR(H5E_HEAP, H5E_CANTUNPROTECT, FAIL, "unable to release local heap prefix")
+CATCH
+    if(prfx && FAIL == H5AC_unprotect(f, dxpl_id, H5AC_LHEAP_PRFX, heap->prfx_addr, prfx, H5AC__NO_FLAGS_SET))
+        H5E_THROW(H5E_CANTUNPROTECT, "unable to release local heap prefix");
 
-    FUNC_LEAVE_NOAPI(ret_value)
-} /* end H5HL_get_size() */
+END_FUNC(PRIV) /* end H5HL_get_size() */
 
 
 /*-------------------------------------------------------------------------
@@ -1188,22 +1037,20 @@ done:
  * Purpose:     Compute the size in bytes of the specified instance of
  *              H5HL_t via H5HL_size()
  *
- * Return:      Non-negative on success/Negative on failure
+ * Return:      SUCCEED/FAIL
  *
  * Programmer:  Vailin Choi
  *              June 19 2007
  *
  *-------------------------------------------------------------------------
  */
-herr_t
-H5HL_heapsize(H5F_t *f, hid_t dxpl_id, haddr_t addr, hsize_t *heap_size)
-{
-    H5HL_cache_prfx_ud_t prfx_udata;      /* User data for protecting local heap prefix */
-    H5HL_prfx_t *prfx = NULL;   /* Local heap prefix */
-    H5HL_t *heap;               /* Heap data structure */
-    herr_t ret_value = SUCCEED;    /* Return value */
+BEGIN_FUNC(PRIV, ERR,
+herr_t, SUCCEED, FAIL,
+H5HL_heapsize(H5F_t *f, hid_t dxpl_id, haddr_t addr, hsize_t *heap_size))
 
-    FUNC_ENTER_NOAPI(FAIL)
+    H5HL_cache_prfx_ud_t prfx_udata;    /* User data for protecting local heap prefix */
+    H5HL_prfx_t *prfx = NULL;           /* Local heap prefix */
+    H5HL_t *heap;                       /* Heap data structure */
 
     /* check arguments */
     HDassert(f);
@@ -1220,7 +1067,7 @@ H5HL_heapsize(H5F_t *f, hid_t dxpl_id, haddr_t addr, hsize_t *heap_size)
 
     /* Protect the local heap prefix */
     if(NULL == (prfx = (H5HL_prfx_t *)H5AC_protect(f, dxpl_id, H5AC_LHEAP_PRFX, addr, &prfx_udata, H5AC__READ_ONLY_FLAG)))
-        HGOTO_ERROR(H5E_HEAP, H5E_CANTPROTECT, FAIL, "unable to load heap prefix")
+        H5E_THROW(H5E_CANTPROTECT, "unable to load heap prefix");
 
     /* Get the pointer to the heap */
     heap = prfx->heap;
@@ -1228,10 +1075,9 @@ H5HL_heapsize(H5F_t *f, hid_t dxpl_id, haddr_t addr, hsize_t *heap_size)
     /* Accumulate the size of the local heap */
     *heap_size += (hsize_t)(heap->prfx_size + heap->dblk_size);
 
-done:
-    if(prfx && H5AC_unprotect(f, dxpl_id, H5AC_LHEAP_PRFX, heap->prfx_addr, prfx, H5AC__NO_FLAGS_SET) < 0)
-        HDONE_ERROR(H5E_HEAP, H5E_CANTUNPROTECT, FAIL, "unable to release local heap prefix")
+CATCH
+    if(prfx && FAIL == H5AC_unprotect(f, dxpl_id, H5AC_LHEAP_PRFX, heap->prfx_addr, prfx, H5AC__NO_FLAGS_SET))
+        H5E_THROW(H5E_CANTUNPROTECT, "unable to release local heap prefix");
 
-    FUNC_LEAVE_NOAPI(ret_value)
-} /* end H5HL_heapsize() */
+END_FUNC(PRIV) /* end H5HL_heapsize() */