[svn-r7184] Purpose:

    Code cleanup

Description:
    Clean up various warnings from lint

Platforms tested:
    FreeBSD 4.8 (sleipnir)
    no major changes requiring h5committest

1 files changed, 186 insertions, 172 deletions

diff --git a/src/H5A.c b/src/H5A.c
index 4a86613..75287c2 100644
--- a/src/H5A.c
+++ b/src/H5A.c
@@ -41,9 +41,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 +67,16 @@ H5A_init_interface(void)
 {
     herr_t ret_value=SUCCEED;   /* Return value */
 
-    FUNC_ENTER_NOINIT(H5A_init_interface);
+    FUNC_ENTER_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 +101,7 @@ H5A_term_interface(void)
 {
     int	n=0;
 
-    FUNC_ENTER_NOINIT(H5A_term_interface);
+    FUNC_ENTER_NOINIT(H5A_term_interface)
     
     if (interface_initialize_g) {
 	if ((n=H5I_nmembers(H5I_ATTR))) {
@@ -112,7 +112,7 @@ H5A_term_interface(void)
 	    n = 1;
 	}
     }
-    FUNC_LEAVE_NOAPI(n);
+    FUNC_LEAVE_NOAPI(n)
 }
 
 
@@ -164,28 +164,28 @@ 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);
-} /* H5Acreate() */
+    FUNC_LEAVE_API(ret_value)
+} /* H5Acreate() */ /*lint !e715 */
 
 
 /*-------------------------------------------------------------------------
@@ -221,7 +221,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_NOINIT(H5A_create);
+    FUNC_ENTER_NOINIT(H5A_create)
 
     /* check args */
     assert(ent);
@@ -231,7 +231,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);
@@ -241,7 +241,7 @@ H5A_create(const H5G_entry_t *ent, const char *name, const H5T_t *type,
 
     /* Mark any VL datatypes as being on disk now */
     if (H5T_vlen_mark(attr->dt, ent->file, H5T_VLEN_DISK)<0)
-        HGOTO_ERROR(H5E_DATATYPE, H5E_CANTINIT, FAIL, "invalid VL location");
+        HGOTO_ERROR(H5E_DATATYPE, H5E_CANTINIT, FAIL, "invalid VL location")
 
     /* Copy the dataspace for the attribute */
     attr->ds=H5S_copy(space);
@@ -251,7 +251,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 internal sizes */
     attr->dt_size=H5O_raw_size(H5O_DTYPE_ID,attr->ent.file,type);
@@ -262,7 +262,7 @@ H5A_create(const H5G_entry_t *ent, const char *name, const H5T_t *type,
 
     /* 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 */
@@ -273,21 +273,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;
@@ -295,10 +296,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() */
 
 
@@ -329,7 +330,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_NOINIT(H5A_get_index);
+    FUNC_ENTER_NOINIT(H5A_get_index)
 
     assert(ent);
     assert(name);
@@ -342,20 +343,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() */
 
 
@@ -392,27 +395,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() */
 
 
@@ -449,21 +452,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() */
 
 
@@ -495,7 +498,7 @@ H5A_open(H5G_entry_t *ent, unsigned idx, hid_t dxpl_id)
     H5A_t       *attr = NULL;
     hid_t	    ret_value = FAIL;
 
-    FUNC_ENTER_NOINIT(H5A_open);
+    FUNC_ENTER_NOINIT(H5A_open)
 
     /* check args */
     assert(ent);
@@ -503,31 +506,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() */
 
 
@@ -556,23 +558,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() */
 
 
@@ -599,23 +601,26 @@ H5A_write(H5A_t *attr, const H5T_t *mem_type, const void *buf, hid_t dxpl_id)
 {
     uint8_t		*tconv_buf = NULL;	/* data type conv buffer */
     uint8_t		*bkg_buf = NULL;	/* temp conversion buffer */
+    hssize_t		snelmts;		/* elements in attribute */
     hsize_t		nelmts;		    	/* elements in attribute */
     H5T_path_t		*tpath = NULL;		/* conversion information*/
     hid_t		src_id = -1, dst_id = -1;/* temporary type atoms */
     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_NOINIT(H5A_write);
+    FUNC_ENTER_NOINIT(H5A_write)
 
     assert(attr);
     assert(mem_type);
     assert(buf);
 
     /* Create buffer for data to store on disk */
-    nelmts=H5S_get_simple_extent_npoints (attr->ds);
+    if((snelmts=H5S_get_simple_extent_npoints (attr->ds))<0)
+        HGOTO_ERROR (H5E_ATTR, H5E_CANTCOUNT, FAIL, "dataspace is invalid")
+    nelmts=(hsize_t)snelmts;
 
     /* Get the memory and file datatype sizes */
     src_type_size = H5T_get_size(mem_type);
@@ -624,7 +629,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);
@@ -633,19 +638,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)
@@ -653,13 +655,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;
@@ -669,13 +670,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() */
 
 
@@ -704,23 +705,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() */
 
 
@@ -743,10 +744,11 @@ 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 */
+    hssize_t		snelmts;		/* elements in attribute */
     hsize_t		nelmts;			/* elements in attribute*/
     H5T_path_t		*tpath = NULL;		/* type conversion info	*/
     hid_t		src_id = -1, dst_id = -1;/* temporary type atoms*/
@@ -755,14 +757,16 @@ 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_NOINIT(H5A_read);
+    FUNC_ENTER_NOINIT(H5A_read)
 
     assert(attr);
     assert(mem_type);
     assert(buf);
 
     /* Create buffer for data to store on disk */
-    nelmts=H5S_get_simple_extent_npoints (attr->ds);
+    if((snelmts=H5S_get_simple_extent_npoints (attr->ds))<0)
+        HGOTO_ERROR (H5E_ATTR, H5E_CANTCOUNT, FAIL, "dataspace is invalid")
+    nelmts=(hsize_t)snelmts;
 
     /* Get the memory and file datatype sizes */
     src_type_size = H5T_get_size(attr->dt);
@@ -777,7 +781,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);
@@ -786,16 +790,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));
@@ -806,15 +810,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() */
 
 
@@ -843,23 +847,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)))
-	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() */
 
 
@@ -895,12 +899,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
@@ -908,25 +912,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() */
 
 
@@ -960,14 +964,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);
@@ -988,7 +992,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() */
 
 
@@ -1017,18 +1021,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)
 }
 
 
