[svn-r8676] Purpose:

    Code optimization

Description:
    Using existing dataspace extent copying routine instead of duplicating the
code (more slowly).
    Also, back-port improvements to the dataspace message reading which clean
up the clean and centralize operations.

Platforms tested:
    Solaris 2.7 (arabica)
    FreeBSD 4.10 (sleipnir) w/parallel
    Too minor to require h5committest

6 files changed, 310 insertions, 358 deletions

diff --git a/src/H5A.c b/src/H5A.c
index 19001fc..72ec772 100644
--- a/src/H5A.c
+++ b/src/H5A.c
@@ -15,21 +15,17 @@
 #define H5A_PACKAGE		/*suppress error about including H5Apkg	*/
 #define H5S_PACKAGE		/*suppress error about including H5Spkg	*/
 
+/* Pablo information */
+/* (Put before include files to avoid problems with inline functions) */
+#define PABLO_MASK	H5A_mask
+
 /* Private header files */
 #include "H5private.h"		/* Generic Functions			*/
 #include "H5Apkg.h"		/* Attributes				*/
-#include "H5Bprivate.h"		/* B-tree subclass names	  	*/
-#include "H5Dprivate.h"		/* Datasets				*/
 #include "H5Eprivate.h"		/* Error handling		  	*/
-#include "H5Gprivate.h"		/* Groups				*/
 #include "H5Iprivate.h"		/* IDs			  		*/
 #include "H5MMprivate.h"	/* Memory management			*/
-#include "H5Oprivate.h"     	/* Object Headers       		*/
-#include "H5Pprivate.h"		/* Property lists			*/
 #include "H5Spkg.h"		/* Dataspace functions			*/
-#include "H5Tprivate.h"		/* Datatypes				*/
-
-#define PABLO_MASK	H5A_mask
 
 /* Is the interface initialized? */
 static int		interface_initialize_g = 0;
@@ -41,9 +37,9 @@ static hid_t H5A_create(const H5G_entry_t *ent, const char *name,
 			const H5T_t *type, const H5S_t *space, hid_t dxpl_id);
 static hid_t H5A_open(H5G_entry_t *ent, unsigned idx, hid_t dxpl_id);
 static herr_t H5A_write(H5A_t *attr, const H5T_t *mem_type, const void *buf, hid_t dxpl_id);
-static herr_t H5A_read(H5A_t *attr, const H5T_t *mem_type, void *buf, hid_t dxpl_id);
+static herr_t H5A_read(const H5A_t *attr, const H5T_t *mem_type, void *buf, hid_t dxpl_id);
 static int H5A_get_index(H5G_entry_t *ent, const char *name, hid_t dxpl_id);
-static hsize_t H5A_get_storage_size(H5A_t *attr);
+static hsize_t H5A_get_storage_size(const H5A_t *attr);
 static herr_t H5A_rename(H5G_entry_t *ent, const char *old_name, const char *new_name, hid_t dxpl_id);
 
 /* The number of reserved IDs in dataset ID group */
@@ -67,16 +63,16 @@ H5A_init_interface(void)
 {
     herr_t ret_value=SUCCEED;   /* Return value */
 
-    FUNC_ENTER_NOAPI_NOINIT(H5A_init_interface);
+    FUNC_ENTER_NOAPI_NOINIT(H5A_init_interface)
 
     /*
      * Create attribute group.
      */
     if (H5I_init_group(H5I_ATTR, H5I_ATTRID_HASHSIZE, H5A_RESERVED_ATOMS, (H5I_free_t)H5A_close)<0)
-        HGOTO_ERROR(H5E_INTERNAL, H5E_CANTINIT, FAIL, "unable to initialize interface");
+        HGOTO_ERROR(H5E_INTERNAL, H5E_CANTINIT, FAIL, "unable to initialize interface")
     
 done:
-    FUNC_LEAVE_NOAPI(ret_value);
+    FUNC_LEAVE_NOAPI(ret_value)
 }
 
 
@@ -101,7 +97,7 @@ H5A_term_interface(void)
 {
     int	n=0;
 
-    FUNC_ENTER_NOAPI_NOINIT_NOFUNC(H5A_term_interface);
+    FUNC_ENTER_NOAPI_NOINIT_NOFUNC(H5A_term_interface)
     
     if (interface_initialize_g) {
 	if ((n=H5I_nmembers(H5I_ATTR))) {
@@ -112,7 +108,7 @@ H5A_term_interface(void)
 	    n = 1;
 	}
     }
-    FUNC_LEAVE_NOAPI(n);
+    FUNC_LEAVE_NOAPI(n)
 }
 
 
@@ -155,6 +151,7 @@ H5A_term_interface(void)
  *	The LOC_ID can also be a committed data type.
  *	
 --------------------------------------------------------------------------*/
+/* ARGSUSED */
 hid_t
 H5Acreate(hid_t loc_id, const char *name, hid_t type_id, hid_t space_id,
 	  hid_t UNUSED plist_id)
@@ -164,27 +161,27 @@ H5Acreate(hid_t loc_id, const char *name, hid_t type_id, hid_t space_id,
     H5S_t		*space = NULL;
     hid_t		ret_value = FAIL;
 
-    FUNC_ENTER_API(H5Acreate, FAIL);
+    FUNC_ENTER_API(H5Acreate, FAIL)
     H5TRACE5("i","isiii",loc_id,name,type_id,space_id,plist_id);
 
     /* check arguments */
     if (H5I_FILE==H5I_get_type(loc_id) || H5I_ATTR==H5I_get_type(loc_id))
-	HGOTO_ERROR(H5E_ARGS, H5E_BADTYPE, FAIL, "location is not valid for an attribute");
+	HGOTO_ERROR(H5E_ARGS, H5E_BADTYPE, FAIL, "location is not valid for an attribute")
     if (NULL==(ent=H5G_loc(loc_id)))
-	HGOTO_ERROR(H5E_ARGS, H5E_BADTYPE, FAIL, "not a location");
+	HGOTO_ERROR(H5E_ARGS, H5E_BADTYPE, FAIL, "not a location")
     if (!name || !*name)
-	HGOTO_ERROR(H5E_ARGS, H5E_BADVALUE, FAIL, "no name");
+	HGOTO_ERROR(H5E_ARGS, H5E_BADVALUE, FAIL, "no name")
     if (NULL == (type = H5I_object_verify(type_id, H5I_DATATYPE)))
-	HGOTO_ERROR(H5E_ARGS, H5E_BADTYPE, FAIL, "not a type");
+	HGOTO_ERROR(H5E_ARGS, H5E_BADTYPE, FAIL, "not a type")
     if (NULL == (space = H5I_object_verify(space_id, H5I_DATASPACE)))
-	HGOTO_ERROR(H5E_ARGS, H5E_BADTYPE, FAIL, "not a data space");
+	HGOTO_ERROR(H5E_ARGS, H5E_BADTYPE, FAIL, "not a data space")
 
     /* Go do the real work for attaching the attribute to the dataset */
     if ((ret_value=H5A_create(ent,name,type,space, H5AC_dxpl_id))<0)
-	HGOTO_ERROR (H5E_ATTR, H5E_CANTINIT, FAIL, "unable to create attribute");
+	HGOTO_ERROR (H5E_ATTR, H5E_CANTINIT, FAIL, "unable to create attribute")
 
 done:
-    FUNC_LEAVE_API(ret_value);
+    FUNC_LEAVE_API(ret_value)
 } /* H5Acreate() */
 
 
