Merge pull request #811 in HDFFV/hdf5 from hdf5_1_8_20 to 1.8/masterhdf5-1_8_20

* commit '60f76980aab92f0e0730170b99a2363acd3c97fa': (108 commits)
  Update version numbers and remove empty sections in RELEASE.txt.
  Restore line 1154: C2Cppfunction_map.mht to HTML_EXTRA_FILES.
  Update version for 1.8.20 release.
  Fixed documentation warnings
  HDFFV-10329 Correct LINK INTERFACE and VS20013 compile
  Switch default build mode from development to production. Increment version string to pre2.
  Add RELEASE.txt note for HDFFV-10274. (cherry picked from commit f7a7d0a00613cba997212fa8032091629a678797)
  Initialize hid_t variables in test_Attr_bug9. (cherry picked from commit 97bc393449f3fe02c5992872ab2842e12f611ef0)
  Fix HDFFV-10274.  When deleting all (or almost all) of the messages in an object header chunk, where the total amount deleted was greater than 64K, an error would occur due to an off by one error in the code that handled that case.  Fixed this and added a test case. (cherry picked from commit 1b2c2ca9a6a7d7e1fcd5c3302e203f2e2dabf0af)
  Fix linking of libs
  Changed file path to relative.
  iAdd NAG to supported compilers in RELEASE.txt.
  Add description to RELEASE.txt for HDFFV-10323
  Correct issue number
  Set version to 1.8.20-pre1
  Update supported and tested platforms in RELEASE.txt.
  HDFFV-10321 Merge from 1.8
  Incremented lib file .so numbers: revision for all except c++ for code change; current incremented, revision and age set to 0 for c++ due to symbols added and removed.
  updated issues related to Fortran
  Incremented lib file .so numbers: revision for all except c++ for dcode change; current incremented, revision and age set to 0 for c++ due to symbols added and removed.
  ...

21 files changed, 694 insertions, 554 deletions

diff --git a/src/CMakeLists.txt b/src/CMakeLists.txt
index d343208..a825958 100644
--- a/src/CMakeLists.txt
+++ b/src/CMakeLists.txt
@@ -694,12 +694,12 @@ set_source_files_properties (${HDF5_BINARY_DIR}/H5overflow.h GENERATED)
 
 add_library (${HDF5_LIB_TARGET} STATIC ${common_SRCS} ${H5_PUBLIC_HEADERS} ${H5_PRIVATE_HEADERS})
 TARGET_C_PROPERTIES (${HDF5_LIB_TARGET} STATIC " " " ")
-target_link_libraries (${HDF5_LIB_TARGET} ${LINK_LIBS})
+target_link_libraries (${HDF5_LIB_TARGET} PRIVATE ${LINK_LIBS} ${LINK_COMP_LIBS})
 if (NOT WIN32)
-  target_link_libraries (${HDF5_LIB_TARGET} dl)
+  target_link_libraries (${HDF5_LIB_TARGET} PUBLIC dl)
 endif ()
 if (H5_HAVE_PARALLEL AND MPI_C_FOUND)
-  target_link_libraries (${HDF5_LIB_TARGET} ${MPI_C_LIBRARIES})
+  target_include_directories (${HDF5_LIB_TARGET} PUBLIC ${MPI_C_INCLUDE_DIRS})
 endif ()
 set_global_variable (HDF5_LIBRARIES_TO_EXPORT ${HDF5_LIB_TARGET})
 H5_SET_LIB_OPTIONS (${HDF5_LIB_TARGET} ${HDF5_LIB_NAME} STATIC)
@@ -720,12 +720,12 @@ set (install_targets ${HDF5_LIB_TARGET})
 if (BUILD_SHARED_LIBS)
   add_library (${HDF5_LIBSH_TARGET} SHARED ${common_SRCS} ${H5_PUBLIC_HEADERS} ${H5_PRIVATE_HEADERS})
   TARGET_C_PROPERTIES (${HDF5_LIBSH_TARGET} SHARED " " " ")
-  target_link_libraries (${HDF5_LIBSH_TARGET} ${LINK_SHARED_LIBS})
+  target_link_libraries (${HDF5_LIBSH_TARGET} PRIVATE ${LINK_LIBS} ${LINK_COMP_LIBS})
   if (NOT WIN32)
-    target_link_libraries (${HDF5_LIBSH_TARGET} dl)
+    target_link_libraries (${HDF5_LIBSH_TARGET} PUBLIC dl)
   endif ()
   if (H5_HAVE_PARALLEL AND MPI_C_FOUND)
-    target_link_libraries (${HDF5_LIBSH_TARGET} ${MPI_C_LIBRARIES})
+    target_include_directories (${HDF5_LIBSH_TARGET} PUBLIC ${MPI_C_INCLUDE_DIRS})
   endif ()
   set_global_variable (HDF5_LIBRARIES_TO_EXPORT "${HDF5_LIBRARIES_TO_EXPORT};${HDF5_LIBSH_TARGET}")
   H5_SET_LIB_OPTIONS (${HDF5_LIBSH_TARGET} ${HDF5_LIB_NAME} SHARED ${HDF5_PACKAGE_SOVERSION})
@@ -740,7 +740,7 @@ if (BUILD_SHARED_LIBS)
         APPEND PROPERTY COMPILE_DEFINITIONS
             "H5_HAVE_THREADSAFE"
     )
-    target_link_libraries (${HDF5_LIBSH_TARGET} Threads::Threads)
+    target_link_libraries (${HDF5_LIBSH_TARGET} PUBLIC Threads::Threads)
   endif ()
 
   if (HDF5_ENABLE_DEBUG_APIS)
diff --git a/src/H5Dchunk.c b/src/H5Dchunk.c
index fcc752c..021335f 100644
--- a/src/H5Dchunk.c
+++ b/src/H5Dchunk.c
@@ -150,6 +150,10 @@ typedef struct H5D_chunk_it_ud3_t {
 
     /* needed for copy object pointed by refs */
     H5O_copy_t          *cpy_info;              /* Copy options */
+
+    /* needed for getting raw data from chunk cache */
+    hbool_t             chunk_in_cache;
+    uint8_t             *chunk;                 /* the unfiltered chunk data        */
 } H5D_chunk_it_ud3_t;
 
 /* Callback info for iteration to dump index */
