[svn-r5842] Purpose:

    Code cleanup

Description:
    Change most (all?) HRETURN_ERROR macros to HGOTO_ERROR macros, along with
    HRETURN macros to HGOTO_DONE macros.  This unifies the error return path
    from functions and reduces the size of the library by up to 10% on some
    platforms.

    Additionally, I improved a lot of the error cleanup code in many routines.

Platforms tested:
    FreeBSD 4.6 (sleipnir) serial & parallel and IRIX64 6.5 (modi4) serial &
    parallel.

1 files changed, 183 insertions, 206 deletions

diff --git a/src/H5A.c b/src/H5A.c
index 42190e1..a9efaec 100644
--- a/src/H5A.c
+++ b/src/H5A.c
@@ -60,18 +60,18 @@ DESCRIPTION
 static herr_t
 H5A_init_interface(void)
 {
+    herr_t ret_value=SUCCEED;   /* Return value */
+
     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) {
-        HRETURN_ERROR(H5E_INTERNAL, H5E_CANTINIT, FAIL,
-		      "unable to initialize interface");
-    }
+    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");
     
-    FUNC_LEAVE(SUCCEED);
+done:
+    FUNC_LEAVE(ret_value);
 }
 
 
@@ -163,28 +163,22 @@ H5Acreate(hid_t loc_id, const char *name, hid_t type_id, hid_t space_id,
     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)) {
-	HRETURN_ERROR(H5E_ARGS, H5E_BADTYPE, FAIL,
-		      "location is not valid for an attribute");
-    }
-    if (NULL==(ent=H5G_loc(loc_id))) {
-	HRETURN_ERROR(H5E_ARGS, H5E_BADTYPE, FAIL, "not a location");
-    }
-    if (!name || !*name) {
-	HRETURN_ERROR(H5E_ARGS, H5E_BADVALUE, FAIL, "no name");
-    }
+    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");
+    if (NULL==(ent=H5G_loc(loc_id)))
+	HGOTO_ERROR(H5E_ARGS, H5E_BADTYPE, FAIL, "not a location");
+    if (!name || !*name)
+	HGOTO_ERROR(H5E_ARGS, H5E_BADVALUE, FAIL, "no name");
     if (NULL == (type = H5I_object_verify(type_id, H5I_DATATYPE)))
-	HRETURN_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)))
-	HRETURN_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))<0) {
-	HRETURN_ERROR (H5E_ATTR, H5E_CANTINIT, FAIL,
-		       "unable to create attribute");
-    }
+    if ((ret_value=H5A_create(ent,name,type,space))<0)
+	HGOTO_ERROR (H5E_ATTR, H5E_CANTINIT, FAIL, "unable to create attribute");
 
+done:
     FUNC_LEAVE(ret_value);
 } /* H5Acreate() */
 
@@ -228,15 +222,22 @@ 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)
-        HRETURN_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);
+
+    /* Copy the attribute's datatype */
     attr->dt=H5T_copy(type, H5T_COPY_ALL);
+
     /* Mark any VL datatypes as being on disk now */
-    if (H5T_vlen_mark(attr->dt, ent->file, H5T_VLEN_DISK)<0) {
-        HRETURN_ERROR(H5E_DATATYPE, H5E_CANTINIT, FAIL, "invalid VL location");
-    }
+    if (H5T_vlen_mark(attr->dt, ent->file, H5T_VLEN_DISK)<0)
+        HGOTO_ERROR(H5E_DATATYPE, H5E_CANTINIT, FAIL, "invalid VL location");
+
+    /* Copy the dataspace for the attribute */
     attr->ds=H5S_copy(space);
+
+    /* Mark it initially set to initialized */
     attr->initialized = TRUE; /*for now, set to false later*/
 
     /* Copy the symbol table entry */
@@ -261,8 +262,7 @@ H5A_create(const H5G_entry_t *ent, const char *name, const H5T_t *type,
 	 */
 	if(HDstrcmp(found_attr.name,attr->name)==0) {
 	    H5O_reset (H5O_ATTR, &found_attr);
-	    HGOTO_ERROR(H5E_ATTR, H5E_ALREADYEXISTS, FAIL,
-			"attribute already exists");
+	    HGOTO_ERROR(H5E_ATTR, H5E_ALREADYEXISTS, FAIL, "attribute already exists");
 	}
 	H5O_reset (H5O_ATTR, &found_attr);
 	seq++;
@@ -271,22 +271,20 @@ H5A_create(const H5G_entry_t *ent, const char *name, const H5T_t *type,
 
     /* Create the attribute message and save the attribute index */
     if (H5O_modify(&(attr->ent), H5O_ATTR, H5O_NEW_MESG, 0, attr) < 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");
-    }
+    if ((ret_value = H5I_register(H5I_ATTR, attr)) < 0)
+        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;
 
 done:
     if (ret_value < 0) {
-        if(attr) H5A_close(attr);
-    }
+        if(attr)
+            H5A_close(attr);
+    } /* end if */
 
     FUNC_LEAVE(ret_value);
 } /* H5A_create() */