@@ -221,7 +218,7 @@ H5A_create(const H5G_entry_t *ent, const char *name, const H5T_t *type,
     int	seq=0;
     hid_t	ret_value = FAIL;
 
-    FUNC_ENTER_NOAPI_NOINIT(H5A_create);
+    FUNC_ENTER_NOAPI_NOINIT(H5A_create)
 
     /* check args */
     assert(ent);
@@ -231,7 +228,7 @@ H5A_create(const H5G_entry_t *ent, const char *name, const H5T_t *type,
 
     /* Build the attribute information */
     if((attr = H5MM_calloc(sizeof(H5A_t)))==NULL)
-        HGOTO_ERROR(H5E_RESOURCE, H5E_NOSPACE, FAIL, "memory allocation failed for attribute info");
+        HGOTO_ERROR(H5E_RESOURCE, H5E_NOSPACE, FAIL, "memory allocation failed for attribute info")
 
     /* Copy the attribute name */
     attr->name=HDstrdup(name);
@@ -251,7 +248,7 @@ H5A_create(const H5G_entry_t *ent, const char *name, const H5T_t *type,
 
     /* Deep copy of the symbol table entry */
     if (H5G_ent_copy(&(attr->ent),ent,H5G_COPY_DEEP)<0)
-        HGOTO_ERROR(H5E_ATTR, H5E_CANTOPENOBJ, FAIL, "unable to copy entry");
+        HGOTO_ERROR(H5E_ATTR, H5E_CANTOPENOBJ, FAIL, "unable to copy entry")
 
     /* Compute the size of pieces on disk */
     if(H5T_committed(attr->dt)) {
@@ -270,13 +267,13 @@ H5A_create(const H5G_entry_t *ent, const char *name, const H5T_t *type,
     else
         attr->dt_size=H5O_raw_size(H5O_DTYPE_ID,attr->ent.file,type);
     assert(attr->dt_size>0);
-    attr->ds_size=H5O_raw_size(H5O_SDSPACE_ID,attr->ent.file,&(space->extent.u.simple));
+    attr->ds_size=H5O_raw_size(H5O_SDSPACE_ID,attr->ent.file,&(space->extent));
     assert(attr->ds_size>0);
     H5_ASSIGN_OVERFLOW(attr->data_size,H5S_GET_EXTENT_NPOINTS(attr->ds)*H5T_get_size(attr->dt),hssize_t,size_t);
 
     /* Hold the symbol table entry (and file) open */
     if (H5O_open(&(attr->ent)) < 0)
-        HGOTO_ERROR(H5E_ATTR, H5E_CANTOPENOBJ, FAIL, "unable to open");
+        HGOTO_ERROR(H5E_ATTR, H5E_CANTOPENOBJ, FAIL, "unable to open")
     attr->ent_opened=1;
 
     /* Read in the existing attributes to check for duplicates */
@@ -287,21 +284,22 @@ H5A_create(const H5G_entry_t *ent, const char *name, const H5T_t *type,
 	 * if names are the same.
 	 */
 	if(HDstrcmp(found_attr.name,attr->name)==0) {
-	    H5O_reset (H5O_ATTR_ID, &found_attr);
-	    HGOTO_ERROR(H5E_ATTR, H5E_ALREADYEXISTS, FAIL, "attribute already exists");
+	    (void)H5O_reset (H5O_ATTR_ID, &found_attr);
+	    HGOTO_ERROR(H5E_ATTR, H5E_ALREADYEXISTS, FAIL, "attribute already exists")
 	}
-	H5O_reset (H5O_ATTR_ID, &found_attr);
+	if(H5O_reset (H5O_ATTR_ID, &found_attr)<0)
+	    HGOTO_ERROR(H5E_ATTR, H5E_CANTFREE, FAIL, "can't release attribute info")
 	seq++;
     }
     H5E_clear ();
 
     /* Create the attribute message and save the attribute index */
     if (H5O_modify(&(attr->ent), H5O_ATTR_ID, H5O_NEW_MESG, 0, 1, attr, dxpl_id) < 0) 
-        HGOTO_ERROR(H5E_ATTR, H5E_CANTINIT, FAIL, "unable to update attribute header messages");
+        HGOTO_ERROR(H5E_ATTR, H5E_CANTINIT, FAIL, "unable to update attribute header messages")
 
     /* Register the new attribute and get an ID for it */
     if ((ret_value = H5I_register(H5I_ATTR, attr)) < 0)
-        HGOTO_ERROR(H5E_ATOM, H5E_CANTREGISTER, FAIL, "unable to register attribute for ID");
+        HGOTO_ERROR(H5E_ATOM, H5E_CANTREGISTER, FAIL, "unable to register attribute for ID")
 
     /* Now it's safe to say it's uninitialized */
     attr->initialized = FALSE;
@@ -309,10 +307,10 @@ H5A_create(const H5G_entry_t *ent, const char *name, const H5T_t *type,
 done:
     if (ret_value < 0) {
         if(attr)
-            H5A_close(attr);
+            (void)H5A_close(attr);
     } /* end if */
 
-    FUNC_LEAVE_NOAPI(ret_value);
+    FUNC_LEAVE_NOAPI(ret_value)
 } /* H5A_create() */
 
 
@@ -343,7 +341,7 @@ H5A_get_index(H5G_entry_t *ent, const char *name, hid_t dxpl_id)
     int		i;                      /* Index variable */
     int		ret_value=FAIL;         /* Return value */
 
-    FUNC_ENTER_NOAPI_NOINIT(H5A_get_index);
+    FUNC_ENTER_NOAPI_NOINIT(H5A_get_index)
 
     assert(ent);
     assert(name);
@@ -356,20 +354,22 @@ H5A_get_index(H5G_entry_t *ent, const char *name, hid_t dxpl_id)
 	 * if names are the same.
 	 */
 	if(HDstrcmp(found_attr.name,name)==0) {
-	    H5O_reset (H5O_ATTR_ID, &found_attr);
+	    if(H5O_reset (H5O_ATTR_ID, &found_attr)<0)
+                HGOTO_ERROR(H5E_ATTR, H5E_CANTFREE, FAIL, "can't release attribute info")
 	    ret_value = i;
 	    break;
 	}
-	H5O_reset (H5O_ATTR_ID, &found_attr);
+	if(H5O_reset (H5O_ATTR_ID, &found_attr)<0)
+            HGOTO_ERROR(H5E_ATTR, H5E_CANTFREE, FAIL, "can't release attribute info")
 	i++;
     }
     H5E_clear ();
     
     if(ret_value<0)
-        HGOTO_ERROR(H5E_ATTR, H5E_NOTFOUND, FAIL, "attribute not found");
+        HGOTO_ERROR(H5E_ATTR, H5E_NOTFOUND, FAIL, "attribute not found")
 
 done:
-    FUNC_LEAVE_NOAPI(ret_value);
+    FUNC_LEAVE_NOAPI(ret_value)
 } /* H5A_get_index() */
 
 
@@ -406,27 +406,27 @@ H5Aopen_name(hid_t loc_id, const char *name)
     int            	idx=0;
     hid_t		ret_value;
 
-    FUNC_ENTER_API(H5Aopen_name, FAIL);
+    FUNC_ENTER_API(H5Aopen_name, FAIL)
     H5TRACE2("i","is",loc_id,name);
 
     /* check arguments */
     if (H5I_FILE==H5I_get_type(loc_id) || H5I_ATTR==H5I_get_type(loc_id))
-	HGOTO_ERROR(H5E_ARGS, H5E_BADTYPE, FAIL, "location is not valid for an attribute");
+	HGOTO_ERROR(H5E_ARGS, H5E_BADTYPE, FAIL, "location is not valid for an attribute")
     if (NULL==(ent=H5G_loc(loc_id)))
-	HGOTO_ERROR(H5E_ARGS, H5E_BADTYPE, FAIL, "not a location");
+	HGOTO_ERROR(H5E_ARGS, H5E_BADTYPE, FAIL, "not a location")
     if (!name || !*name)
-	HGOTO_ERROR(H5E_ARGS, H5E_BADVALUE, FAIL, "no name");
+	HGOTO_ERROR(H5E_ARGS, H5E_BADVALUE, FAIL, "no name")
 
     /* Look up the attribute for the object */
     if((idx=H5A_get_index(ent,name, H5AC_dxpl_id))<0)
-        HGOTO_ERROR(H5E_ATTR, H5E_BADVALUE, FAIL, "attribute not found");
+        HGOTO_ERROR(H5E_ATTR, H5E_BADVALUE, FAIL, "attribute not found")
 
     /* Go do the real work for opening the attribute */
     if ((ret_value=H5A_open(ent, (unsigned)idx, H5AC_dxpl_id))<0)
-	HGOTO_ERROR (H5E_ATTR, H5E_CANTINIT, FAIL, "unable to open attribute");
+	HGOTO_ERROR (H5E_ATTR, H5E_CANTINIT, FAIL, "unable to open attribute")
     
 done:
-    FUNC_LEAVE_API(ret_value);
+    FUNC_LEAVE_API(ret_value)
 } /* H5Aopen_name() */
 
 
@@ -463,21 +463,21 @@ H5Aopen_idx(hid_t loc_id, unsigned idx)
     H5G_entry_t	*ent = NULL;	/*Symtab entry of object to attribute */
     hid_t	ret_value;
 
-    FUNC_ENTER_API(H5Aopen_idx, FAIL);
+    FUNC_ENTER_API(H5Aopen_idx, FAIL)
     H5TRACE2("i","iIu",loc_id,idx);
 
     /* check arguments */
     if (H5I_FILE==H5I_get_type(loc_id) || H5I_ATTR==H5I_get_type(loc_id))
-	HGOTO_ERROR(H5E_ARGS, H5E_BADTYPE, FAIL, "location is not valid for an attribute");
+	HGOTO_ERROR(H5E_ARGS, H5E_BADTYPE, FAIL, "location is not valid for an attribute")
     if (NULL==(ent=H5G_loc(loc_id)))
-	HGOTO_ERROR(H5E_ARGS, H5E_BADTYPE, FAIL, "not a location");
+	HGOTO_ERROR(H5E_ARGS, H5E_BADTYPE, FAIL, "not a location")
 
     /* Go do the real work for opening the attribute */
     if ((ret_value=H5A_open(ent, idx, H5AC_dxpl_id))<0)
-	HGOTO_ERROR (H5E_ATTR, H5E_CANTINIT, FAIL, "unable to open attribute");
+	HGOTO_ERROR (H5E_ATTR, H5E_CANTINIT, FAIL, "unable to open attribute")
     
 done:
-    FUNC_LEAVE_API(ret_value);
+    FUNC_LEAVE_API(ret_value)
 } /* H5Aopen_idx() */
 
 
@@ -509,7 +509,7 @@ H5A_open(H5G_entry_t *ent, unsigned idx, hid_t dxpl_id)
     H5A_t       *attr = NULL;
     hid_t	    ret_value = FAIL;
 
-    FUNC_ENTER_NOAPI_NOINIT(H5A_open);
+    FUNC_ENTER_NOAPI_NOINIT(H5A_open)
 
     /* check args */
     assert(ent);
@@ -517,31 +517,30 @@ H5A_open(H5G_entry_t *ent, unsigned idx, hid_t dxpl_id)
     /* Read in attribute with H5O_read() */
     H5_CHECK_OVERFLOW(idx,unsigned,int);
     if (NULL==(attr=H5O_read(ent, H5O_ATTR_ID, (int)idx, attr, dxpl_id)))
-        HGOTO_ERROR(H5E_ATTR, H5E_CANTINIT, FAIL, "unable to load attribute info from dataset header");
+        HGOTO_ERROR(H5E_ATTR, H5E_CANTINIT, FAIL, "unable to load attribute info from dataset header")
     attr->initialized=1;
    
     /* Deep copy of the symbol table entry */
     if (H5G_ent_copy(&(attr->ent),ent,H5G_COPY_DEEP)<0)
-        HGOTO_ERROR(H5E_ATTR, H5E_CANTOPENOBJ, FAIL, "unable to copy entry");
+        HGOTO_ERROR(H5E_ATTR, H5E_CANTOPENOBJ, FAIL, "unable to copy entry")
 
     /* Hold the symbol table entry (and file) open */
     if (H5O_open(&(attr->ent)) < 0) {
-        HGOTO_ERROR(H5E_ATTR, H5E_CANTOPENOBJ, FAIL, "unable to open");
+        HGOTO_ERROR(H5E_ATTR, H5E_CANTOPENOBJ, FAIL, "unable to open")
     }
     attr->ent_opened=1;
 
     /* Register the new attribute and get an ID for it */
-    if ((ret_value = H5I_register(H5I_ATTR, attr)) < 0) {
-        HGOTO_ERROR(H5E_ATOM, H5E_CANTREGISTER, FAIL,
-		    "unable to register attribute for ID");
-    }
+    if ((ret_value = H5I_register(H5I_ATTR, attr)) < 0)
+        HGOTO_ERROR(H5E_ATOM, H5E_CANTREGISTER, FAIL, "unable to register attribute for ID")
 
 done:
     if (ret_value < 0) {
-        if(attr) H5A_close(attr);
+        if(attr)
+            (void)H5A_close(attr);
     }
 
-    FUNC_LEAVE_NOAPI(ret_value);
+    FUNC_LEAVE_NOAPI(ret_value)
 } /* H5A_open() */
 
 
@@ -570,23 +569,23 @@ H5Awrite(hid_t attr_id, hid_t type_id, const void *buf)
     const H5T_t    *mem_type = NULL;
     herr_t		    ret_value;
 
-    FUNC_ENTER_API(H5Awrite, FAIL);
+    FUNC_ENTER_API(H5Awrite, FAIL)
     H5TRACE3("e","iix",attr_id,type_id,buf);
 
     /* check arguments */
     if (NULL == (attr = H5I_object_verify(attr_id, H5I_ATTR)))
-        HGOTO_ERROR(H5E_ARGS, H5E_BADTYPE, FAIL, "not an attribute");
+        HGOTO_ERROR(H5E_ARGS, H5E_BADTYPE, FAIL, "not an attribute")
     if (NULL == (mem_type = H5I_object_verify(type_id, H5I_DATATYPE)))
-        HGOTO_ERROR(H5E_ARGS, H5E_BADTYPE, FAIL, "not a data type");
+        HGOTO_ERROR(H5E_ARGS, H5E_BADTYPE, FAIL, "not a data type")
     if (NULL == buf)
-        HGOTO_ERROR(H5E_ARGS, H5E_BADVALUE, FAIL, "null attribute buffer");
+        HGOTO_ERROR(H5E_ARGS, H5E_BADVALUE, FAIL, "null attribute buffer")
 
     /* Go write the actual data to the attribute */
     if ((ret_value=H5A_write(attr,mem_type,buf, H5AC_dxpl_id))<0)
-        HGOTO_ERROR(H5E_ATTR, H5E_WRITEERROR, FAIL, "unable to write attribute");
+        HGOTO_ERROR(H5E_ATTR, H5E_WRITEERROR, FAIL, "unable to write attribute")
 
 done:
-    FUNC_LEAVE_API(ret_value);
+    FUNC_LEAVE_API(ret_value)
 } /* H5Awrite() */
 
 
@@ -620,10 +619,10 @@ H5A_write(H5A_t *attr, const H5T_t *mem_type, const void *buf, hid_t dxpl_id)
     size_t		src_type_size;		/* size of source type	*/
     size_t		dst_type_size;		/* size of destination type*/
     size_t		buf_size;		/* desired buffer size	*/
-    int         idx;	      /* index of attribute in object header */
+    int			idx;			/* index of attribute in object header */
     herr_t		ret_value = FAIL;
 
-    FUNC_ENTER_NOAPI_NOINIT(H5A_write);
+    FUNC_ENTER_NOAPI_NOINIT(H5A_write)
 
     assert(attr);
     assert(mem_type);
@@ -641,7 +640,7 @@ H5A_write(H5A_t *attr, const H5T_t *mem_type, const void *buf, hid_t dxpl_id)
     /* Get the maximum buffer size needed and allocate it */
     H5_ASSIGN_OVERFLOW(buf_size,nelmts*MAX(src_type_size,dst_type_size),hsize_t,size_t);
     if (NULL==(tconv_buf = H5MM_malloc (buf_size)) || NULL==(bkg_buf = H5MM_calloc(buf_size)))
-        HGOTO_ERROR (H5E_RESOURCE, H5E_NOSPACE, FAIL, "memory allocation failed");
+        HGOTO_ERROR (H5E_RESOURCE, H5E_NOSPACE, FAIL, "memory allocation failed")
 
     /* Copy the user's data into the buffer for conversion */
     H5_CHECK_OVERFLOW((src_type_size*nelmts),hsize_t,size_t);
