From 7c733b0afb1b87ddd3314e89b0105b806f6edfb1 Mon Sep 17 00:00:00 2001 From: Quincey Koziol Date: Tue, 30 Jan 2007 13:43:28 -0500 Subject: [svn-r13223] Description: Move datatype messages into new shared message method interface Clean up various formatting & compiler warnings Minor optimizations Tested on: Linux/32 2.6 (chicago) Linux/64 2.6 (chicago2) --- src/H5A.c | 56 +++++----------------- src/H5Adense.c | 8 ++-- src/H5D.c | 9 ++-- src/H5F.c | 2 +- src/H5Gdense.c | 4 +- src/H5Gobj.c | 2 +- src/H5HFcache.c | 14 +++--- src/H5HFhdr.c | 2 +- src/H5Oattr.c | 100 +++++--------------------------------- src/H5Ocopy.c | 16 +++---- src/H5Odtype.c | 22 ++++----- src/H5Omessage.c | 144 +++++++++++++++++++++++++++++++++++++++++++------------ src/H5Opkg.h | 2 +- src/H5Opline.c | 20 ++++---- src/H5Oprivate.h | 6 ++- src/H5Osdspace.c | 4 +- src/H5Oshared.c | 47 ++++++++++-------- src/H5S.c | 92 +++++++++++++---------------------- src/H5SM.c | 61 +++++++++++------------ src/H5SMcache.c | 43 ++++++++--------- src/H5Sprivate.h | 1 - src/H5T.c | 68 +++++++++++++------------- test/dtypes.c | 14 ++---- test/getname.c | 2 +- test/tattr.c | 32 ++++++------- 25 files changed, 360 insertions(+), 411 deletions(-) diff --git a/src/H5A.c b/src/H5A.c index 9e25d02..ef83826 100644 --- a/src/H5A.c +++ b/src/H5A.c @@ -291,7 +291,6 @@ H5A_create(const H5G_loc_t *loc, const char *name, const H5T_t *type, const H5S_t *space, hid_t acpl_id, hid_t dxpl_id) { H5A_t *attr = NULL; - H5O_shared_t sh_mesg; htri_t tri_ret; /* htri_t return value */ hid_t ret_value; /* Return value */ @@ -303,9 +302,6 @@ H5A_create(const H5G_loc_t *loc, const char *name, const H5T_t *type, HDassert(type); HDassert(space); - /* Reset shared message information */ - HDmemset(&sh_mesg, 0, sizeof(H5O_shared_t)); - /* Check for existing attribute with same name */ /* (technically, the "attribute create" operation will fail for a duplicated * name, but it's going to be hard to unwind all the special cases on @@ -373,50 +369,22 @@ H5A_create(const H5G_loc_t *loc, const char *name, const H5T_t *type, HGOTO_ERROR(H5E_OHDR, H5E_BADMESG, FAIL, "trying to share dataspace failed") + /* Check whether datatype is committed & increment ref count + * (to maintain ref. count incr/decr similarity with "shared message" + * type of datatype sharing) + */ + if(H5T_committed(attr->dt)) { + /* Increment the reference count on the shared datatype */ + if(H5T_link(attr->dt, 1, dxpl_id) < 0) + HGOTO_ERROR(H5E_OHDR, H5E_LINKCOUNT, FAIL, "unable to adjust shared datatype link count") + } /* end if */ + /* Compute the size of pieces on disk. This is either the size of the * datatype and dataspace messages themselves, or the size of the "shared" * messages if either or both of them are shared. */ - if((tri_ret = H5O_msg_is_shared(H5O_DTYPE_ID, attr->dt)) == FALSE) { - /* Message wasn't shared after all. Use size of normal datatype - * message. */ - attr->dt_size = H5O_msg_raw_size(attr->oloc.file, H5O_DTYPE_ID, attr->dt); - } /* end if */ - else if(tri_ret > 0) { - /* Check whether datatype is committed & increment ref count */ - /* (to maintain ref. count incr/decr similarity with "shared message" - * type of datatype sharing) - */ - if(H5T_committed(attr->dt)) { - /* Increment the reference count on the shared datatype */ - if(H5T_link(attr->dt, 1, dxpl_id) < 0) - HGOTO_ERROR(H5E_OHDR, H5E_LINKCOUNT, FAIL, "unable to adjust shared datatype link count") - } /* end if */ - - /* Message is shared. Use size of shared message */ - if(NULL == H5O_msg_get_share(H5O_DTYPE_ID, attr->dt, &sh_mesg)) - HGOTO_ERROR(H5E_OHDR, H5E_BADMESG, FAIL, "couldn't get size of shared message") - - attr->dt_size = H5O_msg_raw_size(attr->oloc.file, H5O_SHARED_ID, &sh_mesg); - } /* end else-if */ - else - HGOTO_ERROR(H5E_OHDR, H5E_BADMESG, FAIL, "couldn't determine if dataspace is shared") - - /* Perform the same test for the dataspace message */ - if((tri_ret = H5O_msg_is_shared(H5O_SDSPACE_ID, attr->ds)) == FALSE) { - /* Message wasn't shared after all. Use size of normal dataspace - * message. */ - attr->ds_size = H5O_msg_raw_size(attr->oloc.file, H5O_SDSPACE_ID, attr->ds); - } /* end if */ - else if(tri_ret > 0) { - /* Message is shared. Use size of shared message */ - if(NULL == H5O_msg_get_share(H5O_SDSPACE_ID, attr->ds, &sh_mesg)) - HGOTO_ERROR(H5E_OHDR, H5E_BADMESG, FAIL, "couldn't get size of shared message") - - attr->ds_size = H5O_msg_raw_size(attr->oloc.file, H5O_SHARED_ID, &sh_mesg); - } /* end else-if */ - else - HGOTO_ERROR(H5E_OHDR, H5E_BADMESG, FAIL, "couldn't determine if datatype is shared") + attr->dt_size = H5O_msg_raw_size(attr->oloc.file, H5O_DTYPE_ID, FALSE, attr->dt); + attr->ds_size = H5O_msg_raw_size(attr->oloc.file, H5O_SDSPACE_ID, FALSE, attr->ds); HDassert(attr->dt_size > 0); HDassert(attr->ds_size > 0); diff --git a/src/H5Adense.c b/src/H5Adense.c index b58a192..7091856 100644 --- a/src/H5Adense.c +++ b/src/H5Adense.c @@ -442,7 +442,7 @@ H5A_dense_insert(H5F_t *f, hid_t dxpl_id, const H5O_t *oh, unsigned mesg_flags, size_t attr_size; /* Size of serialized attribute in the heap */ /* Find out the size of buffer needed for serialized message */ - if((attr_size = H5O_msg_raw_size(f, H5O_ATTR_ID, attr)) == 0) + if((attr_size = H5O_msg_raw_size(f, H5O_ATTR_ID, FALSE, attr)) == 0) HGOTO_ERROR(H5E_ATTR, H5E_CANTGETSIZE, FAIL, "can't get message size") /* Allocate space for serialized message, if necessary */ @@ -454,7 +454,7 @@ H5A_dense_insert(H5F_t *f, hid_t dxpl_id, const H5O_t *oh, unsigned mesg_flags, attr_ptr = attr_buf; /* Create serialized form of attribute or shared message */ - if(H5O_msg_encode(f, H5O_ATTR_ID, (unsigned char *)attr_ptr, attr) < 0) + if(H5O_msg_encode(f, H5O_ATTR_ID, FALSE, (unsigned char *)attr_ptr, attr) < 0) HGOTO_ERROR(H5E_ATTR, H5E_CANTENCODE, FAIL, "can't encode attribute") /* Insert the serialized attribute into the fractal heap */ @@ -549,7 +549,7 @@ H5A_dense_write_bt2_cb(void *_record, void *_op_data, hbool_t *changed) size_t attr_size; /* Size of serialized attribute in the heap */ /* Find out the size of buffer needed for serialized attribute */ - if((attr_size = H5O_msg_raw_size(op_data->f, H5O_ATTR_ID, op_data->attr)) == 0) + if((attr_size = H5O_msg_raw_size(op_data->f, H5O_ATTR_ID, FALSE, op_data->attr)) == 0) HGOTO_ERROR(H5E_ATTR, H5E_CANTGETSIZE, FAIL, "can't get attribute size") /* Allocate space for serialized attribute, if necessary */ @@ -561,7 +561,7 @@ H5A_dense_write_bt2_cb(void *_record, void *_op_data, hbool_t *changed) attr_ptr = attr_buf; /* Create serialized form of attribute */ - if(H5O_msg_encode(op_data->f, H5O_ATTR_ID, (unsigned char *)attr_ptr, op_data->attr) < 0) + if(H5O_msg_encode(op_data->f, H5O_ATTR_ID, FALSE, (unsigned char *)attr_ptr, op_data->attr) < 0) HGOTO_ERROR(H5E_ATTR, H5E_CANTENCODE, FAIL, "can't encode attribute") /* Sanity check */ diff --git a/src/H5D.c b/src/H5D.c index 15bb875..b49d88a 100644 --- a/src/H5D.c +++ b/src/H5D.c @@ -1213,10 +1213,11 @@ H5D_update_oh_info(H5F_t *file, hid_t dxpl_id, H5D_t *dset) HGOTO_ERROR(H5E_DATASET, H5E_CANTINIT, FAIL, "unable to update old fill value header message") } /* end if */ - /* Update the type and space header messages */ - if(H5O_msg_append(file, dxpl_id, oh, H5O_DTYPE_ID, H5O_MSG_FLAG_CONSTANT | H5O_MSG_FLAG_SHARED, 0, type, &oh_flags) < 0 || - H5S_append(file, dxpl_id, oh, dset->shared->space, &oh_flags) < 0) - HGOTO_ERROR(H5E_DATASET, H5E_CANTINIT, FAIL, "unable to update type or space header messages") + /* Update the datatype and dataspace header messages */ + if(H5O_msg_append(file, dxpl_id, oh, H5O_DTYPE_ID, H5O_MSG_FLAG_CONSTANT, 0, type, &oh_flags) < 0) + HGOTO_ERROR(H5E_DATASET, H5E_CANTINIT, FAIL, "unable to update datatype header message") + if(H5S_append(file, dxpl_id, oh, dset->shared->space, &oh_flags) < 0) + HGOTO_ERROR(H5E_DATASET, H5E_CANTINIT, FAIL, "unable to update dataspace header message") /* Update the filters message, if this is a chunked dataset */ if(layout->type == H5D_CHUNKED) { diff --git a/src/H5F.c b/src/H5F.c index a073e9a..df58a5e 100644 --- a/src/H5F.c +++ b/src/H5F.c @@ -2080,7 +2080,7 @@ H5F_try_close(H5F_t *f) /* Get the list of IDs of open named datatype objects */ /* (Do this separately from the dataset & attribute IDs, because * they could be using one of the named datatypes and then the - * open named datatype ID will get closed twice. + * open named datatype ID will get closed twice) */ while((obj_count = H5F_get_obj_ids(f, H5F_OBJ_LOCAL|H5F_OBJ_DATATYPE, (int)(sizeof(objs)/sizeof(objs[0])), objs)) != 0) { /* Try to close all the open objects in this file */ diff --git a/src/H5Gdense.c b/src/H5Gdense.c index aaa2ea3..abc7fcc 100644 --- a/src/H5Gdense.c +++ b/src/H5Gdense.c @@ -394,7 +394,7 @@ HDfprintf(stderr, "%s: linfo->name_bt2_addr = %a\n", FUNC, linfo->name_bt2_addr) #endif /* QAK */ /* Find out the size of buffer needed for serialized link */ - if((link_size = H5O_msg_raw_size(f, H5O_LINK_ID, lnk)) == 0) + if((link_size = H5O_msg_raw_size(f, H5O_LINK_ID, FALSE, lnk)) == 0) HGOTO_ERROR(H5E_SYM, H5E_CANTGETSIZE, FAIL, "can't get link size") #ifdef QAK HDfprintf(stderr, "%s: HDstrlen(lnk->name) = %Zu, link_size = %Zu\n", FUNC, HDstrlen(lnk->name), link_size); @@ -409,7 +409,7 @@ HDfprintf(stderr, "%s: HDstrlen(lnk->name) = %Zu, link_size = %Zu\n", FUNC, HDst link_ptr = link_buf; /* Create serialized form of link */ - if(H5O_msg_encode(f, H5O_LINK_ID, link_ptr, lnk) < 0) + if(H5O_msg_encode(f, H5O_LINK_ID, FALSE, link_ptr, lnk) < 0) HGOTO_ERROR(H5E_SYM, H5E_CANTENCODE, FAIL, "can't encode link") /* Open the fractal heap */ diff --git a/src/H5Gobj.c b/src/H5Gobj.c index 8cb384d..189adf9 100644 --- a/src/H5Gobj.c +++ b/src/H5Gobj.c @@ -434,7 +434,7 @@ H5G_obj_insert(H5O_loc_t *grp_oloc, const char *name, H5O_link_t *obj_lnk, } /* end if */ /* Get the link's message size */ - if((link_msg_size = H5O_msg_raw_size(grp_oloc->file, H5O_LINK_ID, obj_lnk)) == 0) + if((link_msg_size = H5O_msg_raw_size(grp_oloc->file, H5O_LINK_ID, FALSE, obj_lnk)) == 0) HGOTO_ERROR(H5E_SYM, H5E_CANTGETSIZE, FAIL, "can't get link size") /* If there's still a small enough number of links, use the 'link' message */ diff --git a/src/H5HFcache.c b/src/H5HFcache.c index 0fbafba..8150e78 100644 --- a/src/H5HFcache.c +++ b/src/H5HFcache.c @@ -375,7 +375,7 @@ HDfprintf(stderr, "%s: Load heap header, addr = %a\n", FUNC, addr); UINT32DECODE(p, hdr->pline_root_direct_filter_mask); /* Decode I/O filter information */ - if(NULL == (pline = H5O_msg_decode(hdr->f, dxpl_id, H5O_PLINE_ID, p))) + if(NULL == (pline = (H5O_pline_t *)H5O_msg_decode(hdr->f, dxpl_id, H5O_PLINE_ID, p))) HGOTO_ERROR(H5E_HEAP, H5E_CANTDECODE, NULL, "can't decode I/O pipeline filters") p += hdr->filter_len; @@ -416,7 +416,7 @@ HDfprintf(stderr, "%s: hdr->fspace = %p\n", FUNC, hdr->fspace); done: if(buf) - H5FL_BLK_FREE(header_block, buf); + buf = H5FL_BLK_FREE(header_block, buf); if(!ret_value && hdr) (void)H5HF_cache_hdr_dest(f, hdr); @@ -530,7 +530,7 @@ HDfprintf(stderr, "%s: Flushing heap header, addr = %a, destroy = %u\n", FUNC, a UINT32ENCODE(p, hdr->pline_root_direct_filter_mask); /* Encode I/O filter information */ - if(H5O_msg_encode(hdr->f, H5O_PLINE_ID, p, &(hdr->pline)) < 0) + if(H5O_msg_encode(hdr->f, H5O_PLINE_ID, FALSE, p, &(hdr->pline)) < 0) HGOTO_ERROR(H5E_HEAP, H5E_CANTENCODE, FAIL, "can't encode I/O pipeline fiters") p += hdr->filter_len; } /* end if */ @@ -546,7 +546,7 @@ HDfprintf(stderr, "%s: Flushing heap header, addr = %a, destroy = %u\n", FUNC, a if(H5F_block_write(f, H5FD_MEM_FHEAP_HDR, addr, size, dxpl_id, buf) < 0) HGOTO_ERROR(H5E_HEAP, H5E_CANTFLUSH, FAIL, "unable to save fractal heap header to disk") - H5FL_BLK_FREE(header_block, buf); + buf = H5FL_BLK_FREE(header_block, buf); hdr->dirty = FALSE; hdr->cache_info.is_dirty = FALSE; @@ -866,7 +866,7 @@ HDfprintf(stderr, "%s: iblock->ents[%Zu] = {%a}\n", FUNC, u, iblock->ents[u].add done: /* Free buffer */ /* XXX: Keep buffer around? */ - H5FL_BLK_FREE(indirect_block, buf); + buf = H5FL_BLK_FREE(indirect_block, buf); if(!ret_value && iblock) (void)H5HF_cache_iblock_dest(f, iblock); @@ -1013,7 +1013,7 @@ HDfprintf(stderr, "%s: iblock->filt_ents[%Zu] = {%Zu, %x}\n", FUNC, u, iblock->f HGOTO_ERROR(H5E_HEAP, H5E_CANTFLUSH, FAIL, "unable to save fractal heap indirect block to disk") /* Free buffer */ - H5FL_BLK_FREE(indirect_block, buf); + buf = H5FL_BLK_FREE(indirect_block, buf); /* Reset dirty flags */ iblock->cache_info.is_dirty = FALSE; @@ -1620,7 +1620,7 @@ HDfprintf(stderr, "%s: Destroying direct block, dblock = %p\n", FUNC, dblock); HGOTO_ERROR(H5E_HEAP, H5E_CANTDEC, FAIL, "can't decrement reference count on shared indirect block") /* Free block's buffer */ - H5FL_BLK_FREE(direct_block, dblock->blk); + dblock->blk = H5FL_BLK_FREE(direct_block, dblock->blk); /* Free fractal heap direct block info */ H5FL_FREE(H5HF_direct_t, dblock); diff --git a/src/H5HFhdr.c b/src/H5HFhdr.c index 6267e76..ad243cf 100644 --- a/src/H5HFhdr.c +++ b/src/H5HFhdr.c @@ -424,7 +424,7 @@ H5HF_hdr_create(H5F_t *f, hid_t dxpl_id, const H5HF_create_t *cparam) HGOTO_ERROR(H5E_HEAP, H5E_CANTCOPY, HADDR_UNDEF, "can't copy I/O filter pipeline") /* Compute the I/O filters' encoded size */ - if(0 == (hdr->filter_len = H5O_msg_raw_size(hdr->f, H5O_PLINE_ID, &(hdr->pline)))) + if(0 == (hdr->filter_len = H5O_msg_raw_size(hdr->f, H5O_PLINE_ID, FALSE, &(hdr->pline)))) HGOTO_ERROR(H5E_HEAP, H5E_CANTGETSIZE, HADDR_UNDEF, "can't get I/O filter pipeline size") #ifdef QAK HDfprintf(stderr, "%s: hdr->filter_len = %u\n", FUNC, hdr->filter_len); diff --git a/src/H5Oattr.c b/src/H5Oattr.c index 8c9b22d..b2d2712 100644 --- a/src/H5Oattr.c +++ b/src/H5Oattr.c @@ -185,25 +185,9 @@ H5O_attr_decode(H5F_t *f, hid_t dxpl_id, unsigned mesg_flags, else p += name_len; /* advance the memory pointer */ - /* decode the attribute datatype */ - if(flags & H5O_ATTR_FLAG_TYPE_SHARED) { - H5O_shared_t *shared; /* Shared information */ - - /* Get the shared information */ - if(NULL == (shared = (H5O_shared_t *)(H5O_MSG_SHARED->decode)(f, dxpl_id, mesg_flags, p))) - HGOTO_ERROR(H5E_OHDR, H5E_CANTDECODE, NULL, "unable to decode shared message") - - /* Get the actual datatype information */ - if((attr->dt = (H5T_t *)H5O_shared_read(f, dxpl_id, shared, H5O_MSG_DTYPE, NULL)) == NULL) - HGOTO_ERROR(H5E_ATTR, H5E_CANTDECODE, NULL, "can't decode attribute datatype") - - /* Free the shared information */ - H5O_msg_free_real(H5O_MSG_SHARED, shared); - } /* end if */ - else { - if((attr->dt = (H5T_t *)(H5O_MSG_DTYPE->decode)(f, dxpl_id, mesg_flags, p)) == NULL) - HGOTO_ERROR(H5E_ATTR, H5E_CANTDECODE, NULL, "can't decode attribute datatype") - } /* end else */ + /* Decode the attribute's datatype */ + if((attr->dt = (H5T_t *)(H5O_MSG_DTYPE->decode)(f, dxpl_id, ((flags & H5O_ATTR_FLAG_TYPE_SHARED) ? H5O_MSG_FLAG_SHARED : 0), p)) == NULL) + HGOTO_ERROR(H5E_ATTR, H5E_CANTDECODE, NULL, "can't decode attribute datatype") if(version < H5O_ATTR_VERSION_2) p += H5O_ALIGN_OLD(attr->dt_size); else @@ -638,8 +622,6 @@ herr_t H5O_attr_delete(H5F_t *f, hid_t dxpl_id, const void *_mesg, hbool_t adj_link) { const H5A_t *attr = (const H5A_t *) _mesg; - htri_t tri_ret; - H5O_shared_t sh_mesg; herr_t ret_value = SUCCEED; /* Return value */ FUNC_ENTER_NOAPI_NOINIT(H5O_attr_delete) @@ -648,26 +630,9 @@ H5O_attr_delete(H5F_t *f, hid_t dxpl_id, const void *_mesg, hbool_t adj_link) HDassert(f); HDassert(attr); - /* Remove both the datatype and dataspace from the SOHM heap if they're - * shared there. - */ - if((tri_ret = H5O_msg_is_shared(H5O_DTYPE_ID, attr->dt)) < 0) - HGOTO_ERROR(H5E_ATTR, H5E_BADMESG, FAIL, "can't tell if datatype is shared") - else if(tri_ret > 0) { - /* Check whether datatype is shared */ - if(H5T_committed(attr->dt)) { - /* Decrement the reference count on the shared datatype, if requested */ - if(adj_link) - if(H5T_link(attr->dt, -1, dxpl_id) < 0) - HGOTO_ERROR(H5E_ATTR, H5E_LINKCOUNT, FAIL, "unable to adjust shared datatype link count") - } /* end if */ - else { - if(NULL == H5O_msg_get_share(H5O_DTYPE_ID, attr->dt, &sh_mesg)) - HGOTO_ERROR(H5E_ATTR, H5E_BADMESG, FAIL, "can't get shared message from datatype") - if(H5SM_try_delete(f, dxpl_id, H5O_DTYPE_ID, &sh_mesg) < 0) - HGOTO_ERROR(H5E_ATTR, H5E_CANTREMOVE, FAIL, "can't remove datatype from heap") - } /* end else */ - } /* end if */ + /* Decrement reference count on datatype in file */ + if((H5O_MSG_DTYPE->del)(f, dxpl_id, attr->dt, adj_link) < 0) + HGOTO_ERROR(H5E_ATTR, H5E_LINKCOUNT, FAIL, "unable to adjust datatype link count") /* Decrement reference count on dataspace in file */ if((H5O_MSG_SDSPACE->del)(f, dxpl_id, attr->ds, adj_link) < 0) @@ -708,18 +673,11 @@ H5O_attr_link(H5F_t *f, hid_t dxpl_id, const void *_mesg) * Otherwise they may be deleted when the attribute * message is deleted. */ - /* Check whether datatype is shared */ - if(H5T_committed(attr->dt)) { - /* Increment the reference count on the shared datatype */ - if(H5T_link(attr->dt, 1, dxpl_id) < 0) - HGOTO_ERROR(H5E_ATTR, H5E_LINKCOUNT, FAIL, "unable to adjust shared datatype link count") - } /* end if */ - else { - if(H5SM_try_share(f, dxpl_id, H5O_DTYPE_ID, attr->dt) < 0) - HGOTO_ERROR(H5E_ATTR, H5E_BADMESG, FAIL, "error trying to re-share attribute datatype") - } /* end else */ - if(H5SM_try_share(f, dxpl_id, H5O_SDSPACE_ID, attr->ds) < 0) - HGOTO_ERROR(H5E_ATTR, H5E_BADMESG, FAIL, "error trying to re-share attribute dataspace") + /* Increment reference count on datatype & dataspace in file */ + if((H5O_MSG_DTYPE->link)(f, dxpl_id, attr->dt) < 0) + HGOTO_ERROR(H5E_ATTR, H5E_LINKCOUNT, FAIL, "unable to adjust datatype link count") + if((H5O_MSG_SDSPACE->link)(f, dxpl_id, attr->ds) < 0) + HGOTO_ERROR(H5E_ATTR, H5E_LINKCOUNT, FAIL, "unable to adjust dataspace link count") done: FUNC_LEAVE_NOAPI(ret_value) @@ -887,9 +845,6 @@ H5O_attr_copy_file(H5F_t *file_src, const H5O_msg_class_t UNUSED *mesg_type, void *reclaim_buf = NULL; /* Buffer for reclaiming data */ hid_t buf_sid = -1; /* ID for buffer dataspace */ - H5O_shared_t sh_mesg; /* Shared message information */ - htri_t tri_ret; /* htri_t return value */ - void *ret_value; /* Return value */ FUNC_ENTER_NOAPI_NOINIT(H5O_attr_copy_file) @@ -975,38 +930,9 @@ H5O_attr_copy_file(H5F_t *file_src, const H5O_msg_class_t UNUSED *mesg_type, /* Compute the sizes of the datatype and dataspace. This is their raw * size unless they're shared. */ - if((tri_ret = H5O_msg_is_shared(H5O_DTYPE_ID, attr_dst->dt)) < 0) - HGOTO_ERROR(H5E_OHDR, H5E_BADMESG, NULL, "unable to determine if datatype is shared") - if(tri_ret == TRUE) { - /* Reset shared message information */ - HDmemset(&sh_mesg, 0, sizeof(H5O_shared_t)); - - /* Get shared message information for datatype */ - if(NULL == H5O_msg_get_share(H5O_DTYPE_ID, attr_dst->dt, &sh_mesg/*out*/)) - HGOTO_ERROR(H5E_ATTR, H5E_CANTOPENOBJ, NULL, "unable to get shared message") - - /* Compute shared message size for datatype */ - attr_dst->dt_size = H5O_msg_raw_size(file_dst, H5O_SHARED_ID, &sh_mesg); - } /* end if */ - else - attr_dst->dt_size = H5O_msg_raw_size(file_dst, H5O_DTYPE_ID, attr_src->dt); + attr_dst->dt_size = H5O_msg_raw_size(file_dst, H5O_DTYPE_ID, FALSE, attr_src->dt); HDassert(attr_dst->dt_size > 0); - - if((tri_ret = H5O_msg_is_shared(H5O_SDSPACE_ID, attr_dst->ds)) < 0) - HGOTO_ERROR(H5E_OHDR, H5E_BADMESG, NULL, "unable to determine if dataspace is shared") - if(tri_ret == TRUE) { - /* Reset shared message information */ - HDmemset(&sh_mesg, 0, sizeof(H5O_shared_t)); - - /* Get shared message information for dataspace */ - if(NULL == H5O_msg_get_share(H5O_SDSPACE_ID, attr_dst->ds, &sh_mesg/*out*/)) - HGOTO_ERROR(H5E_ATTR, H5E_CANTOPENOBJ, NULL, "unable to get shared message") - - /* Compute shared message size for dataspace */ - attr_dst->ds_size = H5O_msg_raw_size(file_dst, H5O_SHARED_ID, &sh_mesg); - } - else - attr_dst->ds_size = H5O_msg_raw_size(file_dst, H5O_SDSPACE_ID, attr_src->ds); + attr_dst->ds_size = H5O_msg_raw_size(file_dst, H5O_SDSPACE_ID, FALSE, attr_src->ds); HDassert(attr_dst->ds_size > 0); /* Compute the size of the data */ diff --git a/src/H5Ocopy.c b/src/H5Ocopy.c index eda97ba..a93b321 100644 --- a/src/H5Ocopy.c +++ b/src/H5Ocopy.c @@ -314,7 +314,7 @@ H5O_copy_header_real(const H5O_loc_t *oloc_src, H5O_loc_t *oloc_dst /*out */, HDassert(cpy_info); /* Get source object header */ - if(NULL == (oh_src = H5AC_protect(oloc_src->file, dxpl_id, H5AC_OHDR, oloc_src->addr, NULL, NULL, H5AC_READ))) + if(NULL == (oh_src = (H5O_t *)H5AC_protect(oloc_src->file, dxpl_id, H5AC_OHDR, oloc_src->addr, NULL, NULL, H5AC_READ))) HGOTO_ERROR(H5E_OHDR, H5E_CANTLOAD, FAIL, "unable to load object header") /* Get pointer to object class for this object */ @@ -380,7 +380,7 @@ H5O_copy_header_real(const H5O_loc_t *oloc_src, H5O_loc_t *oloc_dst /*out */, /* Allocate memory for "deleted" array. This array marks the message in * the source that shouldn't be copied to the destination. */ - if(NULL == (deleted = HDmalloc(sizeof(hbool_t) * oh_src->nmesgs))) + if(NULL == (deleted = (hbool_t *)HDmalloc(sizeof(hbool_t) * oh_src->nmesgs))) HGOTO_ERROR(H5E_RESOURCE, H5E_NOSPACE, FAIL, "memory allocation failed") HDmemset(deleted, FALSE, sizeof(hbool_t) * oh_src->nmesgs); @@ -526,10 +526,10 @@ H5O_copy_header_real(const H5O_loc_t *oloc_src, H5O_loc_t *oloc_dst /*out */, */ if(H5O_NEW_SHARED(mesg_dst->type)) mesg_dst->raw_size = H5O_ALIGN_OH(oh_dst, - H5O_msg_raw_size(oloc_dst->file, mesg_dst->type->id, mesg_dst->native)); + H5O_msg_raw_size(oloc_dst->file, mesg_dst->type->id, FALSE, mesg_dst->native)); else mesg_dst->raw_size = H5O_ALIGN_OH(oh_dst, - H5O_msg_raw_size(oloc_dst->file, H5O_SHARED_ID, mesg_dst->native)); + H5O_msg_raw_size(oloc_dst->file, H5O_SHARED_ID, FALSE, mesg_dst->native)); } /* end if */ else if(shared == FALSE && (mesg_dst->flags & H5O_MSG_FLAG_SHARED)) { /* Unset shared flag */ @@ -539,7 +539,7 @@ H5O_copy_header_real(const H5O_loc_t *oloc_src, H5O_loc_t *oloc_dst /*out */, * an H5O_shared_t) */ mesg_dst->raw_size = H5O_ALIGN_OH(oh_dst, - H5O_msg_raw_size(oloc_dst->file, mesg_dst->type->id, mesg_dst->native)); + H5O_msg_raw_size(oloc_dst->file, mesg_dst->type->id, FALSE, mesg_dst->native)); } /* end else */ /* Mark the message in the destination as dirty, so it'll get encoded when the object header is flushed */ @@ -592,7 +592,7 @@ H5O_copy_header_real(const H5O_loc_t *oloc_src, H5O_loc_t *oloc_dst /*out */, * header. This will be written when the header is flushed to disk. */ if(oh_dst->version > H5O_VERSION_1) - HDmemcpy(current_pos, H5O_HDR_MAGIC, H5O_SIZEOF_MAGIC); + HDmemcpy(current_pos, H5O_HDR_MAGIC, (size_t)H5O_SIZEOF_MAGIC); current_pos += H5O_SIZEOF_HDR(oh_dst) - H5O_SIZEOF_CHKSUM_OH(oh_dst); /* Copy each message that wasn't dirtied above */ @@ -936,7 +936,7 @@ H5O_copy_obj(H5G_loc_t *src_loc, H5G_loc_t *dst_loc, const char *dst_name, HDassert(dst_name); /* Get the copy property list */ - if(NULL == (ocpy_plist = H5I_object(ocpypl_id))) + if(NULL == (ocpy_plist = (H5P_genplist_t *)H5I_object(ocpypl_id))) HGOTO_ERROR(H5E_ARGS, H5E_BADTYPE, FAIL, "not a property list") /* Retrieve the copy parameters */ @@ -1106,7 +1106,7 @@ H5O_copy_expand_ref(H5F_t *file_src, void *_src_ref, hid_t dxpl_id, INT32DECODE(p, hobjid.idx); /* Get the dataset region from the heap (allocate inside routine) */ - if((buf = H5HG_read(src_oloc.file, dxpl_id, &hobjid, NULL, &buf_size)) == NULL) + if((buf = (uint8_t *)H5HG_read(src_oloc.file, dxpl_id, &hobjid, NULL, &buf_size)) == NULL) HGOTO_ERROR(H5E_REFERENCE, H5E_READERROR, FAIL, "Unable to read dataset region information") /* Get the object oid for the dataset */ diff --git a/src/H5Odtype.c b/src/H5Odtype.c index fc09760..31de559 100644 --- a/src/H5Odtype.c +++ b/src/H5Odtype.c @@ -66,20 +66,20 @@ const H5O_msg_class_t H5O_MSG_DTYPE[1] = {{ H5O_DTYPE_ID, /* message id number */ "datatype", /* message name for debugging */ sizeof(H5T_t), /* native message size */ - H5O_dtype_decode, /* decode message */ - H5O_dtype_encode, /* encode message */ + H5O_dtype_shared_decode, /* decode message */ + H5O_dtype_shared_encode, /* encode message */ H5O_dtype_copy, /* copy the native value */ - H5O_dtype_size, /* size of raw message */ + H5O_dtype_shared_size, /* size of raw message */ H5O_dtype_reset, /* reset method */ H5O_dtype_free, /* free method */ - NULL, /* file delete method */ - NULL, /* link method */ + H5O_dtype_shared_delete, /* file delete method */ + H5O_dtype_shared_link, /* link method */ H5O_dtype_get_share, /* get share method */ H5O_dtype_set_share, /* set share method */ H5O_dtype_can_share, /* can share method */ H5O_dtype_is_shared, /* is shared method */ H5O_dtype_pre_copy_file, /* pre copy native value to file */ - H5O_dtype_copy_file, /* copy native value to file */ + H5O_dtype_shared_copy_file, /* copy native value to file */ NULL, /* post copy native value to file */ NULL, /* get creation index */ NULL, /* set creation index */ @@ -179,7 +179,7 @@ H5O_dtype_decode_helper(H5F_t *f, const uint8_t **pp, H5T_t *dt) */ z = flags & (H5T_OPAQUE_TAG_MAX - 1); HDassert(0 == (z & 0x7)); /*must be aligned*/ - if(NULL == (dt->shared->u.opaque.tag = H5MM_malloc(z + 1))) + if(NULL == (dt->shared->u.opaque.tag = (char *)H5MM_malloc(z + 1))) HGOTO_ERROR(H5E_RESOURCE, H5E_NOSPACE, FAIL, "memory allocation failed") HDmemcpy(dt->shared->u.opaque.tag, *pp, z); dt->shared->u.opaque.tag[z] = '\0'; @@ -246,7 +246,7 @@ H5O_dtype_decode_helper(H5F_t *f, const uint8_t **pp, H5T_t *dt) HDassert(dt->shared->u.compnd.nmembs > 0); dt->shared->u.compnd.packed = TRUE; /* Start off packed */ dt->shared->u.compnd.nalloc = dt->shared->u.compnd.nmembs; - dt->shared->u.compnd.memb = H5MM_calloc(dt->shared->u.compnd.nalloc * sizeof(H5T_cmemb_t)); + dt->shared->u.compnd.memb = (H5T_cmemb_t *)H5MM_calloc(dt->shared->u.compnd.nalloc * sizeof(H5T_cmemb_t)); if(NULL == dt->shared->u.compnd.memb) HGOTO_ERROR(H5E_RESOURCE, H5E_NOSPACE, FAIL, "memory allocation failed") for(i = 0; i < dt->shared->u.compnd.nmembs; i++) { @@ -373,8 +373,8 @@ H5O_dtype_decode_helper(H5F_t *f, const uint8_t **pp, H5T_t *dt) HGOTO_ERROR(H5E_RESOURCE, H5E_NOSPACE, FAIL, "memory allocation failed") if(H5O_dtype_decode_helper(f, pp, dt->shared->parent) < 0) HGOTO_ERROR(H5E_DATATYPE, H5E_CANTDECODE, FAIL, "unable to decode parent datatype") - if(NULL == (dt->shared->u.enumer.name = H5MM_calloc(dt->shared->u.enumer.nalloc * sizeof(char*))) || - NULL == (dt->shared->u.enumer.value = H5MM_calloc(dt->shared->u.enumer.nalloc * dt->shared->parent->shared->size))) + if(NULL == (dt->shared->u.enumer.name = (char **)H5MM_calloc(dt->shared->u.enumer.nalloc * sizeof(char*))) || + NULL == (dt->shared->u.enumer.value = (uint8_t *)H5MM_calloc(dt->shared->u.enumer.nalloc * dt->shared->parent->shared->size))) HGOTO_ERROR(H5E_RESOURCE, H5E_NOSPACE, FAIL, "memory allocation failed") /* Names */ @@ -1509,7 +1509,7 @@ H5O_dtype_copy_file(H5F_t UNUSED *file_src, const H5O_msg_class_t *mesg_type, FUNC_ENTER_NOAPI_NOINIT(H5O_dtype_copy_file) /* Perform a normal copy of the object header message */ - if(NULL == (dst_mesg = H5O_dtype_copy(native_src, NULL))) + if(NULL == (dst_mesg = (H5T_t *)H5O_dtype_copy(native_src, NULL))) HGOTO_ERROR(H5E_DATATYPE, H5E_CANTINIT, NULL, "unable to copy") /* The datatype will be in the new file; set its location. */ diff --git a/src/H5Omessage.c b/src/H5Omessage.c index c9de669..6d4a15c 100644 --- a/src/H5Omessage.c +++ b/src/H5Omessage.c @@ -107,8 +107,8 @@ static herr_t H5O_msg_remove_real(const H5O_loc_t *loc, const H5O_msg_class_t *t static herr_t H5O_msg_remove_cb(H5O_t *oh, H5O_mesg_t *mesg/*in,out*/, unsigned sequence, unsigned *oh_flags_ptr, void *_udata/*in,out*/); static unsigned H5O_new_mesg(H5F_t *f, H5O_t *oh, unsigned *flags, - const H5O_msg_class_t *orig_type, const void *orig_mesg, H5O_shared_t *sh_mesg, - const H5O_msg_class_t **new_type, const void **new_mesg, hid_t dxpl_id, + const H5O_msg_class_t *orig_type, void *orig_mesg, H5O_shared_t *sh_mesg, + const H5O_msg_class_t **new_type, void **new_mesg, hid_t dxpl_id, unsigned *oh_flags_ptr); static herr_t H5O_copy_mesg(H5F_t *f, hid_t dxpl_id, H5O_t *oh, unsigned idx, const H5O_msg_class_t *type, const void *mesg, unsigned flags, @@ -167,7 +167,7 @@ H5O_msg_create(H5O_loc_t *loc, unsigned type_id, unsigned mesg_flags, HGOTO_ERROR(H5E_OHDR, H5E_WRITEERROR, FAIL, "no write intent on file") /* Protect the object header */ - if(NULL == (oh = H5AC_protect(loc->file, dxpl_id, H5AC_OHDR, loc->addr, NULL, NULL, H5AC_WRITE))) + if(NULL == (oh = (H5O_t *)H5AC_protect(loc->file, dxpl_id, H5AC_OHDR, loc->addr, NULL, NULL, H5AC_WRITE))) HGOTO_ERROR(H5E_OHDR, H5E_CANTLOAD, FAIL, "unable to load object header") /* Go append message to object header */ @@ -221,14 +221,21 @@ H5O_msg_append(H5F_t *f, hid_t dxpl_id, H5O_t *oh, unsigned type_id, HDassert(oh_flags_ptr); /* Should this message be written as a SOHM? */ - if(!(mesg_flags & H5O_MSG_FLAG_DONTSHARE)) { + if(!(mesg_flags & H5O_MSG_FLAG_DONTSHARE) && !H5O_NEW_SHARED(type)) { htri_t shared_mesg; /* Should this message be stored in the Shared Message table? */ - if((shared_mesg = H5SM_try_share(f, dxpl_id, type_id, mesg)) > 0) - /* Mark the message as shared */ + /* Check if message is already shared */ + if((shared_mesg = H5O_msg_is_shared(type_id, mesg)) < 0) + HGOTO_ERROR(H5E_OHDR, H5E_WRITEERROR, FAIL, "error determining if message is shared") + else if(shared_mesg > 0) mesg_flags |= H5O_MSG_FLAG_SHARED; - else if(shared_mesg < 0) - HGOTO_ERROR(H5E_OHDR, H5E_WRITEERROR, FAIL, "error determining if message should be shared") + else { + if((shared_mesg = H5SM_try_share(f, dxpl_id, type_id, mesg)) > 0) + /* Mark the message as shared */ + mesg_flags |= H5O_MSG_FLAG_SHARED; + else if(shared_mesg < 0) + HGOTO_ERROR(H5E_OHDR, H5E_WRITEERROR, FAIL, "error determining if message should be shared") + } /* end else */ } /* end if */ /* Append new message to object header */ @@ -261,7 +268,7 @@ H5O_msg_append_real(H5F_t *f, hid_t dxpl_id, H5O_t *oh, const H5O_msg_class_t *t unsigned *oh_flags_ptr) { const H5O_msg_class_t *new_type; /* Actual H5O class type for the ID */ - const void *new_mesg; /* Actual message to write */ + void *new_mesg; /* Actual message to write */ H5O_shared_t sh_mesg; /* Shared object header info */ unsigned idx; /* Index of message to modify */ herr_t ret_value = SUCCEED; /* Return value */ @@ -357,7 +364,7 @@ H5O_msg_write(H5O_loc_t *loc, unsigned type_id, unsigned overwrite, } /* end if */ /* Protect the object header */ - if(NULL == (oh = H5AC_protect(loc->file, dxpl_id, H5AC_OHDR, loc->addr, NULL, NULL, H5AC_WRITE))) + if(NULL == (oh = (H5O_t *)H5AC_protect(loc->file, dxpl_id, H5AC_OHDR, loc->addr, NULL, NULL, H5AC_WRITE))) HGOTO_ERROR(H5E_OHDR, H5E_CANTLOAD, FAIL, "unable to load object header") /* Call the "real" modify routine */ @@ -444,7 +451,7 @@ H5O_msg_write_real(H5F_t *f, H5O_t *oh, const H5O_msg_class_t *type, HDassert(!(((H5O_shared_t *)idx_msg->native)->flags & H5O_COMMITTED_FLAG)); /* Remove the old message from the SOHM index */ - if(H5SM_try_delete(f, dxpl_id, idx_msg->type->id, idx_msg->native) < 0) + if(H5SM_try_delete(f, dxpl_id, idx_msg->type->id, (H5O_shared_t *)idx_msg->native) < 0) HGOTO_ERROR(H5E_OHDR, H5E_CANTFREE, FAIL, "unable to delete message from SOHM table") if(H5O_NEW_SHARED(type)) { @@ -537,7 +544,7 @@ H5O_msg_read(const H5O_loc_t *loc, unsigned type_id, int sequence, void *mesg, HDassert(sequence >= 0); /* Get the object header */ - if(NULL == (oh = H5AC_protect(loc->file, dxpl_id, H5AC_OHDR, loc->addr, NULL, NULL, H5AC_READ))) + if(NULL == (oh = (H5O_t *)H5AC_protect(loc->file, dxpl_id, H5AC_OHDR, loc->addr, NULL, NULL, H5AC_READ))) HGOTO_ERROR(H5E_OHDR, H5E_CANTLOAD, NULL, "unable to load object header") /* Call the "real" read routine */ @@ -616,7 +623,7 @@ H5O_msg_read_real(H5F_t *f, H5O_t *oh, unsigned type_id, int sequence, * H5O_MSG_SHARED message. We use that information to look up the real * message in the global heap or some other object header. */ - if(NULL == (ret_value = H5O_shared_read(f, dxpl_id, oh->mesg[idx].native, type, mesg))) + if(NULL == (ret_value = H5O_shared_read(f, dxpl_id, (const H5O_shared_t *)oh->mesg[idx].native, type, mesg))) HGOTO_ERROR(H5E_OHDR, H5E_CANTINIT, NULL, "unable to copy message to user space") } else { /* @@ -916,7 +923,7 @@ H5O_msg_count(const H5O_loc_t *loc, unsigned type_id, hid_t dxpl_id) HDassert(type); /* Load the object header */ - if(NULL == (oh = H5AC_protect(loc->file, dxpl_id, H5AC_OHDR, loc->addr, NULL, NULL, H5AC_READ))) + if(NULL == (oh = (H5O_t *)H5AC_protect(loc->file, dxpl_id, H5AC_OHDR, loc->addr, NULL, NULL, H5AC_READ))) HGOTO_ERROR(H5E_OHDR, H5E_CANTLOAD, FAIL, "unable to load object header") /* Loop over all messages, counting the ones of the type looked for */ @@ -967,7 +974,7 @@ H5O_msg_exists(H5O_loc_t *loc, unsigned type_id, int sequence, hid_t dxpl_id) HDassert(sequence >= 0); /* Load the object header */ - if(NULL == (oh = H5AC_protect(loc->file, dxpl_id, H5AC_OHDR, loc->addr, NULL, NULL, H5AC_READ))) + if(NULL == (oh = (H5O_t *)H5AC_protect(loc->file, dxpl_id, H5AC_OHDR, loc->addr, NULL, NULL, H5AC_READ))) HGOTO_ERROR(H5E_OHDR, H5E_CANTLOAD, FAIL, "unable to load object header") /* Call the "real" exists routine */ @@ -1239,7 +1246,7 @@ H5O_msg_remove_real(const H5O_loc_t *loc, const H5O_msg_class_t *type, int seque udata.adj_link = adj_link; /* Protect the object header to iterate over */ - if(NULL == (oh = H5AC_protect(loc->file, dxpl_id, H5AC_OHDR, loc->addr, NULL, NULL, H5AC_WRITE))) + if(NULL == (oh = (H5O_t *)H5AC_protect(loc->file, dxpl_id, H5AC_OHDR, loc->addr, NULL, NULL, H5AC_WRITE))) HGOTO_ERROR(H5E_OHDR, H5E_CANTLOAD, FAIL, "unable to load object header") /* Iterate over the messages, deleting appropriate one(s) */ @@ -1311,7 +1318,7 @@ H5O_msg_iterate(const H5O_loc_t *loc, unsigned type_id, H5O_operator_t app_op, HDassert(type); /* Protect the object header to iterate over */ - if(NULL == (oh = H5AC_protect(loc->file, dxpl_id, H5AC_OHDR, loc->addr, NULL, NULL, H5AC_WRITE))) + if(NULL == (oh = (H5O_t *)H5AC_protect(loc->file, dxpl_id, H5AC_OHDR, loc->addr, NULL, NULL, H5AC_WRITE))) HGOTO_ERROR(H5E_OHDR, H5E_CANTLOAD, FAIL, "unable to load object header") /* Call the "real" iterate routine */ @@ -1394,7 +1401,7 @@ H5O_msg_iterate_real(H5F_t *f, H5O_t *oh, const H5O_msg_class_t *type, else { /* If the message is shared, get the real message it points to */ if((idx_msg->flags & H5O_MSG_FLAG_SHARED) && !H5O_NEW_SHARED(idx_msg->type)) { - if(NULL == (native_mesg = H5O_shared_read(f, dxpl_id, idx_msg->native, idx_msg->type, NULL))) + if(NULL == (native_mesg = H5O_shared_read(f, dxpl_id, (const H5O_shared_t *)idx_msg->native, idx_msg->type, NULL))) HGOTO_ERROR(H5E_OHDR, H5E_BADMESG, FAIL, "unable to read shared message") native_mesg_alloc = TRUE; } /* end if */ @@ -1459,10 +1466,12 @@ done: *------------------------------------------------------------------------- */ size_t -H5O_msg_raw_size(const H5F_t *f, unsigned type_id, const void *mesg) +H5O_msg_raw_size(const H5F_t *f, unsigned type_id, hbool_t disable_shared, + const void *mesg) { - const H5O_msg_class_t *type; /* Actual H5O class type for the ID */ - size_t ret_value; /* Return value */ + const H5O_msg_class_t *type; /* Actual H5O class type for the ID */ + unsigned old_sh_mesg_flags = 0; /* Message's current shared message flags */ + size_t ret_value; /* Return value */ FUNC_ENTER_NOAPI(H5O_msg_raw_size, 0) @@ -1474,10 +1483,32 @@ H5O_msg_raw_size(const H5F_t *f, unsigned type_id, const void *mesg) HDassert(f); HDassert(mesg); + /* Check for disabling shared message encoding, to encode the "base" type */ + if(disable_shared) { + H5O_shared_t *sh_mesg = (H5O_shared_t *)mesg; /* Pointer to message's shared message info */ + + /* Try to make certain that this routine doesn't get invoked for + * unsharable message classes + */ + HDassert(type->is_shared); + + /* Preserve message's shared message info while getting the + * "real" encoded size & buffer (*ick* - QAK) + * (XXX: Harmless but ugly for message classes that aren't using shared + * message method interface yet - QAK) + */ + old_sh_mesg_flags = sh_mesg->flags; + sh_mesg->flags = 0; + } /* end if */ + /* Compute the raw data size for the mesg */ if((ret_value = (type->raw_size)(f, mesg)) == 0) HGOTO_ERROR(H5E_OHDR, H5E_CANTCOUNT, 0, "unable to determine size of message") + /* Restore message's shared message info, if appropriate (*ick* - QAK) */ + if(disable_shared) + ((H5O_shared_t *)mesg)->flags = old_sh_mesg_flags; + done: FUNC_LEAVE_NOAPI(ret_value) } /* end H5O_msg_raw_size() */ @@ -1778,10 +1809,12 @@ done: *------------------------------------------------------------------------- */ herr_t -H5O_msg_encode(H5F_t *f, unsigned type_id, unsigned char *buf, const void *mesg) +H5O_msg_encode(H5F_t *f, unsigned type_id, hbool_t disable_shared, + unsigned char *buf, const void *mesg) { - const H5O_msg_class_t *type; /* Actual H5O class type for the ID */ - herr_t ret_value = SUCCEED; /* Return value */ + const H5O_msg_class_t *type; /* Actual H5O class type for the ID */ + unsigned old_sh_mesg_flags = 0; /* Message's current shared message flags */ + herr_t ret_value = SUCCEED; /* Return value */ FUNC_ENTER_NOAPI(H5O_msg_encode,FAIL) @@ -1791,10 +1824,32 @@ H5O_msg_encode(H5F_t *f, unsigned type_id, unsigned char *buf, const void *mesg) type = H5O_msg_class_g[type_id]; /* map the type ID to the actual type object */ HDassert(type); + /* Check for disabling shared message encoding, to encode the "base" type */ + if(disable_shared) { + H5O_shared_t *sh_mesg = (H5O_shared_t *)mesg; /* Pointer to message's shared message info */ + + /* Try to make certain that this routine doesn't get invoked for + * unsharable message classes + */ + HDassert(type->is_shared); + + /* Preserve message's shared message info while getting the + * "real" encoded size & buffer (*ick* - QAK) + * (XXX: Harmless but ugly for message classes that aren't using shared + * message method interface yet - QAK) + */ + old_sh_mesg_flags = sh_mesg->flags; + sh_mesg->flags = 0; + } /* end if */ + /* Encode */ if((type->encode)(f, buf, mesg) < 0) HGOTO_ERROR(H5E_OHDR, H5E_CANTENCODE, FAIL, "unable to encode message") + /* Restore message's shared message info, if appropriate (*ick* - QAK) */ + if(disable_shared) + ((H5O_shared_t *)mesg)->flags = old_sh_mesg_flags; + done: FUNC_LEAVE_NOAPI(ret_value) } /* end H5O_msg_encode() */ @@ -1973,8 +2028,8 @@ done: */ static unsigned H5O_new_mesg(H5F_t *f, H5O_t *oh, unsigned *mesg_flags, const H5O_msg_class_t *orig_type, - const void *orig_mesg, H5O_shared_t *sh_mesg, const H5O_msg_class_t **new_type, - const void **new_mesg, hid_t dxpl_id, unsigned *oh_flags_ptr) + void *orig_mesg, H5O_shared_t *sh_mesg, const H5O_msg_class_t **new_type, + void **new_mesg, hid_t dxpl_id, unsigned *oh_flags_ptr) { size_t size; /* Size of space allocated for object header */ unsigned ret_value = UFAIL; /* Return value */ @@ -2024,6 +2079,33 @@ H5O_new_mesg(H5F_t *f, H5O_t *oh, unsigned *mesg_flags, const H5O_msg_class_t *o *new_mesg = orig_mesg; } /* end else */ + if(H5O_NEW_SHARED(orig_type)) { + htri_t shared_mesg; /* Should this message be stored in the Shared Message table? */ + + HDassert(!(*mesg_flags & H5O_MSG_FLAG_SHARED)); + + /* Check if message is already shared */ + if((shared_mesg = H5O_msg_is_shared((*new_type)->id, (*new_mesg))) < 0) + HGOTO_ERROR(H5E_OHDR, H5E_WRITEERROR, UFAIL, "error determining if message is shared") + else if(shared_mesg > 0) { + /* Increment message's reference count */ + if((*new_type)->link && ((*new_type)->link)(f, dxpl_id, (*new_mesg)) < 0) + HGOTO_ERROR(H5E_OHDR, H5E_LINKCOUNT, UFAIL, "unable to adjust shared message ref count") + *mesg_flags |= H5O_MSG_FLAG_SHARED; + } /* end if */ + else { + /* Check for unsharable message */ + if(!(*mesg_flags & H5O_MSG_FLAG_DONTSHARE)) { + /* Attempt to share message */ + if((shared_mesg = H5SM_try_share(f, dxpl_id, (*new_type)->id, (*new_mesg))) > 0) + /* Mark the message as shared */ + *mesg_flags |= H5O_MSG_FLAG_SHARED; + else if(shared_mesg < 0) + HGOTO_ERROR(H5E_OHDR, H5E_WRITEERROR, UFAIL, "error determining if message should be shared") + } /* end if */ + } /* end else */ + } /* end if */ + /* Compute the size needed to store the message on disk */ if((size = ((*new_type)->raw_size)(f, *new_mesg)) >= H5O_MESG_MAX_SIZE) HGOTO_ERROR(H5E_OHDR, H5E_CANTINIT, UFAIL, "object header message is too large") @@ -2039,9 +2121,11 @@ H5O_new_mesg(H5F_t *f, H5O_t *oh, unsigned *mesg_flags, const H5O_msg_class_t *o HGOTO_ERROR(H5E_OHDR, H5E_CANTGET, UFAIL, "unable to retrieve creation index") } /* end if */ - /* Increment any links in message */ - if((*new_type)->link && ((*new_type)->link)(f, dxpl_id, (*new_mesg)) < 0) - HGOTO_ERROR(H5E_OHDR, H5E_LINKCOUNT, UFAIL, "unable to adjust shared object link count") + if(!H5O_NEW_SHARED(orig_type)) { + /* Increment any links in message */ + if((*new_type)->link && ((*new_type)->link)(f, dxpl_id, (*new_mesg)) < 0) + HGOTO_ERROR(H5E_OHDR, H5E_LINKCOUNT, UFAIL, "unable to adjust shared object link count") + } /* end if */ done: FUNC_LEAVE_NOAPI(ret_value) @@ -2199,7 +2283,7 @@ H5O_delete_mesg(H5F_t *f, hid_t dxpl_id, H5O_mesg_t *mesg, hbool_t adj_link) * it's a shared message. */ if(type == H5O_MSG_SHARED) { - if(H5SM_try_delete(f, dxpl_id, mesg->type->id, mesg->native) < 0) + if(H5SM_try_delete(f, dxpl_id, mesg->type->id, (H5O_shared_t *)mesg->native) < 0) HGOTO_ERROR(H5E_OHDR, H5E_CANTFREE, FAIL, "unable to delete message from SOHM table") } /* end if */ diff --git a/src/H5Opkg.h b/src/H5Opkg.h index 1ecf283..83065d4 100644 --- a/src/H5Opkg.h +++ b/src/H5Opkg.h @@ -160,7 +160,7 @@ /* Temporary macro to define which message classes are using the "new" * shared message "interface" for their methods. */ -#define H5O_NEW_SHARED(T) ((T) == H5O_MSG_PLINE || (T) == H5O_MSG_FILL_NEW || (T) == H5O_MSG_FILL || (T) == H5O_MSG_SDSPACE) +#define H5O_NEW_SHARED(T) ((T) == H5O_MSG_PLINE || (T) == H5O_MSG_FILL_NEW || (T) == H5O_MSG_FILL || (T) == H5O_MSG_SDSPACE || (T) == H5O_MSG_DTYPE) /* The "message class" type */ diff --git a/src/H5Opline.c b/src/H5Opline.c index 199ad69..d87c781 100644 --- a/src/H5Opline.c +++ b/src/H5Opline.c @@ -151,7 +151,7 @@ H5O_pline_decode(H5F_t UNUSED *f, hid_t UNUSED dxpl_id, unsigned UNUSED mesg_fla /* Allocate array for filters */ pline->nalloc = pline->nused; - if(NULL == (pline->filter = H5MM_calloc(pline->nalloc * sizeof(pline->filter[0])))) + if(NULL == (pline->filter = (H5Z_filter_info_t *)H5MM_calloc(pline->nalloc * sizeof(pline->filter[0])))) HGOTO_ERROR(H5E_RESOURCE, H5E_NOSPACE, NULL, "memory allocation failed") /* Decode filters */ @@ -184,7 +184,7 @@ H5O_pline_decode(H5F_t UNUSED *f, hid_t UNUSED dxpl_id, unsigned UNUSED mesg_fla /* Allocate space for the filter name, or use the internal buffer */ if(actual_name_length > H5Z_COMMON_NAME_LEN) { - filter->name = H5MM_malloc(actual_name_length); + filter->name = (char *)H5MM_malloc(actual_name_length); if(NULL == filter->name) HGOTO_ERROR(H5E_RESOURCE, H5E_NOSPACE, NULL, "memory allocation failed for filter name") } /* end if */ @@ -201,7 +201,7 @@ H5O_pline_decode(H5F_t UNUSED *f, hid_t UNUSED dxpl_id, unsigned UNUSED mesg_fla /* Allocate space for the client data elements, or use the internal buffer */ if(filter->cd_nelmts > H5Z_COMMON_CD_VALUES) { - filter->cd_values = H5MM_malloc(filter->cd_nelmts * sizeof(unsigned)); + filter->cd_values = (unsigned *)H5MM_malloc(filter->cd_nelmts * sizeof(unsigned)); if(NULL == filter->cd_values) HGOTO_ERROR(H5E_RESOURCE, H5E_NOSPACE, NULL, "memory allocation failed for client data") } /* end if */ @@ -374,7 +374,7 @@ H5O_pline_copy(const void *_src, void *_dst/*out*/) dst->nalloc = dst->nused; if(dst->nalloc) { /* Allocate array to hold filters */ - if(NULL == (dst->filter = H5MM_calloc(dst->nalloc * sizeof(dst->filter[0])))) + if(NULL == (dst->filter = (H5Z_filter_info_t *)H5MM_calloc(dst->nalloc * sizeof(dst->filter[0])))) HGOTO_ERROR(H5E_RESOURCE, H5E_NOSPACE, NULL, "memory allocation failed") /* Deep-copy filters */ @@ -390,7 +390,7 @@ H5O_pline_copy(const void *_src, void *_dst/*out*/) /* Allocate space for the filter name, or use the internal buffer */ if(namelen > H5Z_COMMON_NAME_LEN) { - dst->filter[i].name = H5MM_malloc(namelen); + dst->filter[i].name = (char *)H5MM_malloc(namelen); if(NULL == dst->filter[i].name) HGOTO_ERROR(H5E_RESOURCE, H5E_NOSPACE, NULL, "memory allocation failed for filter name") @@ -405,7 +405,7 @@ H5O_pline_copy(const void *_src, void *_dst/*out*/) if(src->filter[i].cd_nelmts > 0) { /* Allocate space for the client data elements, or use the internal buffer */ if(src->filter[i].cd_nelmts > H5Z_COMMON_CD_VALUES) { - if(NULL == (dst->filter[i].cd_values = H5MM_malloc(src->filter[i].cd_nelmts* sizeof(unsigned)))) + if(NULL == (dst->filter[i].cd_values = (unsigned *)H5MM_malloc(src->filter[i].cd_nelmts* sizeof(unsigned)))) HGOTO_ERROR(H5E_RESOURCE, H5E_NOSPACE, NULL, "memory allocation failed") HDmemcpy(dst->filter[i].cd_values, src->filter[i].cd_values, @@ -529,16 +529,16 @@ H5O_pline_reset(void *mesg) if(pline->filter[i].name && pline->filter[i].name != pline->filter[i]._name) HDassert((HDstrlen(pline->filter[i].name) + 1) > H5Z_COMMON_NAME_LEN); if(pline->filter[i].name != pline->filter[i]._name) - pline->filter[i].name = H5MM_xfree(pline->filter[i].name); + pline->filter[i].name = (char *)H5MM_xfree(pline->filter[i].name); if(pline->filter[i].cd_values && pline->filter[i].cd_values != pline->filter[i]._cd_values) HDassert(pline->filter[i].cd_nelmts > H5Z_COMMON_CD_VALUES); if(pline->filter[i].cd_values != pline->filter[i]._cd_values) - pline->filter[i].cd_values = H5MM_xfree(pline->filter[i].cd_values); + pline->filter[i].cd_values = (unsigned *)H5MM_xfree(pline->filter[i].cd_values); } /* end for */ /* Free filter array */ if(pline->filter) - pline->filter = H5MM_xfree(pline->filter); + pline->filter = (H5Z_filter_info_t *)H5MM_xfree(pline->filter); /* Reset # of filters */ pline->nused = pline->nalloc = 0; @@ -606,7 +606,7 @@ H5O_pline_pre_copy_file(H5F_t UNUSED *file_src, const H5O_msg_class_t UNUSED *ty * the object copying process. */ if(udata) - if(NULL == (udata->src_pline = H5O_pline_copy(pline_src, NULL))) + if(NULL == (udata->src_pline = (H5O_pline_t *)H5O_pline_copy(pline_src, NULL))) HGOTO_ERROR(H5E_PLINE, H5E_CANTINIT, FAIL, "unable to copy") done: diff --git a/src/H5Oprivate.h b/src/H5Oprivate.h index d5a2376..62285e1 100644 --- a/src/H5Oprivate.h +++ b/src/H5Oprivate.h @@ -422,7 +422,8 @@ H5_DLL herr_t H5O_msg_remove_op(const H5O_loc_t *loc, unsigned type_id, int sequ H5O_operator_t op, void *op_data, hbool_t adj_link, hid_t dxpl_id); H5_DLL herr_t H5O_msg_iterate(const H5O_loc_t *loc, unsigned type_id, H5O_operator_t op, void *op_data, hid_t dxpl_id); -H5_DLL size_t H5O_msg_raw_size(const H5F_t *f, unsigned type_id, const void *mesg); +H5_DLL size_t H5O_msg_raw_size(const H5F_t *f, unsigned type_id, + hbool_t disable_shared, const void *mesg); H5_DLL size_t H5O_msg_mesg_size(const H5F_t *f, unsigned type_id, const void *mesg, size_t extra_raw); H5_DLL void *H5O_msg_get_share(unsigned type_id, const void *mesg, H5O_shared_t *share); @@ -430,7 +431,8 @@ H5_DLL htri_t H5O_msg_is_shared(unsigned type_id, const void *mesg); H5_DLL htri_t H5O_msg_can_share(unsigned type_id, const void *mesg); H5_DLL herr_t H5O_msg_set_share(unsigned type_id, H5O_shared_t *share, void *mesg); H5_DLL herr_t H5O_msg_reset_share(unsigned type_id, void *mesg); -H5_DLL herr_t H5O_msg_encode(H5F_t *f, unsigned type_id, unsigned char *buf, const void *obj); +H5_DLL herr_t H5O_msg_encode(H5F_t *f, unsigned type_id, hbool_t disable_shared, + unsigned char *buf, const void *obj); H5_DLL void* H5O_msg_decode(H5F_t *f, hid_t dxpl_id, unsigned type_id, const unsigned char *buf); H5_DLL herr_t H5O_msg_delete(H5F_t *f, hid_t dxpl_id, unsigned type_id, const void *mesg); diff --git a/src/H5Osdspace.c b/src/H5Osdspace.c index 57a48e6..1d406d9 100644 --- a/src/H5Osdspace.c +++ b/src/H5Osdspace.c @@ -171,7 +171,7 @@ H5O_sdspace_decode(H5F_t *f, hid_t UNUSED dxpl_id, unsigned UNUSED mesg_flags, /* Decode dimension sizes */ if(sdim->rank > 0) { - if(NULL == (sdim->size = H5FL_ARR_MALLOC(hsize_t, (size_t)sdim->rank))) + if(NULL == (sdim->size = (hsize_t *)H5FL_ARR_MALLOC(hsize_t, (size_t)sdim->rank))) HGOTO_ERROR(H5E_RESOURCE, H5E_NOSPACE, NULL, "memory allocation failed") for(i = 0; i < sdim->rank; i++) { H5F_DECODE_LENGTH(f, p, sdim->size[i]); @@ -183,7 +183,7 @@ H5O_sdspace_decode(H5F_t *f, hid_t UNUSED dxpl_id, unsigned UNUSED mesg_flags, } /* end for */ if(flags & H5S_VALID_MAX) { - if(NULL == (sdim->max = H5FL_ARR_MALLOC(hsize_t, (size_t)sdim->rank))) + if(NULL == (sdim->max = (hsize_t *)H5FL_ARR_MALLOC(hsize_t, (size_t)sdim->rank))) HGOTO_ERROR(H5E_RESOURCE, H5E_NOSPACE, NULL, "memory allocation failed") for(i = 0; i < sdim->rank; i++) H5F_DECODE_LENGTH (f, p, sdim->max[i]); diff --git a/src/H5Oshared.c b/src/H5Oshared.c index e8c73ca..8a77744 100644 --- a/src/H5Oshared.c +++ b/src/H5Oshared.c @@ -196,7 +196,7 @@ H5O_shared_read(H5F_t *f, hid_t dxpl_id, const H5O_shared_t *shared, done: /* Release resources */ if(buf && buf != mesg_buf) - H5FL_BLK_FREE(ser_mesg, buf); + buf = H5FL_BLK_FREE(ser_mesg, buf); if(native_mesg) H5O_msg_free(type->id, native_mesg); if(fheap && H5HF_close(fheap, dxpl_id) < 0) @@ -218,7 +218,7 @@ done: * reference count is stored in the file-wide shared message * index and is changed in a different place in the code. * - * Return: Success: New link count, or 1 for messages in heap + * Return: Success: Non-negative * Failure: Negative * * Programmer: Quincey Koziol @@ -227,11 +227,11 @@ done: * *------------------------------------------------------------------------- */ -static int +static herr_t H5O_shared_link_adj_new(H5F_t *f, hid_t dxpl_id, const H5O_shared_t *shared, const H5O_msg_class_t *type, int adjust) { - int ret_value; /* Return value */ + herr_t ret_value = SUCCEED; /* Return value */ FUNC_ENTER_NOAPI_NOINIT(H5O_shared_link_adj_new) @@ -239,29 +239,33 @@ H5O_shared_link_adj_new(H5F_t *f, hid_t dxpl_id, const H5O_shared_t *shared, HDassert(f); HDassert(shared); - /* - * The shared message is stored in some other object header. - * The other object header must be in the same file as the - * new object header. Adjust the reference count on that - * object header. - */ + /* Check for type of shared message */ if(shared->flags & H5O_COMMITTED_FLAG) { + /* + * The shared message is stored in some other object header. + * The other object header must be in the same file as the + * new object header. Adjust the reference count on that + * object header. + */ if(shared->u.oloc.file->shared != f->shared) HGOTO_ERROR(H5E_LINK, H5E_CANTINIT, FAIL, "interfile hard links are not allowed") - if((ret_value = H5O_link(&(shared->u.oloc), adjust, dxpl_id)) < 0) + if(H5O_link(&(shared->u.oloc), adjust, dxpl_id) < 0) HGOTO_ERROR(H5E_OHDR, H5E_LINKCOUNT, FAIL, "unable to adjust shared object link count") } /* end if */ else { + HDassert(shared->flags & H5O_SHARED_IN_HEAP_FLAG); + + /* Check for decrementing reference count on shared message */ if(adjust < 0) { if(H5SM_try_delete(f, dxpl_id, type->id, shared) < 0) - HGOTO_ERROR(H5E_OHDR, H5E_CANTFREE, FAIL, "unable to delete message from SOHM table") + HGOTO_ERROR(H5E_OHDR, H5E_CANTDEC, FAIL, "unable to delete message from SOHM table") + } /* end if */ + /* Check for incrementing reference count on message */ + else if(adjust > 0) { + /* Casting away const OK -QAK */ + if(H5SM_try_share(f, dxpl_id, type->id, (void *)shared) < 0) + HGOTO_ERROR(H5E_OHDR, H5E_CANTINC, FAIL, "error trying to share message") } /* end if */ - - /* Messages in the heap don't have file object ref counts; they - * return 1 as a dummy value. - */ - HDassert(shared->flags & H5O_SHARED_IN_HEAP_FLAG); - ret_value = 1; } /* end else */ done: @@ -395,6 +399,7 @@ H5O_shared_decode_new(H5F_t *f, hid_t dxpl_id, const uint8_t *buf, const H5O_msg H5F_addr_decode(f, &buf, &sh_mesg.u.oloc.addr); sh_mesg.u.oloc.file = f; + sh_mesg.u.oloc.holding_file = FALSE; } /* end else */ } /* end else if */ @@ -436,7 +441,7 @@ H5O_shared_decode(H5F_t *f, hid_t UNUSED dxpl_id, unsigned UNUSED mesg_flags, HDassert(buf); /* Decode */ - if(NULL == (mesg = H5MM_calloc(sizeof(H5O_shared_t)))) + if(NULL == (mesg = (H5O_shared_t *)H5MM_calloc(sizeof(H5O_shared_t)))) HGOTO_ERROR(H5E_RESOURCE, H5E_NOSPACE, NULL, "memory allocation failed") /* Version */ @@ -625,7 +630,7 @@ H5O_shared_copy(const void *_mesg, void *_dest) /* check args */ HDassert(mesg); - if(!dest && NULL == (dest = H5MM_malloc(sizeof(H5O_shared_t)))) + if(!dest && NULL == (dest = (H5O_shared_t *)H5MM_malloc(sizeof(H5O_shared_t)))) HGOTO_ERROR(H5E_RESOURCE, H5E_NOSPACE, NULL, "memory allocation failed") /* copy */ @@ -1020,7 +1025,7 @@ H5O_shared_copy_file(H5F_t *file_src, const H5O_msg_class_t *mesg_type, */ if(shared_src->flags & H5O_COMMITTED_FLAG) { /* Allocate space for the destination message */ - if(NULL == (shared_dst = H5MM_malloc(sizeof(H5O_shared_t)))) + if(NULL == (shared_dst = (H5O_shared_t *)H5MM_malloc(sizeof(H5O_shared_t)))) HGOTO_ERROR(H5E_RESOURCE, H5E_NOSPACE, NULL, "memory allocation failed") /* Reset group entry for new object */ diff --git a/src/H5S.c b/src/H5S.c index 820978e..8604750 100644 --- a/src/H5S.c +++ b/src/H5S.c @@ -516,7 +516,7 @@ done: hid_t H5Scopy(hid_t space_id) { - H5S_t *src = NULL; + H5S_t *src; H5S_t *dst = NULL; hid_t ret_value; @@ -524,7 +524,7 @@ H5Scopy(hid_t space_id) H5TRACE1("i", "i", space_id); /* Check args */ - if (NULL==(src=H5I_object_verify(space_id, H5I_DATASPACE))) + if (NULL==(src=(H5S_t *)H5I_object_verify(space_id, H5I_DATASPACE))) HGOTO_ERROR (H5E_ARGS, H5E_BADTYPE, FAIL, "not a data space"); /* Copy */ @@ -562,17 +562,17 @@ done: herr_t H5Sextent_copy(hid_t dst_id,hid_t src_id) { - H5S_t *src = NULL; - H5S_t *dst = NULL; + H5S_t *src; + H5S_t *dst; hid_t ret_value = SUCCEED; FUNC_ENTER_API(H5Sextent_copy, FAIL); H5TRACE2("e", "ii", dst_id, src_id); /* Check args */ - if (NULL==(src=H5I_object_verify(src_id, H5I_DATASPACE))) + if (NULL==(src=(H5S_t *)H5I_object_verify(src_id, H5I_DATASPACE))) HGOTO_ERROR (H5E_ARGS, H5E_BADTYPE, FAIL, "not a data space"); - if (NULL==(dst=H5I_object_verify(dst_id, H5I_DATASPACE))) + if (NULL==(dst=(H5S_t *)H5I_object_verify(dst_id, H5I_DATASPACE))) HGOTO_ERROR (H5E_ARGS, H5E_BADTYPE, FAIL, "not a data space"); /* Copy */ @@ -620,14 +620,14 @@ H5S_extent_copy(H5S_extent_t *dst, const H5S_extent_t *src) case H5S_SIMPLE: if(src->size) { - dst->size = H5FL_ARR_MALLOC(hsize_t, (size_t)src->rank); + dst->size = (hsize_t *)H5FL_ARR_MALLOC(hsize_t, (size_t)src->rank); for(u = 0; u < src->rank; u++) dst->size[u] = src->size[u]; } /* end if */ else dst->size = NULL; if(src->max) { - dst->max = H5FL_ARR_MALLOC(hsize_t, (size_t)src->rank); + dst->max = (hsize_t *)H5FL_ARR_MALLOC(hsize_t, (size_t)src->rank); for(u = 0; u < src->rank; u++) dst->max[u] = src->max[u]; } /* end if */ @@ -756,14 +756,14 @@ done: hssize_t H5Sget_simple_extent_npoints(hid_t space_id) { - H5S_t *ds = NULL; + H5S_t *ds; hssize_t ret_value; FUNC_ENTER_API(H5Sget_simple_extent_npoints, FAIL); H5TRACE1("Hs", "i", space_id); /* Check args */ - if (NULL == (ds = H5I_object_verify(space_id, H5I_DATASPACE))) + if (NULL == (ds = (H5S_t *)H5I_object_verify(space_id, H5I_DATASPACE))) HGOTO_ERROR(H5E_ARGS, H5E_BADTYPE, FAIL, "not a data space"); ret_value = H5S_GET_EXTENT_NPOINTS(ds); @@ -860,14 +860,14 @@ done: int H5Sget_simple_extent_ndims(hid_t space_id) { - H5S_t *ds = NULL; + H5S_t *ds; int ret_value; FUNC_ENTER_API(H5Sget_simple_extent_ndims, FAIL); H5TRACE1("Is", "i", space_id); /* Check args */ - if (NULL == (ds = H5I_object_verify(space_id, H5I_DATASPACE))) + if (NULL == (ds = (H5S_t *)H5I_object_verify(space_id, H5I_DATASPACE))) HGOTO_ERROR(H5E_ARGS, H5E_BADTYPE, FAIL, "not a data space"); ret_value = H5S_GET_EXTENT_NDIMS(ds); @@ -951,14 +951,14 @@ int H5Sget_simple_extent_dims(hid_t space_id, hsize_t dims[]/*out*/, hsize_t maxdims[]/*out*/) { - H5S_t *ds = NULL; + H5S_t *ds; int ret_value; FUNC_ENTER_API(H5Sget_simple_extent_dims, FAIL); H5TRACE3("Is", "ixx", space_id, dims, maxdims); /* Check args */ - if (NULL == (ds = H5I_object_verify(space_id, H5I_DATASPACE))) + if (NULL == (ds = (H5S_t *)H5I_object_verify(space_id, H5I_DATASPACE))) HGOTO_ERROR(H5E_ARGS, H5E_BADTYPE, FAIL, "not a dataspace"); ret_value = H5S_get_simple_extent_dims(ds, dims, maxdims); @@ -1215,14 +1215,14 @@ done: htri_t H5Sis_simple(hid_t space_id) { - H5S_t *space = NULL; /* dataspace to modify */ + H5S_t *space; /* dataspace to modify */ htri_t ret_value; FUNC_ENTER_API(H5Sis_simple, FAIL); H5TRACE1("t", "i", space_id); /* Check args and all the boring stuff. */ - if ((space = H5I_object_verify(space_id,H5I_DATASPACE)) == NULL) + if ((space = (H5S_t *)H5I_object_verify(space_id,H5I_DATASPACE)) == NULL) HGOTO_ERROR(H5E_ATOM, H5E_BADATOM, FAIL, "not a data space"); ret_value = H5S_is_simple(space); @@ -1268,7 +1268,7 @@ herr_t H5Sset_extent_simple(hid_t space_id, int rank, const hsize_t dims[/*rank*/], const hsize_t max[/*rank*/]) { - H5S_t *space = NULL; /* dataspace to modify */ + H5S_t *space; /* dataspace to modify */ int u; /* local counting variable */ herr_t ret_value=SUCCEED; /* Return value */ @@ -1276,7 +1276,7 @@ H5Sset_extent_simple(hid_t space_id, int rank, const hsize_t dims[/*rank*/], H5TRACE4("e", "iIs*[a1]h*[a1]h", space_id, rank, dims, max); /* Check args */ - if ((space = H5I_object_verify(space_id,H5I_DATASPACE)) == NULL) + if ((space = (H5S_t *)H5I_object_verify(space_id,H5I_DATASPACE)) == NULL) HGOTO_ERROR(H5E_ATOM, H5E_BADATOM, FAIL, "not a data space"); if (rank > 0 && dims == NULL) HGOTO_ERROR(H5E_ARGS, H5E_BADVALUE, FAIL, "no dimensions specified"); @@ -1351,7 +1351,7 @@ H5S_set_extent_simple (H5S_t *space, unsigned rank, const hsize_t *dims, /* Set the rank and allocate space for the dims */ space->extent.rank = rank; - space->extent.size = H5FL_ARR_MALLOC(hsize_t, (size_t)rank); + space->extent.size = (hsize_t *)H5FL_ARR_MALLOC(hsize_t, (size_t)rank); /* Copy the dimensions & compute the number of elements in the extent */ for(u = 0, nelem = 1; u < space->extent.rank; u++) { @@ -1362,7 +1362,7 @@ H5S_set_extent_simple (H5S_t *space, unsigned rank, const hsize_t *dims, /* Copy the maximum dimensions if specified */ if(max != NULL) { - space->extent.max = H5FL_ARR_MALLOC(hsize_t, (size_t)rank); + space->extent.max = (hsize_t *)H5FL_ARR_MALLOC(hsize_t, (size_t)rank); HDmemcpy(space->extent.max, max, sizeof(hsize_t) * rank); } /* end if */ else @@ -1696,10 +1696,10 @@ H5Sencode(hid_t obj_id, void *buf, size_t *nalloc) H5TRACE3("e", "ix*z", obj_id, buf, nalloc); /* Check argument and retrieve object */ - if (NULL==(dspace=H5I_object_verify(obj_id, H5I_DATASPACE))) + if (NULL==(dspace=(H5S_t *)H5I_object_verify(obj_id, H5I_DATASPACE))) HGOTO_ERROR (H5E_ARGS, H5E_BADTYPE, FAIL, "not a dataspace") - if(H5S_encode(dspace, buf, nalloc)<0) + if(H5S_encode(dspace, (unsigned char *)buf, nalloc)<0) HGOTO_ERROR(H5E_DATATYPE, H5E_CANTENCODE, FAIL, "can't encode datatype"); done: @@ -1739,7 +1739,7 @@ H5S_encode(H5S_t *obj, unsigned char *buf, size_t *nalloc) HGOTO_ERROR(H5E_DATASPACE, H5E_CANTALLOC, FAIL, "can't allocate fake file struct") /* Find out the size of buffer needed for extent */ - if((extent_size = H5O_msg_raw_size(f, H5O_SDSPACE_ID, obj)) == 0) + if((extent_size = H5O_msg_raw_size(f, H5O_SDSPACE_ID, TRUE, obj)) == 0) HGOTO_ERROR(H5E_DATASPACE, H5E_BADSIZE, FAIL, "can't find dataspace size") /* Find out the size of buffer needed for selection */ @@ -1765,7 +1765,7 @@ H5S_encode(H5S_t *obj, unsigned char *buf, size_t *nalloc) UINT32ENCODE(buf, extent_size); /* Encode the extent part of dataspace */ - if(H5O_msg_encode(f, H5O_SDSPACE_ID, buf, obj) < 0) + if(H5O_msg_encode(f, H5O_SDSPACE_ID, TRUE, buf, obj) < 0) HGOTO_ERROR(H5E_DATASPACE, H5E_CANTENCODE, FAIL, "can't encode extent space") buf += extent_size; @@ -1811,7 +1811,7 @@ H5Sdecode(const void *buf) if(buf == NULL) HGOTO_ERROR(H5E_ARGS, H5E_BADVALUE, FAIL, "empty buffer") - if((ds = H5S_decode(buf)) == NULL) + if((ds = H5S_decode((const unsigned char *)buf)) == NULL) HGOTO_ERROR(H5E_DATASPACE, H5E_CANTDECODE, FAIL, "can't decode object"); /* Register the type and return the ID */ @@ -1871,7 +1871,7 @@ H5S_decode(const unsigned char *buf) /* Decode the extent part of dataspace */ /* (pass mostly bogus file pointer and bogus DXPL) */ - if((extent = H5O_msg_decode(f, H5P_DEFAULT, H5O_SDSPACE_ID, buf))==NULL) + if((extent = (H5S_extent_t *)H5O_msg_decode(f, H5P_DEFAULT, H5O_SDSPACE_ID, buf))==NULL) HGOTO_ERROR(H5E_DATASPACE, H5E_CANTDECODE, NULL, "can't decode object") buf += extent_size; @@ -1905,30 +1905,6 @@ done: /*------------------------------------------------------------------------- - * Function: H5S_raw_size - * - * Purpose: Compute the 'raw' size of the extent, as stored on disk. - * - * Return: Success: non-zero - * Failure: zero - * - * Programmer: Quincey Koziol - * koziol@ncsa.uiuc.edu - * October 14, 2004 - * - *------------------------------------------------------------------------- - */ -size_t -H5S_raw_size(const H5F_t *f, const H5S_t *space) -{ - FUNC_ENTER_NOAPI_NOINIT_NOFUNC(H5S_raw_size) - - /* Return the size of buffer needed for extent */ - FUNC_LEAVE_NOAPI(H5O_msg_raw_size(f, H5O_SDSPACE_ID, &(space->extent))) -} /* end H5S_raw_size() */ - - -/*------------------------------------------------------------------------- * Function: H5S_get_simple_extent_type * * Purpose: Internal function for retrieving the type of extent for a dataspace object @@ -1987,14 +1963,14 @@ done: H5S_class_t H5Sget_simple_extent_type(hid_t sid) { - H5S_class_t ret_value; H5S_t *space; + H5S_class_t ret_value; FUNC_ENTER_API(H5Sget_simple_extent_type, H5S_NO_CLASS); H5TRACE1("Sc", "i", sid); /* Check arguments */ - if (NULL == (space = H5I_object_verify(sid, H5I_DATASPACE))) + if (NULL == (space = (H5S_t *)H5I_object_verify(sid, H5I_DATASPACE))) HGOTO_ERROR(H5E_ARGS, H5E_BADTYPE, H5S_NO_CLASS, "not a dataspace"); ret_value=H5S_GET_EXTENT_TYPE(space); @@ -2021,14 +1997,14 @@ done: herr_t H5Sset_extent_none(hid_t space_id) { - H5S_t *space = NULL; /* dataspace to modify */ + H5S_t *space; /* dataspace to modify */ herr_t ret_value=SUCCEED; /* Return value */ FUNC_ENTER_API(H5Sset_extent_none, FAIL); H5TRACE1("e", "i", space_id); /* Check args */ - if (NULL == (space = H5I_object_verify(space_id, H5I_DATASPACE))) + if (NULL == (space = (H5S_t *)H5I_object_verify(space_id, H5I_DATASPACE))) HGOTO_ERROR(H5E_ATOM, H5E_BADATOM, FAIL, "not a data space"); /* Clear the previous extent from the dataspace */ @@ -2061,14 +2037,14 @@ done: herr_t H5Soffset_simple(hid_t space_id, const hssize_t *offset) { - H5S_t *space = NULL; /* dataspace to modify */ + H5S_t *space; /* dataspace to modify */ herr_t ret_value=SUCCEED; /* Return value */ FUNC_ENTER_API(H5Soffset_simple, FAIL); H5TRACE2("e", "i*Hs", space_id, offset); /* Check args */ - if (NULL == (space = H5I_object_verify(space_id, H5I_DATASPACE))) + if (NULL == (space = (H5S_t *)H5I_object_verify(space_id, H5I_DATASPACE))) HGOTO_ERROR(H5E_ATOM, H5E_BADATOM, FAIL, "not a data space"); if (space->extent.rank==0 || (H5S_GET_EXTENT_TYPE(space)==H5S_SCALAR || H5S_GET_EXTENT_TYPE(space)==H5S_NULL)) @@ -2230,8 +2206,8 @@ H5Sextent_equal(hid_t space1_id, hid_t space2_id) H5TRACE2("t", "ii", space1_id, space2_id); /* check args */ - if(NULL == (ds1 = H5I_object_verify(space1_id, H5I_DATASPACE)) || - NULL == (ds2 = H5I_object_verify(space2_id, H5I_DATASPACE))) + if(NULL == (ds1 = (const H5S_t *)H5I_object_verify(space1_id, H5I_DATASPACE)) || + NULL == (ds2 = (const H5S_t *)H5I_object_verify(space2_id, H5I_DATASPACE))) HGOTO_ERROR(H5E_ARGS, H5E_BADTYPE, FAIL, "not a dataspace") /* Check dataspaces for extent's equality */ diff --git a/src/H5SM.c b/src/H5SM.c index 5a656fb..8b5faf9 100755 --- a/src/H5SM.c +++ b/src/H5SM.c @@ -417,7 +417,7 @@ H5SM_create_index(H5F_t *f, H5SM_index_header_t *header, hid_t dxpl_id) H5HF_t *fheap = NULL; herr_t ret_value = SUCCEED; - FUNC_ENTER_NOAPI(H5SM_create_index, FAIL) + FUNC_ENTER_NOAPI_NOINIT(H5SM_create_index) HDassert(header); HDassert(header->index_addr == HADDR_UNDEF); @@ -506,7 +506,7 @@ H5SM_delete_index(H5F_t *f, H5SM_index_header_t *header, hid_t dxpl_id, hbool_t hsize_t list_size; /* Size of list on disk */ herr_t ret_value = SUCCEED; - FUNC_ENTER_NOAPI(H5SM_delete_index, FAIL) + FUNC_ENTER_NOAPI_NOINIT(H5SM_delete_index) /* Determine whether index is a list or a B-tree. */ if(header->index_type == H5SM_LIST) { @@ -570,7 +570,7 @@ H5SM_create_list(H5F_t *f, H5SM_index_header_t * header, hid_t dxpl_id) haddr_t addr = HADDR_UNDEF; /* Address of the list on disk */ haddr_t ret_value; - FUNC_ENTER_NOAPI(H5SM_create_list, HADDR_UNDEF) + FUNC_ENTER_NOAPI_NOINIT(H5SM_create_list) HDassert(f); HDassert(header); @@ -726,7 +726,7 @@ H5SM_convert_btree_to_list(H5F_t * f, H5SM_index_header_t * header, hid_t dxpl_i haddr_t btree_addr; herr_t ret_value = SUCCEED; - FUNC_ENTER_NOAPI(H5SM_convert_btree_to_list, FAIL) + FUNC_ENTER_NOAPI_NOINIT(H5SM_convert_btree_to_list) /* Remember the address of the old B-tree, but change the header over to be * a list.. @@ -829,7 +829,7 @@ H5SM_try_share(H5F_t *f, hid_t dxpl_id, unsigned type_id, void *mesg) if(H5SM_create_index(f, &(table->indexes[index_num]), dxpl_id) < 0) HGOTO_ERROR(H5E_SOHM, H5E_CANTINIT, FAIL, "unable to create SOHM index") cache_flags |= H5AC__DIRTIED_FLAG; - } + } /* end if */ /* Write the message as a shared message */ if(H5SM_write_mesg(f, dxpl_id, &(table->indexes[index_num]), type_id, mesg, &cache_flags) < 0) @@ -867,12 +867,9 @@ static herr_t H5SM_write_mesg(H5F_t *f, hid_t dxpl_id, H5SM_index_header_t *header, unsigned type_id, void *mesg, unsigned *cache_flags_ptr) { - H5O_shared_t *sh_mesg = (H5O_shared_t *)mesg; /* Pointer to message's shared message info */ - unsigned old_sh_mesg_flags; /* Message's current shared message flags */ H5SM_list_t *list = NULL; /* List index */ H5SM_mesg_key_t key; /* Key used to search the index */ H5O_shared_t shared; /* Shared H5O message */ - hsize_t list_pos; /* Position in a list index */ hbool_t found = FALSE; /* Was the message in the index? */ H5HF_t *fheap = NULL; /* Fractal heap handle */ size_t buf_size; /* Size of the encoded message */ @@ -880,31 +877,20 @@ H5SM_write_mesg(H5F_t *f, hid_t dxpl_id, H5SM_index_header_t *header, size_t empty_pos = UFAIL; /* Empty entry in list */ herr_t ret_value = SUCCEED; - FUNC_ENTER_NOAPI(H5SM_write_mesg, FAIL) + FUNC_ENTER_NOAPI_NOINIT(H5SM_write_mesg) HDassert(cache_flags_ptr); HDassert(header); HDassert(header->index_type != H5SM_BADTYPE); - /* Preserve message's shared message info while getting the - * "real" encoded size & buffer (*ick* - QAK) - * (XXX: Harmless but ugly for message classes that aren't using shared - * message method interface yet - QAK) - */ - old_sh_mesg_flags = sh_mesg->flags; - sh_mesg->flags = 0; - /* Encode the message to be written */ - if((buf_size = H5O_msg_raw_size(f, type_id, mesg)) <= 0) + if((buf_size = H5O_msg_raw_size(f, type_id, TRUE, mesg)) <= 0) HGOTO_ERROR(H5E_OHDR, H5E_BADSIZE, FAIL, "can't find message size") if(NULL == (encoding_buf = H5MM_calloc(buf_size))) HGOTO_ERROR(H5E_RESOURCE, H5E_NOSPACE, FAIL, "can't allocate buffer for encoding") - if(H5O_msg_encode(f, type_id, (unsigned char *)encoding_buf, mesg) < 0) + if(H5O_msg_encode(f, type_id, TRUE, (unsigned char *)encoding_buf, mesg) < 0) HGOTO_ERROR(H5E_OHDR, H5E_CANTENCODE, FAIL, "can't encode message to be shared") - /* Restore message's shared message info (*ick* - QAK) */ - sh_mesg->flags = old_sh_mesg_flags; - /* Open the fractal heap for this index */ if(NULL == (fheap = H5HF_open(f, dxpl_id, header->heap_addr))) HGOTO_ERROR(H5E_HEAP, H5E_CANTOPENOBJ, FAIL, "unable to open fractal heap") @@ -924,6 +910,8 @@ H5SM_write_mesg(H5F_t *f, hid_t dxpl_id, H5SM_index_header_t *header, */ if(header->index_type == H5SM_LIST) { + size_t list_pos; /* Position in a list index */ + /* The index is a list; get it from the cache */ if(NULL == (list = (H5SM_list_t *)H5AC_protect(f, dxpl_id, H5AC_SOHM_LIST, header->index_addr, NULL, header, H5AC_WRITE))) HGOTO_ERROR(H5E_CACHE, H5E_CANTPROTECT, FAIL, "unable to load SOHM index") @@ -1083,7 +1071,7 @@ H5SM_try_delete(H5F_t *f, hid_t dxpl_id, unsigned type_id, * master table needs to be unprotected when we do this. */ if(mesg_buf) { - if(NULL == (native_mesg = H5O_msg_decode(f, dxpl_id, type_id, mesg_buf))) + if(NULL == (native_mesg = H5O_msg_decode(f, dxpl_id, type_id, (const unsigned char *)mesg_buf))) HGOTO_ERROR(H5E_OHDR, H5E_CANTDECODE, FAIL, "can't decode shared message.") if(H5O_msg_delete(f, dxpl_id, type_id, native_mesg) < 0) @@ -1215,12 +1203,12 @@ H5SM_delete_from_index(H5F_t *f, hid_t dxpl_id, H5SM_index_header_t *header, H5SM_list_t *list = NULL; H5SM_mesg_key_t key; H5SM_sohm_t message; /* Deleted message returned from index */ - size_t list_pos = UFAIL; /* Position of the message in the list */ + H5SM_sohm_t *message_ptr; /* Pointer to deleted message returned from index */ H5HF_t *fheap = NULL; /* Fractal heap that contains the message */ H5SM_fh_ud_gh_t udata; /* User data for fractal heap 'op' callback */ herr_t ret_value = SUCCEED; - FUNC_ENTER_NOAPI(H5SM_delete_from_index, FAIL) + FUNC_ENTER_NOAPI_NOINIT(H5SM_delete_from_index) HDassert(header); HDassert(mesg); @@ -1252,6 +1240,8 @@ H5SM_delete_from_index(H5F_t *f, hid_t dxpl_id, H5SM_index_header_t *header, /* Try to find the message in the index */ if(header->index_type == H5SM_LIST) { + size_t list_pos; /* Position of the message in the list */ + /* If the index is stored as a list, get it from the cache */ if(NULL == (list = (H5SM_list_t *)H5AC_protect(f, dxpl_id, H5AC_SOHM_LIST, header->index_addr, NULL, header, H5AC_WRITE))) HGOTO_ERROR(H5E_SOHM, H5E_CANTPROTECT, FAIL, "unable to load SOHM index") @@ -1262,9 +1252,9 @@ H5SM_delete_from_index(H5F_t *f, hid_t dxpl_id, H5SM_index_header_t *header, --(list->messages[list_pos].ref_count); - /* Copy the message */ - message = list->messages[list_pos]; - } + /* Point to the message */ + message_ptr = &list->messages[list_pos]; + } /* end if */ else /* Index is a B-tree */ { HDassert(header->index_type == H5SM_BTREE); @@ -1273,10 +1263,13 @@ H5SM_delete_from_index(H5F_t *f, hid_t dxpl_id, H5SM_index_header_t *header, * If it succeeds, a copy of the modified message will be returned. */ if(H5B2_modify(f, dxpl_id, H5SM_INDEX, header->index_addr, &key, H5SM_decr_ref, &message) <0) HGOTO_ERROR(H5E_SOHM, H5E_NOTFOUND, FAIL, "message not in index") - } + + /* Point to the message */ + message_ptr = &message; + } /* end else */ /* If the ref count is zero, delete the message from the index */ - if(message.ref_count <= 0) + if(message_ptr->ref_count <= 0) { size_t buf_size; @@ -1285,7 +1278,7 @@ H5SM_delete_from_index(H5F_t *f, hid_t dxpl_id, H5SM_index_header_t *header, * shared datatype). */ /* Get the size of the message in the heap */ - if(H5HF_get_obj_len(fheap, dxpl_id, &(message.fheap_id), &buf_size) < 0) + if(H5HF_get_obj_len(fheap, dxpl_id, &(message_ptr->fheap_id), &buf_size) < 0) HGOTO_ERROR(H5E_OHDR, H5E_CANTGET, FAIL, "can't get message size from fractal heap.") /* Allocate a buffer to hold the message */ @@ -1294,7 +1287,7 @@ H5SM_delete_from_index(H5F_t *f, hid_t dxpl_id, H5SM_index_header_t *header, /* Remove the message from the index */ if(header->index_type == H5SM_LIST) - list->messages[list_pos].ref_count = 0; + message_ptr->ref_count = 0; else { if(H5B2_remove(f, dxpl_id, H5SM_INDEX, header->index_addr, &key, NULL, NULL) < 0) @@ -1309,11 +1302,11 @@ H5SM_delete_from_index(H5F_t *f, hid_t dxpl_id, H5SM_index_header_t *header, /* Retrieve the message from the heap so we can return it (to free any * other messages it may reference) */ - if(H5HF_read(fheap, dxpl_id, &(message.fheap_id), *encoded_mesg) < 0) + if(H5HF_read(fheap, dxpl_id, &(message_ptr->fheap_id), *encoded_mesg) < 0) HGOTO_ERROR(H5E_OHDR, H5E_CANTLOAD, FAIL, "can't read message from fractal heap.") /* Remove the message from the heap */ - if(H5HF_remove(fheap, dxpl_id, &(message.fheap_id)) < 0) + if(H5HF_remove(fheap, dxpl_id, &(message_ptr->fheap_id)) < 0) HGOTO_ERROR(H5E_SOHM, H5E_CANTREMOVE, FAIL, "unable to remove message from heap") diff --git a/src/H5SMcache.c b/src/H5SMcache.c index a1f5ac5..2caf83a 100644 --- a/src/H5SMcache.c +++ b/src/H5SMcache.c @@ -104,7 +104,7 @@ H5SM_flush_table(H5F_t *f, hid_t dxpl_id, hbool_t destroy, haddr_t addr, H5SM_ma uint8_t *buf=NULL; /* Temporary buffer */ herr_t ret_value=SUCCEED; - FUNC_ENTER_NOAPI(H5SM_flush_table, FAIL) + FUNC_ENTER_NOAPI_NOINIT(H5SM_flush_table) /* check arguments */ HDassert(f); @@ -170,7 +170,7 @@ H5SM_flush_table(H5F_t *f, hid_t dxpl_id, hbool_t destroy, haddr_t addr, H5SM_ma done: /* Free buffer if allocated */ if(buf) - H5FL_BLK_FREE(shared_mesg_cache, buf); + buf = H5FL_BLK_FREE(shared_mesg_cache, buf); FUNC_LEAVE_NOAPI(ret_value) } /* end H5SM_flush_table */ @@ -202,7 +202,7 @@ H5SM_load_table(H5F_t *f, hid_t dxpl_id, haddr_t addr, const void UNUSED *udata1 uint8_t x; /* Counter variable for index headers */ H5SM_master_table_t *ret_value; - FUNC_ENTER_NOAPI(H5SM_load_table, NULL) + FUNC_ENTER_NOAPI_NOINIT(H5SM_load_table) /* Verify that we're reading version 0 of the table; this is the only * version defined so far. @@ -210,7 +210,7 @@ H5SM_load_table(H5F_t *f, hid_t dxpl_id, haddr_t addr, const void UNUSED *udata1 HDassert(f->shared->sohm_vers == HDF5_SHAREDHEADER_VERSION); /* Allocate space for the master table in memory */ - if(NULL == (table = H5MM_calloc(sizeof(H5SM_master_table_t)))) + if(NULL == (table = (H5SM_master_table_t *)H5MM_calloc(sizeof(H5SM_master_table_t)))) HGOTO_ERROR(H5E_RESOURCE, H5E_NOSPACE, NULL, "memory allocation failed") /* Read number of indexes and version from file superblock */ @@ -246,7 +246,7 @@ H5SM_load_table(H5F_t *f, hid_t dxpl_id, haddr_t addr, const void UNUSED *udata1 HDassert((size_t)(p - buf) == H5SM_TABLE_SIZE(f) - H5SM_SIZEOF_CHECKSUM); /* Allocate space for the index headers in memory*/ - if(NULL == (table->indexes = H5FL_ARR_MALLOC(H5SM_index_header_t, (size_t)table->num_indexes))) + if(NULL == (table->indexes = (H5SM_index_header_t *)H5FL_ARR_MALLOC(H5SM_index_header_t, (size_t)table->num_indexes))) HGOTO_ERROR(H5E_RESOURCE, H5E_NOSPACE, NULL, "memory allocation failed for SOHM indexes") /* Read in the index headers */ @@ -282,7 +282,7 @@ H5SM_load_table(H5F_t *f, hid_t dxpl_id, haddr_t addr, const void UNUSED *udata1 done: /* Free buffer if allocated */ if(buf) - H5FL_BLK_FREE(shared_mesg_cache, buf); + buf = H5FL_BLK_FREE(shared_mesg_cache, buf); FUNC_LEAVE_NOAPI(ret_value) } /* end H5SM_load_table */ @@ -341,7 +341,7 @@ done: static herr_t H5SM_dest_table(H5F_t UNUSED *f, H5SM_master_table_t* table) { - FUNC_ENTER_NOAPI_NOFUNC(H5SM_dest_table) + FUNC_ENTER_NOAPI_NOINIT_NOFUNC(H5SM_dest_table) HDassert(table); HDassert(table->indexes); @@ -402,7 +402,7 @@ H5SM_flush_list(H5F_t *f, hid_t dxpl_id, hbool_t destroy, haddr_t addr, H5SM_lis uint8_t *buf=NULL; /* Temporary buffer */ herr_t ret_value = SUCCEED; - FUNC_ENTER_NOAPI(H5SM_flush_list, FAIL) + FUNC_ENTER_NOAPI_NOINIT(H5SM_flush_list) /* check arguments */ HDassert(f); @@ -463,7 +463,7 @@ H5SM_flush_list(H5F_t *f, hid_t dxpl_id, hbool_t destroy, haddr_t addr, H5SM_lis done: /* Free buffer if allocated */ if(buf) - H5FL_BLK_FREE(shared_mesg_cache, buf); + buf = H5FL_BLK_FREE(shared_mesg_cache, buf); FUNC_LEAVE_NOAPI(ret_value) } /* end H5SM_flush_list */ @@ -495,7 +495,7 @@ H5SM_load_list(H5F_t *f, hid_t dxpl_id, haddr_t addr, const void UNUSED *udata1, hsize_t x; /* Counter variable for messages in list */ H5SM_list_t *ret_value=NULL; - FUNC_ENTER_NOAPI(H5SM_load_list, NULL) + FUNC_ENTER_NOAPI_NOINIT(H5SM_load_list) HDassert(header); @@ -505,7 +505,7 @@ H5SM_load_list(H5F_t *f, hid_t dxpl_id, haddr_t addr, const void UNUSED *udata1, HDmemset(&list->cache_info, 0, sizeof(H5AC_info_t)); /* Allocate list in memory as an array*/ - if((list->messages = H5FL_ARR_MALLOC(H5SM_sohm_t, header->list_max)) == NULL) + if((list->messages = (H5SM_sohm_t *)H5FL_ARR_MALLOC(H5SM_sohm_t, header->list_max)) == NULL) HGOTO_ERROR(H5E_RESOURCE, H5E_NOSPACE, NULL, "file allocation failed for SOHM list") list->header = header; @@ -528,12 +528,12 @@ H5SM_load_list(H5F_t *f, hid_t dxpl_id, haddr_t addr, const void UNUSED *udata1, p += H5SM_LIST_SIZEOF_MAGIC; /* Read messages into the list array */ - for(x=0; xnum_messages; x++) + for(x = 0; x < header->num_messages; x++) { if(H5SM_message_decode(f, p, &(list->messages[x])) < 0) HGOTO_ERROR(H5E_SOHM, H5E_CANTLOAD, NULL, "can't decode shared message"); p += H5SM_SOHM_ENTRY_SIZE(f); - } + } /* end for */ /* Read in checksum */ UINT32DECODE(p, stored_chksum); @@ -551,25 +551,24 @@ H5SM_load_list(H5F_t *f, hid_t dxpl_id, haddr_t addr, const void UNUSED *udata1, /* Initialize the rest of the array */ - for(x=header->num_messages; xlist_max; x++) - { + for(x = header->num_messages; x < header->list_max; x++) list->messages[x].ref_count = 0; - } ret_value = list; + done: /* Free buffer if allocated */ if(buf) - H5FL_BLK_FREE(shared_mesg_cache, buf); + buf = H5FL_BLK_FREE(shared_mesg_cache, buf); if(ret_value == NULL) { if(list) { - if(list->messages) { + if(list->messages) H5FL_ARR_FREE(H5SM_sohm_t, list->messages); - } H5FL_FREE(H5SM_list_t, list); - } - } + } /* end if */ + } /* end if */ + FUNC_LEAVE_NOAPI(ret_value) } /* end H5SM_load_list */ @@ -625,7 +624,7 @@ done: static herr_t H5SM_dest_list(H5F_t UNUSED *f, H5SM_list_t* list) { - FUNC_ENTER_NOAPI_NOFUNC(H5SM_dest_list) + FUNC_ENTER_NOAPI_NOINIT_NOFUNC(H5SM_dest_list) HDassert(list); HDassert(list->messages); diff --git a/src/H5Sprivate.h b/src/H5Sprivate.h index 7538cbd..8e1f2e7 100644 --- a/src/H5Sprivate.h +++ b/src/H5Sprivate.h @@ -206,7 +206,6 @@ H5_DLL herr_t H5S_write(struct H5O_loc_t *loc, const H5S_t *space, hbool_t update_time, hid_t dxpl_id); H5_DLL herr_t H5S_append(H5F_t *f, hid_t dxpl_id, struct H5O_t *oh, const H5S_t *ds, unsigned * oh_flags_ptr); -H5_DLL size_t H5S_raw_size(const H5F_t *f, const H5S_t *space); H5_DLL H5S_t *H5S_read(const struct H5O_loc_t *loc, hid_t dxpl_id); H5_DLL int H5S_extend(H5S_t *space, const hsize_t *size); H5_DLL int H5S_set_extent(H5S_t *space, const hsize_t *size); diff --git a/src/H5T.c b/src/H5T.c index e9ba093..b3395de 100644 --- a/src/H5T.c +++ b/src/H5T.c @@ -463,13 +463,13 @@ static H5T_t *H5T_decode(const unsigned char *buf); #define H5T_INIT_TYPE_COPY_CREATE(BASE) { \ /* Base off of existing datatype */ \ if(NULL==(dt = H5T_copy(BASE,H5T_COPY_TRANSIENT))) \ - HGOTO_ERROR (H5E_RESOURCE, H5E_CANTCOPY, FAIL, "duplicating base type failed") \ + HGOTO_ERROR(H5E_RESOURCE, H5E_CANTCOPY, FAIL, "duplicating base type failed") \ } #define H5T_INIT_TYPE_ALLOC_CREATE(BASE) { \ /* Allocate new datatype info */ \ if (NULL==(dt = H5T_alloc())) \ - HGOTO_ERROR (H5E_RESOURCE, H5E_NOSPACE, FAIL, "memory allocation failed") \ + HGOTO_ERROR(H5E_RESOURCE, H5E_NOSPACE, FAIL, "memory allocation failed") \ } @@ -550,12 +550,12 @@ H5T_init_inf(void) /* Get the float datatype */ if (NULL==(dst_p=H5I_object(H5T_NATIVE_FLOAT_g))) - HGOTO_ERROR (H5E_ARGS, H5E_BADTYPE, FAIL, "not a datatype"); + HGOTO_ERROR(H5E_ARGS, H5E_BADTYPE, FAIL, "not a datatype"); dst = &dst_p->shared->u.atomic; /* Check that we can re-order the bytes correctly */ if (H5T_ORDER_LE!=H5T_native_order_g && H5T_ORDER_BE!=H5T_native_order_g) - HGOTO_ERROR (H5E_DATATYPE, H5E_UNSUPPORTED, FAIL, "unsupported byte order"); + HGOTO_ERROR(H5E_DATATYPE, H5E_UNSUPPORTED, FAIL, "unsupported byte order"); /* +Inf */ d=(uint8_t *)&H5T_NATIVE_FLOAT_POS_INF_g; @@ -591,12 +591,12 @@ H5T_init_inf(void) /* Get the double datatype */ if (NULL==(dst_p=H5I_object(H5T_NATIVE_DOUBLE_g))) - HGOTO_ERROR (H5E_ARGS, H5E_BADTYPE, FAIL, "not a datatype"); + HGOTO_ERROR(H5E_ARGS, H5E_BADTYPE, FAIL, "not a datatype"); dst = &dst_p->shared->u.atomic; /* Check that we can re-order the bytes correctly */ if (H5T_ORDER_LE!=H5T_native_order_g && H5T_ORDER_BE!=H5T_native_order_g) - HGOTO_ERROR (H5E_DATATYPE, H5E_UNSUPPORTED, FAIL, "unsupported byte order"); + HGOTO_ERROR(H5E_DATATYPE, H5E_UNSUPPORTED, FAIL, "unsupported byte order"); /* +Inf */ d=(uint8_t *)&H5T_NATIVE_DOUBLE_POS_INF_g; @@ -1644,19 +1644,19 @@ H5Tcopy(hid_t type_id) case H5I_DATATYPE: /* The argument is a data type handle */ if (NULL==(dt=H5I_object (type_id))) - HGOTO_ERROR (H5E_ARGS, H5E_BADTYPE, FAIL, "not a data type"); + HGOTO_ERROR(H5E_ARGS, H5E_BADTYPE, FAIL, "not a data type"); break; case H5I_DATASET: /* The argument is a dataset handle */ if (NULL==(dset=H5I_object (type_id))) - HGOTO_ERROR (H5E_ARGS, H5E_BADTYPE, FAIL, "not a dataset"); + HGOTO_ERROR(H5E_ARGS, H5E_BADTYPE, FAIL, "not a dataset"); if (NULL==(dt=H5D_typeof (dset))) - HGOTO_ERROR (H5E_DATASET, H5E_CANTINIT, FAIL, "unable to get the dataset data type"); + HGOTO_ERROR(H5E_DATASET, H5E_CANTINIT, FAIL, "unable to get the dataset data type"); break; default: - HGOTO_ERROR (H5E_ARGS, H5E_BADTYPE, FAIL, "not a data type or dataset"); + HGOTO_ERROR(H5E_ARGS, H5E_BADTYPE, FAIL, "not a data type or dataset"); } /* end switch */ /* Copy */ @@ -1792,10 +1792,10 @@ H5Tlock(hid_t type_id) if (NULL == (dt = H5I_object_verify(type_id,H5I_DATATYPE))) HGOTO_ERROR(H5E_ARGS, H5E_BADTYPE, FAIL, "not a data type"); if (H5T_STATE_NAMED==dt->shared->state || H5T_STATE_OPEN==dt->shared->state) - HGOTO_ERROR (H5E_ARGS, H5E_BADVALUE, FAIL, "unable to lock named data type"); + HGOTO_ERROR(H5E_ARGS, H5E_BADVALUE, FAIL, "unable to lock named data type"); if (H5T_lock (dt, TRUE)<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"); done: FUNC_LEAVE_API(ret_value); @@ -2413,7 +2413,7 @@ H5Tregister(H5T_pers_t pers, const char *name, hid_t src_id, hid_t dst_id, if (H5T_PERS_HARD!=pers && H5T_PERS_SOFT!=pers) HGOTO_ERROR(H5E_ARGS, H5E_BADVALUE, FAIL, "invalid function persistence"); if (!name || !*name) - HGOTO_ERROR (H5E_ARGS, H5E_BADVALUE, FAIL, "conversion must have a name for debugging"); + HGOTO_ERROR(H5E_ARGS, H5E_BADVALUE, FAIL, "conversion must have a name for debugging"); if (NULL==(src=H5I_object_verify(src_id,H5I_DATATYPE))) HGOTO_ERROR(H5E_ARGS, H5E_BADTYPE, FAIL, "not a data type"); if (NULL==(dst=H5I_object_verify(dst_id,H5I_DATATYPE))) @@ -2459,7 +2459,7 @@ H5T_unregister(H5T_pers_t pers, const char *name, H5T_t *src, H5T_t *dst, int i; /*counter */ herr_t ret_value=SUCCEED; /* Return value */ - FUNC_ENTER_NOAPI(H5T_unregister, FAIL); + FUNC_ENTER_NOAPI_NOINIT(H5T_unregister); /* Remove matching entries from the soft list */ if (H5T_PERS_DONTCARE==pers || H5T_PERS_SOFT==pers) { @@ -2607,7 +2607,7 @@ H5Tfind(hid_t src_id, hid_t dst_id, H5T_cdata_t **pcdata) NULL == (dst = H5I_object_verify(dst_id,H5I_DATATYPE))) HGOTO_ERROR(H5E_ARGS, H5E_BADTYPE, NULL, "not a data type"); if (!pcdata) - HGOTO_ERROR (H5E_ARGS, H5E_BADVALUE, NULL, "no address to receive cdata pointer"); + HGOTO_ERROR(H5E_ARGS, H5E_BADVALUE, NULL, "no address to receive cdata pointer"); /* Find it */ if (NULL==(path=H5T_path_find(src, dst, NULL, NULL, H5AC_ind_dxpl_id, FALSE))) @@ -2716,10 +2716,10 @@ H5Tconvert(hid_t src_id, hid_t dst_id, size_t nelmts, void *buf, /* Find the conversion function */ if (NULL==(tpath=H5T_path_find(src, dst, NULL, NULL, dxpl_id, FALSE))) - HGOTO_ERROR (H5E_DATATYPE, H5E_CANTINIT, FAIL, "unable to convert between src and dst data types"); + HGOTO_ERROR(H5E_DATATYPE, H5E_CANTINIT, FAIL, "unable to convert between src and dst data types"); if (H5T_convert(tpath, src_id, dst_id, nelmts, (size_t)0, (size_t)0, buf, background, dxpl_id)<0) - HGOTO_ERROR (H5E_DATATYPE, H5E_CANTINIT, FAIL, "data type conversion failed"); + HGOTO_ERROR(H5E_DATATYPE, H5E_CANTINIT, FAIL, "data type conversion failed"); done: FUNC_LEAVE_API(ret_value); @@ -2790,18 +2790,20 @@ H5Tdecode(const void *buf) H5T_t *dt; hid_t ret_value; - FUNC_ENTER_API (H5Tdecode, FAIL); + FUNC_ENTER_API(H5Tdecode, FAIL) H5TRACE1("i", "x", buf); + /* Check args */ if(buf == NULL) HGOTO_ERROR(H5E_ARGS, H5E_BADVALUE, FAIL, "empty buffer") + /* Create datatype by decoding buffer */ if((dt = H5T_decode(buf)) == NULL) HGOTO_ERROR(H5E_DATATYPE, H5E_CANTDECODE, FAIL, "can't decode object") /* Register the type and return the ID */ - if((ret_value = H5I_register (H5I_DATATYPE, dt)) < 0) - HGOTO_ERROR (H5E_DATATYPE, H5E_CANTREGISTER, FAIL, "unable to register data type") + if((ret_value = H5I_register(H5I_DATATYPE, dt)) < 0) + HGOTO_ERROR(H5E_DATATYPE, H5E_CANTREGISTER, FAIL, "unable to register data type") done: FUNC_LEAVE_API(ret_value) @@ -2836,14 +2838,14 @@ H5T_encode(H5T_t *obj, unsigned char *buf, size_t *nalloc) H5F_t *f = NULL; /* Fake file structure*/ herr_t ret_value = SUCCEED; - FUNC_ENTER_NOAPI(H5T_encode, FAIL) + FUNC_ENTER_NOAPI_NOINIT(H5T_encode) /* Allocate "fake" file structure */ if(NULL == (f = H5F_fake_alloc((size_t)0))) HGOTO_ERROR(H5E_DATATYPE, H5E_CANTALLOC, FAIL, "can't allocate fake file struct") /* Find out the size of buffer needed */ - if((buf_size = H5O_msg_raw_size(f, H5O_DTYPE_ID, obj)) == 0) + if((buf_size = H5O_msg_raw_size(f, H5O_DTYPE_ID, TRUE, obj)) == 0) HGOTO_ERROR(H5E_DATATYPE, H5E_BADSIZE, FAIL, "can't find datatype size") /* Don't encode if buffer size isn't big enough or buffer is empty */ @@ -2857,7 +2859,7 @@ H5T_encode(H5T_t *obj, unsigned char *buf, size_t *nalloc) *buf++ = H5T_ENCODE_VERSION; /* Encode into user's buffer */ - if(H5O_msg_encode(f, H5O_DTYPE_ID, buf, obj) < 0) + if(H5O_msg_encode(f, H5O_DTYPE_ID, TRUE, buf, obj) < 0) HGOTO_ERROR(H5E_DATATYPE, H5E_CANTENCODE, FAIL, "can't encode object") } /* end else */ @@ -2892,7 +2894,7 @@ H5T_decode(const unsigned char *buf) H5F_t *f = NULL; /* Fake file structure*/ H5T_t *ret_value; - FUNC_ENTER_NOAPI(H5T_decode, NULL) + FUNC_ENTER_NOAPI_NOINIT(H5T_decode) /* Allocate "fake" file structure */ if(NULL == (f = H5F_fake_alloc((size_t)0))) @@ -2957,7 +2959,7 @@ H5T_create(H5T_class_t type, size_t size) case H5T_OPAQUE: case H5T_COMPOUND: if(NULL == (dt = H5T_alloc())) - HGOTO_ERROR (H5E_RESOURCE, H5E_NOSPACE, NULL, "memory allocation failed"); + HGOTO_ERROR(H5E_RESOURCE, H5E_NOSPACE, NULL, "memory allocation failed"); dt->shared->type = type; if(type==H5T_COMPOUND) @@ -3068,9 +3070,9 @@ H5T_copy(const H5T_t *old_dt, H5T_copy_t method) /* Allocate space */ if (NULL==(new_dt = H5FL_MALLOC(H5T_t))) - HGOTO_ERROR (H5E_RESOURCE, H5E_NOSPACE, NULL, "memory allocation failed"); + HGOTO_ERROR(H5E_RESOURCE, H5E_NOSPACE, NULL, "memory allocation failed"); if (NULL==(new_dt->shared = H5FL_MALLOC(H5T_shared_t))) - HGOTO_ERROR (H5E_RESOURCE, H5E_NOSPACE, NULL, "memory allocation failed"); + HGOTO_ERROR(H5E_RESOURCE, H5E_NOSPACE, NULL, "memory allocation failed"); /* Copy shared information (entry information is copied last) */ *(new_dt->shared) = *(old_dt->shared); @@ -3113,7 +3115,7 @@ H5T_copy(const H5T_t *old_dt, H5T_copy_t method) /* Open named datatype again */ if(H5O_open(&(old_dt->sh_loc.u.oloc)) < 0) - HGOTO_ERROR (H5E_DATATYPE, H5E_CANTOPENOBJ, NULL, "unable to reopen named data type"); + HGOTO_ERROR(H5E_DATATYPE, H5E_CANTOPENOBJ, NULL, "unable to reopen named data type"); /* Insert opened named datatype into opened object list for the file */ if(H5FO_insert(old_dt->sh_loc.u.oloc.file, old_dt->sh_loc.u.oloc.addr, new_dt->shared, FALSE)<0) @@ -3164,7 +3166,7 @@ H5T_copy(const H5T_t *old_dt, H5T_copy_t method) new_dt->shared->u.compnd.memb = H5MM_malloc(new_dt->shared->u.compnd.nalloc * sizeof(H5T_cmemb_t)); if (NULL==new_dt->shared->u.compnd.memb) - HGOTO_ERROR (H5E_RESOURCE, H5E_NOSPACE, NULL, "memory allocation failed"); + HGOTO_ERROR(H5E_RESOURCE, H5E_NOSPACE, NULL, "memory allocation failed"); HDmemcpy(new_dt->shared->u.compnd.memb, old_dt->shared->u.compnd.memb, new_dt->shared->u.compnd.nmembs * sizeof(H5T_cmemb_t)); @@ -3834,7 +3836,7 @@ H5T_cmp(const H5T_t *dt1, const H5T_t *dt2, hbool_t superset) /* Build an index for each type so the names are sorted */ if (NULL==(idx1 = H5MM_malloc(dt1->shared->u.compnd.nmembs * sizeof(unsigned))) || NULL==(idx2 = H5MM_malloc(dt2->shared->u.compnd.nmembs * sizeof(unsigned)))) - HGOTO_ERROR (H5E_RESOURCE, H5E_NOSPACE, 0, "memory allocation failed"); + HGOTO_ERROR(H5E_RESOURCE, H5E_NOSPACE, 0, "memory allocation failed"); for (u=0; ushared->u.compnd.nmembs; u++) idx1[u] = idx2[u] = u; if(dt1->shared->u.enumer.nmembs > 1) { @@ -3912,7 +3914,7 @@ H5T_cmp(const H5T_t *dt1, const H5T_t *dt2, hbool_t superset) /* Build an index for each type so the names are sorted */ if (NULL==(idx1 = H5MM_malloc(dt1->shared->u.enumer.nmembs * sizeof(unsigned))) || NULL==(idx2 = H5MM_malloc(dt2->shared->u.enumer.nmembs * sizeof(unsigned)))) - HGOTO_ERROR (H5E_RESOURCE, H5E_NOSPACE, 0, "memory allocation failed"); + HGOTO_ERROR(H5E_RESOURCE, H5E_NOSPACE, 0, "memory allocation failed"); for (u=0; ushared->u.enumer.nmembs; u++) idx1[u] = u; if(dt1->shared->u.enumer.nmembs > 1) @@ -4431,7 +4433,7 @@ H5T_path_find(const H5T_t *src, const H5T_t *dst, const char *name, H5T_path_t **x = H5MM_realloc (H5T_g.path, na*sizeof(H5T_path_t*)); if (!x) - HGOTO_ERROR (H5E_RESOURCE, H5E_NOSPACE, NULL, "memory allocation failed"); + HGOTO_ERROR(H5E_RESOURCE, H5E_NOSPACE, NULL, "memory allocation failed"); H5T_g.apaths = (int)na; H5T_g.path = x; } @@ -4687,7 +4689,7 @@ H5T_nameof(H5T_t *dt) case H5T_STATE_TRANSIENT: case H5T_STATE_RDONLY: case H5T_STATE_IMMUTABLE: - HGOTO_ERROR (H5E_DATATYPE, H5E_CANTINIT, NULL, "not a named datatype") + HGOTO_ERROR(H5E_DATATYPE, H5E_CANTINIT, NULL, "not a named datatype") case H5T_STATE_NAMED: case H5T_STATE_OPEN: ret_value = &(dt->path); diff --git a/test/dtypes.c b/test/dtypes.c index a7be6e6..d44dfb0 100644 --- a/test/dtypes.c +++ b/test/dtypes.c @@ -4079,11 +4079,8 @@ test_encode(void) } /* end if */ /* Decode from the compound buffer and return an object handle */ - if((decoded_tid1=H5Tdecode(cmpd_buf))<0) { - H5_FAILED(); - printf("Can't decode compound type\n"); - goto error; - } /* end if */ + if((decoded_tid1 = H5Tdecode(cmpd_buf)) < 0) + FAIL_PUTS_ERROR("Can't decode compound type\n") /* Verify that the datatype was copied exactly */ if(H5Tequal(decoded_tid1, tid1)<=0) { @@ -4219,11 +4216,8 @@ test_encode(void) } /* end if */ /* Decode from the compound buffer and return an object handle */ - if((decoded_tid1=H5Tdecode(cmpd_buf))<0) { - H5_FAILED(); - printf("Can't decode compound type\n"); - goto error; - } /* end if */ + if((decoded_tid1 = H5Tdecode(cmpd_buf)) < 0) + FAIL_PUTS_ERROR("Can't decode compound type\n") /* Verify that the datatype was copied exactly */ if(H5Tequal(decoded_tid1, tid1)<=0) { diff --git a/test/getname.c b/test/getname.c index f367242..9cda380 100644 --- a/test/getname.c +++ b/test/getname.c @@ -1015,7 +1015,7 @@ test_main(hid_t file_id, hid_t fapl) if((type_id=H5Dget_type(dataset_id))<0) TEST_ERROR; /* Verify */ - if(check_name(type_id, "/g17/t", "") < 0) TEST_ERROR; + if(check_name(type_id, "/g17/t", "/g17/t") < 0) TEST_ERROR; /* Close */ H5Dclose( dataset_id ); diff --git a/test/tattr.c b/test/tattr.c index 31ffe2c..e4403c8 100644 --- a/test/tattr.c +++ b/test/tattr.c @@ -2918,11 +2918,11 @@ test_attr_shared_write(hid_t fcpl, hid_t fapl) /* Close file */ ret = H5Fclose(fid); CHECK(ret, FAIL, "H5Fclose"); - } /* end for */ - /* Check size of file */ - filesize = h5_get_file_size(FILENAME); - VERIFY(filesize, empty_filesize, "h5_get_file_size"); + /* Check size of file */ + filesize = h5_get_file_size(FILENAME); + VERIFY(filesize, empty_filesize, "h5_get_file_size"); + } /* end for */ /* Close dataspaces */ ret = H5Sclose(sid); @@ -3359,11 +3359,11 @@ test_attr_shared_rename(hid_t fcpl, hid_t fapl) /* Close file */ ret = H5Fclose(fid); CHECK(ret, FAIL, "H5Fclose"); - } /* end for */ - /* Check size of file */ - filesize = h5_get_file_size(FILENAME); - VERIFY(filesize, empty_filesize, "h5_get_file_size"); + /* Check size of file */ + filesize = h5_get_file_size(FILENAME); + VERIFY(filesize, empty_filesize, "h5_get_file_size"); + } /* end for */ /* Close dataspaces */ ret = H5Sclose(sid); @@ -3722,11 +3722,11 @@ test_attr_shared_delete(hid_t fcpl, hid_t fapl) /* Close file */ ret = H5Fclose(fid); CHECK(ret, FAIL, "H5Fclose"); - } /* end for */ - /* Check size of file */ - filesize = h5_get_file_size(FILENAME); - VERIFY(filesize, empty_filesize, "h5_get_file_size"); + /* Check size of file */ + filesize = h5_get_file_size(FILENAME); + VERIFY(filesize, empty_filesize, "h5_get_file_size"); + } /* end for */ /* Close dataspaces */ ret = H5Sclose(sid); @@ -4071,11 +4071,11 @@ test_attr_shared_unlink(hid_t fcpl, hid_t fapl) /* Close file */ ret = H5Fclose(fid); CHECK(ret, FAIL, "H5Fclose"); - } /* end for */ - /* Check size of file */ - filesize = h5_get_file_size(FILENAME); - VERIFY(filesize, empty_filesize, "h5_get_file_size"); + /* Check size of file */ + filesize = h5_get_file_size(FILENAME); + VERIFY(filesize, empty_filesize, "h5_get_file_size"); + } /* end for */ /* Close dataspaces */ ret = H5Sclose(sid); -- cgit v0.12