@@ -324,7 +328,6 @@ H5D__chunk_direct_write(const H5D_t *dset, hid_t dxpl_id, uint32_t filters, hsiz
     H5D_dxpl_cache_t *dxpl_cache = &_dxpl_cache;   /* Data transfer property cache */
     const H5D_rdcc_t       *rdcc = &(dset->shared->cache.chunk);    /*raw data chunk cache */
     unsigned    space_ndims;            /* Dataset's space rank */
-    hsize_t     space_dim[H5O_LAYOUT_NDIMS];    /* Dataset's dataspace dimensions */
     herr_t ret_value = SUCCEED;         /* Return value */
 
     FUNC_ENTER_STATIC
@@ -414,7 +417,6 @@ H5D__chunk_direct_read(const H5D_t *dset, hid_t dxpl_id, hsize_t *offset,
     const H5D_rdcc_t   *rdcc = &(dset->shared->cache.chunk); /* raw data chunk cache */
     H5D_chunk_ud_t     udata;          /* User data for querying chunk info */
     unsigned            space_ndims;    /* Dataset's space rank */
-    hsize_t            space_dim[H5O_LAYOUT_NDIMS]; /* Dataset's dataspace dimensions */
     hsize_t            chunk_offset[H5O_LAYOUT_NDIMS]; /* Dataset's chunk offset */
     hsize_t            chunk_idx;      /* Index of chunk cache entry */
     H5D_dxpl_cache_t   _dxpl_cache;    /* Data transfer property cache buffer */
@@ -521,7 +523,6 @@ H5D__get_chunk_storage_size(H5D_t *dset, hid_t dxpl_id, const hsize_t *offset, h
     const H5D_rdcc_t   *rdcc = &(dset->shared->cache.chunk); /* raw data chunk cache */
     H5D_chunk_ud_t     udata;          /* User data for querying chunk info */
     unsigned           space_ndims;    /* Dataset's space rank */
-    hsize_t            space_dim[H5O_LAYOUT_NDIMS]; /* Dataset's dataspace dimensions */
     hsize_t            chunk_offset[H5O_LAYOUT_NDIMS]; /* Dataset's chunk offset */
     hsize_t            chunk_idx;      /* Index of chunk cache entry */
     H5D_dxpl_cache_t   _dxpl_cache;    /* Data transfer property cache buffer */
@@ -4836,12 +4837,57 @@ H5D__chunk_copy_cb(const H5D_chunk_rec_t *chunk_rec, void *_udata)
         udata->buf_size = buf_size = nbytes;
     } /* end if */
 
-    /* read chunk data from the source file */
-    if(H5F_block_read(udata->file_src, H5FD_MEM_DRAW, chunk_rec->chunk_addr, nbytes, udata->idx_info_dst->dxpl_id, buf) < 0)
-        HGOTO_ERROR(H5E_IO, H5E_READERROR, H5_ITER_ERROR, "unable to read raw data chunk")
+    if(udata->chunk_in_cache && udata->chunk) {
+        HDassert(!H5F_addr_defined(chunk_rec->chunk_addr));
+        HDmemcpy(buf, udata->chunk, nbytes);
+        udata->chunk = NULL;
+    } else {
+        H5D_rdcc_ent_t *ent = NULL;    /* Cache entry */
+        unsigned idx;                   /* Index of chunk in cache, if present */
+        unsigned u;                     /* Counter */
+        H5D_shared_t *shared_fo = udata->cpy_info->shared_fo;
+
+        /* See if the written chunk is in the chunk cache */
+        if(shared_fo && shared_fo->cache.chunk.nslots > 0) {
+            hsize_t chunk_idx;                  /* Index of chunk cache entry */
+            H5O_layout_t  *layout = &shared_fo->layout;
+
+            /* Calculate the index of this chunk */
+            if(H5VM_chunk_index(layout->u.chunk.ndims - 1, chunk_rec->offset,
+                                layout->u.chunk.dim, layout->u.chunk.down_chunks, &chunk_idx) < 0)
+                HGOTO_ERROR(H5E_DATASET, H5E_CANTINIT, FAIL, "can't get chunk index")
+            idx = H5D_CHUNK_HASH(shared_fo, chunk_idx);
+
+            /* Get the chunk cache entry for that location */
+            ent = shared_fo->cache.chunk.slot[idx];
+            if(ent) {
+                /* Speculatively set the 'found' flag */
+                udata->chunk_in_cache = TRUE;
+
+                /* Verify that the cache entry is the correct chunk */
+                for(u = 0; u < (layout->u.chunk.ndims -1); u++)
+                    if(chunk_rec->offset[u] != ent->offset[u]) {
+                        udata->chunk_in_cache = FALSE;
+                        break;
+                    } /* end if */
+            } /* end if */
+        } /* end if */
+
+        if(udata->chunk_in_cache) {
+            HDassert(H5F_addr_defined(chunk_rec->chunk_addr));
+            HDassert(H5F_addr_defined(ent->chunk_addr));
+
+            H5_CHECKED_ASSIGN(nbytes, size_t, shared_fo->layout.u.chunk.size, uint32_t);
+            HDmemcpy(buf, ent->chunk, nbytes);
+        } else {
+            /* read chunk data from the source file */
+            if(H5F_block_read(udata->file_src, H5FD_MEM_DRAW, chunk_rec->chunk_addr, nbytes, udata->idx_info_dst->dxpl_id, buf) < 0)
+                HGOTO_ERROR(H5E_IO, H5E_READERROR, H5_ITER_ERROR, "unable to read raw data chunk")
+        }
+    }
 
     /* Need to uncompress variable-length & reference data elements */
-    if(has_filters && (is_vlen || fix_ref)) {
+    if(has_filters && (is_vlen || fix_ref) && !udata->chunk_in_cache) {
         unsigned filter_mask = chunk_rec->filter_mask;
 
         if(H5Z_pipeline(pline, H5Z_FLAG_REVERSE, &filter_mask, H5Z_NO_EDC, cb_struct, &nbytes, &buf_size, &buf) < 0)
@@ -4906,7 +4952,7 @@ H5D__chunk_copy_cb(const H5D_chunk_rec_t *chunk_rec, void *_udata)
     udata_dst.addr = HADDR_UNDEF;
 
     /* Need to compress variable-length & reference data elements before writing to file */
-    if(has_filters && (is_vlen || fix_ref) ) {
+    if(has_filters && (is_vlen || fix_ref || udata->chunk_in_cache) ) {
         if(H5Z_pipeline(pline, 0, &(udata_dst.filter_mask), H5Z_NO_EDC, cb_struct, &nbytes, &buf_size, &buf) < 0)
             HGOTO_ERROR(H5E_PLINE, H5E_CANTFILTER, H5_ITER_ERROR, "output pipeline failed")
 #if H5_SIZEOF_SIZE_T > 4
@@ -4971,6 +5017,7 @@ H5D__chunk_copy(H5F_t *f_src, H5O_storage_chunk_t *storage_src,
     uint32_t    nelmts = 0;             /* Number of elements in buffer */
     hbool_t     do_convert = FALSE;     /* Indicate that type conversions should be performed */
     hbool_t     copy_setup_done = FALSE;        /* Indicate that 'copy setup' is done */
+    H5D_shared_t *shared_fo = (H5D_shared_t *)cpy_info->shared_fo;
     herr_t      ret_value = SUCCEED;    /* Return value */
 
     FUNC_ENTER_PACKAGE
@@ -5157,11 +5204,39 @@ H5D__chunk_copy(H5F_t *f_src, H5O_storage_chunk_t *storage_src,
     udata.nelmts = nelmts;
     udata.pline = pline;
     udata.cpy_info = cpy_info;
+    udata.chunk_in_cache = FALSE;
+    udata.chunk = NULL;
+
+    if(!H5F_addr_defined(idx_info_src.storage->idx_addr))
+        idx_info_src.storage = &shared_fo->layout.storage.u.chunk;
+
+    HDassert(H5F_addr_defined(idx_info_src.storage->idx_addr));
 
     /* Iterate over chunks to copy data */
     if((storage_src->ops->iterate)(&idx_info_src, H5D__chunk_copy_cb, &udata) < 0)
         HGOTO_ERROR(H5E_DATASET, H5E_BADITER, FAIL, "unable to iterate over chunk index to copy data")
 
+     /* Iterate over the chunk cache to copy data for chunks with undefined address */
+    if(shared_fo) {
+        H5D_rdcc_ent_t  *ent, *next;
+        H5D_chunk_rec_t chunk_rec;
+
+        chunk_rec.nbytes = layout_src->size;
+        chunk_rec.filter_mask = 0;
+        chunk_rec.chunk_addr = HADDR_UNDEF;
+
+        for(ent = shared_fo->cache.chunk.head; ent; ent = next) {
+            if(!H5F_addr_defined(ent->chunk_addr)) {
+                HDmemcpy(chunk_rec.offset, ent->offset, sizeof(chunk_rec.offset));
+                udata.chunk = ent->chunk;
+                udata.chunk_in_cache = TRUE;
+                if(H5D__chunk_copy_cb(&chunk_rec, &udata) < 0)
+                    HGOTO_ERROR(H5E_DATASET, H5E_CANTCOPY, FAIL, "unable to copy chunk data in cache")
+            }
+            next = ent->next;
+        } /* end for */
+    }
+
     /* I/O buffers may have been re-allocated */
     buf = udata.buf;
     bkg = udata.bkg;
diff --git a/src/H5Dcompact.c b/src/H5Dcompact.c
index b142f3b..4b61442 100644
--- a/src/H5Dcompact.c
+++ b/src/H5Dcompact.c
@@ -396,7 +396,7 @@ done:
  *-------------------------------------------------------------------------
  */
 herr_t
-H5D__compact_copy(H5F_t *f_src, H5O_storage_compact_t *storage_src, H5F_t *f_dst,
+H5D__compact_copy(H5F_t *f_src, H5O_storage_compact_t *_storage_src, H5F_t *f_dst,
     H5O_storage_compact_t *storage_dst, H5T_t *dt_src, H5O_copy_t *cpy_info,
     hid_t dxpl_id)
 {
@@ -407,6 +407,8 @@ H5D__compact_copy(H5F_t *f_src, H5O_storage_compact_t *storage_src, H5F_t *f_dst
     void       *bkg = NULL;             /* Temporary buffer for copying data */
     void       *reclaim_buf = NULL;     /* Buffer for reclaiming data */
     hid_t       buf_sid = -1;           /* ID for buffer dataspace */
+    H5D_shared_t    *shared_fo = cpy_info->shared_fo;   /* Pointer to the shared struct for dataset object */
+    H5O_storage_compact_t *storage_src = _storage_src;  /* Pointer to storage_src */
     herr_t      ret_value = SUCCEED;    /* Return value */
 
     FUNC_ENTER_PACKAGE
@@ -418,6 +420,10 @@ H5D__compact_copy(H5F_t *f_src, H5O_storage_compact_t *storage_src, H5F_t *f_dst
     HDassert(storage_dst);
     HDassert(dt_src);
 
+    /* If the dataset is open in the file, point to "layout" in the shared struct */
+    if(shared_fo != NULL)
+        storage_src = &(shared_fo->layout.storage.u.compact);
+
     /* Allocate space for destination data */
     if(NULL == (storage_dst->buf = H5MM_malloc(storage_src->size)))
         HGOTO_ERROR(H5E_DATASET, H5E_CANTALLOC, FAIL, "unable to allocate memory for compact dataset")
diff --git a/src/H5Dcontig.c b/src/H5Dcontig.c
index c6cef57..9516d53 100644
--- a/src/H5Dcontig.c
+++ b/src/H5Dcontig.c
@@ -1298,6 +1298,10 @@ H5D__contig_copy(H5F_t *f_src, const H5O_storage_contig_t *storage_src,
     hsize_t     buf_dim[1] = {0};       /* Dimension for buffer */
     hbool_t     is_vlen = FALSE;        /* Flag to indicate that VL type conversion should occur */
     hbool_t     fix_ref = FALSE;        /* Flag to indicate that ref values should be fixed */
+    H5D_shared_t    *shared_fo = cpy_info->shared_fo;  /* Pointer to the shared struct for dataset object */
+    hbool_t     try_sieve = FALSE;          /* Try to get data from the sieve buffer */
+    haddr_t     sieve_start = HADDR_UNDEF;  /* Start location of sieve buffer */
+    haddr_t     sieve_end = HADDR_UNDEF;    /* End locations of sieve buffer */ 
     herr_t      ret_value = SUCCEED;    /* Return value */
 
     FUNC_ENTER_PACKAGE
@@ -1418,9 +1422,32 @@ H5D__contig_copy(H5F_t *f_src, const H5O_storage_contig_t *storage_src,
             HGOTO_ERROR(H5E_RESOURCE, H5E_NOSPACE, FAIL, "memory allocation failed for copy buffer")
     } /* end if */
 
-    /* Loop over copying data */
     addr_src = storage_src->addr;
     addr_dst = storage_dst->addr;
+
+    /* If data sieving is enabled and the dataset is open in the file,
+       set up to copy data out of the sieve buffer if deemed possible later */
+    if(H5F_HAS_FEATURE(f_src, H5FD_FEAT_DATA_SIEVE) &&
+       shared_fo && shared_fo->cache.contig.sieve_buf) {
+        try_sieve = TRUE;
+        sieve_start = shared_fo->cache.contig.sieve_loc;
+        sieve_end = sieve_start + shared_fo->cache.contig.sieve_size;
+        /* 
+         * It is possble for addr_src to be undefined when:
+         *  (a) The dataset is created and data is written to it.
+         *  (b) The dataset is then copied via H5Ocopy().
+         *  H5D_mark() in H5Dint.c is different between 
+         *  1.8 and develop branches:
+         *  1.8--it just sets dataset->shared->layout_dirty as TRUE 
+         *       to be flushed later.
+         *  develop--it will flush the layout message if it has been changed.
+         */
+        if(!H5F_addr_defined(addr_src))
+            addr_src = sieve_start;
+    }
+
+    HDassert(H5F_addr_defined(addr_src));
+    /* Loop over copying data */
     while(total_src_nbytes > 0) {
         /* Check if we should reduce the number of bytes to transfer */
         if(total_src_nbytes < src_nbytes) {
@@ -1446,14 +1473,20 @@ H5D__contig_copy(H5F_t *f_src, const H5O_storage_contig_t *storage_src,
                 dst_nbytes = mem_nbytes = src_nbytes;
         } /* end if */
 
-        /* Read raw data from source file */
-        if(H5F_block_read(f_src, H5FD_MEM_DRAW, addr_src, src_nbytes, H5P_DATASET_XFER_DEFAULT, buf) < 0)
-            HGOTO_ERROR(H5E_DATASET, H5E_READERROR, FAIL, "unable to read raw data")
+         /* If the entire copy is within the sieve buffer, copy data from the sieve buffer */
+        if(try_sieve && (addr_src >= sieve_start) && ((addr_src + src_nbytes -1) < sieve_end)) {
+            unsigned char *base_sieve_buf = shared_fo->cache.contig.sieve_buf + (addr_src - sieve_start);
+
+            HDmemcpy(buf, base_sieve_buf, src_nbytes);
+        } else
+            /* Read raw data from source file */
+            if(H5F_block_read(f_src, H5FD_MEM_DRAW, addr_src, src_nbytes, H5P_DATASET_XFER_DEFAULT, buf) < 0)
+                HGOTO_ERROR(H5E_DATASET, H5E_READERROR, FAIL, "unable to read raw data")
 
         /* Perform datatype conversion, if necessary */
         if(is_vlen) {
             /* Convert from source file to memory */
-	    if(H5T_convert(tpath_src_mem, tid_src, tid_mem, nelmts, (size_t)0, (size_t)0, buf, bkg, dxpl_id) < 0)
+            if(H5T_convert(tpath_src_mem, tid_src, tid_mem, nelmts, (size_t)0, (size_t)0, buf, bkg, dxpl_id) < 0)
                 HGOTO_ERROR(H5E_DATATYPE, H5E_CANTINIT, FAIL, "datatype conversion failed")
 
             /* Copy into another buffer, to reclaim memory later */
@@ -1463,13 +1496,13 @@ H5D__contig_copy(H5F_t *f_src, const H5O_storage_contig_t *storage_src,
             HDmemset(bkg, 0, buf_size);
 
             /* Convert from memory to destination file */
-	    if(H5T_convert(tpath_mem_dst, tid_mem, tid_dst, nelmts, (size_t)0, (size_t)0, buf, bkg, dxpl_id) < 0)
+            if(H5T_convert(tpath_mem_dst, tid_mem, tid_dst, nelmts, (size_t)0, (size_t)0, buf, bkg, dxpl_id) < 0)
                 HGOTO_ERROR(H5E_DATATYPE, H5E_CANTINIT, FAIL, "datatype conversion failed")
 
             /* Reclaim space from variable length data */
             if(H5D_vlen_reclaim(tid_mem, buf_space, H5P_DATASET_XFER_DEFAULT, reclaim_buf) < 0)
                 HGOTO_ERROR(H5E_DATASET, H5E_BADITER, FAIL, "unable to reclaim variable-length data")
-	} /* end if */
+        } /* end if */
         else if(fix_ref) {
             /* Check for expanding references */
             if(cpy_info->expand_ref) {
diff --git a/src/H5Gent.c b/src/H5Gent.c
index 05e8b3c..bb6aa38 100644
--- a/src/H5Gent.c
+++ b/src/H5Gent.c
@@ -541,8 +541,8 @@ herr_t
 H5G__ent_debug(const H5G_entry_t *ent, FILE *stream, int indent, int fwidth,
     const H5HL_t *heap)
 {
-    const char		*lval = NULL;
-    int nested_indent, nested_fwidth;
+    const char  *lval = NULL;
+    int         nested_indent, nested_fwidth;
 
     FUNC_ENTER_PACKAGE_NOERR
 
@@ -551,14 +551,14 @@ H5G__ent_debug(const H5G_entry_t *ent, FILE *stream, int indent, int fwidth,
     nested_fwidth = MAX(0, fwidth - 3);
 
     HDfprintf(stream, "%*s%-*s %lu\n", indent, "", fwidth,
-	      "Name offset into private heap:",
-	      (unsigned long) (ent->name_off));
+              "Name offset into private heap:",
+	          (unsigned long) (ent->name_off));
 
     HDfprintf(stream, "%*s%-*s %a\n", indent, "", fwidth,
-	      "Object header address:", ent->header);
+              "Object header address:", ent->header);
 
     HDfprintf(stream, "%*s%-*s ", indent, "", fwidth,
-	      "Cache info type:");
+              "Cache info type:");
     switch(ent->type) {
         case H5G_NOTHING_CACHED:
             HDfprintf(stream, "Nothing Cached\n");
@@ -581,13 +581,13 @@ H5G__ent_debug(const H5G_entry_t *ent, FILE *stream, int indent, int fwidth,
             HDfprintf(stream, "%*s%-*s\n", indent, "", fwidth,
                       "Cached information:");
             HDfprintf(stream, "%*s%-*s %lu\n", nested_indent, "", nested_fwidth,
-                       "Link value offset:",
-                       (unsigned long)(ent->cache.slink.lval_offset));
+                      "Link value offset:",
+                      (unsigned long)(ent->cache.slink.lval_offset));
             if(heap) {
                 lval = (const char *)H5HL_offset_into(heap, ent->cache.slink.lval_offset);
                 HDfprintf(stream, "%*s%-*s %s\n", nested_indent, "", nested_fwidth,
-                           "Link value:",
-                           lval);
+                          "Link value:",
+                          (lval == NULL) ? "" : lval);
             } /* end if */
             else
                 HDfprintf(stream, "%*s%-*s\n", nested_indent, "", nested_fwidth, "Warning: Invalid heap address given, name not displayed!");
diff --git a/src/H5Glink.c b/src/H5Glink.c
index 7b99207..255add0 100644
--- a/src/H5Glink.c
+++ b/src/H5Glink.c
@@ -224,7 +224,10 @@ herr_t
 H5G__ent_to_link(H5O_link_t *lnk, const H5HL_t *heap,
     const H5G_entry_t *ent, const char *name)
 {
-    FUNC_ENTER_PACKAGE_NOERR
+    hbool_t dup_soft = FALSE;           /* xstrdup the symbolic link name or not */
+    herr_t ret_value = SUCCEED;         /* Return value */
+
+    FUNC_ENTER_PACKAGE
 
     /* check arguments */
     HDassert(lnk);
@@ -236,18 +239,21 @@ H5G__ent_to_link(H5O_link_t *lnk, const H5HL_t *heap,
     lnk->cset = H5F_DEFAULT_CSET;
     lnk->corder = 0;
     lnk->corder_valid = FALSE;       /* Creation order not valid for this link */
-    lnk->name = H5MM_xstrdup(name);
-    HDassert(lnk->name);
+    if((lnk->name = H5MM_xstrdup(name)) == NULL)
+        HGOTO_ERROR(H5E_LINK, H5E_CANTGET, FAIL, "unable to duplicate link name")
 
     /* Object is a symbolic or hard link */
     if(ent->type == H5G_CACHED_SLINK) {
         const char *s;          /* Pointer to link value */
 
-        s = (const char *)H5HL_offset_into(heap, ent->cache.slink.lval_offset);
-        HDassert(s);
+        if((s = (const char *)H5HL_offset_into(heap, ent->cache.slink.lval_offset)) == NULL)
+            HGOTO_ERROR(H5E_LINK, H5E_CANTGET, FAIL, "unable to get symbolic link name")
 
         /* Copy the link value */
-        lnk->u.soft.name = H5MM_xstrdup(s);
+        if((lnk->u.soft.name = H5MM_xstrdup(s)) == NULL)
+            HGOTO_ERROR(H5E_LINK, H5E_CANTGET, FAIL, "unable to duplicate symbolic link name")
+
+        dup_soft = TRUE;
 
         /* Set link type */
         lnk->type = H5L_TYPE_SOFT;
@@ -260,7 +266,14 @@ H5G__ent_to_link(H5O_link_t *lnk, const H5HL_t *heap,
         lnk->type = H5L_TYPE_HARD;
     } /* end else */
 
-    FUNC_LEAVE_NOAPI(SUCCEED)
+done:
+    if(ret_value < 0) {
+        if(lnk->name)
+            H5MM_xfree(lnk->name);
+        if(ent->type == H5G_CACHED_SLINK && dup_soft)
+            H5MM_xfree(lnk->u.soft.name);
+    }
+    FUNC_LEAVE_NOAPI(ret_value)
 } /* end H5G__ent_to_link() */
 
 
diff --git a/src/H5Gnode.c b/src/H5Gnode.c
index 12e0d5e..2c4b840 100644
--- a/src/H5Gnode.c
+++ b/src/H5Gnode.c
@@ -13,14 +13,14 @@
 
 /*-------------------------------------------------------------------------
  *
- * Created:		H5Gnode.c
- *			Jun 26 1997
- *			Robb Matzke <matzke@llnl.gov>
+ * Created:	    H5Gnode.c
+ *              Jun 26 1997
+ *              Robb Matzke <matzke@llnl.gov>
  *
- * Purpose:		Functions for handling symbol table nodes.  A
- *			symbol table node is a small collection of symbol
- *			table entries.	A B-tree usually points to the
- *			symbol table nodes for any given symbol table.
+ * Purpose:     Functions for handling symbol table nodes.  A
+ *              symbol table node is a small collection of symbol
+ *              table entries.	A B-tree usually points to the
+ *              symbol table nodes for any given symbol table.
  *
  *-------------------------------------------------------------------------
  */
@@ -35,16 +35,16 @@
 /***********/
 /* Headers */
 /***********/
-#include "H5private.h"		/* Generic Functions			*/
-#include "H5ACprivate.h"	/* Metadata cache			*/
-#include "H5Eprivate.h"		/* Error handling		  	*/
-#include "H5Fprivate.h"		/* File access				*/
-#include "H5FLprivate.h"	/* Free Lists                           */
-#include "H5Gpkg.h"		/* Groups		  		*/
-#include "H5HLprivate.h"	/* Local Heaps				*/
-#include "H5MFprivate.h"	/* File memory management		*/
-#include "H5MMprivate.h"	/* Memory management			*/
-#include "H5Ppublic.h"		/* Property Lists                       */
+#include "H5private.h"      /* Generic Functions        */
+#include "H5ACprivate.h"    /* Metadata cache           */
+#include "H5Eprivate.h"     /* Error handling           */
+#include "H5Fprivate.h"     /* File access              */
+#include "H5FLprivate.h"    /* Free Lists               */
+#include "H5Gpkg.h"         /* Groups                   */
+#include "H5HLprivate.h"    /* Local Heaps              */
+#include "H5MFprivate.h"    /* File memory management   */
+#include "H5MMprivate.h"    /* Memory management        */
+#include "H5Ppublic.h"      /* Property Lists           */
 
 
 /****************/
@@ -77,20 +77,16 @@ typedef struct H5G_node_key_t {
 /* B-tree callbacks */
 static H5RC_t *H5G_node_get_shared(const H5F_t *f, const void *_udata);
 static herr_t H5G_node_create(H5F_t *f, hid_t dxpl_id, H5B_ins_t op, void *_lt_key,
-			      void *_udata, void *_rt_key,
-			      haddr_t *addr_p/*out*/);
+    void *_udata, void *_rt_key, haddr_t *addr_p/*out*/);
 static int H5G_node_cmp2(void *_lt_key, void *_udata, void *_rt_key);
 static int H5G_node_cmp3(void *_lt_key, void *_udata, void *_rt_key);
 static htri_t H5G_node_found(H5F_t *f, hid_t dxpl_id, haddr_t addr, const void *_lt_key,
-			     void *_udata);
+    void *_udata);
 static H5B_ins_t H5G_node_insert(H5F_t *f, hid_t dxpl_id, haddr_t addr, void *_lt_key,
-				 hbool_t *lt_key_changed, void *_md_key,
-				 void *_udata, void *_rt_key,
-				 hbool_t *rt_key_changed,
-				 haddr_t *new_node_p/*out*/);
+    hbool_t *lt_key_changed, void *_md_key, void *_udata, void *_rt_key,
+	hbool_t *rt_key_changed, haddr_t *new_node_p/*out*/);
 static H5B_ins_t H5G_node_remove(H5F_t *f, hid_t dxpl_id, haddr_t addr, void *lt_key,
-				 hbool_t *lt_key_changed, void *udata,
-				 void *rt_key, hbool_t *rt_key_changed);
+    hbool_t *lt_key_changed, void *udata, void *rt_key, hbool_t *rt_key_changed);
 static herr_t H5G_node_decode_key(const H5B_shared_t *shared, const uint8_t *raw, void *_key);
 static herr_t H5G_node_encode_key(const H5B_shared_t *shared, uint8_t *raw, const void *_key);
 static herr_t H5G_node_debug_key(FILE *stream, int indent, int fwidth,
@@ -103,21 +99,21 @@ static herr_t H5G_node_debug_key(FILE *stream, int indent, int fwidth,
 
 /* H5G inherits B-tree like properties from H5B */
 H5B_class_t H5B_SNODE[1] = {{
-    H5B_SNODE_ID,		/*id			*/
-    sizeof(H5G_node_key_t), 	/*sizeof_nkey		*/
-    H5G_node_get_shared,	/*get_shared		*/
-    H5G_node_create,		/*new			*/
-    H5G_node_cmp2,		/*cmp2			*/
-    H5G_node_cmp3,		/*cmp3			*/
-    H5G_node_found,		/*found			*/
-    H5G_node_insert,		/*insert		*/
-    TRUE,			/*follow min branch?	*/
-    TRUE,			/*follow max branch?	*/
-    H5B_RIGHT,                  /*critical key          */
-    H5G_node_remove,		/*remove		*/
-    H5G_node_decode_key,	/*decode		*/
-    H5G_node_encode_key,	/*encode		*/
-    H5G_node_debug_key,		/*debug			*/
+    H5B_SNODE_ID,               /*id            */
+    sizeof(H5G_node_key_t),     /*sizeof_nkey   */
+    H5G_node_get_shared,        /*get_shared    */
+    H5G_node_create,            /*new           */
+    H5G_node_cmp2,              /*cmp2          */
+    H5G_node_cmp3,              /*cmp3          */
+    H5G_node_found,             /*found	        */
+    H5G_node_insert,            /*insert        */
+    TRUE,                       /*follow min branch?    */
+    TRUE,                       /*follow max branch?    */
+    H5B_RIGHT,                  /*critical key  */
+    H5G_node_remove,            /*remove        */
+    H5G_node_decode_key,        /*decode        */
+    H5G_node_encode_key,        /*encode        */
+    H5G_node_debug_key          /*debug         */
 }};
 
 /* Declare a free list to manage the H5G_node_t struct */
@@ -138,17 +134,16 @@ H5FL_SEQ_DEFINE(H5G_entry_t);
 
 
 /*-------------------------------------------------------------------------
- * Function:	H5G_node_get_shared
+ * Function:    H5G_node_get_shared
  *
- * Purpose:	Returns the shared B-tree info for the specified UDATA.
+ * Purpose:     Returns the shared B-tree info for the specified UDATA.
  *
- * Return:	Success:	Pointer to the raw B-tree page for this
-                                file's groups
+ * Return:      Success:    Pointer to the raw B-tree page for this file's groups
  *
- *		Failure:	Can't fail
+ *              Failure:	Can't fail
  *
- * Programmer:	Robb Matzke
- *		Wednesday, October  8, 1997
+ * Programmer:  Robb Matzke
+ *              Wednesday, October  8, 1997
  *
  * Modifications:
  *
@@ -167,22 +162,22 @@ H5G_node_get_shared(const H5F_t *f, const void H5_ATTR_UNUSED *_udata)
 
 
 /*-------------------------------------------------------------------------
- * Function:	H5G_node_decode_key
+ * Function:    H5G_node_decode_key
  *
- * Purpose:	Decodes a raw key into a native key.
+ * Purpose:     Decodes a raw key into a native key.
  *
- * Return:	Non-negative on success/Negative on failure
+ * Return:      Non-negative on success/Negative on failure
  *
- * Programmer:	Robb Matzke
- *		matzke@llnl.gov
- *		Jul  8 1997
+ * Programmer:  Robb Matzke
+ *              matzke@llnl.gov
+ *              Jul  8 1997
  *
  *-------------------------------------------------------------------------
  */
 static herr_t
 H5G_node_decode_key(const H5B_shared_t *shared, const uint8_t *raw, void *_key)
 {
-    H5G_node_key_t	   *key = (H5G_node_key_t *) _key;
+    H5G_node_key_t  *key = (H5G_node_key_t *) _key;
 
     FUNC_ENTER_NOAPI_NOINIT_NOERR
 
@@ -199,13 +194,13 @@ H5G_node_decode_key(const H5B_shared_t *shared, const uint8_t *raw, void *_key)
 /*-------------------------------------------------------------------------
  * Function:	H5G_node_encode_key
  *
- * Purpose:	Encodes a native key into a raw key.
+ * Purpose:     Encodes a native key into a raw key.
  *
- * Return:	Non-negative on success/Negative on failure
+ * Return:      Non-negative on success/Negative on failure
  *
- * Programmer:	Robb Matzke
- *		matzke@llnl.gov
- *		Jul  8 1997
+ * Programmer:  Robb Matzke
+ *              matzke@llnl.gov
+ *              Jul  8 1997
  *
  *-------------------------------------------------------------------------
  */
@@ -227,13 +222,13 @@ H5G_node_encode_key(const H5B_shared_t *shared, uint8_t *raw, const void *_key)
 
 
 /*-------------------------------------------------------------------------
- * Function:	H5G_node_debug_key
+ * Function:    H5G_node_debug_key
  *
- * Purpose:	Prints a key.
+ * Purpose:     Prints a key.
  *
- * Return:	Non-negative on success/Negative on failure
+ * Return:      Non-negative on success/Negative on failure
  *
- * Programmer:	Quincey Koziol
+ * Programmer:  Quincey Koziol
  *              Friday, February 28, 2003
  *
  *-------------------------------------------------------------------------
@@ -242,7 +237,7 @@ static herr_t
 H5G_node_debug_key(FILE *stream, int indent, int fwidth, const void *_key,
     const void *_udata)
 {
-    const H5G_node_key_t   *key = (const H5G_node_key_t *) _key;
+    const H5G_node_key_t    *key = (const H5G_node_key_t *) _key;
     const H5G_bt_common_t   *udata = (const H5G_bt_common_t *) _udata;
 
     FUNC_ENTER_NOAPI_NOINIT_NOERR
@@ -250,15 +245,15 @@ H5G_node_debug_key(FILE *stream, int indent, int fwidth, const void *_key,
     HDassert(key);
 
     HDfprintf(stream, "%*s%-*s %u\n", indent, "", fwidth, "Heap offset:",
-        (unsigned)key->offset);
+              (unsigned)key->offset);
 
     if(udata->heap) {
         const char *s;
 
         HDfprintf(stream, "%*s%-*s ", indent, "", fwidth, "Name:");
 
-        s = (const char *)H5HL_offset_into(udata->heap, key->offset);
-        HDfprintf(stream, "%s\n", s);
+        if((s = (const char *)H5HL_offset_into(udata->heap, key->offset)) != NULL)
+            HDfprintf(stream, "%s\n", s);
     } /* end if */
     else
         HDfprintf(stream, "%*s%-*s ", indent, "", fwidth, "Cannot get name; heap address not specified\n");
@@ -270,13 +265,13 @@ H5G_node_debug_key(FILE *stream, int indent, int fwidth, const void *_key,
 /*-------------------------------------------------------------------------
  * Function:	H5G__node_free
  *
- * Purpose:	Destroy a symbol table node in memory.
+ * Purpose:     Destroy a symbol table node in memory.
  *
- * Return:	Non-negative on success/Negative on failure
+ * Return:      Non-negative on success/Negative on failure
  *
- * Programmer:	Quincey Koziol
- *		koziol@ncsa.uiuc.edu
- *		Jan 15 2003
+ * Programmer:  Quincey Koziol
+ *              koziol@ncsa.uiuc.edu
+ *              Jan 15 2003
  *
  *-------------------------------------------------------------------------
  */
@@ -305,29 +300,29 @@ H5G__node_free(H5G_node_t *sym)
  * Function:	H5G_node_create
  *
  * Purpose:	Creates a new empty symbol table node.	This function is
- *		called by the B-tree insert function for an empty tree.	 It
- *		is also called internally to split a symbol node with LT_KEY
- *		and RT_KEY null pointers.
+ *          called by the B-tree insert function for an empty tree.	 It
+ *          is also called internally to split a symbol node with LT_KEY
+ *          and RT_KEY null pointers.
  *
- * Return:	Success:	Non-negative.  The address of symbol table
- *				node is returned through the ADDR_P argument.
+ * Return:  Success:    Non-negative.   The address of symbol table
+ *                      node is returned through the ADDR_P argument.
  *
- *		Failure:	Negative
+ *          Failure:    Negative
  *
- * Programmer:	Robb Matzke
- *		matzke@llnl.gov
- *		Jun 23 1997
+ * Programmer:  Robb Matzke
+ *              matzke@llnl.gov
+ *              Jun 23 1997
  *
  *-------------------------------------------------------------------------
  */
 static herr_t
 H5G_node_create(H5F_t *f, hid_t dxpl_id, H5B_ins_t H5_ATTR_UNUSED op, void *_lt_key,
-		void H5_ATTR_UNUSED *_udata, void *_rt_key, haddr_t *addr_p/*out*/)
+    void H5_ATTR_UNUSED *_udata, void *_rt_key, haddr_t *addr_p/*out*/)
 {
-    H5G_node_key_t	*lt_key = (H5G_node_key_t *)_lt_key;
-    H5G_node_key_t	*rt_key = (H5G_node_key_t *)_rt_key;
-    H5G_node_t		*sym = NULL;
-    herr_t              ret_value = SUCCEED;       /* Return value */
+    H5G_node_key_t  *lt_key = (H5G_node_key_t *)_lt_key;
+    H5G_node_key_t  *rt_key = (H5G_node_key_t *)_rt_key;
+    H5G_node_t      *sym = NULL;
+    herr_t          ret_value = SUCCEED;       /* Return value */
 
     FUNC_ENTER_NOAPI_NOINIT
 
@@ -338,15 +333,15 @@ H5G_node_create(H5F_t *f, hid_t dxpl_id, H5B_ins_t H5_ATTR_UNUSED op, void *_lt_
     HDassert(H5B_INS_FIRST == op);
 
     if(NULL == (sym = H5FL_CALLOC(H5G_node_t)))
-	HGOTO_ERROR(H5E_RESOURCE, H5E_NOSPACE, FAIL, "memory allocation failed")
+        HGOTO_ERROR(H5E_RESOURCE, H5E_NOSPACE, FAIL, "memory allocation failed")
     sym->node_size = H5G_NODE_SIZE(f);
     if(HADDR_UNDEF == (*addr_p = H5MF_alloc(f, H5FD_MEM_BTREE, dxpl_id, (hsize_t)sym->node_size)))
-	HGOTO_ERROR(H5E_SYM, H5E_CANTINIT, FAIL, "unable to allocate file space")
+        HGOTO_ERROR(H5E_SYM, H5E_CANTINIT, FAIL, "unable to allocate file space")
     if(NULL == (sym->entry = H5FL_SEQ_CALLOC(H5G_entry_t, (size_t)(2 * H5F_SYM_LEAF_K(f)))))
-	HGOTO_ERROR(H5E_SYM, H5E_CANTALLOC, FAIL, "memory allocation failed")
+        HGOTO_ERROR(H5E_SYM, H5E_CANTALLOC, FAIL, "memory allocation failed")
 
     if(H5AC_insert_entry(f, dxpl_id, H5AC_SNODE, *addr_p, sym, H5AC__NO_FLAGS_SET) < 0)
-	HGOTO_ERROR(H5E_SYM, H5E_CANTINIT, FAIL, "unable to cache symbol table leaf node")
+        HGOTO_ERROR(H5E_SYM, H5E_CANTINIT, FAIL, "unable to cache symbol table leaf node")
     /*
      * The left and right symbols in an empty tree are both the
      * empty string stored at offset zero by the H5G functions. This
@@ -375,53 +370,51 @@ done:
  * Function:	H5G_node_cmp2
  *
  * Purpose:	Compares two keys from a B-tree node (LT_KEY and RT_KEY).
- *		The UDATA pointer supplies extra data not contained in the
- *		keys (in this case, the heap address).
+ *          The UDATA pointer supplies extra data not contained in the
+ *          keys (in this case, the heap address).
  *
- * Return:	Success:	negative if LT_KEY is less than RT_KEY.
+ * Return:  Success:    negative if LT_KEY is less than RT_KEY.
  *
- *				positive if LT_KEY is greater than RT_KEY.
+ *                      positive if LT_KEY is greater than RT_KEY.
  *
- *				zero if LT_KEY and RT_KEY are equal.
+ *                      zero if LT_KEY and RT_KEY are equal.
  *
- *		Failure:	FAIL (same as LT_KEY<RT_KEY)
+ *          Failure:    FAIL (same as LT_KEY<RT_KEY)
  *
- * Programmer:	Robb Matzke
- *		matzke@llnl.gov
- *		Jun 23 1997
+ * Programmer:  Robb Matzke
+ *              matzke@llnl.gov
+ *              Jun 23 1997
  *
  * Modifications:
  *
  *-------------------------------------------------------------------------
  */
-static int
+static herr_t
 H5G_node_cmp2(void *_lt_key, void *_udata, void *_rt_key)
 {
-    H5G_bt_common_t	   *udata = (H5G_bt_common_t *) _udata;
-    H5G_node_key_t	   *lt_key = (H5G_node_key_t *) _lt_key;
-    H5G_node_key_t	   *rt_key = (H5G_node_key_t *) _rt_key;
-    const char		   *s1, *s2;
-    const char		   *base;           /* Base of heap */
-    int		           ret_value;
+    H5G_bt_common_t     *udata = (H5G_bt_common_t *) _udata;
+    H5G_node_key_t      *lt_key = (H5G_node_key_t *) _lt_key;
+    H5G_node_key_t      *rt_key = (H5G_node_key_t *) _rt_key;
+    const char          *s1, *s2;
+    int                 ret_value = SUCCEED; /* Return value */
 
-    FUNC_ENTER_NOAPI_NOINIT_NOERR
+    FUNC_ENTER_NOAPI_NOINIT
 
     /* Sanity checks */
     HDassert(udata && udata->heap);
     HDassert(lt_key);
     HDassert(rt_key);
 
-    /* Get base address of heap */
-    base = (const char *)H5HL_offset_into(udata->heap, (size_t)0);
-    HDassert(base);
-
     /* Get pointers to string names */
-    s1 = base + lt_key->offset;
-    s2 = base + rt_key->offset;
+    if((s1 = (const char *)H5HL_offset_into(udata->heap, lt_key->offset)) == NULL)
+        HGOTO_ERROR(H5E_SYM, H5E_CANTGET, FAIL, "unable to get key name")
+    if((s2 = (const char *)H5HL_offset_into(udata->heap, rt_key->offset)) == NULL)
+        HGOTO_ERROR(H5E_SYM, H5E_CANTGET, FAIL, "unable to get key name")
 
     /* Set return value */
     ret_value = HDstrcmp(s1, s2);
 
+done:
     FUNC_LEAVE_NOAPI(ret_value)
 } /* H5G_node_cmp2() */
 
@@ -430,88 +423,86 @@ H5G_node_cmp2(void *_lt_key, void *_udata, void *_rt_key)
  * Function:	H5G_node_cmp3
  *
  * Purpose:	Compares two keys from a B-tree node (LT_KEY and RT_KEY)
- *		against another key (not necessarily the same type)
- *		pointed to by UDATA.
+ *          against another key (not necessarily the same type)
+ *          pointed to by UDATA.
  *
- * Return:	Success:	negative if the UDATA key is less than
- *				or equal to the LT_KEY
+ * Return:  Success:    negative if the UDATA key is less than
+ *                      or equal to the LT_KEY
  *
- *				positive if the UDATA key is greater
- *				than the RT_KEY.
+ *                      positive if the UDATA key is greater
+ *                      than the RT_KEY.
  *
- *				zero if the UDATA key falls between
- *				the LT_KEY (exclusive) and the
- *				RT_KEY (inclusive).
+ *                      zero if the UDATA key falls between
+ *                      the LT_KEY (exclusive) and the
+ *                      RT_KEY (inclusive).
  *
- *		Failure:	FAIL (same as UDATA < LT_KEY)
+ *          Failure:    FAIL (same as UDATA < LT_KEY)
  *
- * Programmer:	Robb Matzke
- *		matzke@llnl.gov
- *		Jun 23 1997
+ * Programmer:  Robb Matzke
+ *              matzke@llnl.gov
+ *              Jun 23 1997
  *
  * Modifications:
  *
  *-------------------------------------------------------------------------
  */
-static int
+static herr_t
 H5G_node_cmp3(void *_lt_key, void *_udata, void *_rt_key)
 {
-    H5G_bt_common_t	*udata = (H5G_bt_common_t *) _udata;
-    H5G_node_key_t	*lt_key = (H5G_node_key_t *) _lt_key;
-    H5G_node_key_t	*rt_key = (H5G_node_key_t *) _rt_key;
-    const char		*s;
-    const char          *base;              /* Base of heap */
-    int                  ret_value = 0;       /* Return value */
+    H5G_bt_common_t *udata = (H5G_bt_common_t *) _udata;
+    H5G_node_key_t  *lt_key = (H5G_node_key_t *) _lt_key;
+    H5G_node_key_t  *rt_key = (H5G_node_key_t *) _rt_key;
+    const char      *s;
+    herr_t          ret_value = SUCCEED;    /* Return value */
 
-    FUNC_ENTER_NOAPI_NOINIT_NOERR
+    FUNC_ENTER_NOAPI_NOINIT
 
     /* Sanity checks */
     HDassert(udata && udata->heap);
     HDassert(lt_key);
     HDassert(rt_key);
 
-    /* Get base address of heap */
-    base = (const char *)H5HL_offset_into(udata->heap, (size_t)0);
-    HDassert(base);
-
     /* left side */
-    s = base + lt_key->offset;
+    if((s = (const char *)H5HL_offset_into(udata->heap, lt_key->offset)) == NULL)
+        HGOTO_ERROR(H5E_SYM, H5E_CANTGET, FAIL, "unable to get key name")
     if(HDstrcmp(udata->name, s) <= 0)
-	ret_value = (-1);
+        ret_value = (-1);
     else {
         /* right side */
-        s = base + rt_key->offset;
+        if((s = (const char *)H5HL_offset_into(udata->heap, rt_key->offset)) == NULL)
+            HGOTO_ERROR(H5E_SYM, H5E_CANTGET, FAIL, "unable to get key name")
         if(HDstrcmp(udata->name, s) > 0)
             ret_value = 1;
     } /* end else */
 
+done:
     FUNC_LEAVE_NOAPI(ret_value)
 } /* end H5G_node_cmp3() */
 
 
 /*-------------------------------------------------------------------------
- * Function:	H5G_node_found
+ * Function:    H5G_node_found
  *
- * Purpose:	The B-tree search engine has found the symbol table node
- *		which contains the requested symbol if the symbol exists.
- *		This function should examine that node for the symbol and
- *		return information about the symbol through the UDATA
- *		structure which contains the symbol name on function
- *		entry.
+ * Purpose:     The B-tree search engine has found the symbol table node
+ *              which contains the requested symbol if the symbol exists.
+ *              This function should examine that node for the symbol and
+ *              return information about the symbol through the UDATA
+ *              structure which contains the symbol name on function
+ *              entry.
  *
- *		If the operation flag in UDATA is H5G_OPER_FIND, then
- *		the entry is copied from the symbol table to the UDATA
- *		entry field.  Otherwise the entry is copied from the
- *		UDATA entry field to the symbol table.
+ *              If the operation flag in UDATA is H5G_OPER_FIND, then
+ *              the entry is copied from the symbol table to the UDATA
+ *              entry field.  Otherwise the entry is copied from the
+ *              UDATA entry field to the symbol table.
  *
- * Return:	Success:	Non-negative (TRUE/FALSE) if found and data
- *                              returned through the UDATA pointer.
+ * Return:      Success:    Non-negative (TRUE/FALSE) if found and data
+ *                          returned through the UDATA pointer.
  *
- *		Failure:	Negative if not found.
+ *              Failure:    Negative if not found.
  *
- * Programmer:	Robb Matzke
- *		matzke@llnl.gov
- *		Jun 23 1997
+ * Programmer:  Robb Matzke
+ *              matzke@llnl.gov
+ *              Jun 23 1997
  *
  *-------------------------------------------------------------------------
  */
@@ -519,13 +510,12 @@ static htri_t
 H5G_node_found(H5F_t *f, hid_t dxpl_id, haddr_t addr, const void H5_ATTR_UNUSED *_lt_key,
     void *_udata)
 {
-    H5G_bt_lkp_t	*udata = (H5G_bt_lkp_t *)_udata;
-    H5G_node_t		*sn = NULL;
-    unsigned		lt = 0, idx = 0, rt;
-    int		        cmp = 1;
-    const char		*s;
-    const char          *base;                  /* Base of heap */
-    htri_t              ret_value = TRUE;       /* Return value */
+    H5G_bt_lkp_t    *udata = (H5G_bt_lkp_t *)_udata;
+    H5G_node_t      *sn = NULL;
+    unsigned        lt = 0, idx = 0, rt;
+    int             cmp = 1;
+    const char      *s;
+    htri_t          ret_value = TRUE;   /* Return value */
 
     FUNC_ENTER_NOAPI_NOINIT
 
@@ -540,25 +530,23 @@ H5G_node_found(H5F_t *f, hid_t dxpl_id, haddr_t addr, const void H5_ATTR_UNUSED
      * Load the symbol table node for exclusive access.
      */
     if(NULL == (sn = (H5G_node_t *)H5AC_protect(f, dxpl_id, H5AC_SNODE, addr, f, H5AC_READ)))
-	HGOTO_ERROR(H5E_SYM, H5E_CANTLOAD, FAIL, "unable to protect symbol table node")
-
-    /* Get base address of heap */
-    base = (const char *)H5HL_offset_into(udata->common.heap, (size_t)0);
-    HDassert(base);
+        HGOTO_ERROR(H5E_SYM, H5E_CANTLOAD, FAIL, "unable to protect symbol table node")
 
     /*
      * Binary search.
      */
     rt = sn->nsyms;
     while(lt < rt && cmp) {
-	idx = (lt + rt) / 2;
-        s = base + sn->entry[idx].name_off;
-	cmp = HDstrcmp(udata->common.name, s);
-
-	if (cmp < 0)
-	    rt = idx;
-	else
-	    lt = idx + 1;
+        idx = (lt + rt) / 2;
+        
+        if((s = (const char *)H5HL_offset_into(udata->common.heap, sn->entry[idx].name_off)) == NULL)
+            HGOTO_ERROR(H5E_SYM, H5E_CANTGET, FAIL, "unable to get symbol table name")
+        cmp = HDstrcmp(udata->common.name, s);
+
+        if (cmp < 0)
+            rt = idx;
+        else
+            lt = idx + 1;
     } /* end while */
 
     if(cmp)
@@ -570,43 +558,41 @@ H5G_node_found(H5F_t *f, hid_t dxpl_id, haddr_t addr, const void H5_ATTR_UNUSED
 
 done:
     if(sn && H5AC_unprotect(f, dxpl_id, H5AC_SNODE, addr, sn, H5AC__NO_FLAGS_SET) < 0)
-	HDONE_ERROR(H5E_SYM, H5E_PROTECT, FAIL, "unable to release symbol table node")
+        HDONE_ERROR(H5E_SYM, H5E_PROTECT, FAIL, "unable to release symbol table node")
 
     FUNC_LEAVE_NOAPI(ret_value)
 } /* end H5G_node_found() */
 
 
 /*-------------------------------------------------------------------------
- * Function:	H5G_node_insert
+ * Function:    H5G_node_insert
  *
- * Purpose:	The B-tree insertion engine has found the symbol table node
- *		which should receive the new symbol/address pair.  This
- *		function adds it to that node unless it already existed.
+ * Purpose:     The B-tree insertion engine has found the symbol table node
+ *              which should receive the new symbol/address pair.  This
+ *              function adds it to that node unless it already existed.
  *
- *		If the node has no room for the symbol then the node is
- *		split into two nodes.  The original node contains the
- *		low values and the new node contains the high values.
- *		The new symbol table entry is added to either node as
- *		appropriate.  When a split occurs, this function will
- *		write the maximum key of the low node to the MID buffer
- *		and return the address of the new node.
+ *              If the node has no room for the symbol then the node is
+ *              split into two nodes.  The original node contains the
+ *              low values and the new node contains the high values.
+ *              The new symbol table entry is added to either node as
+ *              appropriate.  When a split occurs, this function will
+ *              write the maximum key of the low node to the MID buffer
+ *              and return the address of the new node.
  *
- *		If the new key is larger than RIGHT then update RIGHT
- *		with the new key.
+ *              If the new key is larger than RIGHT then update RIGHT
+ *              with the new key.
  *
- * Return:	Success:	An insertion command for the caller, one of
- *				the H5B_INS_* constants.  The address of the
- *				new node, if any, is returned through the
- *				NEW_NODE_P argument.  NEW_NODE_P might not be
- *				initialized if the return value is
- *				H5B_INS_NOOP.
+ * Return:      Success:    An insertion command for the caller, one of
+ *                          the H5B_INS_* constants.  The address of the
+ *                          new node, if any, is returned through the
+ *                          NEW_NODE_P argument.  NEW_NODE_P might not be
+ *                          initialized if the return value is H5B_INS_NOOP.
  *
- *		Failure:	H5B_INS_ERROR, NEW_NODE_P might not be
- *				initialized.
+ *              Failure:    H5B_INS_ERROR, NEW_NODE_P might not be initialized.
  *
- * Programmer:	Robb Matzke
- *		matzke@llnl.gov
- *		Jun 24 1997
+ * Programmer:  Robb Matzke
+ *              matzke@llnl.gov
+ *              Jun 24 1997
  *
  *-------------------------------------------------------------------------
  */
@@ -617,18 +603,17 @@ H5G_node_insert(H5F_t *f, hid_t dxpl_id, haddr_t addr,
     void *_rt_key, hbool_t *rt_key_changed,
     haddr_t *new_node_p)
 {
-    H5G_node_key_t	*md_key = (H5G_node_key_t *) _md_key;
-    H5G_node_key_t	*rt_key = (H5G_node_key_t *) _rt_key;
-    H5G_bt_ins_t	*udata = (H5G_bt_ins_t *) _udata;
-    H5G_node_t		*sn = NULL, *snrt = NULL;
-    unsigned		sn_flags = H5AC__NO_FLAGS_SET, snrt_flags = H5AC__NO_FLAGS_SET;
-    const char		*s;
-    const char          *base;                  /* Base of heap */
-    unsigned		lt = 0, rt;		/* Binary search cntrs	*/
-    int		        cmp = 1, idx = -1;
-    H5G_node_t		*insert_into = NULL;	/*node that gets new entry*/
-    H5G_entry_t         ent;                    /* Entry to insert in node */
-    H5B_ins_t		ret_value = H5B_INS_ERROR;
+    H5G_node_key_t  *md_key = (H5G_node_key_t *) _md_key;
+    H5G_node_key_t  *rt_key = (H5G_node_key_t *) _rt_key;
+    H5G_bt_ins_t    *udata = (H5G_bt_ins_t *) _udata;
+    H5G_node_t      *sn = NULL, *snrt = NULL;
+    unsigned        sn_flags = H5AC__NO_FLAGS_SET, snrt_flags = H5AC__NO_FLAGS_SET;
+    const char      *s;
+    unsigned        lt = 0, rt;             /* Binary search cntrs	*/
+    int             cmp = 1, idx = -1;
+    H5G_node_t      *insert_into = NULL;    /*node that gets new entry*/
+    H5G_entry_t     ent;                    /* Entry to insert in node */
+    H5B_ins_t       ret_value = H5B_INS_ERROR;
 
     FUNC_ENTER_NOAPI_NOINIT
 
@@ -646,96 +631,93 @@ H5G_node_insert(H5F_t *f, hid_t dxpl_id, haddr_t addr,
      * Load the symbol node.
      */
     if(NULL == (sn = (H5G_node_t *)H5AC_protect(f, dxpl_id, H5AC_SNODE, addr, f, H5AC_WRITE)))
-	HGOTO_ERROR(H5E_SYM, H5E_CANTLOAD, H5B_INS_ERROR, "unable to protect symbol table node")
-
-    /* Get base address of heap */
-    base = (const char *)H5HL_offset_into(udata->common.heap, (size_t)0);
-    HDassert(base);
+        HGOTO_ERROR(H5E_SYM, H5E_CANTLOAD, H5B_INS_ERROR, "unable to protect symbol table node")
 
     /*
      * Where does the new symbol get inserted?	We use a binary search.
      */
     rt = sn->nsyms;
     while(lt < rt) {
-	idx = (int)((lt + rt) / 2);
-        s = base + sn->entry[idx].name_off;
+        idx = (int)((lt + rt) / 2);
+        if((s = (const char *)H5HL_offset_into(udata->common.heap, sn->entry[idx].name_off)) == NULL)
+            HGOTO_ERROR(H5E_SYM, H5E_CANTGET, FAIL, "unable to get symbol table name")
 
         /* Check if symbol is already present */
-	if(0 == (cmp = HDstrcmp(udata->common.name, s)))
+        if(0 == (cmp = HDstrcmp(udata->common.name, s)))
             HGOTO_ERROR(H5E_SYM, H5E_CANTINSERT, H5B_INS_ERROR, "symbol is already present in symbol table")
 
-	if (cmp < 0)
-	    rt = (unsigned)idx;
-	else
-	    lt = (unsigned)(idx + 1);
+        if (cmp < 0)
+            rt = (unsigned)idx;
+        else
+            lt = (unsigned)(idx + 1);
     } /* end while */
     idx += cmp > 0 ? 1 : 0;
 
     /* Convert link information & name to symbol table entry */
     if(H5G__ent_convert(f, dxpl_id, udata->common.heap, udata->common.name,
             udata->lnk, udata->obj_type, udata->crt_info, &ent) < 0)
-	HGOTO_ERROR(H5E_SYM, H5E_CANTCONVERT, H5B_INS_ERROR, "unable to convert link")
+        HGOTO_ERROR(H5E_SYM, H5E_CANTCONVERT, H5B_INS_ERROR, "unable to convert link")
 
     /* Determine where to place entry in node */
     if(sn->nsyms >= 2 * H5F_SYM_LEAF_K(f)) {
-	/*
-	 * The node is full.  Split it into a left and right
-	 * node and return the address of the new right node (the
-	 * left node is at the same address as the original node).
-	 */
-	ret_value = H5B_INS_RIGHT;
-
-	/* The right node */
-	if(H5G_node_create(f, dxpl_id, H5B_INS_FIRST, NULL, NULL, NULL, new_node_p/*out*/) < 0)
-	    HGOTO_ERROR(H5E_SYM, H5E_CANTINIT, H5B_INS_ERROR, "unable to split symbol table node")
-
-	if(NULL == (snrt = (H5G_node_t *)H5AC_protect(f, dxpl_id, H5AC_SNODE, *new_node_p, f, H5AC_WRITE)))
-	    HGOTO_ERROR(H5E_SYM, H5E_CANTLOAD, H5B_INS_ERROR, "unable to split symbol table node")
-
-	HDmemcpy(snrt->entry, sn->entry + H5F_SYM_LEAF_K(f),
-		 H5F_SYM_LEAF_K(f) * sizeof(H5G_entry_t));
-	snrt->nsyms = H5F_SYM_LEAF_K(f);
+        /*
+         * The node is full.  Split it into a left and right
+         * node and return the address of the new right node (the
+         * left node is at the same address as the original node).
+         */
+        ret_value = H5B_INS_RIGHT;
+
+        /* The right node */
+        if(H5G_node_create(f, dxpl_id, H5B_INS_FIRST, NULL, NULL, NULL, new_node_p/*out*/) < 0)
+            HGOTO_ERROR(H5E_SYM, H5E_CANTINIT, H5B_INS_ERROR, "unable to split symbol table node")
+
+        if(NULL == (snrt = (H5G_node_t *)H5AC_protect(f, dxpl_id, H5AC_SNODE, *new_node_p, f, H5AC_WRITE)))
+            HGOTO_ERROR(H5E_SYM, H5E_CANTLOAD, H5B_INS_ERROR, "unable to split symbol table node")
+
+        HDmemcpy(snrt->entry, sn->entry + H5F_SYM_LEAF_K(f),
+            H5F_SYM_LEAF_K(f) * sizeof(H5G_entry_t));
+        snrt->nsyms = H5F_SYM_LEAF_K(f);
         snrt_flags |= H5AC__DIRTIED_FLAG;
 
-	/* The left node */
-	HDmemset(sn->entry + H5F_SYM_LEAF_K(f), 0,
-		 H5F_SYM_LEAF_K(f) * sizeof(H5G_entry_t));
-	sn->nsyms = H5F_SYM_LEAF_K(f);
+        /* The left node */
+        HDmemset(sn->entry + H5F_SYM_LEAF_K(f), 0,
+            H5F_SYM_LEAF_K(f) * sizeof(H5G_entry_t));
+        sn->nsyms = H5F_SYM_LEAF_K(f);
         sn_flags |= H5AC__DIRTIED_FLAG;
 
-	/* The middle key */
-	md_key->offset = sn->entry[sn->nsyms - 1].name_off;
+        /* The middle key */
+        md_key->offset = sn->entry[sn->nsyms - 1].name_off;
 
-	/* Where to insert the new entry? */
-	if(idx <= (int)H5F_SYM_LEAF_K(f)) {
-	    insert_into = sn;
-	    if(idx == (int)H5F_SYM_LEAF_K(f))
-		md_key->offset = ent.name_off;
-	} /* end if */
+        /* Where to insert the new entry? */
+        if(idx <= (int)H5F_SYM_LEAF_K(f)) {
+            insert_into = sn;
+            if(idx == (int)H5F_SYM_LEAF_K(f))
+                md_key->offset = ent.name_off;
+        } /* end if */
         else {
-	    idx -= H5F_SYM_LEAF_K(f);
-	    insert_into = snrt;
-	    if(idx == (int)H5F_SYM_LEAF_K(f)) {
-		rt_key->offset = ent.name_off;
-		*rt_key_changed = TRUE;
-	    } /* end if */
-	} /* end else */
+            idx -= H5F_SYM_LEAF_K(f);
+            insert_into = snrt;
+            if(idx == (int)H5F_SYM_LEAF_K(f)) {
+                rt_key->offset = ent.name_off;
+                *rt_key_changed = TRUE;
+            } /* end if */
+        } /* end else */
     } /* end if */
     else {
-	/* Where to insert the new entry? */
-	ret_value = H5B_INS_NOOP;
+        /* Where to insert the new entry? */
+        ret_value = H5B_INS_NOOP;
         sn_flags |= H5AC__DIRTIED_FLAG;
-	insert_into = sn;
-	if(idx == (int)sn->nsyms) {
-	    rt_key->offset = ent.name_off;
-	    *rt_key_changed = TRUE;
-	} /* end if */
+        insert_into = sn;
+        if(idx == (int)sn->nsyms) {
+            rt_key->offset = ent.name_off;
+            *rt_key_changed = TRUE;
+        } /* end if */
     } /* end else */
 
     /* Move entries down to make room for new entry */
     HDassert(idx >= 0);
     HDmemmove(insert_into->entry + idx + 1, insert_into->entry + idx,
-	      (insert_into->nsyms - (unsigned)idx) * sizeof(H5G_entry_t));
+        (insert_into->nsyms - (unsigned)idx) * sizeof(H5G_entry_t));
 
     /* Copy new entry into table */
     H5G__ent_copy(&(insert_into->entry[idx]), &ent, H5_COPY_SHALLOW);
@@ -745,56 +727,56 @@ H5G_node_insert(H5F_t *f, hid_t dxpl_id, haddr_t addr,
 
 done:
     if(snrt && H5AC_unprotect(f, dxpl_id, H5AC_SNODE, *new_node_p, snrt, snrt_flags) < 0)
-	HDONE_ERROR(H5E_SYM, H5E_PROTECT, H5B_INS_ERROR, "unable to release symbol table node")
+        HDONE_ERROR(H5E_SYM, H5E_PROTECT, H5B_INS_ERROR, "unable to release symbol table node")
     if(sn && H5AC_unprotect(f, dxpl_id, H5AC_SNODE, addr, sn, sn_flags) < 0)
-	HDONE_ERROR(H5E_SYM, H5E_PROTECT, H5B_INS_ERROR, "unable to release symbol table node")
+        HDONE_ERROR(H5E_SYM, H5E_PROTECT, H5B_INS_ERROR, "unable to release symbol table node")
 
     FUNC_LEAVE_NOAPI(ret_value)
 } /* end H5G_node_insert() */
 
 
 /*-------------------------------------------------------------------------
- * Function:	H5G_node_remove
+ * Function:    H5G_node_remove
  *
- * Purpose:	The B-tree removal engine has found the symbol table node
- *		which should contain the name which is being removed.  This
- *		function removes the name from the symbol table and
- *		decrements the link count on the object to which the name
- *		points.
+ * Purpose: The B-tree removal engine has found the symbol table node
+ *          which should contain the name which is being removed.  This
+ *          function removes the name from the symbol table and
+ *          decrements the link count on the object to which the name
+ *          points.
  *
- *              If the udata->name parameter is set to NULL, then remove
- *              all entries in this symbol table node.  This only occurs
- *              during the deletion of the entire group, so don't bother
- *              freeing individual name entries in the local heap, the group's
- *              symbol table removal code will just free the entire local
- *              heap eventually.  Do reduce the link counts for each object
- *              however.
+ *          If the udata->name parameter is set to NULL, then remove
+ *          all entries in this symbol table node.  This only occurs
+ *          during the deletion of the entire group, so don't bother
+ *          freeing individual name entries in the local heap, the group's
+ *          symbol table removal code will just free the entire local
+ *          heap eventually.  Do reduce the link counts for each object
+ *          however.
  *
- * Return:	Success:	If all names are removed from the symbol
- *				table node then H5B_INS_REMOVE is returned;
- *				otherwise H5B_INS_NOOP is returned.
+ * Return:  Success:    If all names are removed from the symbol
+ *                      table node then H5B_INS_REMOVE is returned;
+ *                      otherwise H5B_INS_NOOP is returned.
  *
- *		Failure:	H5B_INS_ERROR
+ *          Failure:    H5B_INS_ERROR
  *
- * Programmer:	Robb Matzke
+ * Programmer:  Robb Matzke
  *              Thursday, September 24, 1998
  *
  *-------------------------------------------------------------------------
  */
 static H5B_ins_t
 H5G_node_remove(H5F_t *f, hid_t dxpl_id, haddr_t addr, void *_lt_key/*in,out*/,
-		hbool_t H5_ATTR_UNUSED *lt_key_changed/*out*/,
-		void *_udata/*in,out*/, void *_rt_key/*in,out*/,
-		hbool_t *rt_key_changed/*out*/)
+    hbool_t H5_ATTR_UNUSED *lt_key_changed/*out*/,
+    void *_udata/*in,out*/, void *_rt_key/*in,out*/,
+    hbool_t *rt_key_changed/*out*/)
 {
-    H5G_node_key_t	*lt_key = (H5G_node_key_t *)_lt_key;
-    H5G_node_key_t	*rt_key = (H5G_node_key_t *)_rt_key;
-    H5G_bt_rm_t	*udata = (H5G_bt_rm_t *)_udata;
-    H5G_node_t		*sn = NULL;
-    unsigned		sn_flags = H5AC__NO_FLAGS_SET;
-    unsigned		lt = 0, rt, idx = 0;
-    int		        cmp = 1;
-    H5B_ins_t		ret_value = H5B_INS_ERROR;
+    H5G_node_key_t  *lt_key = (H5G_node_key_t *)_lt_key;
+    H5G_node_key_t  *rt_key = (H5G_node_key_t *)_rt_key;
+    H5G_bt_rm_t     *udata = (H5G_bt_rm_t *)_udata;
+    H5G_node_t      *sn = NULL;
+    unsigned        sn_flags = H5AC__NO_FLAGS_SET;
+    unsigned        lt = 0, rt, idx = 0;
+    int             cmp = 1;
+    H5B_ins_t       ret_value = H5B_INS_ERROR;
 
     FUNC_ENTER_NOAPI_NOINIT
 
@@ -807,16 +789,12 @@ H5G_node_remove(H5F_t *f, hid_t dxpl_id, haddr_t addr, void *_lt_key/*in,out*/,
 
     /* Load the symbol table */
     if(NULL == (sn = (H5G_node_t *)H5AC_protect(f, dxpl_id, H5AC_SNODE, addr, f, H5AC_WRITE)))
-	HGOTO_ERROR(H5E_SYM, H5E_CANTLOAD, H5B_INS_ERROR, "unable to protect symbol table node")
+        HGOTO_ERROR(H5E_SYM, H5E_CANTLOAD, H5B_INS_ERROR, "unable to protect symbol table node")
 
     /* "Normal" removal of a single entry from the symbol table node */
     if(udata->common.name != NULL) {
         H5O_link_t lnk;         /* Constructed link for replacement */
         size_t link_name_len;   /* Length of string in local heap */
-        const char *base;       /* Base of heap */
-
-        /* Get base address of heap */
-        base = (const char *)H5HL_offset_into(udata->common.heap, (size_t)0);
 
         /* Find the name with a binary search */
         rt = sn->nsyms;
@@ -824,7 +802,8 @@ H5G_node_remove(H5F_t *f, hid_t dxpl_id, haddr_t addr, void *_lt_key/*in,out*/,
             const char *s;          /* Pointer to string in local heap */
 
             idx = (lt + rt) / 2;
-            s = base + sn->entry[idx].name_off;
+            if((s = H5HL_offset_into(udata->common.heap, sn->entry[idx].name_off)) == NULL)
+                HGOTO_ERROR(H5E_SYM, H5E_CANTGET, FAIL, "unable to get symbol table name")
             cmp = HDstrcmp(udata->common.name, s);
             if(cmp < 0)
                 rt = idx;
@@ -846,7 +825,8 @@ H5G_node_remove(H5F_t *f, hid_t dxpl_id, haddr_t addr, void *_lt_key/*in,out*/,
         lnk.cset = H5T_CSET_ASCII;
         if(sn->entry[idx].type == H5G_CACHED_SLINK) {
             lnk.type = H5L_TYPE_SOFT;
-            lnk.u.soft.name = (char *)H5HL_offset_into(udata->common.heap, sn->entry[idx].cache.slink.lval_offset);
+            if(NULL == (lnk.u.soft.name = (char *)H5HL_offset_into(udata->common.heap, sn->entry[idx].cache.slink.lval_offset)))
+                HGOTO_ERROR(H5E_SYM, H5E_CANTGET, H5B_INS_ERROR, "unable to get link name")
         } /* end if */
         else {
             lnk.type = H5L_TYPE_HARD;
@@ -960,22 +940,22 @@ H5G_node_remove(H5F_t *f, hid_t dxpl_id, haddr_t addr, void *_lt_key/*in,out*/,
 
 done:
     if(sn && H5AC_unprotect(f, dxpl_id, H5AC_SNODE, addr, sn, sn_flags) < 0)
-	HDONE_ERROR(H5E_SYM, H5E_CANTUNPROTECT, H5B_INS_ERROR, "unable to release symbol table node")
+        HDONE_ERROR(H5E_SYM, H5E_CANTUNPROTECT, H5B_INS_ERROR, "unable to release symbol table node")
 
     FUNC_LEAVE_NOAPI(ret_value)
 } /* end H5G_node_remove() */
 
 
 /*-------------------------------------------------------------------------
- * Function:	H5G__node_iterate
+ * Function:    H5G__node_iterate
  *
- * Purpose:	This function gets called during a group iterate operation.
+ * Purpose:     This function gets called during a group iterate operation.
  *
- * Return:	Non-negative on success/Negative on failure
+ * Return:      Non-negative on success/Negative on failure
  *
- * Programmer:	Robb Matzke
- *		matzke@llnl.gov
- *		Jun 24 1997
+ * Programmer:  Robb Matzke
+ *              matzke@llnl.gov
+ *              Jun 24 1997
  *
  *-------------------------------------------------------------------------
  */
@@ -983,11 +963,11 @@ int
 H5G__node_iterate(H5F_t *f, hid_t dxpl_id, const void H5_ATTR_UNUSED *_lt_key, haddr_t addr,
     const void H5_ATTR_UNUSED *_rt_key, void *_udata)
 {
-    H5G_bt_it_it_t	*udata = (H5G_bt_it_it_t *)_udata;
-    H5G_node_t		*sn = NULL;
-    H5G_entry_t		*ents;                  /* Pointer to entries in this node */
-    unsigned		u;                      /* Local index variable */
-    int	                ret_value = H5_ITER_CONT;
+    H5G_bt_it_it_t  *udata = (H5G_bt_it_it_t *)_udata;
+    H5G_node_t      *sn = NULL;
+    H5G_entry_t     *ents;              /* Pointer to entries in this node */
+    unsigned        u;                  /* Local index variable */
+    int             ret_value = H5_ITER_CONT;
 
     FUNC_ENTER_PACKAGE
 
@@ -1000,7 +980,7 @@ H5G__node_iterate(H5F_t *f, hid_t dxpl_id, const void H5_ATTR_UNUSED *_lt_key, h
 
     /* Protect the symbol table node & local heap while we iterate over entries */
     if(NULL == (sn = (H5G_node_t *)H5AC_protect(f, dxpl_id, H5AC_SNODE, addr, f, H5AC_READ)))
-	HGOTO_ERROR(H5E_SYM, H5E_CANTLOAD, H5_ITER_ERROR, "unable to load symbol table node")
+        HGOTO_ERROR(H5E_SYM, H5E_CANTLOAD, H5_ITER_ERROR, "unable to load symbol table node")
 
     /*
      * Iterate over the symbol table node entries.
@@ -1013,8 +993,8 @@ H5G__node_iterate(H5F_t *f, hid_t dxpl_id, const void H5_ATTR_UNUSED *_lt_key, h
             const char *name;   /* Pointer to link name in heap */
 
             /* Get the pointer to the name of the link in the heap */
-            name = (const char *)H5HL_offset_into(udata->heap, ents[u].name_off);
-            HDassert(name);
+            if((name = (const char *)H5HL_offset_into(udata->heap, ents[u].name_off)) == NULL)
+                HGOTO_ERROR(H5E_SYM, H5E_CANTGET, H5_ITER_ERROR, "unable to get symbol table node name")
 
             /* Convert the entry to a link */
             if(H5G__ent_to_link(&lnk, udata->heap, &ents[u], name) < 0)
@@ -1043,15 +1023,14 @@ done:
 
     FUNC_LEAVE_NOAPI(ret_value)
 } /* end H5G__node_iterate() */
-
 
 /*-------------------------------------------------------------------------
- * Function:	H5G__node_sumup
+ * Function:    H5G__node_sumup
  *
- * Purpose:	This function gets called during a group iterate operation
+ * Purpose:     This function gets called during a group iterate operation
  *              to return total number of members in the group.
  *
- * Return:	Non-negative on success/Negative on failure
+ * Return:      Non-negative on success/Negative on failure
  *
  * Programmer:  Raymond Lu
  *              Nov 20, 2002
@@ -1060,11 +1039,11 @@ done:
  */
 int
 H5G__node_sumup(H5F_t *f, hid_t dxpl_id, const void H5_ATTR_UNUSED *_lt_key, haddr_t addr,
-		  const void H5_ATTR_UNUSED *_rt_key, void *_udata)
+    const void H5_ATTR_UNUSED *_rt_key, void *_udata)
 {
     hsize_t	        *num_objs = (hsize_t *)_udata;
-    H5G_node_t		*sn = NULL;
-    int                  ret_value = H5_ITER_CONT;
+    H5G_node_t      *sn = NULL;
+    int             ret_value = H5_ITER_CONT;
 
     FUNC_ENTER_PACKAGE
 
@@ -1077,7 +1056,7 @@ H5G__node_sumup(H5F_t *f, hid_t dxpl_id, const void H5_ATTR_UNUSED *_lt_key, had
 
     /* Find the object node and add the number of symbol entries. */
     if(NULL == (sn = (H5G_node_t *)H5AC_protect(f, dxpl_id, H5AC_SNODE, addr, f, H5AC_READ)))
-	HGOTO_ERROR(H5E_SYM, H5E_CANTLOAD, H5_ITER_ERROR, "unable to load symbol table node")
+        HGOTO_ERROR(H5E_SYM, H5E_CANTLOAD, H5_ITER_ERROR, "unable to load symbol table node")
 
     *num_objs += sn->nsyms;
 
@@ -1090,12 +1069,12 @@ done:
 
 
 /*-------------------------------------------------------------------------
- * Function:	H5G__node_by_idx
+ * Function:    H5G__node_by_idx
  *
- * Purpose:	This function gets called during a group iterate operation
+ * Purpose:     This function gets called during a group iterate operation
  *              to return object name by giving idx.
  *
- * Return:	0 if object isn't found in this node; 1 if object is found;
+ * Return:      0 if object isn't found in this node; 1 if object is found;
  *              Negative on failure
  *
  * Programmer:  Raymond Lu
@@ -1105,11 +1084,11 @@ done:
  */
 int
 H5G__node_by_idx(H5F_t *f, hid_t dxpl_id, const void H5_ATTR_UNUSED *_lt_key, haddr_t addr,
-		  const void H5_ATTR_UNUSED *_rt_key, void *_udata)
+    const void H5_ATTR_UNUSED *_rt_key, void *_udata)
 {
-    H5G_bt_it_idx_common_t	*udata = (H5G_bt_it_idx_common_t *)_udata;
-    H5G_node_t		*sn = NULL;
-    int                 ret_value = H5_ITER_CONT;
+    H5G_bt_it_idx_common_t  *udata = (H5G_bt_it_idx_common_t *)_udata;
+    H5G_node_t              *sn = NULL;
+    int                     ret_value = H5_ITER_CONT;
 
     FUNC_ENTER_PACKAGE
 
@@ -1122,7 +1101,7 @@ H5G__node_by_idx(H5F_t *f, hid_t dxpl_id, const void H5_ATTR_UNUSED *_lt_key, ha
 
     /* Get a pointer to the symbol table node */
     if(NULL == (sn = (H5G_node_t *)H5AC_protect(f, dxpl_id, H5AC_SNODE, addr, f, H5AC_READ)))
-	HGOTO_ERROR(H5E_SYM, H5E_CANTLOAD, H5_ITER_ERROR, "unable to load symbol table node");
+        HGOTO_ERROR(H5E_SYM, H5E_CANTLOAD, H5_ITER_ERROR, "unable to load symbol table node");
 
     /* Find the node, locate the object symbol table entry and retrieve the name */
     if(udata->idx >= udata->num_objs && udata->idx < (udata->num_objs + sn->nsyms)) {
@@ -1151,12 +1130,12 @@ done:
 
 
 /*-------------------------------------------------------------------------
- * Function:	H5G__node_init
+ * Function:    H5G__node_init
  *
- * Purpose:	This function gets called during a file opening to initialize
+ * Purpose:     This function gets called during a file opening to initialize
  *              global information about group B-tree nodes for file.
  *
- * Return:	Non-negative on success
+ * Return:      Non-negative on success
  *              Negative on failure
  *
  * Programmer:  Quincey Koziol
@@ -1167,9 +1146,9 @@ done:
 herr_t
 H5G__node_init(H5F_t *f)
 {
-    H5B_shared_t *shared;               /* Shared B-tree node info */
-    size_t	sizeof_rkey;	        /* Size of raw (disk) key	     */
-    herr_t      ret_value = SUCCEED;    /* Return value */
+    H5B_shared_t    *shared;                /* Shared B-tree node info  */
+    size_t          sizeof_rkey;            /* Size of raw (disk) key   */
+    herr_t          ret_value = SUCCEED;    /* Return value             */
 
     FUNC_ENTER_PACKAGE
 
@@ -1181,14 +1160,14 @@ H5G__node_init(H5F_t *f)
 
     /* Allocate & initialize global info for the shared structure */
     if(NULL == (shared = H5B_shared_new(f, H5B_SNODE, sizeof_rkey)))
-	HGOTO_ERROR(H5E_BTREE, H5E_NOSPACE, FAIL, "memory allocation failed for shared B-tree info")
+        HGOTO_ERROR(H5E_BTREE, H5E_NOSPACE, FAIL, "memory allocation failed for shared B-tree info")
 
     /* Set up the "local" information for this file's groups */
-        /* <none> */
+    /* <none> */
 
     /* Make shared B-tree info reference counted */
     if(H5F_SET_GRP_BTREE_SHARED(f, H5RC_create(shared, H5B_shared_free)) < 0)
-	HGOTO_ERROR(H5E_RESOURCE, H5E_NOSPACE, FAIL, "can't create ref-count wrapper for shared B-tree info")
+        HGOTO_ERROR(H5E_RESOURCE, H5E_NOSPACE, FAIL, "can't create ref-count wrapper for shared B-tree info")
 
 done:
     FUNC_LEAVE_NOAPI(ret_value)
@@ -1196,12 +1175,12 @@ done:
 
 
 /*-------------------------------------------------------------------------
- * Function:	H5G_node_close
+ * Function:    H5G_node_close
  *
- * Purpose:	This function gets called during a file close to shutdown
+ * Purpose:     This function gets called during a file close to shutdown
  *              global information about group B-tree nodes for file.
  *
- * Return:	Non-negative on success
+ * Return:      Non-negative on success
  *              Negative on failure
  *
  * Programmer:  Quincey Koziol
@@ -1227,12 +1206,12 @@ H5G_node_close(const H5F_t *f)
 
 
 /*-------------------------------------------------------------------------
- * Function:	H5G__node_copy
+ * Function:    H5G__node_copy
  *
- * Purpose:	This function gets called during a group iterate operation
+ * Purpose:     This function gets called during a group iterate operation
  *              to copy objects of this node into a new location.
  *
- * Return:	0(zero) on success/Negative on failure
+ * Return:      0(zero) on success/Negative on failure
  *
  * Programmer:  Peter Cao
  *              Sept 10, 2005
@@ -1241,7 +1220,7 @@ H5G_node_close(const H5F_t *f)
  */
 int
 H5G__node_copy(H5F_t *f, hid_t dxpl_id, const void H5_ATTR_UNUSED *_lt_key, haddr_t addr,
-		  const void H5_ATTR_UNUSED *_rt_key, void *_udata)
+    const void H5_ATTR_UNUSED *_rt_key, void *_udata)
 {
     H5G_bt_it_cpy_t     *udata = (H5G_bt_it_cpy_t *)_udata;
     const H5O_loc_t     *src_oloc = udata->src_oloc;
@@ -1260,7 +1239,7 @@ H5G__node_copy(H5F_t *f, hid_t dxpl_id, const void H5_ATTR_UNUSED *_lt_key, hadd
 
     /* load the symbol table into memory from the source file */
     if(NULL == (sn = (H5G_node_t *)H5AC_protect(f, dxpl_id, H5AC_SNODE, addr, f, H5AC_READ)))
-	HGOTO_ERROR(H5E_SYM, H5E_CANTLOAD, H5_ITER_ERROR, "unable to load symbol table node")
+        HGOTO_ERROR(H5E_SYM, H5E_CANTLOAD, H5_ITER_ERROR, "unable to load symbol table node")
 
     /* get the base address of the heap */
     if(NULL == (heap = H5HL_protect(f, dxpl_id, udata->src_heap_addr, H5AC_READ)))
@@ -1292,7 +1271,8 @@ H5G__node_copy(H5F_t *f, hid_t dxpl_id, const void H5_ATTR_UNUSED *_lt_key, hadd
             grp_loc.oloc = (H5O_loc_t *)src_oloc;
 
             /* Get pointer to link value in local heap */
-            link_name = (char *)H5HL_offset_into(heap, tmp_src_ent.cache.slink.lval_offset);
+            if((link_name = (char *)H5HL_offset_into(heap, tmp_src_ent.cache.slink.lval_offset)) == NULL)
+                HGOTO_ERROR(H5E_OHDR, H5E_CANTGET, H5_ITER_ERROR, "unable to get link name")
 
             /* Check if the object pointed by the soft link exists in the source file */
             if(H5G_loc_info(&grp_loc, link_name, FALSE, &oinfo, H5P_DEFAULT, dxpl_id) >= 0) {
@@ -1342,7 +1322,8 @@ H5G__node_copy(H5F_t *f, hid_t dxpl_id, const void H5_ATTR_UNUSED *_lt_key, hadd
 
             /* Construct link information for eventual insertion */
             lnk.type = H5L_TYPE_SOFT;
-            lnk.u.soft.name = (char *)H5HL_offset_into(heap, src_ent->cache.slink.lval_offset);
+            if((lnk.u.soft.name = (char *)H5HL_offset_into(heap, src_ent->cache.slink.lval_offset)) == NULL)
+                HGOTO_ERROR(H5E_OHDR, H5E_CANTGET, H5_ITER_ERROR, "unable to get link name")
         } /* else if */
         else
             HDassert(0 && "Unknown entry type");
@@ -1354,8 +1335,8 @@ H5G__node_copy(H5F_t *f, hid_t dxpl_id, const void H5_ATTR_UNUSED *_lt_key, hadd
         /* lnk.name = name; */              /* This will be set in callback */
 
         /* Determine name of source object */
-        name = (const char *)H5HL_offset_into(heap, src_ent->name_off);
-	HDassert(name);
+        if((name = (const char *)H5HL_offset_into(heap, src_ent->name_off)) == NULL)
+            HGOTO_ERROR(H5E_OHDR, H5E_CANTGET, H5_ITER_ERROR, "unable to get source object name")
 
         /* Insert the new object in the destination file's group */
         /* (Don't increment the link count - that's already done above for hard links) */
@@ -1377,15 +1358,15 @@ done:
 
 
 /*-------------------------------------------------------------------------
- * Function:	H5G__node_build_table
+ * Function:    H5G__node_build_table
  *
- * Purpose:	B-link tree callback for building table of links
+ * Purpose:     B-link tree callback for building table of links
  *
- * Return:	Non-negative on success/Negative on failure
+ * Return:      Non-negative on success/Negative on failure
  *
- * Programmer:	Quincey Koziol
- *		koziol@hdfgroup.org
- *		Nov 19 2006
+ * Programmer:  Quincey Koziol
+ *              koziol@hdfgroup.org
+ *              Nov 19 2006
  *
  *-------------------------------------------------------------------------
  */
@@ -1393,10 +1374,10 @@ int
 H5G__node_build_table(H5F_t *f, hid_t dxpl_id, const void H5_ATTR_UNUSED *_lt_key, haddr_t addr,
     const void H5_ATTR_UNUSED *_rt_key, void *_udata)
 {
-    H5G_bt_it_bt_t	*udata = (H5G_bt_it_bt_t *)_udata;
-    H5G_node_t		*sn = NULL;             /* Symbol table node */
-    unsigned		u;                      /* Local index variable */
-    int	                ret_value = H5_ITER_CONT;
+    H5G_bt_it_bt_t  *udata = (H5G_bt_it_bt_t *)_udata;
+    H5G_node_t      *sn = NULL;             /* Symbol table node */
+    unsigned        u;                      /* Local index variable */
+    int             ret_value = H5_ITER_CONT;
 
     FUNC_ENTER_PACKAGE
 
@@ -1412,7 +1393,7 @@ H5G__node_build_table(H5F_t *f, hid_t dxpl_id, const void H5_ATTR_UNUSED *_lt_ke
      * because we're about to call an application function.
      */
     if(NULL == (sn = (H5G_node_t *)H5AC_protect(f, dxpl_id, H5AC_SNODE, addr, f, H5AC_READ)))
-	HGOTO_ERROR(H5E_SYM, H5E_CANTLOAD, H5_ITER_ERROR, "unable to load symbol table node")
+        HGOTO_ERROR(H5E_SYM, H5E_CANTLOAD, H5_ITER_ERROR, "unable to load symbol table node")
 
     /* Check if the link table needs to be extended */
     if((udata->ltable->nlinks + sn->nsyms) >= udata->alloc_nlinks) {
@@ -1431,8 +1412,8 @@ H5G__node_build_table(H5F_t *f, hid_t dxpl_id, const void H5_ATTR_UNUSED *_lt_ke
         size_t          linkno;         /* Link allocated */
 
         /* Get pointer to link's name in the heap */
-        name = (const char *)H5HL_offset_into(udata->heap, sn->entry[u].name_off);
-        HDassert(name);
+        if((name = (const char *)H5HL_offset_into(udata->heap, sn->entry[u].name_off)) == NULL)
+            HGOTO_ERROR(H5E_SYM, H5E_CANTGET, H5_ITER_ERROR, "unable to get symbol table link name")
 
         /* Determine the link to operate on in the table */
         linkno = udata->ltable->nlinks++;
@@ -1465,8 +1446,8 @@ done:
  *-------------------------------------------------------------------------
  */
 herr_t
-H5G__node_iterate_size(H5F_t *f, hid_t H5_ATTR_UNUSED dxpl_id, const void H5_ATTR_UNUSED *_lt_key, haddr_t H5_ATTR_UNUSED addr,
-    const void H5_ATTR_UNUSED *_rt_key, void *_udata)
+H5G__node_iterate_size(H5F_t *f, hid_t H5_ATTR_UNUSED dxpl_id, const void H5_ATTR_UNUSED *_lt_key, 
+    haddr_t H5_ATTR_UNUSED addr, const void H5_ATTR_UNUSED *_rt_key, void *_udata)
 {
     hsize_t     *stab_size = (hsize_t *)_udata;         /* User data */
 
@@ -1483,16 +1464,16 @@ H5G__node_iterate_size(H5F_t *f, hid_t H5_ATTR_UNUSED dxpl_id, const void H5_ATT
 
 
 /*-------------------------------------------------------------------------
- * Function:	H5G_node_debug
+ * Function:    H5G_node_debug
  *
- * Purpose:	Prints debugging information about a symbol table node
- *		or a B-tree node for a symbol table B-tree.
+ * Purpose:     Prints debugging information about a symbol table node
+ *              or a B-tree node for a symbol table B-tree.
  *
- * Return:	0(zero) on success/Negative on failure
+ * Return:      0(zero) on success/Negative on failure
  *
- * Programmer:	Robb Matzke
- *		matzke@llnl.gov
- *		Aug  4 1997
+ * Programmer:  Robb Matzke
+ *              matzke@llnl.gov
+ *              Aug  4 1997
  *
  *-------------------------------------------------------------------------
  */
@@ -1500,10 +1481,10 @@ herr_t
 H5G_node_debug(H5F_t *f, hid_t dxpl_id, haddr_t addr, FILE * stream, int indent,
     int fwidth, haddr_t heap_addr)
 {
-    H5G_node_t		*sn = NULL;
-    H5HL_t              *heap = NULL;
-    unsigned		u;                      /* Local index variable */
-    herr_t              ret_value = SUCCEED;    /* Return value */
+    H5G_node_t *sn = NULL;
+    H5HL_t     *heap = NULL;
+    unsigned    u;                      /* Local index variable */
+    herr_t     ret_value = SUCCEED;     /* Return value */
 
     FUNC_ENTER_NOAPI(FAIL)
 
@@ -1530,33 +1511,33 @@ H5G_node_debug(H5F_t *f, hid_t dxpl_id, haddr_t addr, FILE * stream, int indent,
 
         H5E_clear_stack(NULL); /* discard that error */
         udata.heap = heap;
-	if(H5B_debug(f, dxpl_id, addr, stream, indent, fwidth, H5B_SNODE, &udata) < 0)
-	    HGOTO_ERROR(H5E_SYM, H5E_CANTLOAD, FAIL, "unable to debug B-tree node");
+        if(H5B_debug(f, dxpl_id, addr, stream, indent, fwidth, H5B_SNODE, &udata) < 0)
+            HGOTO_ERROR(H5E_SYM, H5E_CANTLOAD, FAIL, "unable to debug B-tree node");
     } /* end if */
     else {
-        fprintf(stream, "%*sSymbol Table Node...\n", indent, "");
-        fprintf(stream, "%*s%-*s %s\n", indent, "", fwidth,
+        HDfprintf(stream, "%*sSymbol Table Node...\n", indent, "");
+        HDfprintf(stream, "%*s%-*s %s\n", indent, "", fwidth,
                 "Dirty:",
                 sn->cache_info.is_dirty ? "Yes" : "No");
-        fprintf(stream, "%*s%-*s %u\n", indent, "", fwidth,
+        HDfprintf(stream, "%*s%-*s %u\n", indent, "", fwidth,
                 "Size of Node (in bytes):", (unsigned)sn->node_size);
-        fprintf(stream, "%*s%-*s %u of %u\n", indent, "", fwidth,
+        HDfprintf(stream, "%*s%-*s %u of %u\n", indent, "", fwidth,
                 "Number of Symbols:",
                 sn->nsyms, (unsigned)(2 * H5F_SYM_LEAF_K(f)));
 
         indent += 3;
         fwidth = MAX(0, fwidth - 3);
         for(u = 0; u < sn->nsyms; u++) {
-            fprintf(stream, "%*sSymbol %u:\n", indent - 3, "", u);
+            HDfprintf(stream, "%*sSymbol %u:\n", indent - 3, "", u);
 
             if(heap) {
                 const char *s = (const char *)H5HL_offset_into(heap, sn->entry[u].name_off);
 
                 if(s)
-                    fprintf(stream, "%*s%-*s `%s'\n", indent, "", fwidth, "Name:", s);
+                    HDfprintf(stream, "%*s%-*s `%s'\n", indent, "", fwidth, "Name:", s);
             } /* end if */
             else
-                fprintf(stream, "%*s%-*s\n", indent, "", fwidth, "Warning: Invalid heap address given, name not displayed!");
+                HDfprintf(stream, "%*s%-*s\n", indent, "", fwidth, "Warning: Invalid heap address given, name not displayed!");
 
             H5G__ent_debug(sn->entry + u, stream, indent, fwidth, heap);
         } /* end for */
@@ -1564,7 +1545,7 @@ H5G_node_debug(H5F_t *f, hid_t dxpl_id, haddr_t addr, FILE * stream, int indent,
 
 done:
     if(sn && H5AC_unprotect(f, dxpl_id, H5AC_SNODE, addr, sn, H5AC__NO_FLAGS_SET) < 0)
-	HDONE_ERROR(H5E_SYM, H5E_PROTECT, FAIL, "unable to release symbol table node")
+        HDONE_ERROR(H5E_SYM, H5E_PROTECT, FAIL, "unable to release symbol table node")
     if(heap && H5HL_unprotect(heap) < 0)
         HDONE_ERROR(H5E_SYM, H5E_PROTECT, FAIL, "unable to unprotect symbol table heap")
 
diff --git a/src/H5Gstab.c b/src/H5Gstab.c
index f9a8884..0eb7b0b 100644
--- a/src/H5Gstab.c
+++ b/src/H5Gstab.c
@@ -707,11 +707,12 @@ done:
 static herr_t
 H5G_stab_get_name_by_idx_cb(const H5G_entry_t *ent, void *_udata)
 {
-    H5G_bt_it_gnbi_t	*udata = (H5G_bt_it_gnbi_t *)_udata;
+    H5G_bt_it_gnbi_t    *udata = (H5G_bt_it_gnbi_t *)_udata;
     size_t name_off;                    /* Offset of name in heap */
     const char *name;                   /* Pointer to name string in heap */
+    herr_t ret_value = SUCCEED;         /* Return value */
 
-    FUNC_ENTER_NOAPI_NOINIT_NOERR
+    FUNC_ENTER_NOAPI_NOINIT
 
     /* Sanity check */
     HDassert(ent);
@@ -719,12 +720,15 @@ H5G_stab_get_name_by_idx_cb(const H5G_entry_t *ent, void *_udata)
 
     /* Get name offset in heap */
     name_off = ent->name_off;
-    name = (const char *)H5HL_offset_into(udata->heap, name_off);
-    HDassert(name);
-    udata->name = H5MM_strdup(name);
-    HDassert(udata->name);
 
-    FUNC_LEAVE_NOAPI(SUCCEED)
+    if((name = (const char *)H5HL_offset_into(udata->heap, name_off)) == NULL)
+        HGOTO_ERROR(H5E_SYM, H5E_CANTGET, FAIL, "unable to get symbol table link name")
+
+    if((udata->name = H5MM_strdup(name)) == NULL)
+        HGOTO_ERROR(H5E_SYM, H5E_CANTGET, FAIL, "unable to duplicate symbol table link name")
+
+done:
+    FUNC_LEAVE_NOAPI(ret_value)
 } /* end H5G_stab_get_name_by_idx_cb */
 
 
@@ -941,8 +945,8 @@ H5G_stab_lookup_by_idx_cb(const H5G_entry_t *ent, void *_udata)
     HDassert(udata && udata->heap);
 
     /* Get a pointer to the link name */
-    name = (const char *)H5HL_offset_into(udata->heap, ent->name_off);
-    HDassert(name);
+    if((name = (const char *)H5HL_offset_into(udata->heap, ent->name_off)) == NULL)
+        HGOTO_ERROR(H5E_SYM, H5E_CANTGET, FAIL, "unable to get symbol table link name")
 
     /* Convert the entry to a link */
     if(H5G__ent_to_link(udata->lnk, udata->heap, ent, name) < 0)
diff --git a/src/H5HL.c b/src/H5HL.c
index b731647..01ace76 100644
--- a/src/H5HL.c
+++ b/src/H5HL.c
@@ -533,17 +533,18 @@ done:
 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
+    void *ret_value = NULL;
+
+    FUNC_ENTER_NOAPI(NULL)
 
     /* Sanity check */
     HDassert(heap);
-    HDassert(offset < heap->dblk_size);
+    if(offset >= heap->dblk_size)
+       HGOTO_ERROR(H5E_HEAP, H5E_CANTGET, NULL, "unable to offset into local heap data block")
+    ret_value = heap->dblk_image + offset;
 
-    FUNC_LEAVE_NOAPI(heap->dblk_image + offset)
+done:
+    FUNC_LEAVE_NOAPI(ret_value)
 } /* end H5HL_offset_into() */
 
 
diff --git a/src/H5Oalloc.c b/src/H5Oalloc.c
index c81bdf9..25052e7 100644
--- a/src/H5Oalloc.c
+++ b/src/H5Oalloc.c
@@ -2200,16 +2200,17 @@ H5O_alloc_shrink_chunk(H5F_t *f, hid_t dxpl_id, H5O_t *oh, unsigned chunkno)
         oh->nmesgs++;
 
         /* Initialize new null message to make the chunk large enough */
-        oh->mesg[oh->nmesgs].type = H5O_MSG_NULL;
-        oh->mesg[oh->nmesgs].dirty = TRUE;
-        oh->mesg[oh->nmesgs].native = NULL;
-        oh->mesg[oh->nmesgs].raw = old_image + new_size + sizeof_msghdr - sizeof_chksum;
-        oh->mesg[oh->nmesgs].raw_size = MAX(H5O_ALIGN_OH(oh, min_chunk_size - total_msg_size),
+        curr_msg = &oh->mesg[oh->nmesgs - 1];
+        curr_msg->type = H5O_MSG_NULL;
+        curr_msg->dirty = TRUE;
+        curr_msg->native = NULL;
+        curr_msg->raw = old_image + new_size + sizeof_msghdr - sizeof_chksum;
+        curr_msg->raw_size = MAX(H5O_ALIGN_OH(oh, min_chunk_size - total_msg_size),
             sizeof_msghdr) - sizeof_msghdr;
-        oh->mesg[oh->nmesgs].chunkno = chunkno;
+        curr_msg->chunkno = chunkno;
 
         /* update the new chunk size */
-        new_size += oh->mesg[oh->nmesgs].raw_size + sizeof_msghdr;
+        new_size += curr_msg->raw_size + sizeof_msghdr;
     } /* end if */
 
     /* Check for changing the chunk #0 data size enough to need adjusting the flags */
diff --git a/src/H5Ocopy.c b/src/H5Ocopy.c
index 9193a4c..31beb0e 100644
--- a/src/H5Ocopy.c
+++ b/src/H5Ocopy.c
@@ -357,24 +357,8 @@ H5O_copy_header_real(const H5O_loc_t *oloc_src, H5O_loc_t *oloc_dst /*out*/,
     if((obj_class = H5O_obj_class(oloc_src, dxpl_id)) == NULL)
         HGOTO_ERROR(H5E_OHDR, H5E_CANTINIT, FAIL, "unable to determine object type")
 
-    /* Check if the object at the address is already open in the file */
-    if(H5FO_opened(oloc_src->file, oloc_src->addr) != NULL) {
-	
-	H5G_loc_t   tmp_loc; 	/* Location of object */
-	H5O_loc_t   tmp_oloc; 	/* Location of object */
-	H5G_name_t  tmp_path;	/* Object's path */
-
-	tmp_loc.oloc = &tmp_oloc;
-	tmp_loc.path = &tmp_path;
-	tmp_oloc.file = oloc_src->file;
-	tmp_oloc.addr = oloc_src->addr;
-	tmp_oloc.holding_file = oloc_src->holding_file;
-	H5G_name_reset(tmp_loc.path);
-
-	/* Flush the object of this class */
-        if(obj_class->flush && obj_class->flush(&tmp_loc, dxpl_id) < 0)
-            HGOTO_ERROR(H5E_OHDR, H5E_CANTFLUSH, FAIL, "unable to flush object")
-    }
+    /* Set the pointer to the shared struct for the object if opened in the file */
+    cpy_info->shared_fo = H5FO_opened(oloc_src->file, oloc_src->addr);
 
     /* Get source object header */
     if(NULL == (oh_src = H5O_protect(oloc_src, dxpl_id, H5AC_READ)))
diff --git a/src/H5Oefl.c b/src/H5Oefl.c
index 1de3059..218d250 100644
--- a/src/H5Oefl.c
+++ b/src/H5Oefl.c
@@ -67,17 +67,17 @@ const H5O_msg_class_t H5O_MSG_EFL[1] = {{
 
 
 /*-------------------------------------------------------------------------
- * Function:	H5O_efl_decode
+ * Function:    H5O_efl_decode
  *
  * Purpose:	Decode an external file list message and return a pointer to
- *		the message (and some other data).
+ *          the message (and some other data).
  *
- * Return:	Success:	Ptr to a new message struct.
+ * Return:  Success:    Ptr to a new message struct.
  *
- *		Failure:	NULL
+ *          Failure:    NULL
  *
  * Programmer:	Robb Matzke
- *		Tuesday, November 25, 1997
+ *              Tuesday, November 25, 1997
  *
  * Modification:
  *              Raymond Lu
@@ -90,12 +90,12 @@ static void *
 H5O_efl_decode(H5F_t *f, hid_t dxpl_id, H5O_t H5_ATTR_UNUSED *open_oh,
     unsigned H5_ATTR_UNUSED mesg_flags, unsigned H5_ATTR_UNUSED *ioflags, const uint8_t *p)
 {
-    H5O_efl_t		*mesg = NULL;
-    int			version;
-    const char		*s = NULL;
-    H5HL_t              *heap;
-    size_t		u;      /* Local index variable */
-    void *ret_value;            /* Return value */
+    H5O_efl_t   *mesg = NULL;
+    int         version;
+    const char  *s = NULL;
+    H5HL_t      *heap;
+    size_t      u;                  /* Local index variable */
+    void        *ret_value = NULL;  /* Return value */
 
     FUNC_ENTER_NOAPI_NOINIT
 
@@ -104,12 +104,12 @@ H5O_efl_decode(H5F_t *f, hid_t dxpl_id, H5O_t H5_ATTR_UNUSED *open_oh,
     HDassert(p);
 
     if(NULL == (mesg = (H5O_efl_t *)H5MM_calloc(sizeof(H5O_efl_t))))
-	HGOTO_ERROR(H5E_RESOURCE, H5E_NOSPACE, NULL, "memory allocation failed")
+        HGOTO_ERROR(H5E_RESOURCE, H5E_NOSPACE, NULL, "memory allocation failed")
 
     /* Version */
     version = *p++;
     if(version != H5O_EFL_VERSION)
-	HGOTO_ERROR(H5E_OHDR, H5E_CANTLOAD, NULL, "bad version number for external file list message")
+        HGOTO_ERROR(H5E_OHDR, H5E_CANTLOAD, NULL, "bad version number for external file list message")
 
     /* Reserved */
     p += 3;
@@ -141,24 +141,26 @@ H5O_efl_decode(H5F_t *f, hid_t dxpl_id, H5O_t H5_ATTR_UNUSED *open_oh,
     /* Decode the file list */
     mesg->slot = (H5O_efl_entry_t *)H5MM_calloc(mesg->nalloc * sizeof(H5O_efl_entry_t));
     if(NULL == mesg->slot)
-	HGOTO_ERROR(H5E_RESOURCE, H5E_NOSPACE, NULL, "memory allocation failed")
+        HGOTO_ERROR(H5E_RESOURCE, H5E_NOSPACE, NULL, "memory allocation failed")
 
     if(NULL == (heap = H5HL_protect(f, dxpl_id, mesg->heap_addr, H5AC_READ)))
         HGOTO_ERROR(H5E_SYM, H5E_NOTFOUND, NULL, "unable to read protect link value")
     for(u = 0; u < mesg->nused; u++) {
-	/* Name */
-	H5F_DECODE_LENGTH (f, p, mesg->slot[u].name_offset);
-
-        s = (const char *)H5HL_offset_into(heap, mesg->slot[u].name_offset);
-	HDassert(s && *s);
-	mesg->slot[u].name = H5MM_xstrdup (s);
+        /* Name */
+        H5F_DECODE_LENGTH (f, p, mesg->slot[u].name_offset);
+
+        if((s = (const char *)H5HL_offset_into(heap, mesg->slot[u].name_offset)) == NULL)
+            HGOTO_ERROR(H5E_SYM, H5E_CANTGET, NULL, "unable to get external file name")
+        if(*s == (char)NULL)
+            HGOTO_ERROR(H5E_SYM, H5E_CANTGET, NULL, "invalid external file name")
+        mesg->slot[u].name = H5MM_xstrdup (s);
         HDassert(mesg->slot[u].name);
 
-	/* File offset */
-	H5F_DECODE_LENGTH (f, p, mesg->slot[u].offset);
+        /* File offset */
+        H5F_DECODE_LENGTH (f, p, mesg->slot[u].offset);
 
-	/* Size */
-	H5F_DECODE_LENGTH (f, p, mesg->slot[u].size);
+        /* Size */
+        H5F_DECODE_LENGTH (f, p, mesg->slot[u].size);
     } /* end for */
 
     if(H5HL_unprotect(heap) < 0)
diff --git a/src/H5Olayout.c b/src/H5Olayout.c
index 95d66ab..17385c2 100644
--- a/src/H5Olayout.c
+++ b/src/H5Olayout.c
@@ -592,6 +592,7 @@ H5O_layout_copy_file(H5F_t *file_src, void *mesg_src, H5F_t *file_dst,
     H5O_layout_t       *layout_src = (H5O_layout_t *) mesg_src;
     H5O_layout_t       *layout_dst = NULL;
     hbool_t             copied = FALSE;                         /* Whether the data was copied */
+    H5D_shared_t *shared_fo = (H5D_shared_t *)cpy_info->shared_fo;
     void               *ret_value;                              /* Return value */
 
     FUNC_ENTER_NOAPI_NOINIT
@@ -628,7 +629,9 @@ H5O_layout_copy_file(H5F_t *file_src, void *mesg_src, H5F_t *file_dst,
                 layout_dst->storage.u.contig.size = H5S_extent_nelem(udata->src_space_extent) *
                                         H5T_get_size(udata->src_dtype);
 
-            if(H5D__contig_is_space_alloc(&layout_src->storage)) {
+            if(H5D__contig_is_space_alloc(&layout_src->storage) || 
+               (H5F_HAS_FEATURE(file_src, H5FD_FEAT_DATA_SIEVE) && 
+                shared_fo && shared_fo->cache.contig.sieve_buf)) {
                 /* copy contiguous raw data */
                 if(H5D__contig_copy(file_src, &layout_src->storage.u.contig, file_dst, &layout_dst->storage.u.contig, udata->src_dtype, cpy_info, dxpl_id) < 0)
                     HGOTO_ERROR(H5E_OHDR, H5E_CANTCOPY, NULL, "unable to copy contiguous storage")
@@ -637,7 +640,8 @@ H5O_layout_copy_file(H5F_t *file_src, void *mesg_src, H5F_t *file_dst,
             break;
 
         case H5D_CHUNKED:
-            if(H5D__chunk_is_space_alloc(&layout_src->storage)) {
+            if(H5D__chunk_is_space_alloc(&layout_src->storage) || 
+               (shared_fo && H5D__chunk_is_space_alloc(&shared_fo->layout.storage))) {
                 /* Create chunked layout */
                 if(H5D__chunk_copy(file_src, &layout_src->storage.u.chunk, &layout_src->u.chunk, file_dst, &layout_dst->storage.u.chunk, udata->src_space_extent, udata->src_dtype, udata->common.src_pline, cpy_info, dxpl_id) < 0)
                     HGOTO_ERROR(H5E_OHDR, H5E_CANTCOPY, NULL, "unable to copy chunked storage")
diff --git a/src/H5Oprivate.h b/src/H5Oprivate.h
index 9b24977..ca0fc8e 100644
--- a/src/H5Oprivate.h
+++ b/src/H5Oprivate.h
@@ -169,6 +169,7 @@ typedef struct H5O_copy_t {
     H5SL_t  *dst_dt_list;               /* Skip list to hold committed datatypes in dest file */
     hbool_t dst_dt_list_complete;       /* Whether the destination datatype list is complete (i.e. not only populated with "suggestions" from H5Padd_merge_committed_dtype_path) */
     H5O_t   *oh_dst;                    /* The destination object header */
+    void    *shared_fo;                 /* The shared pointer for the object */
     H5O_mcdt_search_cb_t mcdt_cb;	/* The callback to invoke before searching the global list of committed datatypes at destination */
     void *mcdt_ud;			/* User data passed to callback */
 } H5O_copy_t;
diff --git a/src/H5Pocpl.c b/src/H5Pocpl.c
index b2fe4d1..5db1788 100644
--- a/src/H5Pocpl.c
+++ b/src/H5Pocpl.c
@@ -807,16 +807,6 @@ H5P__set_filter(H5P_genplist_t *plist, H5Z_filter_t filter, unsigned int flags,
     if((filter_avail = H5Z_filter_avail(filter)) < 0)
         HGOTO_ERROR(H5E_PLIST, H5E_CANTGET, FAIL, "can't check filter availability")
 
-    /* If filter is not available, try to dynamically load it */
-    if(!filter_avail) {
-        const H5Z_class2_t *filter_info;
-
-        if(NULL == (filter_info = (const H5Z_class2_t *)H5PL_load(H5PL_TYPE_FILTER, (int)filter)))
-            HGOTO_ERROR(H5E_PLINE, H5E_CANTLOAD, FAIL, "failed to load dynamically loaded plugin")
-        if(H5Z_register(filter_info) < 0)
-	    HGOTO_ERROR(H5E_PLINE, H5E_CANTINIT, FAIL, "unable to register dynamic filter")
-    } /* end if */
-
     /* Get the pipeline property to append to */
     if(H5P_get(plist, H5O_CRT_PIPELINE_NAME, &pline) < 0)
         HGOTO_ERROR(H5E_PLIST, H5E_CANTGET, FAIL, "can't get pipeline")
diff --git a/src/H5Shyper.c b/src/H5Shyper.c
index 32f6200..09d450f 100644
--- a/src/H5Shyper.c
+++ b/src/H5Shyper.c
@@ -2071,21 +2071,53 @@ H5S_hyper_serialize (const H5S_t *space, uint8_t *buf)
 {
     const H5S_hyper_dim_t *diminfo;         /* Alias for dataspace's diminfo information */
     hsize_t tmp_count[H5O_LAYOUT_NDIMS];    /* Temporary hyperslab counts */
-    hsize_t offset[H5O_LAYOUT_NDIMS];      /* Offset of element in dataspace */
-    hsize_t start[H5O_LAYOUT_NDIMS];   /* Location of start of hyperslab */
-    hsize_t end[H5O_LAYOUT_NDIMS];     /* Location of end of hyperslab */
-    hsize_t temp_off;            /* Offset in a given dimension */
+    hsize_t offset[H5O_LAYOUT_NDIMS];       /* Offset of element in dataspace */
+    hsize_t start[H5O_LAYOUT_NDIMS];        /* Location of start of hyperslab */
+    hsize_t end[H5O_LAYOUT_NDIMS];          /* Location of end of hyperslab */
+    hsize_t bounds_start[H5S_MAX_RANK];     /* Selection bounds */
+    hsize_t bounds_end[H5S_MAX_RANK];       /* Selection bounds */
+    hsize_t temp_off;       /* Offset in a given dimension */
     uint8_t *lenp;          /* pointer to length location for later storage */
     uint32_t len = 0;       /* number of bytes used */
     hsize_t block_count;    /* block counter for regular hyperslabs */
     unsigned fast_dim;      /* Rank of the fastest changing dimension for the dataspace */
     unsigned ndims;         /* Rank of the dataspace */
     int done;               /* Whether we are done with the iteration */
+    unsigned u;             /* Local index variable */
+    herr_t ret_value = SUCCEED;             /* Return value */
 
-    FUNC_ENTER_NOAPI_NOINIT_NOERR
+    FUNC_ENTER_NOAPI_NOINIT
 
     HDassert(space);
 
+    /* Set some convienence values */
+    ndims = space->extent.rank;
+    fast_dim = ndims - 1;
+    diminfo=space->select.sel_info.hslab->opt_diminfo;
+
+    /* Calculate the # of blocks */
+    if(H5S_hyper_is_regular(space)) {
+        /* Check each dimension */
+        for(block_count = 1, u = 0; u < ndims; u++)
+            block_count *= diminfo[u].count;
+    } /* end if */
+    else
+        /* Spin through hyperslab spans */
+        block_count = H5S_hyper_span_nblocks(space->select.sel_info.hslab->span_lst);
+
+    /* Get bounding box */
+    if(H5S_hyper_bounds(space, bounds_start, bounds_end) < 0)
+        HGOTO_ERROR(H5E_DATASPACE, H5E_CANTGET, FAIL, "can't get selection bounds")
+
+    /* Determine whether the number of blocks or the high bounds in the selection exceed (2^32 - 1) */
+    if(block_count > H5S_UINT32_MAX)
+        HGOTO_ERROR(H5E_DATASPACE, H5E_BADVALUE, FAIL, "invalid number of blocks in selection")
+    else {
+        for(u = 0; u < ndims; u++)
+            if(bounds_end[u] > H5S_UINT32_MAX)
+                HGOTO_ERROR(H5E_DATASPACE, H5E_BADVALUE, FAIL, "invalid hyperslab selection")
+    }
+
     /* Store the preamble information */
     UINT32ENCODE(buf, (uint32_t)H5S_GET_SELECT_TYPE(space));  /* Store the type of selection */
     UINT32ENCODE(buf, (uint32_t)1);  /* Store the version number */
@@ -2101,15 +2133,6 @@ H5S_hyper_serialize (const H5S_t *space, uint8_t *buf)
     if(space->select.sel_info.hslab->diminfo_valid) {
         unsigned u;     /* Local counting variable */
 
-        /* Set some convienence values */
-        ndims = space->extent.rank;
-        fast_dim = ndims - 1;
-        diminfo=space->select.sel_info.hslab->opt_diminfo;
-
-        /* Check each dimension */
-        for(block_count = 1, u = 0; u < ndims; u++)
-            block_count *= diminfo[u].count;
-
         /* Encode number of hyperslabs */
         H5_CHECK_OVERFLOW(block_count, hsize_t, uint32_t);
         UINT32ENCODE(buf, (uint32_t)block_count);
@@ -2188,7 +2211,6 @@ H5S_hyper_serialize (const H5S_t *space, uint8_t *buf)
     } /* end if */
     else {
         /* Encode number of hyperslabs */
-        block_count = H5S_hyper_span_nblocks(space->select.sel_info.hslab->span_lst);
         H5_CHECK_OVERFLOW(block_count, hsize_t, uint32_t);
         UINT32ENCODE(buf, (uint32_t)block_count);
         len+=4;
@@ -2204,7 +2226,8 @@ H5S_hyper_serialize (const H5S_t *space, uint8_t *buf)
     /* Encode length */
     UINT32ENCODE(lenp, (uint32_t)len);  /* Store the length of the extra information */
 
-    FUNC_LEAVE_NOAPI(SUCCEED)
+done:
+    FUNC_LEAVE_NOAPI(ret_value)
 }   /* H5S_hyper_serialize() */
 
 
diff --git a/src/H5Spkg.h b/src/H5Spkg.h
index 2fa872b..0597994 100644
--- a/src/H5Spkg.h
+++ b/src/H5Spkg.h
@@ -46,6 +46,9 @@
  *      and 'size' callbacks for places to change when updating this. */
 #define H5O_SDSPACE_VERSION_LATEST H5O_SDSPACE_VERSION_2
 
+/* Maximum values for uint16_t and uint32_t */
+#define H5S_UINT16_MAX      65535       /* 2^16 - 1 */
+#define H5S_UINT32_MAX      4294967295  /* 2^32 - 1 */
 
 /*
  * Dataspace extent information
diff --git a/src/H5Spoint.c b/src/H5Spoint.c
index 36684ea..e1dbb4d 100644
--- a/src/H5Spoint.c
+++ b/src/H5Spoint.c
@@ -821,12 +821,29 @@ H5S_point_serialize (const H5S_t *space, uint8_t *buf)
     H5S_pnt_node_t *curr;   /* Point information nodes */
     uint8_t *lenp;          /* pointer to length location for later storage */
     uint32_t len=0;         /* number of bytes used */
-    unsigned u;                /* local counting variable */
+    unsigned u;                 /* local counting variable */
+    hsize_t bounds_start[H5S_MAX_RANK]; /* Selection bounding box */
+    hsize_t bounds_end[H5S_MAX_RANK];   /* Selection bounding box */
+    herr_t ret_value = SUCCEED; /* Return value */
 
-    FUNC_ENTER_NOAPI_NOINIT_NOERR
+    FUNC_ENTER_NOAPI_NOINIT
 
     HDassert(space);
 
+     /* Get bounding box for the selection */
+    HDmemset(bounds_end, 0, sizeof(bounds_end));
+    if(H5S_point_bounds(space, bounds_start, bounds_end) < 0)
+        HGOTO_ERROR(H5E_DATASPACE, H5E_CANTGET, FAIL, "can't get selection bounds")
+
+    /* Determine whether the number of points or the high bounds in the selection exceed (2^32 - 1) */
+    if(space->select.num_elem > H5S_UINT32_MAX)
+        HGOTO_ERROR(H5E_DATASPACE, H5E_BADVALUE, FAIL, "invalid number of points in selection")
+    else {
+        for(u = 0; u < space->extent.rank; u++)
+            if(bounds_end[u] > H5S_UINT32_MAX)
+                HGOTO_ERROR(H5E_DATASPACE, H5E_BADVALUE, FAIL, "invalid points selection")
+    }
+
     /* Store the preamble information */
     UINT32ENCODE(buf, (uint32_t)H5S_GET_SELECT_TYPE(space));  /* Store the type of selection */
     UINT32ENCODE(buf, (uint32_t)1);  /* Store the version number */
@@ -858,7 +875,8 @@ H5S_point_serialize (const H5S_t *space, uint8_t *buf)
     /* Encode length */
     UINT32ENCODE(lenp, (uint32_t)len);  /* Store the length of the extra information */
 
-    FUNC_LEAVE_NOAPI(SUCCEED)
+done:
+    FUNC_LEAVE_NOAPI(ret_value)
 }   /* H5S_point_serialize() */
 
 
diff --git a/src/H5Z.c b/src/H5Z.c
index 1223556..0579c62 100644
--- a/src/H5Z.c
+++ b/src/H5Z.c
@@ -653,15 +653,9 @@ H5Zfilter_avail(H5Z_filter_t id)
     /* Check args */
     if(id<0 || id>H5Z_FILTER_MAX)
         HGOTO_ERROR (H5E_ARGS, H5E_BADVALUE, FAIL, "invalid filter identification number")
- 
-    if((ret_value = H5Z_filter_avail(id)) < 0)
-    	HGOTO_ERROR(H5E_PLINE, H5E_NOTFOUND, FAIL, "unable to check the availability of the filter")
-    else if(ret_value == FALSE) {
-        const H5Z_class2_t *filter_info;
 
-        if(NULL != (filter_info = (const H5Z_class2_t *)H5PL_load(H5PL_TYPE_FILTER, (int)id)))
-        	ret_value = TRUE;
-    } /* end if */
+    if((ret_value = H5Z_filter_avail(id)) < 0)
+        HGOTO_ERROR(H5E_PLINE, H5E_NOTFOUND, FAIL, "unable to check the availability of the filter")
 
 done:
     FUNC_LEAVE_API(ret_value)
@@ -684,15 +678,21 @@ htri_t
 H5Z_filter_avail(H5Z_filter_t id)
 {
     size_t i;                   /* Local index variable */
+    const H5Z_class2_t *filter_info;
     htri_t ret_value = FALSE;   /* Return value */
 
     FUNC_ENTER_NOAPI(FAIL)
 
     /* Is the filter already registered? */
     for(i = 0; i < H5Z_table_used_g; i++)
-	if(H5Z_table_g[i].id == id)
-	    HGOTO_DONE(TRUE)
+        if(H5Z_table_g[i].id == id)
+            HGOTO_DONE(TRUE)
 
+    if(NULL != (filter_info = (const H5Z_class2_t *)H5PL_load(H5PL_TYPE_FILTER, (int)id))) {
+        if(H5Z_register(filter_info) < 0)
+            HGOTO_ERROR(H5E_PLINE, H5E_CANTINIT, FAIL, "unable to register loaded filter")
+        HGOTO_DONE(TRUE)
+    }
 done:
     FUNC_LEAVE_NOAPI(ret_value)
 } /* end H5Z_filter_avail() */
diff --git a/src/H5public.h b/src/H5public.h
index a479123..ba98cf2 100644
--- a/src/H5public.h
+++ b/src/H5public.h
@@ -92,10 +92,10 @@ extern "C" {
 /* Version numbers */
 #define H5_VERS_MAJOR	1	/* For major interface/format changes  	     */
 #define H5_VERS_MINOR	8	/* For minor interface/format changes  	     */
-#define H5_VERS_RELEASE	19	/* For tweaks, bug-fixes, or development     */
+#define H5_VERS_RELEASE	20	/* For tweaks, bug-fixes, or development     */
 #define H5_VERS_SUBRELEASE ""	/* For pre-releases like snap0       */
 				/* Empty string for real releases.           */
-#define H5_VERS_INFO    "HDF5 library version: 1.8.19"      /* Full version string */
+#define H5_VERS_INFO    "HDF5 library version: 1.8.20"      /* Full version string */
 
 #define H5check()	H5check_version(H5_VERS_MAJOR,H5_VERS_MINOR,	      \
 				        H5_VERS_RELEASE)
diff --git a/src/Makefile.in b/src/Makefile.in
index 33e4a08..f6a7526 100644
--- a/src/Makefile.in
+++ b/src/Makefile.in
@@ -643,6 +643,7 @@ dvidir = @dvidir@
 enable_shared = @enable_shared@
 enable_static = @enable_static@
 exec_prefix = @exec_prefix@
+fortran_linux_linker_option = @fortran_linux_linker_option@
 host = @host@
 host_alias = @host_alias@
 host_cpu = @host_cpu@
@@ -730,25 +731,25 @@ CHECK_CLEANFILES = *.chkexe *.chklog *.clog *.clog2
 # After making changes, run bin/reconfigure to update other configure related
 # files like Makefile.in.
 LT_VERS_INTERFACE = 13
-LT_VERS_REVISION = 0
+LT_VERS_REVISION = 1
 LT_VERS_AGE = 3
-LT_CXX_VERS_INTERFACE = 14
+LT_CXX_VERS_INTERFACE = 15
 LT_CXX_VERS_REVISION = 0
 LT_CXX_VERS_AGE = 0
 LT_F_VERS_INTERFACE = 10
-LT_F_VERS_REVISION = 4
+LT_F_VERS_REVISION = 5
 LT_F_VERS_AGE = 0
 LT_HL_VERS_INTERFACE = 12
-LT_HL_VERS_REVISION = 0
+LT_HL_VERS_REVISION = 1
 LT_HL_VERS_AGE = 2
 LT_HL_CXX_VERS_INTERFACE = 12
-LT_HL_CXX_VERS_REVISION = 0
+LT_HL_CXX_VERS_REVISION = 1
 LT_HL_CXX_VERS_AGE = 1
 LT_HL_F_VERS_INTERFACE = 10
-LT_HL_F_VERS_REVISION = 3
+LT_HL_F_VERS_REVISION = 4
 LT_HL_F_VERS_AGE = 0
 LT_TOOLS_VERS_INTERFACE = 10
-LT_TOOLS_VERS_REVISION = 5
+LT_TOOLS_VERS_REVISION = 6
 LT_TOOLS_VERS_AGE = 0
 
 # Our main target, the HDF5 library