@@ -650,19 +649,16 @@ H5A_write(H5A_t *attr, const H5T_t *mem_type, const void *buf, hid_t dxpl_id)
     /* Convert memory buffer into disk buffer */
     /* Set up type conversion function */
     if (NULL == (tpath = H5T_path_find(mem_type, attr->dt, NULL, NULL, dxpl_id))) {
-        HGOTO_ERROR(H5E_ATTR, H5E_UNSUPPORTED, FAIL, "unable to convert between src and dest data types");
+        HGOTO_ERROR(H5E_ATTR, H5E_UNSUPPORTED, FAIL, "unable to convert between src and dest data types")
     } else if (!H5T_path_noop(tpath)) {
         if ((src_id = H5I_register(H5I_DATATYPE, H5T_copy(mem_type, H5T_COPY_ALL)))<0 ||
                 (dst_id = H5I_register(H5I_DATATYPE, H5T_copy(attr->dt, H5T_COPY_ALL)))<0)
-            HGOTO_ERROR(H5E_ATTR, H5E_CANTREGISTER, FAIL, "unable to register types for conversion");
+            HGOTO_ERROR(H5E_ATTR, H5E_CANTREGISTER, FAIL, "unable to register types for conversion")
     }
 
     /* Perform data type conversion */
-    if (H5T_convert(tpath, src_id, dst_id, nelmts, 0, 0, tconv_buf, bkg_buf,
-                    dxpl_id)<0) {
-        HGOTO_ERROR(H5E_ATTR, H5E_CANTENCODE, FAIL,
-		    "data type conversion failed");
-    }
+    if (H5T_convert(tpath, src_id, dst_id, nelmts, 0, 0, tconv_buf, bkg_buf, dxpl_id)<0)
+        HGOTO_ERROR(H5E_ATTR, H5E_CANTENCODE, FAIL, "data type conversion failed")
 
     /* Free the previous attribute data buffer, if there is one */
     if(attr->data)
@@ -670,13 +666,12 @@ H5A_write(H5A_t *attr, const H5T_t *mem_type, const void *buf, hid_t dxpl_id)
 
     /* Look up the attribute for the object */
     if((idx=H5A_get_index(&(attr->ent),attr->name,dxpl_id))<0)
-        HGOTO_ERROR(H5E_ATTR, H5E_BADVALUE, FAIL, "attribute not found");
+        HGOTO_ERROR(H5E_ATTR, H5E_BADVALUE, FAIL, "attribute not found")
 
     /* Modify the attribute data */
     attr->data=tconv_buf;   /* Set the data pointer temporarily */
     if (H5O_modify(&(attr->ent), H5O_ATTR_ID, idx, 0, 1, attr, dxpl_id) < 0) 
-        HGOTO_ERROR(H5E_ATTR, H5E_CANTINIT, FAIL,
-		    "unable to update attribute header messages");
+        HGOTO_ERROR(H5E_ATTR, H5E_CANTINIT, FAIL, "unable to update attribute header messages")
 
     /* Indicate the the attribute doesn't need fill-values */
     attr->initialized=TRUE;
@@ -686,13 +681,13 @@ H5A_write(H5A_t *attr, const H5T_t *mem_type, const void *buf, hid_t dxpl_id)
 done:
     /* Release resources */
     if (src_id >= 0) 
-        H5I_dec_ref(src_id);
+        (void)H5I_dec_ref(src_id);
     if (dst_id >= 0) 
-        H5I_dec_ref(dst_id);
+        (void)H5I_dec_ref(dst_id);
     if (bkg_buf)
         H5MM_xfree(bkg_buf);
 
-    FUNC_LEAVE_NOAPI(ret_value);
+    FUNC_LEAVE_NOAPI(ret_value)
 } /* H5A_write() */
 
 
@@ -721,23 +716,23 @@ H5Aread(hid_t attr_id, hid_t type_id, void *buf)
     const H5T_t    	*mem_type = NULL;
     herr_t		ret_value;
 
-    FUNC_ENTER_API(H5Aread, FAIL);
+    FUNC_ENTER_API(H5Aread, FAIL)
     H5TRACE3("e","iix",attr_id,type_id,buf);
 
     /* check arguments */
     if (NULL == (attr = H5I_object_verify(attr_id, H5I_ATTR)))
-        HGOTO_ERROR(H5E_ARGS, H5E_BADTYPE, FAIL, "not an attribute");
+        HGOTO_ERROR(H5E_ARGS, H5E_BADTYPE, FAIL, "not an attribute")
     if (NULL == (mem_type = H5I_object_verify(type_id, H5I_DATATYPE)))
-        HGOTO_ERROR(H5E_ARGS, H5E_BADTYPE, FAIL, "not a data type");
+        HGOTO_ERROR(H5E_ARGS, H5E_BADTYPE, FAIL, "not a data type")
     if (NULL == buf)
-        HGOTO_ERROR(H5E_ARGS, H5E_BADVALUE, FAIL, "null attribute buffer");
+        HGOTO_ERROR(H5E_ARGS, H5E_BADVALUE, FAIL, "null attribute buffer")
 
     /* Go write the actual data to the attribute */
     if ((ret_value=H5A_read(attr,mem_type,buf,H5AC_dxpl_id))<0)
-        HGOTO_ERROR(H5E_ATTR, H5E_READERROR, FAIL, "unable to read attribute");
+        HGOTO_ERROR(H5E_ATTR, H5E_READERROR, FAIL, "unable to read attribute")
 
 done:
-    FUNC_LEAVE_API(ret_value);
+    FUNC_LEAVE_API(ret_value)
 } /* H5Aread() */
 
 
@@ -760,7 +755,7 @@ done:
     This function reads a complete attribute from disk.
 --------------------------------------------------------------------------*/
 static herr_t
-H5A_read(H5A_t *attr, const H5T_t *mem_type, void *buf, hid_t dxpl_id)
+H5A_read(const H5A_t *attr, const H5T_t *mem_type, void *buf, hid_t dxpl_id)
 {
     uint8_t		*tconv_buf = NULL;	/* data type conv buffer*/
     uint8_t		*bkg_buf = NULL;	/* background buffer */
@@ -773,7 +768,7 @@ H5A_read(H5A_t *attr, const H5T_t *mem_type, void *buf, hid_t dxpl_id)
     size_t		buf_size;		/* desired buffer size	*/
     herr_t		ret_value = FAIL;
 
-    FUNC_ENTER_NOAPI_NOINIT(H5A_read);
+    FUNC_ENTER_NOAPI_NOINIT(H5A_read)
 
     assert(attr);
     assert(mem_type);
@@ -797,7 +792,7 @@ H5A_read(H5A_t *attr, const H5T_t *mem_type, void *buf, hid_t dxpl_id)
         /* Get the maximum buffer size needed and allocate it */
         H5_ASSIGN_OVERFLOW(buf_size,(nelmts*MAX(src_type_size,dst_type_size)),hsize_t,size_t);
         if (NULL==(tconv_buf = H5MM_malloc (buf_size)) || NULL==(bkg_buf = H5MM_calloc(buf_size)))
-            HGOTO_ERROR (H5E_RESOURCE, H5E_NOSPACE, FAIL, "memory allocation failed");
+            HGOTO_ERROR (H5E_RESOURCE, H5E_NOSPACE, FAIL, "memory allocation failed")
 
         /* Copy the attribute data into the buffer for conversion */
         H5_CHECK_OVERFLOW((src_type_size*nelmts),hsize_t,size_t);
@@ -806,16 +801,16 @@ H5A_read(H5A_t *attr, const H5T_t *mem_type, void *buf, hid_t dxpl_id)
         /* Convert memory buffer into disk buffer */
         /* Set up type conversion function */
         if (NULL == (tpath = H5T_path_find(attr->dt, mem_type, NULL, NULL, dxpl_id))) {
-            HGOTO_ERROR(H5E_ATTR, H5E_UNSUPPORTED, FAIL, "unable to convert between src and dest data types");
+            HGOTO_ERROR(H5E_ATTR, H5E_UNSUPPORTED, FAIL, "unable to convert between src and dest data types")
         } else if (!H5T_path_noop(tpath)) {
             if ((src_id = H5I_register(H5I_DATATYPE, H5T_copy(attr->dt, H5T_COPY_ALL)))<0 ||
                     (dst_id = H5I_register(H5I_DATATYPE, H5T_copy(mem_type, H5T_COPY_ALL)))<0)
-                HGOTO_ERROR(H5E_ATTR, H5E_CANTREGISTER, FAIL, "unable to register types for conversion");
+                HGOTO_ERROR(H5E_ATTR, H5E_CANTREGISTER, FAIL, "unable to register types for conversion")
         }
 
         /* Perform data type conversion.  */
         if (H5T_convert(tpath, src_id, dst_id, nelmts, 0, 0, tconv_buf, bkg_buf, dxpl_id)<0)
-            HGOTO_ERROR(H5E_ATTR, H5E_CANTENCODE, FAIL, "data type conversion failed");
+            HGOTO_ERROR(H5E_ATTR, H5E_CANTENCODE, FAIL, "data type conversion failed")
 
         /* Copy the converted data into the user's buffer */
         HDmemcpy(buf,tconv_buf,(size_t)(dst_type_size*nelmts));
@@ -826,15 +821,15 @@ H5A_read(H5A_t *attr, const H5T_t *mem_type, void *buf, hid_t dxpl_id)
 done:
     /* Release resources */
     if (src_id >= 0) 
-        H5I_dec_ref(src_id);
+        (void)H5I_dec_ref(src_id);
     if (dst_id >= 0) 
-        H5I_dec_ref(dst_id);
+        (void)H5I_dec_ref(dst_id);
     if (tconv_buf)
         H5MM_xfree(tconv_buf);
     if (bkg_buf)
 	H5MM_xfree(bkg_buf);
 
-    FUNC_LEAVE_NOAPI(ret_value);
+    FUNC_LEAVE_NOAPI(ret_value)
 } /* H5A_read() */
 
 
@@ -863,23 +858,23 @@ H5Aget_space(hid_t attr_id)
     H5S_t	*dst = NULL;
     hid_t	ret_value;
 
-    FUNC_ENTER_API(H5Aget_space, FAIL);
+    FUNC_ENTER_API(H5Aget_space, FAIL)
     H5TRACE1("i","i",attr_id);
 
     /* check arguments */
     if (NULL == (attr = H5I_object_verify(attr_id, H5I_ATTR)))
-        HGOTO_ERROR(H5E_ARGS, H5E_BADTYPE, FAIL, "not an attribute");
+        HGOTO_ERROR(H5E_ARGS, H5E_BADTYPE, FAIL, "not an attribute")
 
     /* Copy the attribute's dataspace */
     if (NULL==(dst=H5S_copy (attr->ds, FALSE)))
-	HGOTO_ERROR (H5E_ATTR, H5E_CANTINIT, FAIL, "unable to copy dataspace");
+	HGOTO_ERROR (H5E_ATTR, H5E_CANTINIT, FAIL, "unable to copy dataspace")
 
     /* Atomize */
     if ((ret_value=H5I_register (H5I_DATASPACE, dst))<0)
-        HGOTO_ERROR (H5E_ATOM, H5E_CANTREGISTER, FAIL, "unable to register dataspace atom");
+        HGOTO_ERROR (H5E_ATOM, H5E_CANTREGISTER, FAIL, "unable to register dataspace atom")
 
 done:
-    FUNC_LEAVE_API(ret_value);
+    FUNC_LEAVE_API(ret_value)
 } /* H5Aget_space() */
 
 
@@ -915,12 +910,12 @@ H5Aget_type(hid_t attr_id)
     H5T_t	*dst = NULL;
     hid_t	 ret_value;
 
-    FUNC_ENTER_API(H5Aget_type, FAIL);
+    FUNC_ENTER_API(H5Aget_type, FAIL)
     H5TRACE1("i","i",attr_id);
 
     /* check arguments */
     if (NULL == (attr = H5I_object_verify(attr_id, H5I_ATTR)))
