From 6ed61e5dda6a877b955aab386379b189346bf74c Mon Sep 17 00:00:00 2001 From: Quincey Koziol Date: Sun, 13 Jun 2004 15:12:55 -0500 Subject: [svn-r8676] Purpose: Code optimization Description: Using existing dataspace extent copying routine instead of duplicating the code (more slowly). Also, back-port improvements to the dataspace message reading which clean up the clean and centralize operations. Platforms tested: Solaris 2.7 (arabica) FreeBSD 4.10 (sleipnir) w/parallel Too minor to require h5committest --- src/H5A.c | 363 ++++++++++++++++++++++++++++--------------------------- src/H5Apkg.h | 4 +- src/H5Oattr.c | 62 ++++------ src/H5Osdspace.c | 161 ++++++++++++------------ src/H5S.c | 76 +++--------- src/H5Spkg.h | 2 +- 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(idx0) - 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; uds->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; iu.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; uextent.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 */ -- cgit v0.12