@@ -316,7 +314,8 @@ static int
 H5A_get_index(H5G_entry_t *ent, const char *name)
 {
     H5A_t      	found_attr;
-    int		ret_value=FAIL, i;
+    int		i;                      /* Index variable */
+    int		ret_value=FAIL;         /* Return value */
 
     FUNC_ENTER_NOINIT(H5A_get_index);
 
@@ -340,11 +339,10 @@ H5A_get_index(H5G_entry_t *ent, const char *name)
     }
     H5E_clear ();
     
-    if(ret_value<0) {
-        HRETURN_ERROR(H5E_ATTR, H5E_NOTFOUND, FAIL,
-		      "attribute not found");
-    }
+    if(ret_value<0)
+        HGOTO_ERROR(H5E_ATTR, H5E_NOTFOUND, FAIL, "attribute not found");
 
+done:
     FUNC_LEAVE(ret_value);
 } /* H5A_get_index() */
 
@@ -380,34 +378,28 @@ H5Aopen_name(hid_t loc_id, const char *name)
 {
     H5G_entry_t    	*ent = NULL;   /*Symtab entry of object to attribute*/
     int            	idx=0;
-    hid_t		ret_value = FAIL;
+    hid_t		ret_value;
 
     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)) {
-	HRETURN_ERROR(H5E_ARGS, H5E_BADTYPE, FAIL,
-		      "location is not valid for an attribute");
-    }
-    if (NULL==(ent=H5G_loc(loc_id))) {
-	HRETURN_ERROR(H5E_ARGS, H5E_BADTYPE, FAIL, "not a location");
-    }
-    if (!name || !*name) {
-	HRETURN_ERROR(H5E_ARGS, H5E_BADVALUE, FAIL, "no name");
-    }
+    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");
+    if (NULL==(ent=H5G_loc(loc_id)))
+	HGOTO_ERROR(H5E_ARGS, H5E_BADTYPE, FAIL, "not a location");
+    if (!name || !*name)
+	HGOTO_ERROR(H5E_ARGS, H5E_BADVALUE, FAIL, "no name");
 
     /* Look up the attribute for the object */
     if((idx=H5A_get_index(ent,name))<0)
-        HRETURN_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))<0) {
-	HRETURN_ERROR (H5E_ATTR, H5E_CANTINIT, FAIL,
-		       "unable to open attribute");
-    }
+    if ((ret_value=H5A_open(ent, (unsigned)idx))<0)
+	HGOTO_ERROR (H5E_ATTR, H5E_CANTINIT, FAIL, "unable to open attribute");
     
+done:
     FUNC_LEAVE(ret_value);
 } /* H5Aopen_name() */
 
@@ -443,27 +435,22 @@ hid_t
 H5Aopen_idx(hid_t loc_id, unsigned idx)
 {
     H5G_entry_t	*ent = NULL;	/*Symtab entry of object to attribute */
-    hid_t	ret_value = FAIL;
+    hid_t	ret_value;
 
     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)) {
-	HRETURN_ERROR(H5E_ARGS, H5E_BADTYPE, FAIL,
-		      "location is not valid for an attribute");
-    }
-    if (NULL==(ent=H5G_loc(loc_id))) {
-	HRETURN_ERROR(H5E_ARGS, H5E_BADTYPE, FAIL, "not a location");
-    }
+    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");
+    if (NULL==(ent=H5G_loc(loc_id)))
+	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))<0) {
-	HRETURN_ERROR (H5E_ATTR, H5E_CANTINIT, FAIL,
-		       "unable to open attribute");
-    }
+    if ((ret_value=H5A_open(ent, idx))<0)
+	HGOTO_ERROR (H5E_ATTR, H5E_CANTINIT, FAIL, "unable to open attribute");
     
+done:
     FUNC_LEAVE(ret_value);
 } /* H5Aopen_idx() */
 