@@ -1053,16 +1057,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_NOINIT(H5A_get_storage_size);
+    FUNC_ENTER_NOINIT(H5A_get_storage_size)
 
     /* Set return value */
     ret_value = attr->data_size;
 
-    FUNC_LEAVE_NOAPI(ret_value);
+    FUNC_LEAVE_NOAPI(ret_value)
 }
  
 
@@ -1094,34 +1098,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() */
 
 
@@ -1147,22 +1151,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() */
 
 
@@ -1189,7 +1193,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_NOINIT(H5A_rename);
+    FUNC_ENTER_NOINIT(H5A_rename)
 
     /* Check arguments */
     assert(ent);
@@ -1198,7 +1202,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;
@@ -1210,19 +1214,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;
@@ -1230,13 +1235,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)
 }
 
 
@@ -1294,22 +1300,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) {
 	    /*
@@ -1317,22 +1323,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() */
 
 
@@ -1369,16 +1377,16 @@ H5Adelete(hid_t loc_id, const char *name)
     int        idx=0, found=-1;
     herr_t	ret_value;
 
-    FUNC_ENTER_API(H5Aopen_name, FAIL);
+    FUNC_ENTER_API(H5Aopen_name, 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;
@@ -1388,23 +1396,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() */
 
 
@@ -1430,18 +1440,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() */
 
 
@@ -1467,14 +1478,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;
@@ -1488,7 +1499,7 @@ H5A_copy(const H5A_t *old_attr)
     new_attr->ds=H5S_copy(old_attr->ds);
     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 */
 
@@ -1502,10 +1513,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)
 }
 
 
@@ -1528,7 +1539,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);
 
@@ -1536,11 +1547,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);
@@ -1550,15 +1561,18 @@ 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));
+        if(H5O_close(&(attr->ent))<0)
+	    HGOTO_ERROR(H5E_ATTR, H5E_CANTRELEASE, FAIL, "can't release object header info")
 
 #ifndef LATER
     /* Do something with the shared information? */
@@ -1567,7 +1581,7 @@ H5A_close(H5A_t *attr)
     H5MM_xfree(attr);
     
 done:
-    FUNC_LEAVE_NOAPI(ret_value);
+    FUNC_LEAVE_NOAPI(ret_value)
 }
 
 
@@ -1594,12 +1608,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)
 }