-        HGOTO_ERROR(H5E_ARGS, H5E_BADTYPE, FAIL, "not an attribute");
+        HGOTO_ERROR(H5E_ARGS, H5E_BADTYPE, FAIL, "not an attribute")
 
     /*
      * Copy the attribute's data type.  If the type is a named type then
@@ -928,25 +923,25 @@ H5Aget_type(hid_t attr_id)
      * read-only.
      */
     if (NULL==(dst=H5T_copy(attr->dt, H5T_COPY_REOPEN)))
-	HGOTO_ERROR(H5E_ATTR, H5E_CANTINIT, FAIL, "unable to copy datatype");
+	HGOTO_ERROR(H5E_ATTR, H5E_CANTINIT, FAIL, "unable to copy datatype")
 
     /* Mark any VL datatypes as being in memory now */
     if (H5T_vlen_mark(dst, NULL, H5T_VLEN_MEMORY)<0)
-        HGOTO_ERROR(H5E_DATATYPE, H5E_CANTINIT, FAIL, "invalid VL location");
+        HGOTO_ERROR(H5E_DATATYPE, H5E_CANTINIT, FAIL, "invalid VL location")
     if (H5T_lock(dst, FALSE)<0)
-	HGOTO_ERROR(H5E_DATATYPE, H5E_CANTINIT, FAIL, "unable to lock transient data type");
+	HGOTO_ERROR(H5E_DATATYPE, H5E_CANTINIT, FAIL, "unable to lock transient data type")
     
     /* Atomize */
     if ((ret_value=H5I_register(H5I_DATATYPE, dst))<0)
-        HGOTO_ERROR(H5E_ATOM, H5E_CANTREGISTER, FAIL, "unable to register datatype atom");
+        HGOTO_ERROR(H5E_ATOM, H5E_CANTREGISTER, FAIL, "unable to register datatype atom")
 
 done:
     if(ret_value<0) {
         if(dst!=NULL)
-            H5T_close(dst);
+            (void)H5T_close(dst);
     } /* end if */
 
-    FUNC_LEAVE_API(ret_value);
+    FUNC_LEAVE_API(ret_value)
 } /* H5Aget_type() */
 
 
@@ -980,14 +975,14 @@ H5Aget_name(hid_t attr_id, size_t buf_size, char *buf)
     size_t              copy_len, nbytes;
     ssize_t		ret_value;
 
-    FUNC_ENTER_API(H5Aget_name, FAIL);
+    FUNC_ENTER_API(H5Aget_name, FAIL)
     H5TRACE3("Zs","izs",attr_id,buf_size,buf);
 
     /* check arguments */
     if (NULL == (attr = H5I_object_verify(attr_id, H5I_ATTR)))
-        HGOTO_ERROR(H5E_ARGS, H5E_BADTYPE, FAIL, "not an attribute");
+        HGOTO_ERROR(H5E_ARGS, H5E_BADTYPE, FAIL, "not an attribute")
     if (!buf && buf_size)
-	HGOTO_ERROR(H5E_ARGS, H5E_BADVALUE, FAIL, "invalid buffer");
+	HGOTO_ERROR(H5E_ARGS, H5E_BADVALUE, FAIL, "invalid buffer")
 
     /* get the real attribute length */
     nbytes = HDstrlen(attr->name);
@@ -1008,7 +1003,7 @@ H5Aget_name(hid_t attr_id, size_t buf_size, char *buf)
     ret_value = (ssize_t)nbytes;
 
 done:
-    FUNC_LEAVE_API(ret_value);
+    FUNC_LEAVE_API(ret_value)
 } /* H5Aget_type() */
 
 
@@ -1037,18 +1032,18 @@ H5Aget_storage_size(hid_t attr_id)
     H5A_t	*attr=NULL;
     hsize_t	ret_value;      /* Return value */
     
-    FUNC_ENTER_API(H5Aget_storage_size, 0);
+    FUNC_ENTER_API(H5Aget_storage_size, 0)
     H5TRACE1("h","i",attr_id);
 
     /* Check args */
     if (NULL==(attr=H5I_object_verify(attr_id, H5I_ATTR)))
-        HGOTO_ERROR(H5E_ARGS, H5E_BADTYPE, 0, "not an attribute");
+        HGOTO_ERROR(H5E_ARGS, H5E_BADTYPE, 0, "not an attribute")
 
     /* Set return value */
     ret_value = H5A_get_storage_size(attr);
 
 done:
-    FUNC_LEAVE_API(ret_value);
+    FUNC_LEAVE_API(ret_value)
 }
 
 
@@ -1073,16 +1068,16 @@ done:
  *-------------------------------------------------------------------------
  */
 static hsize_t
-H5A_get_storage_size(H5A_t *attr)
+H5A_get_storage_size(const H5A_t *attr)
 {
     hsize_t	ret_value;      /* Return value */
     
-    FUNC_ENTER_NOAPI_NOINIT_NOFUNC(H5A_get_storage_size);
+    FUNC_ENTER_NOAPI_NOINIT_NOFUNC(H5A_get_storage_size)
 
     /* Set return value */
     ret_value = attr->data_size;
 
-    FUNC_LEAVE_NOAPI(ret_value);
+    FUNC_LEAVE_NOAPI(ret_value)
 }
  
 
@@ -1114,34 +1109,34 @@ H5Aget_num_attrs(hid_t loc_id)
     void           	*obj = NULL;
     int			ret_value;
 
-    FUNC_ENTER_API(H5Aget_num_attrs, FAIL);
+    FUNC_ENTER_API(H5Aget_num_attrs, FAIL)
     H5TRACE1("Is","i",loc_id);
 
     /* check arguments */
     if (H5I_FILE==H5I_get_type(loc_id) || H5I_ATTR==H5I_get_type(loc_id))
-	HGOTO_ERROR(H5E_ARGS, H5E_BADTYPE, FAIL, "location is not valid for an attribute");
+	HGOTO_ERROR(H5E_ARGS, H5E_BADTYPE, FAIL, "location is not valid for an attribute")
     if(NULL == (obj = H5I_object(loc_id)))
-        HGOTO_ERROR(H5E_ARGS, H5E_BADATOM, FAIL, "illegal object atom");
+        HGOTO_ERROR(H5E_ARGS, H5E_BADATOM, FAIL, "illegal object atom")
     switch (H5I_get_type (loc_id)) {
         case H5I_DATASET:
             ent = H5D_entof ((H5D_t*)obj);
             break;
         case H5I_DATATYPE:
             if (NULL==(ent=H5T_entof ((H5T_t*)obj)))
-                HGOTO_ERROR (H5E_ARGS, H5E_BADTYPE, FAIL, "target data type is not committed");
+                HGOTO_ERROR (H5E_ARGS, H5E_BADTYPE, FAIL, "target data type is not committed")
             break;
         case H5I_GROUP:
             ent = H5G_entof ((H5G_t*)obj);
             break;
         default:
-            HGOTO_ERROR (H5E_ARGS, H5E_BADTYPE, FAIL, "inappropriate attribute target");
+            HGOTO_ERROR (H5E_ARGS, H5E_BADTYPE, FAIL, "inappropriate attribute target")
     }
 
     /* Look up the attribute for the object */
     ret_value=H5O_count(ent, H5O_ATTR_ID, H5AC_ind_dxpl_id);
 
 done:
-    FUNC_LEAVE_API(ret_value);
+    FUNC_LEAVE_API(ret_value)
 } /* H5Aget_num_attrs() */
 
 
@@ -1167,22 +1162,22 @@ H5Arename(hid_t loc_id, const char *old_name, const char *new_name)
     H5G_entry_t	*ent = NULL;	/*symtab ent of object to attribute */
     herr_t	ret_value;      /* Return value */
     
-    FUNC_ENTER_API(H5Arename, FAIL);
+    FUNC_ENTER_API(H5Arename, FAIL)
     H5TRACE3("e","iss",loc_id,old_name,new_name);
 
     /* check arguments */
     if (!old_name || !new_name)
-	HGOTO_ERROR(H5E_ARGS, H5E_BADTYPE, FAIL, "name is nil");
+	HGOTO_ERROR(H5E_ARGS, H5E_BADTYPE, FAIL, "name is nil")
     if (H5I_FILE==H5I_get_type(loc_id) || H5I_ATTR==H5I_get_type(loc_id))
-	HGOTO_ERROR(H5E_ARGS, H5E_BADTYPE, FAIL, "location is not valid for an attribute");
+	HGOTO_ERROR(H5E_ARGS, H5E_BADTYPE, FAIL, "location is not valid for an attribute")
     if (NULL==(ent=H5G_loc(loc_id)))
-	HGOTO_ERROR(H5E_ARGS, H5E_BADTYPE, FAIL, "not a location");
+	HGOTO_ERROR(H5E_ARGS, H5E_BADTYPE, FAIL, "not a location")
 
     /* Call private function */
     ret_value = H5A_rename(ent, old_name, new_name, H5AC_dxpl_id);
 
 done:
-    FUNC_LEAVE_API(ret_value);
+    FUNC_LEAVE_API(ret_value)
 } /* H5Arename() */
 
 