@@ -551,26 +538,24 @@ H5Awrite(hid_t attr_id, hid_t type_id, const void *buf)
 {
     H5A_t		   *attr = NULL;
     const H5T_t    *mem_type = NULL;
-    herr_t		    ret_value = FAIL;
+    herr_t		    ret_value;
 
     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)))
-        HRETURN_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)))
-        HRETURN_ERROR(H5E_ARGS, H5E_BADTYPE, FAIL, "not a data type");
-    if (NULL == buf) {
-        HRETURN_ERROR(H5E_ARGS, H5E_BADVALUE, FAIL, "null attribute buffer");
-    }
+        HGOTO_ERROR(H5E_ARGS, H5E_BADTYPE, FAIL, "not a data type");
+    if (NULL == buf)
+        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))<0) {
-        HRETURN_ERROR(H5E_ATTR, H5E_WRITEERROR, FAIL,
-		      "unable to write attribute");
-    }
+    if ((ret_value=H5A_write(attr,mem_type,buf))<0)
+        HGOTO_ERROR(H5E_ATTR, H5E_WRITEERROR, FAIL, "unable to write attribute");
 
+done:
     FUNC_LEAVE(ret_value);
 } /* H5Awrite() */
 
@@ -701,26 +686,24 @@ H5Aread(hid_t attr_id, hid_t type_id, void *buf)
 {
     H5A_t		*attr = NULL;
     const H5T_t    	*mem_type = NULL;
-    herr_t		ret_value = FAIL;
+    herr_t		ret_value;
 
     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)))
-        HRETURN_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)))
-        HRETURN_ERROR(H5E_ARGS, H5E_BADTYPE, FAIL, "not a data type");
-    if (NULL == buf) {
-        HRETURN_ERROR(H5E_ARGS, H5E_BADVALUE, FAIL, "null attribute buffer");
-    }
+        HGOTO_ERROR(H5E_ARGS, H5E_BADTYPE, FAIL, "not a data type");
+    if (NULL == buf)
+        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))<0) {
-        HRETURN_ERROR(H5E_ATTR, H5E_READERROR, FAIL,
-		      "unable to read attribute");
-    }
+    if ((ret_value=H5A_read(attr,mem_type,buf))<0)
+        HGOTO_ERROR(H5E_ATTR, H5E_READERROR, FAIL, "unable to read attribute");
 
+done:
     FUNC_LEAVE(ret_value);
 } /* H5Aread() */
 
@@ -842,27 +825,24 @@ H5Aget_space(hid_t attr_id)
 {
     H5A_t	*attr = NULL;
     H5S_t	*dst = NULL;
-    hid_t	ret_value = FAIL;
+    hid_t	ret_value;
 
     FUNC_ENTER_API(H5Aget_space, FAIL);
     H5TRACE1("i","i",attr_id);
 
     /* check arguments */
     if (NULL == (attr = H5I_object_verify(attr_id, H5I_ATTR)))
-        HRETURN_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))) {
-	HRETURN_ERROR (H5E_ATTR, H5E_CANTINIT, FAIL,
-		       "unable to copy dataspace");
-    }
+    if (NULL==(dst=H5S_copy (attr->ds)))
+	HGOTO_ERROR (H5E_ATTR, H5E_CANTINIT, FAIL, "unable to copy dataspace");
 
     /* Atomize */
-    if ((ret_value=H5I_register (H5I_DATASPACE, dst))<0) {
-        HRETURN_ERROR (H5E_ATOM, H5E_CANTREGISTER, FAIL,
-		       "unable to register dataspace atom");
-    }
+    if ((ret_value=H5I_register (H5I_DATASPACE, dst))<0)
+        HGOTO_ERROR (H5E_ATOM, H5E_CANTREGISTER, FAIL, "unable to register dataspace atom");
 
+done:
     FUNC_LEAVE(ret_value);
 } /* H5Aget_space() */
 
