summaryrefslogtreecommitdiffstats
diff options
context:
space:
mode:
Diffstat
-rw-r--r--src/H5A.c363
-rw-r--r--src/H5Apkg.h4
-rw-r--r--src/H5Oattr.c62
-rw-r--r--src/H5Osdspace.c161
-rw-r--r--src/H5S.c76
-rw-r--r--src/H5Spkg.h2
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 */
generated by cgit v0.12 at 2024-11-02 19:23:18 (GMT)