@@ -1209,7 +1204,7 @@ H5A_rename(H5G_entry_t *ent, const char *old_name, const char *new_name, hid_t d
     H5A_t       *found_attr;    /* Attribute with OLD_NAME */
     herr_t	ret_value=SUCCEED;      /* Return value */
     
-    FUNC_ENTER_NOAPI_NOINIT(H5A_rename);
+    FUNC_ENTER_NOAPI_NOINIT(H5A_rename)
 
     /* Check arguments */
     assert(ent);
@@ -1218,7 +1213,7 @@ H5A_rename(H5G_entry_t *ent, const char *old_name, const char *new_name, hid_t d
     
     /* Build the attribute information */
     if((found_attr = HDcalloc(1, sizeof(H5A_t)))==NULL)
-        HGOTO_ERROR(H5E_RESOURCE, H5E_NOSPACE, FAIL, "memory allocation failed for attribute info");
+        HGOTO_ERROR(H5E_RESOURCE, H5E_NOSPACE, FAIL, "memory allocation failed for attribute info")
         
     /* Read in the existing attributes to check for duplicates */
     seq=0;
@@ -1230,19 +1225,20 @@ H5A_rename(H5G_entry_t *ent, const char *old_name, const char *new_name, hid_t d
             idx = seq;
             break;
 	}
-	H5O_reset (H5O_ATTR_ID, found_attr);
+	if(H5O_reset (H5O_ATTR_ID, found_attr)<0)
+	    HGOTO_ERROR(H5E_ATTR, H5E_CANTFREE, FAIL, "can't release attribute info")
 	seq++;
     }
  
     if(idx<0)
-	HGOTO_ERROR(H5E_ARGS, H5E_BADTYPE, FAIL, "attribute cannot be found");
+	HGOTO_ERROR(H5E_ARGS, H5E_BADTYPE, FAIL, "attribute cannot be found")
         
     /* Copy the attribute name. */
     if(found_attr->name)
         HDfree(found_attr->name);
     found_attr->name = HDstrdup(new_name); 
     if(!found_attr->name) 
-        HGOTO_ERROR(H5E_RESOURCE, H5E_NOSPACE, FAIL, "String copy failed");
+        HGOTO_ERROR(H5E_RESOURCE, H5E_NOSPACE, FAIL, "String copy failed")
 
     /* Indicate entry is not opened and the attribute doesn't need fill-values. */
     found_attr->ent_opened=FALSE;
@@ -1250,13 +1246,14 @@ H5A_rename(H5G_entry_t *ent, const char *old_name, const char *new_name, hid_t d
 
     /* Modify the attribute message */
     if (H5O_modify(ent, H5O_ATTR_ID, idx, 0, 1, found_attr, dxpl_id) < 0) 
-        HGOTO_ERROR(H5E_ATTR, H5E_CANTINIT, FAIL, "unable to update attribute header messages");
+        HGOTO_ERROR(H5E_ATTR, H5E_CANTINIT, FAIL, "unable to update attribute header messages")
    
     /* Close the attribute */
-    H5A_close(found_attr);
+    if(H5A_close(found_attr)<0)
+        HGOTO_ERROR(H5E_ATTR, H5E_CANTRELEASE, FAIL, "unable to close renamed attribute")
 
 done:
-    FUNC_LEAVE_NOAPI(ret_value);
+    FUNC_LEAVE_NOAPI(ret_value)
 }
 
 
@@ -1314,22 +1311,22 @@ H5Aiterate(hid_t loc_id, unsigned *attr_num, H5A_operator_t op, void *op_data)
     herr_t	        ret_value = 0;
     int		idx, start_idx;
 
-    FUNC_ENTER_API(H5Aiterate, FAIL);
+    FUNC_ENTER_API(H5Aiterate, FAIL)
     H5TRACE4("e","i*Iuxx",loc_id,attr_num,op,op_data);
 
     /* check arguments */
     if (H5I_FILE==H5I_get_type(loc_id) || H5I_ATTR==H5I_get_type(loc_id))
-	HGOTO_ERROR(H5E_ARGS, H5E_BADTYPE, FAIL, "location is not valid for an attribute");
+	HGOTO_ERROR(H5E_ARGS, H5E_BADTYPE, FAIL, "location is not valid for an attribute")
     if (NULL==(ent=H5G_loc(loc_id)))
-	HGOTO_ERROR(H5E_ARGS, H5E_BADTYPE, FAIL, "not a location");
+	HGOTO_ERROR(H5E_ARGS, H5E_BADTYPE, FAIL, "not a location")
 
     /*
      * Look up the attribute for the object. Make certain the start point is
      * reasonable.
      */
-    start_idx = idx = attr_num ? (int)*attr_num : 0;
+    start_idx = idx = (attr_num ? (int)*attr_num : 0);
     if (idx<0)
-	HGOTO_ERROR (H5E_ARGS, H5E_BADVALUE, FAIL, "invalid index specified");
+	HGOTO_ERROR (H5E_ARGS, H5E_BADVALUE, FAIL, "invalid index specified")
     if(idx<H5O_count(ent, H5O_ATTR_ID, H5AC_dxpl_id)) {
         while(H5O_read(ent, H5O_ATTR_ID, idx++, &found_attr, H5AC_dxpl_id)!=NULL) {
 	    /*
@@ -1337,22 +1334,24 @@ H5Aiterate(hid_t loc_id, unsigned *attr_num, H5A_operator_t op, void *op_data)
 	     * creation if names are the same.
 	     */
 	    if((ret_value=(op)(loc_id,found_attr.name,op_data))!=0) {
-		H5O_reset (H5O_ATTR_ID, &found_attr);
+		if(H5O_reset (H5O_ATTR_ID, &found_attr)<0)
+                    HGOTO_ERROR(H5E_ATTR, H5E_CANTFREE, FAIL, "can't release attribute info")
 		break;
 	    }
-	    H5O_reset (H5O_ATTR_ID, &found_attr);
+	    if(H5O_reset (H5O_ATTR_ID, &found_attr)<0)
+                HGOTO_ERROR(H5E_ATTR, H5E_CANTFREE, FAIL, "can't release attribute info")
 	}
 	H5E_clear ();
     }
     else
         if(start_idx>0)
-            HGOTO_ERROR (H5E_ARGS, H5E_BADVALUE, FAIL, "invalid index specified");
+            HGOTO_ERROR (H5E_ARGS, H5E_BADVALUE, FAIL, "invalid index specified")
 
     if (attr_num)
         *attr_num = (unsigned)idx;
 
 done:
-    FUNC_LEAVE_API(ret_value);
+    FUNC_LEAVE_API(ret_value)
 } /* H5Aiterate() */
 
 
@@ -1389,16 +1388,16 @@ H5Adelete(hid_t loc_id, const char *name)
     int        idx=0, found=-1;
     herr_t	ret_value;
 
-    FUNC_ENTER_API(H5Adelete, FAIL);
+    FUNC_ENTER_API(H5Adelete, FAIL)
     H5TRACE2("e","is",loc_id,name);
 
     /* check arguments */
     if (H5I_FILE==H5I_get_type(loc_id) || H5I_ATTR==H5I_get_type(loc_id))
-	HGOTO_ERROR(H5E_ARGS, H5E_BADTYPE, FAIL, "location is not valid for an attribute");
+	HGOTO_ERROR(H5E_ARGS, H5E_BADTYPE, FAIL, "location is not valid for an attribute")
     if (NULL==(ent=H5G_loc(loc_id)))
-	HGOTO_ERROR(H5E_ARGS, H5E_BADTYPE, FAIL, "not a location");
+	HGOTO_ERROR(H5E_ARGS, H5E_BADTYPE, FAIL, "not a location")
     if (!name || !*name)
-	HGOTO_ERROR(H5E_ARGS, H5E_BADVALUE, FAIL, "no name");
+	HGOTO_ERROR(H5E_ARGS, H5E_BADVALUE, FAIL, "no name")
 
     /* Look up the attribute for the object */
     idx=0;
@@ -1408,23 +1407,25 @@ H5Adelete(hid_t loc_id, const char *name)
 	 * creation if names are the same.
 	 */
 	if(HDstrcmp(found_attr.name,name)==0) {
-	    H5O_reset (H5O_ATTR_ID, &found_attr);
+	    if(H5O_reset (H5O_ATTR_ID, &found_attr)<0)
+                HGOTO_ERROR(H5E_ATTR, H5E_CANTFREE, FAIL, "can't release attribute info")
 	    found = idx;
 	    break;
 	}
-	H5O_reset (H5O_ATTR_ID, &found_attr);
+	if(H5O_reset (H5O_ATTR_ID, &found_attr)<0)
+            HGOTO_ERROR(H5E_ATTR, H5E_CANTFREE, FAIL, "can't release attribute info")
 	idx++;
     }
     H5E_clear ();
     if (found<0)
-        HGOTO_ERROR(H5E_ATTR, H5E_NOTFOUND, FAIL, "attribute not found");
+        HGOTO_ERROR(H5E_ATTR, H5E_NOTFOUND, FAIL, "attribute not found")
 
     /* Delete the attribute from the location */
     if ((ret_value=H5O_remove(ent, H5O_ATTR_ID, found, H5AC_dxpl_id)) < 0)
-        HGOTO_ERROR(H5E_ATTR, H5E_CANTDELETE, FAIL, "unable to delete attribute header message");
+        HGOTO_ERROR(H5E_ATTR, H5E_CANTDELETE, FAIL, "unable to delete attribute header message")
     
 done:
-    FUNC_LEAVE_API(ret_value);
+    FUNC_LEAVE_API(ret_value)
 } /* H5Adelete() */
 
 
@@ -1450,18 +1451,19 @@ H5Aclose(hid_t attr_id)
 {
     herr_t ret_value=SUCCEED;   /* Return value */
 
-    FUNC_ENTER_API(H5Aclose, FAIL);
+    FUNC_ENTER_API(H5Aclose, FAIL)
     H5TRACE1("e","i",attr_id);
 
     /* check arguments */
     if (NULL == H5I_object_verify(attr_id, H5I_ATTR))
-        HGOTO_ERROR(H5E_ARGS, H5E_BADTYPE, FAIL, "not an attribute");
+        HGOTO_ERROR(H5E_ARGS, H5E_BADTYPE, FAIL, "not an attribute")
 
     /* Decrement references to that atom (and close it) */
-    H5I_dec_ref (attr_id);
+    if(H5I_dec_ref (attr_id)<0)
+        HGOTO_ERROR(H5E_ATTR, H5E_CANTDEC, FAIL, "can't close attribute")
 
 done:
-    FUNC_LEAVE_API(ret_value);
+    FUNC_LEAVE_API(ret_value)
 } /* H5Aclose() */
 
 
@@ -1487,14 +1489,14 @@ H5A_copy(const H5A_t *old_attr)
     H5A_t	*new_attr=NULL;
     H5A_t	*ret_value=NULL;        /* Return value */
 
-    FUNC_ENTER_NOAPI(H5A_copy, NULL);
+    FUNC_ENTER_NOAPI(H5A_copy, NULL)
 
     /* check args */
     assert(old_attr);
 
     /* get space */
     if (NULL==(new_attr = H5MM_calloc(sizeof(H5A_t))))
-	HGOTO_ERROR (H5E_RESOURCE, H5E_NOSPACE, NULL, "memory allocation failed");
+	HGOTO_ERROR (H5E_RESOURCE, H5E_NOSPACE, NULL, "memory allocation failed")
 
     /* Copy the top level of the attribute */
     *new_attr = *old_attr;
@@ -1508,7 +1510,7 @@ H5A_copy(const H5A_t *old_attr)
     new_attr->ds=H5S_copy(old_attr->ds, FALSE);
     if(old_attr->data) {
         if (NULL==(new_attr->data=H5MM_malloc(old_attr->data_size)))
-	    HGOTO_ERROR (H5E_RESOURCE, H5E_NOSPACE, NULL, "memory allocation failed");
+	    HGOTO_ERROR (H5E_RESOURCE, H5E_NOSPACE, NULL, "memory allocation failed")
         HDmemcpy(new_attr->data,old_attr->data,old_attr->data_size);
     } /* end if */
 
@@ -1522,10 +1524,10 @@ H5A_copy(const H5A_t *old_attr)
 done:
     if(ret_value==NULL) {
         if(new_attr!=NULL)
-            H5A_close(new_attr);
+            (void)H5A_close(new_attr);
     } /* end if */
 
-    FUNC_LEAVE_NOAPI(ret_value);
+    FUNC_LEAVE_NOAPI(ret_value)
 }
 
 