@@ -895,43 +875,40 @@ H5Aget_space(hid_t attr_id)
 hid_t
 H5Aget_type(hid_t attr_id)
 {
-    H5A_t		   *attr = NULL;
+    H5A_t	*attr = NULL;
     H5T_t	*dst = NULL;
-    hid_t		        ret_value = FAIL;
+    hid_t	 ret_value;
 
     FUNC_ENTER_API(H5Aget_type, FAIL);
     H5TRACE1("i","i",attr_id);
 
     /* check arguments */
     if (NULL == (attr = H5I_object_verify(attr_id, H5I_ATTR)))
-        HRETURN_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
      * reopen the type before returning it to the user. Make the type
      * read-only.
      */
-    if (NULL==(dst=H5T_copy(attr->dt, H5T_COPY_REOPEN))) {
-	HRETURN_ERROR(H5E_ATTR, H5E_CANTINIT, FAIL,
-		      "unable to copy datatype");
-    }
+    if (NULL==(dst=H5T_copy(attr->dt, H5T_COPY_REOPEN)))
+	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) {
-        HRETURN_ERROR(H5E_DATATYPE, H5E_CANTINIT, FAIL,
-			  "invalid VL location");
-    }
-    if (H5T_lock(dst, FALSE)<0) {
-	H5T_close(dst);
-	HRETURN_ERROR(H5E_DATATYPE, H5E_CANTINIT, FAIL,
-		      "unable to lock transient data type");
-    }
+    if (H5T_vlen_mark(dst, NULL, H5T_VLEN_MEMORY)<0)
+        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");
     
     /* Atomize */
-    if ((ret_value=H5I_register(H5I_DATATYPE, dst))<0) {
-	H5T_close(dst);
-        HRETURN_ERROR(H5E_ATOM, H5E_CANTREGISTER, FAIL,
-		      "unable to register datatype atom");
-    }
+    if ((ret_value=H5I_register(H5I_DATATYPE, dst))<0)
+        HGOTO_ERROR(H5E_ATOM, H5E_CANTREGISTER, FAIL, "unable to register datatype atom");
+
+done:
+    if(ret_value<0) {
+        if(dst!=NULL)
+            H5T_close(dst);
+    } /* end if */
 
     FUNC_LEAVE(ret_value);
 } /* H5Aget_type() */
@@ -965,17 +942,16 @@ H5Aget_name(hid_t attr_id, size_t buf_size, char *buf)
 {
     H5A_t		*attr = NULL;
     size_t              copy_len, nbytes;
-    ssize_t		ret_value = FAIL;
+    ssize_t		ret_value;
 
     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)))
-        HRETURN_ERROR(H5E_ARGS, H5E_BADTYPE, FAIL, "not an attribute");
-    if (!buf || buf_size<1) {
-	HRETURN_ERROR(H5E_ARGS, H5E_BADVALUE, FAIL, "invalid buffer");
-    }
+        HGOTO_ERROR(H5E_ARGS, H5E_BADTYPE, FAIL, "not an attribute");
+    if (!buf || buf_size<1)
+	HGOTO_ERROR(H5E_ARGS, H5E_BADVALUE, FAIL, "invalid buffer");
 
     /* get the real attribute length */
     nbytes = HDstrlen(attr->name);
@@ -990,7 +966,10 @@ H5Aget_name(hid_t attr_id, size_t buf_size, char *buf)
     /* Terminate the string */
     buf[copy_len]='\0';
 
+    /* Set return value */
     ret_value = (ssize_t)nbytes;
+
+done:
     FUNC_LEAVE(ret_value);
 } /* H5Aget_type() */
 
@@ -1021,41 +1000,35 @@ H5Aget_num_attrs(hid_t loc_id)
 {
     H5G_entry_t    	*ent = NULL;	/*symtab ent of object to attribute */
     void           	*obj = NULL;
-    int			ret_value = 0;
+    int			ret_value;
 
     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)) {
-	HRETURN_ERROR(H5E_ARGS, H5E_BADTYPE, FAIL,
-		      "location is not valid for an attribute");
-    }
-    if(NULL == (obj = H5I_object(loc_id))) {
-        HRETURN_ERROR(H5E_ARGS, H5E_BADATOM, FAIL, "illegal object atom");
-    }
+    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");
+    if(NULL == (obj = H5I_object(loc_id)))
+        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))) {
-	    HRETURN_ERROR (H5E_ARGS, H5E_BADTYPE, FAIL,
-			   "target data type is not committed");
-	}
-	break;
-    case H5I_GROUP:
-	ent = H5G_entof ((H5G_t*)obj);
-	break;
-    default:
-	HRETURN_ERROR (H5E_ARGS, H5E_BADTYPE, FAIL,
-		       "inappropriate attribute target");
+        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");
+            break;
+        case H5I_GROUP:
+            ent = H5G_entof ((H5G_t*)obj);
+            break;
+        default:
+            HGOTO_ERROR (H5E_ARGS, H5E_BADTYPE, FAIL, "inappropriate attribute target");
     }
 
     /* Look up the attribute for the object */
     ret_value=H5O_count(ent, H5O_ATTR);
 
+done:
     FUNC_LEAVE(ret_value);
 } /* H5Aget_num_attrs() */
 
@@ -1111,21 +1084,17 @@ H5Aiterate(hid_t loc_id, unsigned *attr_num, H5A_operator_t op, void *op_data)
 {
     H5G_entry_t		*ent = NULL;	/*symtab ent of object to attribute */
     H5A_t          	found_attr;
-    herr_t	        ret_value = 0;
+    herr_t	        ret_value = FAIL;
     int		idx;
 
     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)) {
-	HRETURN_ERROR(H5E_ARGS, H5E_BADTYPE, FAIL,
-		      "location is not valid for an attribute");
-    }
-    if (NULL==(ent=H5G_loc(loc_id))) {
-	HRETURN_ERROR(H5E_ARGS, H5E_BADTYPE, FAIL, "not a location");
-    }
+    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");
+    if (NULL==(ent=H5G_loc(loc_id)))
+	HGOTO_ERROR(H5E_ARGS, H5E_BADTYPE, FAIL, "not a location");
 
     /*
      * Look up the attribute for the object. Make certain the start point is
@@ -1147,7 +1116,10 @@ H5Aiterate(hid_t loc_id, unsigned *attr_num, H5A_operator_t op, void *op_data)
 	H5E_clear ();
     }
 
-    if (attr_num) *attr_num = (unsigned)idx;
+    if (attr_num)
+        *attr_num = (unsigned)idx;
+
+done:
     FUNC_LEAVE(ret_value);
 } /* H5Aiterate() */
 
@@ -1183,23 +1155,18 @@ H5Adelete(hid_t loc_id, const char *name)
     H5A_t       found_attr;
     H5G_entry_t	*ent = NULL;		/*symtab ent of object to attribute */
     int        idx=0, found=-1;
-    herr_t	ret_value = FAIL;
+    herr_t	ret_value;
 
     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)) {
-	HRETURN_ERROR(H5E_ARGS, H5E_BADTYPE, FAIL,
-		      "location is not valid for an attribute");
-    }
-    if (NULL==(ent=H5G_loc(loc_id))) {
-	HRETURN_ERROR(H5E_ARGS, H5E_BADTYPE, FAIL, "not a location");
-    }
-    if (!name || !*name) {
-	HRETURN_ERROR(H5E_ARGS, H5E_BADVALUE, FAIL, "no name");
-    }
+    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");
+    if (NULL==(ent=H5G_loc(loc_id)))
+	HGOTO_ERROR(H5E_ARGS, H5E_BADTYPE, FAIL, "not a location");
+    if (!name || !*name)
+	HGOTO_ERROR(H5E_ARGS, H5E_BADVALUE, FAIL, "no name");
 
     /* Look up the attribute for the object */
     idx=0;
@@ -1217,16 +1184,14 @@ H5Adelete(hid_t loc_id, const char *name)
 	idx++;
     }
     H5E_clear ();
-    if (found<0) {
-        HRETURN_ERROR(H5E_ATTR, H5E_NOTFOUND, FAIL, "attribute not found");
-    }
+    if (found<0)
+        HGOTO_ERROR(H5E_ATTR, H5E_NOTFOUND, FAIL, "attribute not found");
 
     /* Delete the attribute from the location */
-    if ((ret_value=H5O_remove(ent, H5O_ATTR, found)) < 0) {
-        HRETURN_ERROR(H5E_ATTR, H5E_CANTDELETE, FAIL,
-		      "unable to delete attribute header message");
-    }
+    if ((ret_value=H5O_remove(ent, H5O_ATTR, found)) < 0)
+        HGOTO_ERROR(H5E_ATTR, H5E_CANTDELETE, FAIL, "unable to delete attribute header message");
     
+done:
     FUNC_LEAVE(ret_value);
 } /* H5Adelete() */
 
@@ -1251,17 +1216,20 @@ H5Adelete(hid_t loc_id, const char *name)
 herr_t
 H5Aclose(hid_t attr_id)
 {
+    herr_t ret_value=SUCCEED;   /* Return value */
+
     FUNC_ENTER_API(H5Aclose, FAIL);
     H5TRACE1("e","i",attr_id);
 
     /* check arguments */
     if (NULL == H5I_object_verify(attr_id, H5I_ATTR))
-        HRETURN_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);
 