@@ -1548,7 +1550,7 @@ H5A_close(H5A_t *attr)
 {
     herr_t ret_value=SUCCEED;           /* Return value */
 
-    FUNC_ENTER_NOAPI(H5A_close, FAIL);
+    FUNC_ENTER_NOAPI(H5A_close, FAIL)
 
     assert(attr);
 
@@ -1556,11 +1558,11 @@ H5A_close(H5A_t *attr)
     if(attr->ent_opened && !attr->initialized) {
         uint8_t *tmp_buf=H5MM_calloc(attr->data_size);
         if (NULL == tmp_buf)
-            HGOTO_ERROR(H5E_ATTR, H5E_NOSPACE, FAIL, "memory allocation failed for attribute fill-value");
+            HGOTO_ERROR(H5E_ATTR, H5E_NOSPACE, FAIL, "memory allocation failed for attribute fill-value")
 
         /* Go write the fill data to the attribute */
         if (H5A_write(attr,attr->dt,tmp_buf,H5AC_dxpl_id)<0)
-            HGOTO_ERROR(H5E_ATTR, H5E_WRITEERROR, FAIL, "unable to write attribute");
+            HGOTO_ERROR(H5E_ATTR, H5E_WRITEERROR, FAIL, "unable to write attribute")
 
         /* Free temporary buffer */
         H5MM_xfree(tmp_buf);
@@ -1570,24 +1572,23 @@ H5A_close(H5A_t *attr)
     if(attr->name)
         H5MM_xfree(attr->name);
     if(attr->dt)
-        H5T_close(attr->dt);
+        if(H5T_close(attr->dt)<0)
+	    HGOTO_ERROR(H5E_ATTR, H5E_CANTRELEASE, FAIL, "can't release datatype info")
     if(attr->ds)
-        H5S_close(attr->ds);
+        if(H5S_close(attr->ds)<0)
+	    HGOTO_ERROR(H5E_ATTR, H5E_CANTRELEASE, FAIL, "can't release dataspace info")
     if(attr->data)
         H5MM_xfree(attr->data);
 
     /* Close the object's symbol-table entry */
     if(attr->ent_opened)
-        H5O_close(&(attr->ent));
-
-#ifndef LATER
-    /* Do something with the shared information? */
-#endif
+        if(H5O_close(&(attr->ent))<0)
+	    HGOTO_ERROR(H5E_ATTR, H5E_CANTRELEASE, FAIL, "can't release object header info")
 
     H5MM_xfree(attr);
     
 done:
-    FUNC_LEAVE_NOAPI(ret_value);
+    FUNC_LEAVE_NOAPI(ret_value)
 }
 
 
@@ -1614,12 +1615,12 @@ H5A_entof(H5A_t *attr)
 {
     H5G_entry_t *ret_value;   /* Return value */
 
-    FUNC_ENTER_NOAPI(H5A_entof, NULL);
+    FUNC_ENTER_NOAPI(H5A_entof, NULL)
     assert(attr);
 
     /* Set return value */
     ret_value=&(attr->ent);
 
 done:
-    FUNC_LEAVE_NOAPI(ret_value);
+    FUNC_LEAVE_NOAPI(ret_value)
 }
diff --git a/src/H5Apkg.h b/src/H5Apkg.h
index c66cf9c..9c837ab 100644
--- a/src/H5Apkg.h
+++ b/src/H5Apkg.h
@@ -38,8 +38,8 @@
 #include "H5Aprivate.h"
 
 /* Other private headers needed by this file */
-#include "H5HGprivate.h"	/* Global heaps				*/
 #include "H5Sprivate.h"		/* Dataspace				*/
+#include "H5Tprivate.h"		/* Datatype functions			*/
 
 struct H5A_t {
     unsigned       initialized;/* Indicate whether the attribute has been modified */
@@ -52,8 +52,6 @@ struct H5A_t {
     size_t      ds_size;    /* Size of dataspace on disk */
     void        *data;      /* Attribute data (on a temporary basis) */
     size_t      data_size;  /* Size of data on disk */
-    H5HG_t	sh_heap;    /*if defined, attribute is in global heap	     */
-    H5F_t	*sh_file;   /*file pointer if this is a shared attribute    */
 };
 
 /* Function prototypes for H5A package scope */
diff --git a/src/H5Oattr.c b/src/H5Oattr.c
index e1528ef..f454b74 100644
--- a/src/H5Oattr.c
+++ b/src/H5Oattr.c
@@ -74,8 +74,8 @@ static int		interface_initialize_g = 0;
 /* Declare external the free list for H5S_t's */
 H5FL_EXTERN(H5S_t);
 
-/* Declare external the free list for H5S_simple_t's */
-H5FL_EXTERN(H5S_simple_t);
+/* Declare external the free list for H5S_extent_t's */
+H5FL_EXTERN(H5S_extent_t);
 
 /*--------------------------------------------------------------------------
  NAME
@@ -101,12 +101,16 @@ H5FL_EXTERN(H5S_simple_t);
  *
  * 	Robb Matzke, 20 Jul 1998
  *	Added a version number at the beginning.
+ *
+ *	Raymond Lu, 8 April 2004
+ *	Changed Dataspace operation on H5S_simple_t to H5S_extent_t.
+ *
 --------------------------------------------------------------------------*/
 static void *
 H5O_attr_decode(H5F_t *f, hid_t dxpl_id, const uint8_t *p, H5O_shared_t UNUSED *sh)
 {
     H5A_t		*attr = NULL;
-    H5S_simple_t	*simple;	/*simple dimensionality information  */
+    H5S_extent_t	*extent;	/*extent dimensionality information  */
     size_t		name_len;   	/*attribute name length */
     int		        version;	/*message version number*/
     unsigned            flags=0;        /* Attribute flags */
@@ -176,30 +180,16 @@ H5O_attr_decode(H5F_t *f, hid_t dxpl_id, const uint8_t *p, H5O_shared_t UNUSED *
     /* decode the attribute dataspace */
     if (NULL==(attr->ds = H5FL_CALLOC(H5S_t)))
 	HGOTO_ERROR (H5E_RESOURCE, H5E_NOSPACE, NULL, "memory allocation failed");
-    if((simple=(H5O_SDSPACE->decode)(f,dxpl_id,p,NULL))!=NULL) {
-        hsize_t nelem;  /* Number of elements in extent */
-        unsigned u;     /* Local index variable */
-
-        /* Set the dataspace type to be simple or scalar as appropriate */
-        if(simple->rank>0)
-            attr->ds->extent.type = H5S_SIMPLE;
-        else
-            attr->ds->extent.type = H5S_SCALAR;
-
-        /* Copy the extent information */
-        HDmemcpy(&(attr->ds->extent.u.simple),simple, sizeof(H5S_simple_t));
-
-        /* Release temporary extent information */
-        H5FL_FREE(H5S_simple_t,simple);
-
-        /* Compute the number of elements in the extent */
-        for(u=0, nelem=1; u<attr->ds->extent.u.simple.rank; u++)
-            nelem*=attr->ds->extent.u.simple.size[u];
-        attr->ds->extent.nelem = nelem;
-    } else {
+    
+    if((extent=(H5O_SDSPACE->decode)(f,dxpl_id,p,NULL))==NULL)
         HGOTO_ERROR(H5E_ATTR, H5E_CANTDECODE, NULL, "can't decode attribute dataspace");
-    }
 
+    /* Copy the extent information */
+    HDmemcpy(&(attr->ds->extent),extent, sizeof(H5S_extent_t));
+
+    /* Release temporary extent information */
+    H5FL_FREE(H5S_extent_t,extent);
+   
     /* Default to entire dataspace being selected */
     if(H5S_select_all(attr->ds,0)<0)
         HGOTO_ERROR (H5E_DATASPACE, H5E_CANTSET, NULL, "unable to set all selection");
@@ -213,20 +203,15 @@ H5O_attr_decode(H5F_t *f, hid_t dxpl_id, const uint8_t *p, H5O_shared_t UNUSED *
     H5_ASSIGN_OVERFLOW(attr->data_size,H5S_GET_EXTENT_NPOINTS(attr->ds)*H5T_get_size(attr->dt),hsize_t,size_t);
 
     /* Go get the data */
-    if (NULL==(attr->data = H5MM_malloc(attr->data_size)))
-	HGOTO_ERROR (H5E_RESOURCE, H5E_NOSPACE, NULL, "memory allocation failed");
-    HDmemcpy(attr->data,p,attr->data_size);
+    if(attr->data_size) {
+        if (NULL==(attr->data = H5MM_malloc(attr->data_size)))
+            HGOTO_ERROR (H5E_RESOURCE, H5E_NOSPACE, NULL, "memory allocation failed");
+        HDmemcpy(attr->data,p,attr->data_size);
+    }
 
     /* Indicate that the fill values aren't to be written out */
     attr->initialized=1;
     
-#ifdef LOTSLATER
-    if (hobj) {
-        attr->sh_heap = *hobj;
-        attr->sh_file = f;
-    }
-#endif 
-
     /* Set return value */
     ret_value=attr;
 
@@ -257,6 +242,11 @@ done:
  *
  * 	Robb Matzke, 20 Jul 1998
  *	Added a version number at the beginning.
+ *
+ *	Raymond Lu, 8 April 2004
+ *	For data space, changed the operation on H5S_simple_t to 
+ *	H5S_extent_t
+ *
 --------------------------------------------------------------------------*/
 static herr_t
 H5O_attr_encode(H5F_t *f, uint8_t *p, const void *mesg)
@@ -344,7 +334,7 @@ H5O_attr_encode(H5F_t *f, uint8_t *p, const void *mesg)
         p += attr->dt_size;
 
     /* encode the attribute dataspace */
-    if((H5O_SDSPACE->encode)(f,p,&(attr->ds->extent.u.simple))<0)
+    if((H5O_SDSPACE->encode)(f,p,&(attr->ds->extent))<0)
         HGOTO_ERROR(H5E_ATTR, H5E_CANTENCODE, FAIL, "can't encode attribute dataspace");
     if(version < H5O_ATTR_VERSION_NEW) {
         HDmemset(p+attr->ds_size, 0, H5O_ALIGN(attr->ds_size)-attr->ds_size);
diff --git a/src/H5Osdspace.c b/src/H5Osdspace.c
index 8a919e7..9d76a29 100644
--- a/src/H5Osdspace.c
+++ b/src/H5Osdspace.c
@@ -39,7 +39,7 @@ static herr_t H5O_sdspace_debug(H5F_t *f, hid_t dxpl_id, const void *_mesg,
 const H5O_class_t H5O_SDSPACE[1] = {{
     H5O_SDSPACE_ID,	    	/* message id number		    	*/
     "simple_dspace",	    	/* message name for debugging	   	*/
-    sizeof(H5S_simple_t),   	/* native message size		    	*/
+    sizeof(H5S_extent_t),   	/* native message size		    	*/
     H5O_sdspace_decode,	    	/* decode message			*/
     H5O_sdspace_encode,	    	/* encode message			*/
     H5O_sdspace_copy,	    	/* copy the native value		*/
@@ -59,8 +59,8 @@ const H5O_class_t H5O_SDSPACE[1] = {{
 static int interface_initialize_g = 0;
 #define INTERFACE_INIT NULL
 
-/* Declare external the free list for H5S_simple_t's */
-H5FL_EXTERN(H5S_simple_t);
+/* Declare external the free list for H5S_extent_t's */
+H5FL_EXTERN(H5S_extent_t);
 
 /* Declare external the free list for hsize_t arrays */
 H5FL_ARR_EXTERN(hsize_t);
@@ -95,9 +95,9 @@ H5FL_ARR_EXTERN(hsize_t);
 static void *
 H5O_sdspace_decode(H5F_t *f, hid_t UNUSED dxpl_id, const uint8_t *p, H5O_shared_t UNUSED *sh)
 {
-    H5S_simple_t	*sdim = NULL;/* New simple dimensionality structure */
+    H5S_extent_t	*sdim = NULL;/* New extent dimensionality structure */
     void		*ret_value;
-    unsigned		u;		/* local counting variable */
+    unsigned		i;		/* local counting variable */
     unsigned		flags, version;
     
     FUNC_ENTER_NOAPI(H5O_sdspace_decode, NULL);
@@ -108,36 +108,52 @@ H5O_sdspace_decode(H5F_t *f, hid_t UNUSED dxpl_id, const uint8_t *p, H5O_shared_
     assert (!sh);
 
     /* decode */
-    if ((sdim = H5FL_CALLOC(H5S_simple_t)) != NULL) {
+    if ((sdim = H5FL_CALLOC(H5S_extent_t)) != NULL) {
+        /* Check version */
         version = *p++;
         if (version!=H5O_SDSPACE_VERSION)
             HGOTO_ERROR(H5E_OHDR, H5E_CANTINIT, NULL, "wrong version number in data space message");
-        sdim->rank = *p++;
-        if (sdim->rank>H5S_MAX_RANK)
+
+        /* Get rank */
+        sdim->u.simple.rank = *p++;
+        if (sdim->u.simple.rank>H5S_MAX_RANK)
             HGOTO_ERROR(H5E_OHDR, H5E_CANTINIT, NULL, "simple data space dimensionality is too large");
+
+        /* Get dataspace flags for later */
         flags = *p++;
+
+        /* Set the dataspace type to be simple or scalar as appropriate */
+        if(sdim->u.simple.rank>0)
+            sdim->type = H5S_SIMPLE;
+        else
+            sdim->type = H5S_SCALAR;
+
         p += 5; /*reserved*/
 
-        if (sdim->rank > 0) {
-            if (NULL==(sdim->size=H5FL_ARR_MALLOC(hsize_t,sdim->rank)))
+        if (sdim->u.simple.rank > 0) {
+            if (NULL==(sdim->u.simple.size=H5FL_ARR_MALLOC(hsize_t,sdim->u.simple.rank)))
                 HGOTO_ERROR (H5E_RESOURCE, H5E_NOSPACE, NULL, "memory allocation failed");
-            for (u = 0; u < sdim->rank; u++)
-                H5F_DECODE_LENGTH (f, p, sdim->size[u]);
+            for (i = 0; i < sdim->u.simple.rank; i++)
+                H5F_DECODE_LENGTH (f, p, sdim->u.simple.size[i]);
             if (flags & H5S_VALID_MAX) {
-                if (NULL==(sdim->max=H5FL_ARR_MALLOC(hsize_t,sdim->rank)))
+                if (NULL==(sdim->u.simple.max=H5FL_ARR_MALLOC(hsize_t,sdim->u.simple.rank)))
                     HGOTO_ERROR (H5E_RESOURCE, H5E_NOSPACE, NULL, "memory allocation failed");
-                for (u = 0; u < sdim->rank; u++)
-                    H5F_DECODE_LENGTH (f, p, sdim->max[u]);
+                for (i = 0; i < sdim->u.simple.rank; i++)
+                    H5F_DECODE_LENGTH (f, p, sdim->u.simple.max[i]);
             }
 #ifdef LATER
             if (flags & H5S_VALID_PERM) {
-                if (NULL==(sdim->perm=H5FL_ARR_MALLOC(hsize_t,sdim->rank)))
+                if (NULL==(sdim->u.simple.perm=H5FL_ARR_MALLOC(hsize_t,sdim->u.simple.rank)))
                     HGOTO_ERROR (H5E_RESOURCE, H5E_NOSPACE, NULL, "memory allocation failed");
-                for (u = 0; u < sdim->rank; u++)
-                    UINT32DECODE(p, sdim->perm[u]);
+                for (i = 0; i < sdim->u.simple.rank; i++)
+                    H5F_DECODE_LENGTH (f, p, sdim->u.simple.perm[i]);
             }
 #endif /* LATER */
         }
+
+        /* Compute the number of elements in the extent */
+        for(i=0, sdim->nelem=1; i<sdim->u.simple.rank; i++)
+            sdim->nelem*=sdim->u.simple.size[i];
     }
 
     /* Set return value */
@@ -145,8 +161,8 @@ H5O_sdspace_decode(H5F_t *f, hid_t UNUSED dxpl_id, const uint8_t *p, H5O_shared_
     
 done:
     if (!ret_value && sdim) {
-        H5S_release_simple(sdim);
-        H5FL_FREE(H5S_simple_t,sdim);
+        H5S_extent_release(sdim);
+        H5FL_FREE(H5S_extent_t,sdim);
     } /* end if */
 
     FUNC_LEAVE_NOAPI(ret_value);
@@ -160,10 +176,10 @@ done:
     Encode a simple dimensionality message 
  USAGE
     herr_t H5O_sdspace_encode(f, raw_size, p, mesg)
-	H5F_t *f;	  IN: pointer to the HDF5 file struct
+	H5F_t *f;	        IN: pointer to the HDF5 file struct
 	size_t raw_size;	IN: size of the raw information buffer
 	const uint8 *p;		IN: the raw information buffer
-	const void *mesg;	IN: Pointer to the simple dimensionality struct
+	const void *mesg;	IN: Pointer to the extent dimensionality struct
  RETURNS
     Non-negative on success/Negative on failure
  DESCRIPTION
@@ -181,7 +197,7 @@ done:
 static herr_t
 H5O_sdspace_encode(H5F_t *f, uint8_t *p, const void *mesg)
 {
-    const H5S_simple_t	*sdim = (const H5S_simple_t *) mesg;
+    const H5S_extent_t	*sdim = (const H5S_extent_t *) mesg;
     unsigned		u;  /* Local counting variable */
     unsigned		flags = 0;
     herr_t ret_value=SUCCEED;   /* Return value */
@@ -194,16 +210,16 @@ H5O_sdspace_encode(H5F_t *f, uint8_t *p, const void *mesg)
     assert(sdim);
 
     /* set flags */
-    if (sdim->max)
+    if (sdim->u.simple.max)
         flags |= H5S_VALID_MAX;
 #ifdef LATER
-    if (sdim->perm)
+    if (sdim->u.simple.perm)
         flags |= H5S_VALID_PERM;
 #endif
 
     /* encode */
     *p++ = H5O_SDSPACE_VERSION;
-    *p++ = sdim->rank;
+    *p++ = sdim->u.simple.rank;
     *p++ = flags;
     *p++ = 0; /*reserved*/
     *p++ = 0; /*reserved*/
@@ -211,17 +227,17 @@ H5O_sdspace_encode(H5F_t *f, uint8_t *p, const void *mesg)
     *p++ = 0; /*reserved*/
     *p++ = 0; /*reserved*/
 
-    if (sdim->rank > 0) {
-        for (u = 0; u < sdim->rank; u++)
-            H5F_ENCODE_LENGTH (f, p, sdim->size[u]);
+    if (sdim->u.simple.rank > 0) {
+        for (u = 0; u < sdim->u.simple.rank; u++)
+            H5F_ENCODE_LENGTH (f, p, sdim->u.simple.size[u]);
         if (flags & H5S_VALID_MAX) {
-            for (u = 0; u < sdim->rank; u++) 
-                H5F_ENCODE_LENGTH (f, p, sdim->max[u]);
+            for (u = 0; u < sdim->u.simple.rank; u++) 
+                H5F_ENCODE_LENGTH (f, p, sdim->u.simple.max[u]);
         }
 #ifdef LATER
         if (flags & H5S_VALID_PERM) {
-            for (u = 0; u < sdim->rank; u++)
-                UINT32ENCODE(p, sdim->perm[u]);
+            for (u = 0; u < sdim->u.simple.rank; u++)
+                H5F_ENCODE_LENGTH (f, p, sdim->u.simple.perm[u]);
         }
 #endif
     }
@@ -238,8 +254,8 @@ done:
     Copies a message from MESG to DEST, allocating DEST if necessary.
  USAGE
     void *H5O_sdspace_copy(mesg, dest)
-	const void *mesg;	IN: Pointer to the source simple dimensionality struct
-	const void *dest;	IN: Pointer to the destination simple dimensionality struct
+	const void *mesg;	IN: Pointer to the source extent dimensionality struct
+	const void *dest;	IN: Pointer to the destination extent dimensionality struct
  RETURNS
     Pointer to DEST on success, NULL on failure
  DESCRIPTION
@@ -249,37 +265,20 @@ done:
 static void *
 H5O_sdspace_copy(const void *mesg, void *dest)
 {
-    const H5S_simple_t	   *src = (const H5S_simple_t *) mesg;
-    H5S_simple_t	   *dst = (H5S_simple_t *) dest;
+    const H5S_extent_t	   *src = (const H5S_extent_t *) mesg;
+    H5S_extent_t	   *dst = (H5S_extent_t *) dest;
     void                   *ret_value;          /* Return value */
 
     FUNC_ENTER_NOAPI(H5O_sdspace_copy, NULL);
 
     /* check args */
     assert(src);
-    if (!dst && NULL==(dst = H5FL_MALLOC(H5S_simple_t)))
+    if (!dst && NULL==(dst = H5FL_MALLOC(H5S_extent_t)))
 	HGOTO_ERROR (H5E_RESOURCE, H5E_NOSPACE, NULL, "memory allocation failed");
 
-    /* deep copy -- pointed-to values are copied also */
-    HDmemcpy(dst, src, sizeof(H5S_simple_t));
-    
-    if (src->size) {
-	if (NULL==(dst->size = H5FL_ARR_MALLOC(hsize_t,src->rank)))
-	    HGOTO_ERROR (H5E_RESOURCE, H5E_NOSPACE, NULL, "memory allocation failed");
-	HDmemcpy (dst->size, src->size, src->rank*sizeof(src->size[0]));
-    }
-    if (src->max) {
-	if (NULL==(dst->max=H5FL_ARR_MALLOC(hsize_t,src->rank)))
-	    HGOTO_ERROR (H5E_RESOURCE, H5E_NOSPACE, NULL, "memory allocation failed");
-	HDmemcpy (dst->max, src->max, src->rank*sizeof(src->max[0]));
-    }
-#ifdef LATER
-    if (src->perm) {
-	if (NULL==(dst->perm=H5FL_ARR_MALLOC(hsize_t,src->rank)))
-	    HGOTO_ERROR (H5E_RESOURCE, H5E_NOSPACE, NULL, "memory allocation failed");
-	HDmemcpy (dst->perm, src->perm, src->rank*sizeof(src->perm[0]));
-    }
-#endif
+    /* Copy extent information */
+    if(H5S_extent_copy(dst,src)<0)
+        HGOTO_ERROR(H5E_DATASPACE, H5E_CANTCOPY, NULL, "can't copy extent");
 
     /* Set return value */
     ret_value=dst;
@@ -295,9 +294,9 @@ done:
  PURPOSE
     Return the raw message size in bytes
  USAGE
-    void *H5O_sdspace_copy(f, mesg)
+    void *H5O_sdspace_size(f, mesg)
 	H5F_t *f;	  IN: pointer to the HDF5 file struct
-	const void *mesg;	IN: Pointer to the source simple dimensionality struct
+	const void *mesg;	IN: Pointer to the source extent dimensionality struct
  RETURNS
     Size of message on success, zero on failure
  DESCRIPTION
@@ -313,7 +312,7 @@ done:
 static size_t
 H5O_sdspace_size(H5F_t *f, const void *mesg)
 {
-    const H5S_simple_t	   *space = (const H5S_simple_t *) mesg;
+    const H5S_extent_t	   *space = (const H5S_extent_t *) mesg;
     
     /*
      * All dimensionality messages are at least 8 bytes long.
@@ -323,14 +322,14 @@ H5O_sdspace_size(H5F_t *f, const void *mesg)
     FUNC_ENTER_NOAPI(H5O_sdspace_size, 0);
 
     /* add in the dimension sizes */
-    ret_value += space->rank * H5F_SIZEOF_SIZE (f);
+    ret_value += space->u.simple.rank * H5F_SIZEOF_SIZE (f);
 
     /* add in the space for the maximum dimensions, if they are present */
-    ret_value += space->max ? space->rank * H5F_SIZEOF_SIZE (f) : 0;
+    ret_value += space->u.simple.max ? space->u.simple.rank * H5F_SIZEOF_SIZE (f) : 0;
 
 #ifdef LATER
     /* add in the space for the dimension permutations, if they are present */
-    ret_value += space->perm ? space->rank * 4 : 0;
+    ret_value += space->u.simple.perm ? space->u.simple.rank * 4 : 0;
 #endif
 
 done:
@@ -356,12 +355,12 @@ done:
 static herr_t
 H5O_sdspace_reset(void *_mesg)
 {
-    H5S_simple_t	*mesg = (H5S_simple_t*)_mesg;
+    H5S_extent_t	*mesg = (H5S_extent_t*)_mesg;
     herr_t ret_value=SUCCEED;   /* Return value */
     
     FUNC_ENTER_NOAPI(H5O_sdspace_reset, FAIL);
 
-    H5S_release_simple(mesg);
+    H5S_extent_release(mesg);
 
 done:
     FUNC_LEAVE_NOAPI(ret_value);
@@ -391,7 +390,7 @@ H5O_sdspace_free (void *mesg)
 
     assert (mesg);
 
-    H5FL_FREE(H5S_simple_t,mesg);
+    H5FL_FREE(H5S_extent_t,mesg);
 
 done:
     FUNC_LEAVE_NOAPI(ret_value);
@@ -405,8 +404,8 @@ done:
     Prints debugging information for a simple dimensionality message
  USAGE
     void *H5O_sdspace_debug(f, mesg, stream, indent, fwidth)
-	H5F_t *f;	  IN: pointer to the HDF5 file struct
-	const void *mesg;	IN: Pointer to the source simple dimensionality struct
+	H5F_t *f;	        IN: pointer to the HDF5 file struct
+	const void *mesg;	IN: Pointer to the source extent dimensionality struct
 	FILE *stream;		IN: Pointer to the stream for output data
 	int indent;		IN: Amount to indent information by
 	int fwidth;		IN: Field width (?)
@@ -420,7 +419,7 @@ static herr_t
 H5O_sdspace_debug(H5F_t UNUSED *f, hid_t UNUSED dxpl_id, const void *mesg,
 		  FILE * stream, int indent, int fwidth)
 {
-    const H5S_simple_t	   *sdim = (const H5S_simple_t *) mesg;
+    const H5S_extent_t	   *sdim = (const H5S_extent_t *) mesg;
     unsigned		    u;	/* local counting variable */
     herr_t ret_value=SUCCEED;   /* Return value */
 
@@ -435,22 +434,22 @@ H5O_sdspace_debug(H5F_t UNUSED *f, hid_t UNUSED dxpl_id, const void *mesg,
 
     HDfprintf(stream, "%*s%-*s %lu\n", indent, "", fwidth,
 	    "Rank:",
-	    (unsigned long) (sdim->rank));
+	    (unsigned long) (sdim->u.simple.rank));
     
-    if(sdim->rank>0) {
+    if(sdim->u.simple.rank>0) {
         HDfprintf(stream, "%*s%-*s {", indent, "", fwidth, "Dim Size:");
-        for (u = 0; u < sdim->rank; u++)
-            HDfprintf (stream, "%s%Hu", u?", ":"", sdim->size[u]);
+        for (u = 0; u < sdim->u.simple.rank; u++)
+            HDfprintf (stream, "%s%Hu", u?", ":"", sdim->u.simple.size[u]);
         HDfprintf (stream, "}\n");
         
         HDfprintf(stream, "%*s%-*s ", indent, "", fwidth, "Dim Max:");
-        if (sdim->max) {
+        if (sdim->u.simple.max) {
             HDfprintf (stream, "{");
-            for (u = 0; u < sdim->rank; u++) {
-                if (H5S_UNLIMITED==sdim->max[u]) {
+            for (u = 0; u < sdim->u.simple.rank; u++) {
+                if (H5S_UNLIMITED==sdim->u.simple.max[u]) {
                     HDfprintf (stream, "%sINF", u?", ":"");
                 } else {
-                    HDfprintf (stream, "%s%Hu", u?", ":"", sdim->max[u]);
+                    HDfprintf (stream, "%s%Hu", u?", ":"", sdim->u.simple.max[u]);
                 }
             }
             HDfprintf (stream, "}\n");
@@ -459,11 +458,11 @@ H5O_sdspace_debug(H5F_t UNUSED *f, hid_t UNUSED dxpl_id, const void *mesg,
         }
 
 #ifdef LATER
-        if (sdim->perm) {
+        if (sdim->u.simple.perm) {
             HDfprintf(stream, "%*s%-*s {", indent, "", fwidth, "Dim Perm:");
-            for (u = 0; u < sdim->rank; u++) {
+            for (u = 0; u < sdim->u.simple.rank; u++) {
                 HDfprintf (stream, "%s%lu", u?", ":"",
-                     (unsigned long) (sdim->perm[u]));
+                     (unsigned long) (sdim->u.simple.perm[u]));
             }
         }
 #endif
diff --git a/src/H5S.c b/src/H5S.c
index 95faeaf..2f4ab8a 100644
--- a/src/H5S.c
+++ b/src/H5S.c
@@ -28,7 +28,7 @@ static H5S_t * H5S_create(H5S_class_t type);
 static herr_t H5S_set_extent_simple (H5S_t *space, unsigned rank,
     const hsize_t *dims, const hsize_t *max);
 static htri_t H5S_is_simple(const H5S_t *sdim);
-static herr_t H5S_extent_release(H5S_t *ds);
+static herr_t H5S_release_simple(H5S_simple_t *simple);
 
 /* Interface initialization */
 #define PABLO_MASK	H5S_mask
@@ -53,8 +53,8 @@ static size_t			H5S_nconv_g = 0;	/*entries used*/
 hbool_t H5S_mpi_opt_types_g = TRUE;
 #endif /* H5_HAVE_PARALLEL */
 
-/* Declare a free list to manage the H5S_simple_t struct */
-H5FL_DEFINE(H5S_simple_t);
+/* Declare a free list to manage the H5S_extent_t struct */
+H5FL_DEFINE(H5S_extent_t);
 
 /* Declare a free list to manage the H5S_t struct */
 H5FL_DEFINE(H5S_t);
@@ -387,17 +387,17 @@ done:
  *
  *-------------------------------------------------------------------------
  */
-static herr_t
-H5S_extent_release(H5S_t *ds)
+herr_t
+H5S_extent_release(H5S_extent_t *extent)
 {
     herr_t ret_value=SUCCEED;   /* Return value */
 
     FUNC_ENTER_NOAPI(H5S_extent_release, FAIL);
 
-    assert(ds);
+    assert(extent);
 
     /* release extent */
-    switch (ds->extent.type) {
+    switch (extent->type) {
         case H5S_NO_CLASS:
             /*nothing needed */
             break;
@@ -407,7 +407,7 @@ H5S_extent_release(H5S_t *ds)
             break;
 
         case H5S_SIMPLE:
-            ret_value=H5S_release_simple(&(ds->extent.u.simple));
+            ret_value=H5S_release_simple(&(extent->u.simple));
             break;
 
         case H5S_COMPLEX:
@@ -451,7 +451,7 @@ H5S_close(H5S_t *ds)
     H5S_SELECT_RELEASE(ds);
 
     /* Release extent */
-    H5S_extent_release(ds);
+    H5S_extent_release(&ds->extent);
 
     /* Release the main structure */
     H5FL_FREE(H5S_t,ds);
@@ -513,12 +513,10 @@ done:
  *
  *-------------------------------------------------------------------------
  */
-herr_t
+static herr_t
 H5S_release_simple(H5S_simple_t *simple)
 {
-    herr_t ret_value=SUCCEED;   /* Return value */
-
-    FUNC_ENTER_NOAPI(H5S_release_simple, FAIL);
+    FUNC_ENTER_NOAPI_NOINIT_NOFUNC(H5S_release_simple);
 
     assert(simple);
 
@@ -531,8 +529,7 @@ H5S_release_simple(H5S_simple_t *simple)
         H5FL_ARR_FREE(hsize_t,simple->perm);
 #endif /* LATER */
 
-done:
-    FUNC_LEAVE_NOAPI(ret_value);
+    FUNC_LEAVE_NOAPI(SUCCEED);
 }
 
 
@@ -1100,7 +1097,7 @@ H5S_modify(H5G_entry_t *ent, const H5S_t *ds, hbool_t update_time, hid_t dxpl_id
     switch (H5S_GET_EXTENT_TYPE(ds)) {
         case H5S_SCALAR:
         case H5S_SIMPLE:
-            if (H5O_modify(ent, H5O_SDSPACE_ID, 0, 0, update_time, &(ds->extent.u.simple), dxpl_id)<0)
+            if (H5O_modify(ent, H5O_SDSPACE_ID, 0, 0, update_time, &(ds->extent), dxpl_id)<0)
                 HGOTO_ERROR(H5E_DATASPACE, H5E_CANTINIT, FAIL, "can't update simple data space message");
             break;
 
@@ -1146,7 +1143,7 @@ H5S_append(H5F_t *f, hid_t dxpl_id, struct H5O_t *oh, const H5S_t *ds)
     switch (H5S_GET_EXTENT_TYPE(ds)) {
         case H5S_SCALAR:
         case H5S_SIMPLE:
-            if (H5O_append(f, dxpl_id, oh, H5O_SDSPACE_ID, 0, &(ds->extent.u.simple))<0)
+            if (H5O_append(f, dxpl_id, oh, H5O_SDSPACE_ID, 0, &(ds->extent))<0)
                 HGOTO_ERROR(H5E_DATASPACE, H5E_CANTINIT, FAIL, "can't update simple data space message");
             break;
 
@@ -1195,25 +1192,9 @@ H5S_read(H5G_entry_t *ent, hid_t dxpl_id)
     if (NULL==(ds = H5FL_CALLOC(H5S_t)))
         HGOTO_ERROR (H5E_RESOURCE, H5E_NOSPACE, NULL, "memory allocation failed");
 
-    if (H5O_read(ent, H5O_SDSPACE_ID, 0, &(ds->extent.u.simple), dxpl_id) == NULL)
+    if (H5O_read(ent, H5O_SDSPACE_ID, 0, &(ds->extent), dxpl_id) == NULL)
         HGOTO_ERROR(H5E_DATASPACE, H5E_CANTINIT, NULL, "unable to load dataspace info from dataset header");
 
-    if(ds->extent.u.simple.rank != 0) {
-        hsize_t nelem;  /* Number of elements in extent */
-        unsigned u;     /* Local index variable */
-
-        ds->extent.type = H5S_SIMPLE;
-
-        /* Compute the number of elements in the extent */
-        for(u=0, nelem=1; u<ds->extent.u.simple.rank; u++)
-            nelem*=ds->extent.u.simple.size[u];
-        ds->extent.nelem = nelem;
-    } /* end if */
-    else {
-        ds->extent.type = H5S_SCALAR;
-        ds->extent.nelem = 1;
-    } /* end else */
-
     /* Default to entire dataspace being selected */
     if(H5S_select_all(ds,0)<0)
         HGOTO_ERROR (H5E_DATASPACE, H5E_CANTSET, NULL, "unable to set all selection");
@@ -1390,26 +1371,9 @@ H5S_set_extent_simple (H5S_t *space, unsigned rank, const hsize_t *dims,
     assert(rank<=H5S_MAX_RANK);
     assert(0==rank || dims);
 
-    /* shift out of the previous state to a "simple" dataspace */
-    switch (H5S_GET_EXTENT_TYPE(space)) {
-        case H5S_SCALAR:
-            /* do nothing */
-            break;
-
-        case H5S_SIMPLE:
-            H5S_release_simple(&(space->extent.u.simple));
-            break;
-
-        case H5S_COMPLEX:
-        /*
-         * eventually this will destroy whatever "complex" dataspace info
-         * is retained, right now it's an error
-         */
-        /* Fall through to report error */
-
-        default:
-            HGOTO_ERROR(H5E_DATASPACE, H5E_BADVALUE, FAIL, "unknown data space class");
-    }
+    /* shift out of the previous state to a "simple" dataspace.  */
+    if(H5S_extent_release(&space->extent)<0)
+        HGOTO_ERROR (H5E_RESOURCE, H5E_CANTFREE, FAIL, "failed to release previous dataspace extent");
 
     if (rank == 0) {		/* scalar variable */
         space->extent.type = H5S_SCALAR;
@@ -1898,7 +1862,7 @@ H5Sset_extent_none(hid_t space_id)
         HGOTO_ERROR(H5E_ATOM, H5E_BADATOM, FAIL, "not a data space");
 
     /* Clear the previous extent from the dataspace */
-    if(H5S_extent_release(space)<0)
+    if(H5S_extent_release(&space->extent)<0)
         HGOTO_ERROR(H5E_RESOURCE, H5E_CANTDELETE, FAIL, "can't release previous dataspace");
 
     space->extent.type=H5S_NO_CLASS;
@@ -2071,7 +2035,7 @@ H5S_debug(H5F_t *f, hid_t dxpl_id, const void *_mesg, FILE *stream, int indent,
         case H5S_SIMPLE:
             fprintf(stream, "%*s%-*s H5S_SIMPLE\n", indent, "", fwidth,
                     "Space class:");
-            H5O_debug_id(H5O_SDSPACE_ID, f, dxpl_id, &(mesg->extent.u.simple), stream,
+            H5O_debug_id(H5O_SDSPACE_ID, f, dxpl_id, &(mesg->extent), stream,
                                  indent+3, MAX(0, fwidth-3));
             break;
             
diff --git a/src/H5Spkg.h b/src/H5Spkg.h
index 2003b38..72f9fd6 100644
--- a/src/H5Spkg.h
+++ b/src/H5Spkg.h
@@ -228,7 +228,7 @@ H5_DLLVAR const H5S_select_class_t H5S_sel_point[1];
 
 /* Extent functions */
 H5_DLL herr_t H5S_close_simple(H5S_simple_t *simple);
-H5_DLL herr_t H5S_release_simple(H5S_simple_t *simple);
+H5_DLL herr_t H5S_extent_release(H5S_extent_t *extent);
 H5_DLL herr_t H5S_extent_copy(H5S_extent_t *dst, const H5S_extent_t *src);
 
 /* Operations on selections */