-    FUNC_LEAVE(SUCCEED);
+done:
+    FUNC_LEAVE(ret_value);
 } /* H5Aclose() */
 
 
@@ -1285,6 +1253,7 @@ H5A_t *
 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);
 
@@ -1292,10 +1261,8 @@ H5A_copy(const H5A_t *old_attr)
     assert(old_attr);
 
     /* get space */
-    if (NULL==(new_attr = H5MM_calloc(sizeof(H5A_t)))) {
-	HRETURN_ERROR (H5E_RESOURCE, H5E_NOSPACE, NULL,
-		       "memory allocation failed");
-    }
+    if (NULL==(new_attr = H5MM_calloc(sizeof(H5A_t))))
+	HGOTO_ERROR (H5E_RESOURCE, H5E_NOSPACE, NULL, "memory allocation failed");
 
     /* Copy the top level of the attribute */
     *new_attr = *old_attr;
@@ -1308,18 +1275,25 @@ H5A_copy(const H5A_t *old_attr)
     new_attr->dt=H5T_copy(old_attr->dt, H5T_COPY_ALL);
     new_attr->ds=H5S_copy(old_attr->ds);
     if(old_attr->data) {
-        if (NULL==(new_attr->data=H5MM_malloc(old_attr->data_size))) {
-	    HRETURN_ERROR (H5E_RESOURCE, H5E_NOSPACE, NULL,
-			   "memory allocation failed");
-	}
+        if (NULL==(new_attr->data=H5MM_malloc(old_attr->data_size)))
+	    HGOTO_ERROR (H5E_RESOURCE, H5E_NOSPACE, NULL, "memory allocation failed");
         HDmemcpy(new_attr->data,old_attr->data,old_attr->data_size);
     } /* end if */
 
 #ifndef LATER
     /* Copy the share info? */
 #endif
+
+    /* Set the return value */
+    ret_value=new_attr;
     
-    FUNC_LEAVE(new_attr);
+done:
+    if(ret_value==NULL) {
+        if(new_attr!=NULL)
+            H5A_close(new_attr);
+    } /* end if */
+
+    FUNC_LEAVE(ret_value);
 }
 
 
@@ -1340,6 +1314,8 @@ H5A_copy(const H5A_t *old_attr)
 herr_t
 H5A_close(H5A_t *attr)
 {
+    herr_t ret_value=SUCCEED;           /* Return value */
+
     FUNC_ENTER_NOAPI(H5A_close, FAIL);
 
     assert(attr);
@@ -1347,16 +1323,12 @@ H5A_close(H5A_t *attr)
     /* Check if the attribute has any data yet, if not, fill with zeroes */
     if(attr->ent_opened && !attr->initialized) {
         uint8_t *tmp_buf=H5MM_calloc(attr->data_size);
-        if (NULL == tmp_buf) {
-            HRETURN_ERROR(H5E_ATTR, H5E_NOSPACE, FAIL,
-			  "memory allocation failed for attribute fill-value");
-        }
+        if (NULL == tmp_buf)
+            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)<0) {
-            HRETURN_ERROR(H5E_ATTR, H5E_WRITEERROR, FAIL,
-			  "unable to write attribute");
-        }
+        if (H5A_write(attr,attr->dt,tmp_buf)<0)
+            HGOTO_ERROR(H5E_ATTR, H5E_WRITEERROR, FAIL, "unable to write attribute");
 
         /* Free temporary buffer */
         H5MM_xfree(tmp_buf);
@@ -1365,12 +1337,16 @@ H5A_close(H5A_t *attr)
     /* Free dynamicly allocated items */
     if(attr->name)
         H5MM_xfree(attr->name);
-    if(attr->dt) H5T_close(attr->dt);
-    if(attr->ds) H5S_close(attr->ds);
-    if(attr->data) H5MM_xfree(attr->data);
+    if(attr->dt)
+        H5T_close(attr->dt);
+    if(attr->ds)
+        H5S_close(attr->ds);
+    if(attr->data)
+        H5MM_xfree(attr->data);
 
     /* Close the object's symbol-table entry */
-    if(attr->ent_opened) H5O_close(&(attr->ent));
+    if(attr->ent_opened)
+        H5O_close(&(attr->ent));
 
 #ifndef LATER
     /* Do something with the shared information? */
@@ -1378,7 +1354,8 @@ H5A_close(H5A_t *attr)
 
     H5MM_xfree(attr);
     
-    FUNC_LEAVE(SUCCEED);
+done:
+    FUNC_LEAVE(ret_value);
 }