From 38e234b620595f3eac5ff68dd71d4b29cfd46b18 Mon Sep 17 00:00:00 2001 From: Dana Robinson <43805+derobins@users.noreply.github.com> Date: Thu, 27 Jul 2023 16:39:48 -0700 Subject: Convert H5F_addr calls to H5_addr (#3297) --- src/H5AC.c | 20 +++---- src/H5ACproxy_entry.c | 6 +- src/H5Adense.c | 46 +++++++-------- src/H5Aint.c | 6 +- src/H5B.c | 56 +++++++++--------- src/H5B2.c | 10 ++-- src/H5B2cache.c | 8 +-- src/H5B2dbg.c | 16 +++--- src/H5B2hdr.c | 8 +-- src/H5B2int.c | 2 +- src/H5B2internal.c | 20 +++---- src/H5B2leaf.c | 16 +++--- src/H5Bcache.c | 12 ++-- src/H5Bdbg.c | 12 ++-- src/H5C.c | 46 +++++++-------- src/H5Cdbg.c | 8 +-- src/H5Cimage.c | 32 +++++------ src/H5Cmpio.c | 4 +- src/H5Cpkg.h | 14 ++--- src/H5Cquery.c | 4 +- src/H5Ctag.c | 2 +- src/H5Dbtree.c | 32 +++++------ src/H5Dbtree2.c | 42 +++++++------- src/H5Dchunk.c | 118 +++++++++++++++++++------------------- src/H5Dcontig.c | 4 +- src/H5Dearray.c | 48 ++++++++-------- src/H5Defl.c | 6 +- src/H5Dfarray.c | 48 ++++++++-------- src/H5Dint.c | 12 ++-- src/H5Dmpio.c | 38 ++++++------ src/H5Dnone.c | 14 ++--- src/H5Doh.c | 2 +- src/H5Dsingle.c | 20 +++---- src/H5EA.c | 22 +++---- src/H5EAcache.c | 46 +++++++-------- src/H5EAdbg.c | 24 ++++---- src/H5EAdblkpage.c | 2 +- src/H5EAdblock.c | 8 +-- src/H5EAhdr.c | 8 +-- src/H5EAiblock.c | 10 ++-- src/H5EAsblock.c | 10 ++-- src/H5FA.c | 14 ++--- src/H5FAcache.c | 16 +++--- src/H5FAdbg.c | 10 ++-- src/H5FAdblkpage.c | 2 +- src/H5FAdblock.c | 8 +-- src/H5FAhdr.c | 8 +-- src/H5FD.c | 4 +- src/H5FDcore.c | 2 +- src/H5FDint.c | 20 +++---- src/H5FDlog.c | 10 ++-- src/H5FDmpio.c | 2 +- src/H5FDsec2.c | 6 +- src/H5FDspace.c | 14 ++--- src/H5FDsplitter.c | 2 +- src/H5FDsubfiling/H5FDioc.c | 4 +- src/H5FDsubfiling/H5FDsubfiling.c | 6 +- src/H5FO.c | 16 +++--- src/H5FS.c | 34 +++++------ src/H5FScache.c | 46 +++++++-------- src/H5FSdbg.c | 8 +-- src/H5FSsection.c | 32 +++++------ src/H5Faccum.c | 54 ++++++++--------- src/H5Fint.c | 36 ++++++------ src/H5Fio.c | 16 +++--- src/H5Fmount.c | 8 +-- src/H5Fprivate.h | 41 ++----------- src/H5Fquery.c | 2 +- src/H5Fspace.c | 4 +- src/H5Fsuper.c | 38 ++++++------ src/H5Fsuper_cache.c | 38 ++++++------ src/H5Gdense.c | 34 +++++------ src/H5Gent.c | 14 ++--- src/H5Gnode.c | 28 ++++----- src/H5Gobj.c | 20 +++---- src/H5Goh.c | 8 +-- src/H5Gstab.c | 4 +- src/H5Gtest.c | 18 +++--- src/H5Gtraverse.c | 2 +- src/H5HF.c | 4 +- src/H5HFbtree2.c | 16 +++--- src/H5HFcache.c | 84 +++++++++++++-------------- src/H5HFdbg.c | 12 ++-- src/H5HFdblock.c | 10 ++-- src/H5HFhdr.c | 16 +++--- src/H5HFhuge.c | 34 +++++------ src/H5HFiblock.c | 26 ++++----- src/H5HFman.c | 4 +- src/H5HFsection.c | 44 +++++++------- src/H5HFspace.c | 4 +- src/H5HFstat.c | 6 +- src/H5HG.c | 14 ++--- src/H5HGdbg.c | 2 +- src/H5HL.c | 10 ++-- src/H5HLcache.c | 14 ++--- src/H5HLdbg.c | 2 +- src/H5HLdblk.c | 6 +- src/H5Lint.c | 2 +- src/H5MF.c | 84 +++++++++++++-------------- src/H5MFaggr.c | 40 ++++++------- src/H5MFdbg.c | 2 +- src/H5MFpkg.h | 2 +- src/H5MFsection.c | 24 ++++---- src/H5Oainfo.c | 20 +++---- src/H5Oalloc.c | 4 +- src/H5Oattribute.c | 28 ++++----- src/H5Ocache.c | 2 +- src/H5Ocache_image.c | 8 +-- src/H5Ocont.c | 6 +- src/H5Ocopy.c | 8 +-- src/H5Ocopy_ref.c | 12 ++-- src/H5Odbg.c | 10 ++-- src/H5Oefl.c | 8 +-- src/H5Ofsinfo.c | 16 +++--- src/H5Oint.c | 6 +- src/H5Olayout.c | 20 +++---- src/H5Olinfo.c | 22 +++---- src/H5Olink.c | 8 +-- src/H5Omessage.c | 14 ++--- src/H5Oshared.c | 6 +- src/H5Oshmesg.c | 4 +- src/H5Ostab.c | 10 ++-- src/H5Otest.c | 12 ++-- src/H5Rint.c | 6 +- src/H5SM.c | 20 +++---- src/H5SMcache.c | 8 +-- src/H5SMmessage.c | 4 +- src/H5SMtest.c | 2 +- src/H5T.c | 4 +- src/H5Tcommit.c | 2 +- src/H5Tref.c | 4 +- src/H5VLnative.c | 4 +- src/H5VLnative_blob.c | 10 ++-- src/H5private.h | 29 ++++++++++ src/H5trace.c | 2 +- test/btree2.c | 62 ++++++++++---------- test/cache.c | 2 +- test/cache_common.h | 4 +- test/cache_image.c | 12 ++-- test/earray.c | 2 +- test/farray.c | 2 +- test/fheap.c | 96 +++++++++++++++---------------- test/freespace.c | 52 ++++++++--------- test/gheap.c | 2 +- test/links.c | 26 ++++----- test/mf.c | 52 ++++++++--------- 146 files changed, 1291 insertions(+), 1293 deletions(-) diff --git a/src/H5AC.c b/src/H5AC.c index daa6192..39b9502 100644 --- a/src/H5AC.c +++ b/src/H5AC.c @@ -568,7 +568,7 @@ H5AC_expunge_entry(H5F_t *f, const H5AC_class_t *type, haddr_t addr, unsigned fl assert(f->shared->cache); assert(type); assert(type->serialize); - assert(H5F_addr_defined(addr)); + assert(H5_addr_defined(addr)); if (H5C_expunge_entry(f, type, addr, flags) < 0) HGOTO_ERROR(H5E_CACHE, H5E_CANTEXPUNGE, FAIL, "H5C_expunge_entry() failed") @@ -667,7 +667,7 @@ H5AC_get_entry_status(const H5F_t *f, haddr_t addr, unsigned *status) FUNC_ENTER_NOAPI(FAIL) - if ((f == NULL) || (!H5F_addr_defined(addr)) || (status == NULL)) + if ((f == NULL) || (!H5_addr_defined(addr)) || (status == NULL)) HGOTO_ERROR(H5E_CACHE, H5E_SYSTEM, FAIL, "Bad param(s) on entry") if (H5C_get_entry_status(f, addr, NULL, &in_cache, &is_dirty, &is_protected, &is_pinned, &is_corked, @@ -722,7 +722,7 @@ H5AC_insert_entry(H5F_t *f, const H5AC_class_t *type, haddr_t addr, void *thing, assert(f->shared->cache); assert(type); assert(type->serialize); - assert(H5F_addr_defined(addr)); + assert(H5_addr_defined(addr)); assert(thing); /* Check for invalid access request */ @@ -997,9 +997,9 @@ H5AC_move_entry(H5F_t *f, const H5AC_class_t *type, haddr_t old_addr, haddr_t ne assert(f); assert(f->shared->cache); assert(type); - assert(H5F_addr_defined(old_addr)); - assert(H5F_addr_defined(new_addr)); - assert(H5F_addr_ne(old_addr, new_addr)); + assert(H5_addr_defined(old_addr)); + assert(H5_addr_defined(new_addr)); + assert(H5_addr_ne(old_addr, new_addr)); #ifdef H5_HAVE_PARALLEL /* Log moving the entry */ @@ -1258,7 +1258,7 @@ H5AC_protect(H5F_t *f, const H5AC_class_t *type, haddr_t addr, void *udata, unsi assert(f->shared->cache); assert(type); assert(type->serialize); - assert(H5F_addr_defined(addr)); + assert(H5_addr_defined(addr)); /* Check for unexpected flags -- H5C__FLUSH_COLLECTIVELY_FLAG * only permitted in the parallel case. @@ -1526,7 +1526,7 @@ H5AC_unprotect(H5F_t *f, const H5AC_class_t *type, haddr_t addr, void *thing, un assert(type); assert(type->deserialize); assert(type->image_len); - assert(H5F_addr_defined(addr)); + assert(H5_addr_defined(addr)); assert(thing); assert(((H5AC_info_t *)thing)->addr == addr); assert(((H5AC_info_t *)thing)->type == type); @@ -2327,7 +2327,7 @@ H5AC_cork(H5F_t *f, haddr_t obj_addr, unsigned action, hbool_t *corked) assert(f); assert(f->shared); assert(f->shared->cache); - assert(H5F_addr_defined(obj_addr)); + assert(H5_addr_defined(obj_addr)); assert(action == H5AC__SET_CORK || action == H5AC__UNCORK || action == H5AC__GET_CORKED); /* Skip the search on "tag_list" when there are no "corked" objects. @@ -2404,7 +2404,7 @@ H5AC_get_entry_ring(const H5F_t *f, haddr_t addr, H5AC_ring_t *ring) /* Sanity check */ assert(f); - assert(H5F_addr_defined(addr)); + assert(H5_addr_defined(addr)); assert(ring); /* Retrieve the ring value for the entry at address */ diff --git a/src/H5ACproxy_entry.c b/src/H5ACproxy_entry.c index 2431450..eec6402 100644 --- a/src/H5ACproxy_entry.c +++ b/src/H5ACproxy_entry.c @@ -160,7 +160,7 @@ H5AC_proxy_entry_add_parent(H5AC_proxy_entry_t *pentry, void *_parent) /* Add flush dependency on parent */ if (pentry->nchildren > 0) { /* Sanity check */ - assert(H5F_addr_defined(pentry->addr)); + assert(H5_addr_defined(pentry->addr)); if (H5AC_create_flush_dependency(parent, pentry) < 0) HGOTO_ERROR(H5E_CACHE, H5E_CANTDEPEND, FAIL, "unable to set flush dependency on proxy entry") @@ -196,7 +196,7 @@ H5AC_proxy_entry_remove_parent(H5AC_proxy_entry_t *pentry, void *_parent) /* Remove parent from skip list */ if (NULL == (rem_parent = (H5AC_info_t *)H5SL_remove(pentry->parents, &parent->addr))) HGOTO_ERROR(H5E_CACHE, H5E_CANTREMOVE, FAIL, "unable to remove proxy entry parent from skip list") - if (!H5F_addr_eq(rem_parent->addr, parent->addr)) + if (!H5_addr_eq(rem_parent->addr, parent->addr)) HGOTO_ERROR(H5E_CACHE, H5E_BADVALUE, FAIL, "removed proxy entry parent not the same as real parent") /* Shut down the skip list, if this is the last parent */ @@ -270,7 +270,7 @@ H5AC_proxy_entry_add_child(H5AC_proxy_entry_t *pentry, H5F_t *f, void *child) /* Check for first child */ if (0 == pentry->nchildren) { /* Get an address, if the proxy doesn't already have one */ - if (!H5F_addr_defined(pentry->addr)) + if (!H5_addr_defined(pentry->addr)) if (HADDR_UNDEF == (pentry->addr = H5MF_alloc_tmp(f, 1))) HGOTO_ERROR(H5E_CACHE, H5E_CANTALLOC, FAIL, "temporary file space allocation failed for proxy entry") diff --git a/src/H5Adense.c b/src/H5Adense.c index 7ab8781..248f5a7 100644 --- a/src/H5Adense.c +++ b/src/H5Adense.c @@ -353,7 +353,7 @@ H5A__dense_open(H5F_t *f, const H5O_ainfo_t *ainfo, const char *name) HGOTO_ERROR(H5E_ATTR, H5E_CANTGET, NULL, "can't get shared message heap address") /* Check if there are any shared messages currently */ - if (H5F_addr_defined(shared_fheap_addr)) { + if (H5_addr_defined(shared_fheap_addr)) { /* Open the fractal heap for shared header messages */ if (NULL == (shared_fheap = H5HF_open(f, shared_fheap_addr))) HGOTO_ERROR(H5E_ATTR, H5E_CANTOPENOBJ, NULL, "unable to open fractal heap") @@ -453,7 +453,7 @@ H5A__dense_insert(H5F_t *f, const H5O_ainfo_t *ainfo, H5A_t *attr) HGOTO_ERROR(H5E_ATTR, H5E_CANTGET, FAIL, "can't get shared message heap address") /* Check if there are any shared messages currently */ - if (H5F_addr_defined(shared_fheap_addr)) { + if (H5_addr_defined(shared_fheap_addr)) { /* Open the fractal heap for shared header messages */ if (NULL == (shared_fheap = H5HF_open(f, shared_fheap_addr))) HGOTO_ERROR(H5E_ATTR, H5E_CANTOPENOBJ, FAIL, "unable to open fractal heap") @@ -521,7 +521,7 @@ H5A__dense_insert(H5F_t *f, const H5O_ainfo_t *ainfo, H5A_t *attr) /* Check if we should create a creation order index v2 B-tree record */ if (ainfo->index_corder) { /* Open the creation order index v2 B-tree */ - assert(H5F_addr_defined(ainfo->corder_bt2_addr)); + assert(H5_addr_defined(ainfo->corder_bt2_addr)); if (NULL == (bt2_corder = H5B2_open(f, ainfo->corder_bt2_addr, NULL))) HGOTO_ERROR(H5E_ATTR, H5E_CANTOPENOBJ, FAIL, "unable to open v2 B-tree for creation order index") @@ -612,7 +612,7 @@ H5A__dense_write_bt2_cb(void *_record, void *_op_data, hbool_t *changed) record->id = op_data->attr->sh_loc.u.heap_id; /* Check if we need to modify the creation order index with new heap ID */ - if (H5F_addr_defined(op_data->corder_bt2_addr)) { + if (H5_addr_defined(op_data->corder_bt2_addr)) { H5A_bt2_ud_common_t udata; /* User data for v2 B-tree modify */ /* Open the creation order index v2 B-tree */ @@ -711,8 +711,8 @@ H5A__dense_write(H5F_t *f, const H5O_ainfo_t *ainfo, H5A_t *attr) /* Check arguments */ assert(f); assert(ainfo); - assert(H5F_addr_defined(ainfo->fheap_addr)); - assert(H5F_addr_defined(ainfo->name_bt2_addr)); + assert(H5_addr_defined(ainfo->fheap_addr)); + assert(H5_addr_defined(ainfo->name_bt2_addr)); assert(attr); /* Check if attributes are shared in this file */ @@ -728,7 +728,7 @@ H5A__dense_write(H5F_t *f, const H5O_ainfo_t *ainfo, H5A_t *attr) HGOTO_ERROR(H5E_ATTR, H5E_CANTGET, FAIL, "can't get shared message heap address") /* Check if there are any shared messages currently */ - if (H5F_addr_defined(shared_fheap_addr)) { + if (H5_addr_defined(shared_fheap_addr)) { /* Open the fractal heap for shared header messages */ if (NULL == (shared_fheap = H5HF_open(f, shared_fheap_addr))) HGOTO_ERROR(H5E_ATTR, H5E_CANTOPENOBJ, FAIL, "unable to open fractal heap") @@ -861,7 +861,7 @@ H5A__dense_rename(H5F_t *f, const H5O_ainfo_t *ainfo, const char *old_name, cons HGOTO_ERROR(H5E_ATTR, H5E_CANTGET, FAIL, "can't get shared message heap address") /* Check if there are any shared messages currently */ - if (H5F_addr_defined(shared_fheap_addr)) { + if (H5_addr_defined(shared_fheap_addr)) { /* Open the fractal heap for shared header messages */ if (NULL == (shared_fheap = H5HF_open(f, shared_fheap_addr))) HGOTO_ERROR(H5E_ATTR, H5E_CANTOPENOBJ, FAIL, "unable to open fractal heap") @@ -917,7 +917,7 @@ H5A__dense_rename(H5F_t *f, const H5O_ainfo_t *ainfo, const char *old_name, cons hbool_t corder_attr_exists; /* Attribute exists in v2 B-tree */ /* Open the creation order index v2 B-tree */ - assert(H5F_addr_defined(ainfo->corder_bt2_addr)); + assert(H5_addr_defined(ainfo->corder_bt2_addr)); if (NULL == (bt2_corder = H5B2_open(f, ainfo->corder_bt2_addr, NULL))) HGOTO_ERROR(H5E_ATTR, H5E_CANTOPENOBJ, FAIL, "unable to open v2 B-tree for creation index") @@ -1115,8 +1115,8 @@ H5A__dense_iterate(H5F_t *f, hid_t loc_id, const H5O_ainfo_t *ainfo, H5_index_t /* Check arguments */ assert(f); assert(ainfo); - assert(H5F_addr_defined(ainfo->fheap_addr)); - assert(H5F_addr_defined(ainfo->name_bt2_addr)); + assert(H5_addr_defined(ainfo->fheap_addr)); + assert(H5_addr_defined(ainfo->name_bt2_addr)); assert(attr_op); /* Determine the address of the index to use */ @@ -1126,7 +1126,7 @@ H5A__dense_iterate(H5F_t *f, hid_t loc_id, const H5O_ainfo_t *ainfo, H5_index_t * table and sorting it. */ if (order == H5_ITER_NATIVE) { - assert(H5F_addr_defined(ainfo->name_bt2_addr)); + assert(H5_addr_defined(ainfo->name_bt2_addr)); bt2_addr = ainfo->name_bt2_addr; } /* end if */ else @@ -1143,7 +1143,7 @@ H5A__dense_iterate(H5F_t *f, hid_t loc_id, const H5O_ainfo_t *ainfo, H5_index_t } /* end else */ /* Check on iteration order */ - if (order == H5_ITER_NATIVE && H5F_addr_defined(bt2_addr)) { + if (order == H5_ITER_NATIVE && H5_addr_defined(bt2_addr)) { H5A_bt2_ud_it_t udata; /* User data for iterator callback */ htri_t attr_sharable; /* Flag indicating attributes are shareable */ @@ -1164,7 +1164,7 @@ H5A__dense_iterate(H5F_t *f, hid_t loc_id, const H5O_ainfo_t *ainfo, H5_index_t HGOTO_ERROR(H5E_ATTR, H5E_CANTGET, FAIL, "can't get shared message heap address") /* Check if there are any shared messages currently */ - if (H5F_addr_defined(shared_fheap_addr)) { + if (H5_addr_defined(shared_fheap_addr)) { /* Open the fractal heap for shared header messages */ if (NULL == (shared_fheap = H5HF_open(f, shared_fheap_addr))) HGOTO_ERROR(H5E_ATTR, H5E_CANTOPENOBJ, FAIL, "unable to open fractal heap") @@ -1240,7 +1240,7 @@ H5A__dense_remove_bt2_cb(const void *_record, void *_udata) FUNC_ENTER_PACKAGE /* Check for removing the link from the creation order index */ - if (H5F_addr_defined(udata->corder_bt2_addr)) { + if (H5_addr_defined(udata->corder_bt2_addr)) { /* Open the creation order index v2 B-tree */ if (NULL == (bt2_corder = H5B2_open(udata->common.f, udata->corder_bt2_addr, NULL))) HGOTO_ERROR(H5E_ATTR, H5E_CANTOPENOBJ, FAIL, "unable to open v2 B-tree for creation order index") @@ -1323,7 +1323,7 @@ H5A__dense_remove(H5F_t *f, const H5O_ainfo_t *ainfo, const char *name) HGOTO_ERROR(H5E_ATTR, H5E_CANTGET, FAIL, "can't get shared message heap address") /* Check if there are any shared messages currently */ - if (H5F_addr_defined(shared_fheap_addr)) { + if (H5_addr_defined(shared_fheap_addr)) { /* Open the fractal heap for shared header messages */ if (NULL == (shared_fheap = H5HF_open(f, shared_fheap_addr))) HGOTO_ERROR(H5E_ATTR, H5E_CANTOPENOBJ, FAIL, "unable to open fractal heap") @@ -1397,7 +1397,7 @@ H5A__dense_remove_by_idx_bt2_cb(const void *_record, void *_bt2_udata) fheap = bt2_udata->fheap; /* Check whether to make a copy of the attribute or just need the shared location info */ - if (H5F_addr_defined(bt2_udata->other_bt2_addr) || !(record->flags & H5O_MSG_FLAG_SHARED)) { + if (H5_addr_defined(bt2_udata->other_bt2_addr) || !(record->flags & H5O_MSG_FLAG_SHARED)) { /* Call fractal heap 'op' routine, to make copy of attribute to remove */ if (H5HF_op(fheap, &record->id, H5A__dense_copy_fh_cb, &fh_udata) < 0) HGOTO_ERROR(H5E_ATTR, H5E_CANTOPERATE, FAIL, "attribute removal callback failed") @@ -1415,7 +1415,7 @@ H5A__dense_remove_by_idx_bt2_cb(const void *_record, void *_bt2_udata) } /* end else */ /* Check for removing the link from the "other" index (creation order, when name used and vice versa) */ - if (H5F_addr_defined(bt2_udata->other_bt2_addr)) { + if (H5_addr_defined(bt2_udata->other_bt2_addr)) { H5A_bt2_ud_common_t other_bt2_udata; /* Info for B-tree callbacks */ /* Determine the index being used */ @@ -1519,7 +1519,7 @@ H5A__dense_remove_by_idx(H5F_t *f, const H5O_ainfo_t *ainfo, H5_index_t idx_type */ if (order == H5_ITER_NATIVE) { bt2_addr = ainfo->name_bt2_addr; - assert(H5F_addr_defined(bt2_addr)); + assert(H5_addr_defined(bt2_addr)); } /* end if */ else bt2_addr = HADDR_UNDEF; @@ -1535,7 +1535,7 @@ H5A__dense_remove_by_idx(H5F_t *f, const H5O_ainfo_t *ainfo, H5_index_t idx_type } /* end else */ /* If there is an index defined for the field, use it */ - if (H5F_addr_defined(bt2_addr)) { + if (H5_addr_defined(bt2_addr)) { H5A_bt2_ud_rmbi_t udata; /* User data for v2 B-tree record removal */ htri_t attr_sharable; /* Flag indicating attributes are shareable */ @@ -1556,7 +1556,7 @@ H5A__dense_remove_by_idx(H5F_t *f, const H5O_ainfo_t *ainfo, H5_index_t idx_type HGOTO_ERROR(H5E_ATTR, H5E_CANTGET, FAIL, "can't get shared message heap address") /* Check if there are any shared messages currently */ - if (H5F_addr_defined(shared_fheap_addr)) { + if (H5_addr_defined(shared_fheap_addr)) { /* Open the fractal heap for shared header messages */ if (NULL == (shared_fheap = H5HF_open(f, shared_fheap_addr))) HGOTO_ERROR(H5E_ATTR, H5E_CANTOPENOBJ, FAIL, "unable to open fractal heap") @@ -1652,7 +1652,7 @@ H5A__dense_exists(H5F_t *f, const H5O_ainfo_t *ainfo, const char *name, hbool_t HGOTO_ERROR(H5E_ATTR, H5E_CANTGET, FAIL, "can't get shared message heap address") /* Check if there are any shared messages currently */ - if (H5F_addr_defined(shared_fheap_addr)) { + if (H5_addr_defined(shared_fheap_addr)) { /* Open the fractal heap for shared header messages */ if (NULL == (shared_fheap = H5HF_open(f, shared_fheap_addr))) HGOTO_ERROR(H5E_ATTR, H5E_CANTOPENOBJ, FAIL, "unable to open fractal heap") @@ -1797,7 +1797,7 @@ H5A__dense_delete(H5F_t *f, H5O_ainfo_t *ainfo) fheap = NULL; /* Check if we should delete the creation order index v2 B-tree */ - if (H5F_addr_defined(ainfo->corder_bt2_addr)) { + if (H5_addr_defined(ainfo->corder_bt2_addr)) { /* Delete the creation order index, without adjusting the ref. count on the attributes */ if (H5B2_delete(f, ainfo->corder_bt2_addr, NULL, NULL, NULL) < 0) HGOTO_ERROR(H5E_ATTR, H5E_CANTDELETE, FAIL, "unable to delete v2 B-tree for creation order index") diff --git a/src/H5Aint.c b/src/H5Aint.c index 73b1014..62a9592 100644 --- a/src/H5Aint.c +++ b/src/H5Aint.c @@ -1626,8 +1626,8 @@ H5A__dense_build_table(H5F_t *f, const H5O_ainfo_t *ainfo, H5_index_t idx_type, /* Sanity check */ assert(f); assert(ainfo); - assert(H5F_addr_defined(ainfo->fheap_addr)); - assert(H5F_addr_defined(ainfo->name_bt2_addr)); + assert(H5_addr_defined(ainfo->fheap_addr)); + assert(H5_addr_defined(ainfo->name_bt2_addr)); assert(atable); /* Open the name index v2 B-tree */ @@ -1974,7 +1974,7 @@ H5A__get_ainfo(H5F_t *f, H5O_t *oh, H5O_ainfo_t *ainfo) /* Check if we don't know how many attributes there are */ if (ainfo->nattrs == HSIZET_MAX) { /* Check if we are using "dense" attribute storage */ - if (H5F_addr_defined(ainfo->fheap_addr)) { + if (H5_addr_defined(ainfo->fheap_addr)) { /* Open the name index v2 B-tree */ if (NULL == (bt2_name = H5B2_open(f, ainfo->name_bt2_addr, NULL))) HGOTO_ERROR(H5E_ATTR, H5E_CANTOPENOBJ, FAIL, "unable to open v2 B-tree for name index") diff --git a/src/H5B.c b/src/H5B.c index 429cabf..16ae4f1 100644 --- a/src/H5B.c +++ b/src/H5B.c @@ -295,7 +295,7 @@ H5B_find(H5F_t *f, const H5B_class_t *type, haddr_t addr, hbool_t *found, void * assert(type->decode); assert(type->cmp3); assert(type->found); - assert(H5F_addr_defined(addr)); + assert(H5_addr_defined(addr)); /* Get shared info for B-tree */ if (NULL == (rc_shared = (type->get_shared)(f, udata))) @@ -384,7 +384,7 @@ H5B__split(H5F_t *f, H5B_ins_ud_t *bt_ud, unsigned idx, void *udata, H5B_ins_ud_ assert(f); assert(bt_ud); assert(bt_ud->bt); - assert(H5F_addr_defined(bt_ud->addr)); + assert(H5_addr_defined(bt_ud->addr)); assert(split_bt_ud); assert(!split_bt_ud->bt); @@ -403,11 +403,11 @@ H5B__split(H5F_t *f, H5B_ins_ud_t *bt_ud, unsigned idx, void *udata, H5B_ins_ud_ if (H5DEBUG(B)) { const char *side; - if (!H5F_addr_defined(bt_ud->bt->left) && !H5F_addr_defined(bt_ud->bt->right)) + if (!H5_addr_defined(bt_ud->bt->left) && !H5_addr_defined(bt_ud->bt->right)) side = "ONLY"; - else if (!H5F_addr_defined(bt_ud->bt->right)) + else if (!H5_addr_defined(bt_ud->bt->right)) side = "RIGHT"; - else if (!H5F_addr_defined(bt_ud->bt->left)) + else if (!H5_addr_defined(bt_ud->bt->left)) side = "LEFT"; else side = "MIDDLE"; @@ -420,9 +420,9 @@ H5B__split(H5F_t *f, H5B_ins_ud_t *bt_ud, unsigned idx, void *udata, H5B_ins_ud_ * Decide how to split the children of the old node among the old node * and the new node. */ - if (!H5F_addr_defined(bt_ud->bt->right)) + if (!H5_addr_defined(bt_ud->bt->right)) nleft = (unsigned)((double)shared->two_k * split_ratios[2]); /*right*/ - else if (!H5F_addr_defined(bt_ud->bt->left)) + else if (!H5_addr_defined(bt_ud->bt->left)) nleft = (unsigned)((double)shared->two_k * split_ratios[0]); /*left*/ else nleft = (unsigned)((double)shared->two_k * split_ratios[1]); /*middle*/ @@ -478,7 +478,7 @@ H5B__split(H5F_t *f, H5B_ins_ud_t *bt_ud, unsigned idx, void *udata, H5B_ins_ud_ split_bt_ud->bt->left = bt_ud->addr; split_bt_ud->bt->right = bt_ud->bt->right; - if (H5F_addr_defined(bt_ud->bt->right)) { + if (H5_addr_defined(bt_ud->bt->right)) { H5B_t *tmp_bt; if (NULL == @@ -545,7 +545,7 @@ H5B_insert(H5F_t *f, const H5B_class_t *type, haddr_t addr, void *udata) assert(f); assert(type); assert(type->sizeof_nkey <= sizeof _lt_key); - assert(H5F_addr_defined(addr)); + assert(H5_addr_defined(addr)); /* Get shared info for B-tree */ if (NULL == (rc_shared = (type->get_shared)(f, udata))) @@ -574,7 +574,7 @@ H5B_insert(H5F_t *f, const H5B_class_t *type, haddr_t addr, void *udata) } /* end if */ assert(H5B_INS_RIGHT == my_ins); assert(split_bt_ud.bt); - assert(H5F_addr_defined(split_bt_ud.addr)); + assert(H5_addr_defined(split_bt_ud.addr)); /* Get level of old root */ level = bt_ud.bt->level; @@ -679,7 +679,7 @@ H5B__insert_child(H5B_t *bt, unsigned *bt_flags, unsigned idx, haddr_t child, H5 assert(bt); assert(bt_flags); - assert(H5F_addr_defined(child)); + assert(H5_addr_defined(child)); shared = (H5B_shared_t *)H5UC_GET_OBJ(bt->rc_shared); assert(shared); assert(bt->nchildren < shared->two_k); @@ -774,7 +774,7 @@ H5B__insert_helper(H5F_t *f, H5B_ins_ud_t *bt_ud, const H5B_class_t *type, uint8 assert(f); assert(bt_ud); assert(bt_ud->bt); - assert(H5F_addr_defined(bt_ud->addr)); + assert(H5_addr_defined(bt_ud->addr)); assert(type); assert(type->decode); assert(type->cmp3); @@ -785,7 +785,7 @@ H5B__insert_helper(H5F_t *f, H5B_ins_ud_t *bt_ud, const H5B_class_t *type, uint8 assert(rt_key_changed); assert(split_bt_ud); assert(!split_bt_ud->bt); - assert(!H5F_addr_defined(split_bt_ud->addr)); + assert(!H5_addr_defined(split_bt_ud->addr)); assert(split_bt_ud->cache_flags == H5AC__NO_FLAGS_SET); bt = bt_ud->bt; @@ -885,7 +885,7 @@ H5B__insert_helper(H5F_t *f, H5B_ins_ud_t *bt_ud, const H5B_class_t *type, uint8 #ifdef H5_STRICT_FORMAT_CHECKS /* Since we are to the left of the leftmost key there must not be a left * sibling */ - if (H5F_addr_defined(bt->left)) + if (H5_addr_defined(bt->left)) HGOTO_ERROR(H5E_BTREE, H5E_CANTINSERT, H5B_INS_ERROR, "internal error: likely corrupt key values") #endif /* H5_STRICT_FORMAT_CHECKS */ } @@ -936,7 +936,7 @@ H5B__insert_helper(H5F_t *f, H5B_ins_ud_t *bt_ud, const H5B_class_t *type, uint8 #ifdef H5_STRICT_FORMAT_CHECKS /* Since we are to the right of the rightmost key there must not be a * right sibling */ - if (H5F_addr_defined(bt->right)) + if (H5_addr_defined(bt->right)) HGOTO_ERROR(H5E_BTREE, H5E_CANTINSERT, H5B_INS_ERROR, "internal error: likely corrupt key values") #endif /* H5_STRICT_FORMAT_CHECKS */ } @@ -1103,7 +1103,7 @@ H5B__iterate_helper(H5F_t *f, const H5B_class_t *type, haddr_t addr, H5B_operato */ assert(f); assert(type); - assert(H5F_addr_defined(addr)); + assert(H5_addr_defined(addr)); assert(op); assert(udata); @@ -1159,7 +1159,7 @@ H5B_iterate(H5F_t *f, const H5B_class_t *type, haddr_t addr, H5B_operator_t op, */ assert(f); assert(type); - assert(H5F_addr_defined(addr)); + assert(H5_addr_defined(addr)); assert(op); assert(udata); @@ -1208,7 +1208,7 @@ H5B__remove_helper(H5F_t *f, haddr_t addr, const H5B_class_t *type, int level, u FUNC_ENTER_PACKAGE assert(f); - assert(H5F_addr_defined(addr)); + assert(H5_addr_defined(addr)); assert(type); assert(type->decode); assert(type->cmp3); @@ -1329,7 +1329,7 @@ H5B__remove_helper(H5F_t *f, haddr_t addr, const H5B_class_t *type, int level, u * between siblings. Overwrite the key that that is not * "critical" for any child in its node to maintain this * consistency (and avoid breaking key/child consistency) */ - if (H5F_addr_defined(bt->left)) { + if (H5_addr_defined(bt->left)) { if (NULL == (sibling = (H5B_t *)H5AC_protect(f, H5AC_BT, bt->left, &cache_udata, H5AC__NO_FLAGS_SET))) HGOTO_ERROR(H5E_BTREE, H5E_CANTPROTECT, H5B_INS_ERROR, @@ -1349,7 +1349,7 @@ H5B__remove_helper(H5F_t *f, haddr_t addr, const H5B_class_t *type, int level, u "unable to release node from tree") sibling = NULL; /* Make certain future references will be caught */ } /* end if */ - if (H5F_addr_defined(bt->right)) { + if (H5_addr_defined(bt->right)) { if (NULL == (sibling = (H5B_t *)H5AC_protect(f, H5AC_BT, bt->right, &cache_udata, H5AC__NO_FLAGS_SET))) HGOTO_ERROR(H5E_BTREE, H5E_CANTPROTECT, H5B_INS_ERROR, @@ -1466,7 +1466,7 @@ H5B__remove_helper(H5F_t *f, haddr_t addr, const H5B_class_t *type, int level, u ret_value = H5B_INS_NOOP; /* Patch keys in neighboring trees if necessary */ - if (*lt_key_changed && H5F_addr_defined(bt->left)) { + if (*lt_key_changed && H5_addr_defined(bt->left)) { assert(type->critical_key == H5B_LEFT); assert(level > 0); @@ -1481,7 +1481,7 @@ H5B__remove_helper(H5F_t *f, haddr_t addr, const H5B_class_t *type, int level, u HGOTO_ERROR(H5E_BTREE, H5E_CANTUNPROTECT, H5B_INS_ERROR, "unable to release node from tree") sibling = NULL; /* Make certain future references will be caught */ } /* end if */ - else if (*rt_key_changed && H5F_addr_defined(bt->right)) { + else if (*rt_key_changed && H5_addr_defined(bt->right)) { assert(type->critical_key == H5B_RIGHT); assert(level > 0); @@ -1534,7 +1534,7 @@ H5B_remove(H5F_t *f, const H5B_class_t *type, haddr_t addr, void *udata) assert(f); assert(type); assert(type->sizeof_nkey <= sizeof _lt_key); - assert(H5F_addr_defined(addr)); + assert(H5_addr_defined(addr)); /* The actual removal */ if (H5B_INS_ERROR == @@ -1573,7 +1573,7 @@ H5B_delete(H5F_t *f, const H5B_class_t *type, haddr_t addr, void *udata) /* Check args */ assert(f); assert(type); - assert(H5F_addr_defined(addr)); + assert(H5_addr_defined(addr)); /* Get shared info for B-tree */ if (NULL == (rc_shared = (type->get_shared)(f, udata))) @@ -1807,7 +1807,7 @@ H5B__get_info_helper(H5F_t *f, const H5B_class_t *type, haddr_t addr, const H5B_ */ assert(f); assert(type); - assert(H5F_addr_defined(addr)); + assert(H5_addr_defined(addr)); assert(info_udata); assert(info_udata->bt_info); assert(info_udata->udata); @@ -1846,7 +1846,7 @@ H5B__get_info_helper(H5F_t *f, const H5B_class_t *type, haddr_t addr, const H5B_ * Follow the right-sibling pointer from node to node until we've * processed all nodes. */ - while (H5F_addr_defined(next_addr)) { + while (H5_addr_defined(next_addr)) { /* Protect the next node to the right */ addr = next_addr; if (NULL == (bt = (H5B_t *)H5AC_protect(f, H5AC_BT, addr, &cache_udata, H5AC__READ_ONLY_FLAG))) @@ -1903,7 +1903,7 @@ H5B_get_info(H5F_t *f, const H5B_class_t *type, haddr_t addr, H5B_info_t *bt_inf assert(f); assert(type); assert(bt_info); - assert(H5F_addr_defined(addr)); + assert(H5_addr_defined(addr)); assert(udata); /* Portably initialize B-tree info struct */ @@ -1952,7 +1952,7 @@ H5B_valid(H5F_t *f, const H5B_class_t *type, haddr_t addr) assert(f); assert(type); - if (!H5F_addr_defined(addr)) + if (!H5_addr_defined(addr)) HGOTO_ERROR(H5E_BTREE, H5E_BADVALUE, FAIL, "address is undefined") /* Get shared info for B-tree */ diff --git a/src/H5B2.c b/src/H5B2.c index cba50b4..ebbde9b 100644 --- a/src/H5B2.c +++ b/src/H5B2.c @@ -193,7 +193,7 @@ H5B2_open(H5F_t *f, haddr_t addr, void *ctx_udata) /* Check arguments. */ assert(f); - assert(H5F_addr_defined(addr)); + assert(H5_addr_defined(addr)); /* Look up the B-tree header */ if (NULL == (hdr = H5B2__hdr_protect(f, addr, ctx_udata, H5AC__READ_ONLY_FLAG))) @@ -301,7 +301,7 @@ H5B2_update(H5B2_t *bt2, void *udata, H5B2_modify_t op, void *op_data) hdr = bt2->hdr; /* Check if the root node is allocated yet */ - if (!H5F_addr_defined(hdr->root.addr)) { + if (!H5_addr_defined(hdr->root.addr)) { /* Create root node as leaf node in B-tree */ if (H5B2__create_leaf(hdr, hdr, &(hdr->root)) < 0) HGOTO_ERROR(H5E_BTREE, H5E_CANTINIT, FAIL, "unable to create root node") @@ -1079,7 +1079,7 @@ H5B2_neighbor(H5B2_t *bt2, H5B2_compare_t range, void *udata, H5B2_found_t op, v hdr = bt2->hdr; /* Check for empty tree */ - if (!H5F_addr_defined(hdr->root.addr)) + if (!H5_addr_defined(hdr->root.addr)) HGOTO_ERROR(H5E_BTREE, H5E_NOTFOUND, FAIL, "B-tree has no records") /* Attempt to find neighbor record in B-tree */ @@ -1384,7 +1384,7 @@ H5B2_close(H5B2_t *bt2) H5B2_hdr_t *hdr; /* Another pointer to v2 B-tree header */ /* Sanity check */ - assert(H5F_addr_defined(bt2_addr)); + assert(H5_addr_defined(bt2_addr)); #ifndef NDEBUG { @@ -1469,7 +1469,7 @@ H5B2_delete(H5F_t *f, haddr_t addr, void *ctx_udata, H5B2_remove_t op, void *op_ /* Check arguments. */ assert(f); - assert(H5F_addr_defined(addr)); + assert(H5_addr_defined(addr)); /* Lock the v2 B-tree header into memory */ if (NULL == (hdr = H5B2__hdr_protect(f, addr, ctx_udata, H5AC__NO_FLAGS_SET))) diff --git a/src/H5B2cache.c b/src/H5B2cache.c index 1cb61cd..d63baa1 100644 --- a/src/H5B2cache.c +++ b/src/H5B2cache.c @@ -268,7 +268,7 @@ H5B2__cache_hdr_deserialize(const void *_image, size_t H5_ATTR_UNUSED len, void cparam.merge_percent = *image++; /* Root node pointer */ - H5F_addr_decode(udata->f, (const uint8_t **)&image, &(hdr->root.addr)); + H5_addr_decode(udata->f, (const uint8_t **)&image, &(hdr->root.addr)); UINT16DECODE(image, hdr->root.node_nrec); H5F_DECODE_LENGTH(udata->f, image, hdr->root.all_nrec); @@ -378,7 +378,7 @@ H5B2__cache_hdr_serialize(const H5F_t *f, void *_image, size_t H5_ATTR_UNUSED le *image++ = (uint8_t)hdr->merge_percent; /* Root node pointer */ - H5F_addr_encode(f, &image, hdr->root.addr); + H5_addr_encode(f, &image, hdr->root.addr); UINT16ENCODE(image, hdr->root.node_nrec); H5F_ENCODE_LENGTH(f, image, hdr->root.all_nrec); @@ -663,7 +663,7 @@ H5B2__cache_int_deserialize(const void *_image, size_t H5_ATTR_UNUSED len, void int_node_ptr = internal->node_ptrs; for (u = 0; u < (unsigned)(internal->nrec + 1); u++) { /* Decode node pointer */ - H5F_addr_decode(udata->f, (const uint8_t **)&image, &(int_node_ptr->addr)); + H5_addr_decode(udata->f, (const uint8_t **)&image, &(int_node_ptr->addr)); UINT64DECODE_VAR(image, node_nrec, udata->hdr->max_nrec_size); H5_CHECKED_ASSIGN(int_node_ptr->node_nrec, uint16_t, node_nrec, int); if (udata->depth > 1) @@ -779,7 +779,7 @@ H5B2__cache_int_serialize(const H5F_t *f, void *_image, size_t H5_ATTR_UNUSED le int_node_ptr = internal->node_ptrs; for (u = 0; u < (unsigned)(internal->nrec + 1); u++) { /* Encode node pointer */ - H5F_addr_encode(f, &image, int_node_ptr->addr); + H5_addr_encode(f, &image, int_node_ptr->addr); UINT64ENCODE_VAR(image, int_node_ptr->node_nrec, internal->hdr->max_nrec_size); if (internal->depth > 1) UINT64ENCODE_VAR(image, int_node_ptr->all_nrec, diff --git a/src/H5B2dbg.c b/src/H5B2dbg.c index 071eca7..0f498a8 100644 --- a/src/H5B2dbg.c +++ b/src/H5B2dbg.c @@ -85,8 +85,8 @@ H5B2__hdr_debug(H5F_t *f, haddr_t addr, FILE *stream, int indent, int fwidth, * Check arguments. */ assert(f); - assert(H5F_addr_defined(addr)); - assert(H5F_addr_defined(obj_addr)); + assert(H5_addr_defined(addr)); + assert(H5_addr_defined(obj_addr)); assert(stream); assert(indent >= 0); assert(fwidth >= 0); @@ -162,13 +162,13 @@ H5B2__int_debug(H5F_t *f, haddr_t addr, FILE *stream, int indent, int fwidth, co * Check arguments. */ assert(f); - assert(H5F_addr_defined(addr)); + assert(H5_addr_defined(addr)); assert(stream); assert(indent >= 0); assert(fwidth >= 0); assert(type); - assert(H5F_addr_defined(hdr_addr)); - assert(H5F_addr_defined(obj_addr)); + assert(H5_addr_defined(hdr_addr)); + assert(H5_addr_defined(obj_addr)); assert(nrec > 0); /* Load the B-tree header */ @@ -260,13 +260,13 @@ H5B2__leaf_debug(H5F_t *f, haddr_t addr, FILE *stream, int indent, int fwidth, c * Check arguments. */ assert(f); - assert(H5F_addr_defined(addr)); + assert(H5_addr_defined(addr)); assert(stream); assert(indent >= 0); assert(fwidth >= 0); assert(type); - assert(H5F_addr_defined(hdr_addr)); - assert(H5F_addr_defined(obj_addr)); + assert(H5_addr_defined(hdr_addr)); + assert(H5_addr_defined(obj_addr)); assert(nrec > 0); /* Load the B-tree header */ diff --git a/src/H5B2hdr.c b/src/H5B2hdr.c index 3ec4d81..671cdc3 100644 --- a/src/H5B2hdr.c +++ b/src/H5B2hdr.c @@ -306,7 +306,7 @@ H5B2__hdr_create(H5F_t *f, const H5B2_create_t *cparam, void *ctx_udata) ret_value = hdr->addr; done: - if (!H5F_addr_defined(ret_value)) + if (!H5_addr_defined(ret_value)) if (hdr) { /* Remove from cache, if inserted */ if (inserted) @@ -315,7 +315,7 @@ done: "unable to remove v2 B-tree header from cache") /* Release header's disk space */ - if (H5F_addr_defined(hdr->addr) && + if (H5_addr_defined(hdr->addr) && H5MF_xfree(f, H5FD_MEM_BTREE, hdr->addr, (hsize_t)hdr->hdr_size) < 0) HDONE_ERROR(H5E_BTREE, H5E_CANTFREE, HADDR_UNDEF, "unable to free v2 B-tree header") @@ -484,7 +484,7 @@ H5B2__hdr_protect(H5F_t *f, haddr_t hdr_addr, void *ctx_udata, unsigned flags) /* Sanity check */ assert(f); - assert(H5F_addr_defined(hdr_addr)); + assert(H5_addr_defined(hdr_addr)); /* only the H5AC__READ_ONLY_FLAG may appear in flags */ assert((flags & (unsigned)(~H5AC__READ_ONLY_FLAG)) == 0); @@ -664,7 +664,7 @@ H5B2__hdr_delete(H5B2_hdr_t *hdr) #endif /* NDEBUG */ /* Delete all nodes in B-tree */ - if (H5F_addr_defined(hdr->root.addr)) + if (H5_addr_defined(hdr->root.addr)) if (H5B2__delete_node(hdr, hdr->depth, &hdr->root, hdr, hdr->remove_op, hdr->remove_op_data) < 0) HGOTO_ERROR(H5E_BTREE, H5E_CANTDELETE, FAIL, "unable to delete B-tree nodes") diff --git a/src/H5B2int.c b/src/H5B2int.c index e56b211..766157b 100644 --- a/src/H5B2int.c +++ b/src/H5B2int.c @@ -1543,7 +1543,7 @@ H5B2__insert(H5B2_hdr_t *hdr, void *udata) assert(udata); /* Check if the root node is allocated yet */ - if (!H5F_addr_defined(hdr->root.addr)) { + if (!H5_addr_defined(hdr->root.addr)) { /* Create root node as leaf node in B-tree */ if (H5B2__create_leaf(hdr, hdr, &(hdr->root)) < 0) HGOTO_ERROR(H5E_BTREE, H5E_CANTINIT, FAIL, "unable to create root node") diff --git a/src/H5B2internal.c b/src/H5B2internal.c index 46d2a04..e3f1cf9 100644 --- a/src/H5B2internal.c +++ b/src/H5B2internal.c @@ -148,7 +148,7 @@ done: "unable to remove v2 B-tree internal node from cache") /* Release internal node's disk space */ - if (H5F_addr_defined(node_ptr->addr) && + if (H5_addr_defined(node_ptr->addr) && H5MF_xfree(hdr->f, H5FD_MEM_BTREE, node_ptr->addr, (hsize_t)hdr->node_size) < 0) HDONE_ERROR(H5E_BTREE, H5E_CANTFREE, FAIL, "unable to release file space for v2 B-tree internal node") @@ -184,7 +184,7 @@ H5B2__protect_internal(H5B2_hdr_t *hdr, void *parent, H5B2_node_ptr_t *node_ptr, /* Check arguments. */ assert(hdr); assert(node_ptr); - assert(H5F_addr_defined(node_ptr->addr)); + assert(H5_addr_defined(node_ptr->addr)); assert(depth > 0); /* only H5AC__READ_ONLY_FLAG may appear in flags */ @@ -281,7 +281,7 @@ H5B2__neighbor_internal(H5B2_hdr_t *hdr, uint16_t depth, H5B2_node_ptr_t *curr_n assert(hdr); assert(depth > 0); assert(curr_node_ptr); - assert(H5F_addr_defined(curr_node_ptr->addr)); + assert(H5_addr_defined(curr_node_ptr->addr)); assert(op); /* Lock current B-tree node */ @@ -355,7 +355,7 @@ H5B2__insert_internal(H5B2_hdr_t *hdr, uint16_t depth, unsigned *parent_cache_in assert(hdr); assert(depth > 0); assert(curr_node_ptr); - assert(H5F_addr_defined(curr_node_ptr->addr)); + assert(H5_addr_defined(curr_node_ptr->addr)); /* Lock current B-tree node */ if (NULL == @@ -523,7 +523,7 @@ H5B2__update_internal(H5B2_hdr_t *hdr, uint16_t depth, unsigned *parent_cache_in assert(hdr); assert(depth > 0); assert(curr_node_ptr); - assert(H5F_addr_defined(curr_node_ptr->addr)); + assert(H5_addr_defined(curr_node_ptr->addr)); /* Lock current B-tree node */ if (NULL == @@ -728,7 +728,7 @@ H5B2__shadow_internal(H5B2_internal_t *internal, H5B2_node_ptr_t *curr_node_ptr) */ assert(internal); assert(curr_node_ptr); - assert(H5F_addr_defined(curr_node_ptr->addr)); + assert(H5_addr_defined(curr_node_ptr->addr)); hdr = internal->hdr; assert(hdr); assert(hdr->swmr_write); @@ -800,7 +800,7 @@ H5B2__remove_internal(H5B2_hdr_t *hdr, hbool_t *depth_decreased, void *swap_loc, assert(depth > 0); assert(parent_cache_info); assert(curr_node_ptr); - assert(H5F_addr_defined(curr_node_ptr->addr)); + assert(H5_addr_defined(curr_node_ptr->addr)); /* Lock current B-tree node */ if (NULL == (internal = H5B2__protect_internal(hdr, parent_cache_info, curr_node_ptr, depth, FALSE, @@ -1041,7 +1041,7 @@ H5B2__remove_internal_by_idx(H5B2_hdr_t *hdr, hbool_t *depth_decreased, void *sw assert(depth > 0); assert(parent_cache_info); assert(curr_node_ptr); - assert(H5F_addr_defined(curr_node_ptr->addr)); + assert(H5_addr_defined(curr_node_ptr->addr)); /* Lock current B-tree node */ if (NULL == (internal = H5B2__protect_internal(hdr, parent_cache_info, curr_node_ptr, depth, FALSE, @@ -1370,7 +1370,7 @@ H5B2__assert_internal(hsize_t parent_all_nrec, const H5B2_hdr_t H5_ATTR_NDEBUG_U for (u = 0; u < internal->nrec + 1; u++) { tot_all_nrec += internal->node_ptrs[u].all_nrec; - assert(H5F_addr_defined(internal->node_ptrs[u].addr)); + assert(H5_addr_defined(internal->node_ptrs[u].addr)); assert(internal->node_ptrs[u].addr > 0); for (v = 0; v < u; v++) assert(internal->node_ptrs[u].addr != internal->node_ptrs[v].addr); @@ -1407,7 +1407,7 @@ H5B2__assert_internal2(hsize_t parent_all_nrec, const H5B2_hdr_t H5_ATTR_NDEBUG_ for (u = 0; u < internal->nrec + 1; u++) { tot_all_nrec += internal->node_ptrs[u].all_nrec; - assert(H5F_addr_defined(internal->node_ptrs[u].addr)); + assert(H5_addr_defined(internal->node_ptrs[u].addr)); assert(internal->node_ptrs[u].addr > 0); for (v = 0; v < u; v++) assert(internal->node_ptrs[u].addr != internal->node_ptrs[v].addr); diff --git a/src/H5B2leaf.c b/src/H5B2leaf.c index c337d66..4f1e566 100644 --- a/src/H5B2leaf.c +++ b/src/H5B2leaf.c @@ -137,7 +137,7 @@ done: "unable to remove v2 B-tree leaf node from cache") /* Release leaf node's disk space */ - if (H5F_addr_defined(node_ptr->addr) && + if (H5_addr_defined(node_ptr->addr) && H5MF_xfree(hdr->f, H5FD_MEM_BTREE, node_ptr->addr, (hsize_t)hdr->node_size) < 0) HDONE_ERROR(H5E_BTREE, H5E_CANTFREE, FAIL, "unable to release file space for v2 B-tree leaf node") @@ -172,7 +172,7 @@ H5B2__protect_leaf(H5B2_hdr_t *hdr, void *parent, H5B2_node_ptr_t *node_ptr, hbo /* Check arguments. */ assert(hdr); assert(node_ptr); - assert(H5F_addr_defined(node_ptr->addr)); + assert(H5_addr_defined(node_ptr->addr)); /* only H5AC__READ_ONLY_FLAG may appear in flags */ assert((flags & (unsigned)(~H5AC__READ_ONLY_FLAG)) == 0); @@ -264,7 +264,7 @@ H5B2__neighbor_leaf(H5B2_hdr_t *hdr, H5B2_node_ptr_t *curr_node_ptr, void *neigh /* Check arguments. */ assert(hdr); assert(curr_node_ptr); - assert(H5F_addr_defined(curr_node_ptr->addr)); + assert(H5_addr_defined(curr_node_ptr->addr)); assert(op); /* Lock current B-tree node */ @@ -333,7 +333,7 @@ H5B2__insert_leaf(H5B2_hdr_t *hdr, H5B2_node_ptr_t *curr_node_ptr, H5B2_nodepos_ /* Check arguments. */ assert(hdr); assert(curr_node_ptr); - assert(H5F_addr_defined(curr_node_ptr->addr)); + assert(H5_addr_defined(curr_node_ptr->addr)); /* Lock current B-tree node */ if (NULL == (leaf = H5B2__protect_leaf(hdr, parent, curr_node_ptr, FALSE, H5AC__NO_FLAGS_SET))) @@ -444,7 +444,7 @@ H5B2__update_leaf(H5B2_hdr_t *hdr, H5B2_node_ptr_t *curr_node_ptr, H5B2_update_s /* Check arguments. */ assert(hdr); assert(curr_node_ptr); - assert(H5F_addr_defined(curr_node_ptr->addr)); + assert(H5_addr_defined(curr_node_ptr->addr)); /* Lock current B-tree node */ if (NULL == (leaf = H5B2__protect_leaf(hdr, parent, curr_node_ptr, FALSE, H5AC__NO_FLAGS_SET))) @@ -685,7 +685,7 @@ H5B2__shadow_leaf(H5B2_leaf_t *leaf, H5B2_node_ptr_t *curr_node_ptr) */ assert(leaf); assert(curr_node_ptr); - assert(H5F_addr_defined(curr_node_ptr->addr)); + assert(H5_addr_defined(curr_node_ptr->addr)); hdr = leaf->hdr; assert(hdr); assert(hdr->swmr_write); @@ -749,7 +749,7 @@ H5B2__remove_leaf(H5B2_hdr_t *hdr, H5B2_node_ptr_t *curr_node_ptr, H5B2_nodepos_ /* Check arguments. */ assert(hdr); assert(curr_node_ptr); - assert(H5F_addr_defined(curr_node_ptr->addr)); + assert(H5_addr_defined(curr_node_ptr->addr)); /* Lock current B-tree node */ if (NULL == (leaf = H5B2__protect_leaf(hdr, parent, curr_node_ptr, FALSE, H5AC__NO_FLAGS_SET))) @@ -852,7 +852,7 @@ H5B2__remove_leaf_by_idx(H5B2_hdr_t *hdr, H5B2_node_ptr_t *curr_node_ptr, H5B2_n /* Check arguments. */ assert(hdr); assert(curr_node_ptr); - assert(H5F_addr_defined(curr_node_ptr->addr)); + assert(H5_addr_defined(curr_node_ptr->addr)); /* Lock B-tree leaf node */ if (NULL == (leaf = H5B2__protect_leaf(hdr, parent, curr_node_ptr, FALSE, H5AC__NO_FLAGS_SET))) diff --git a/src/H5Bcache.c b/src/H5Bcache.c index ada63ae..939d8aa 100644 --- a/src/H5Bcache.c +++ b/src/H5Bcache.c @@ -181,11 +181,11 @@ H5B__cache_deserialize(const void *_image, size_t len, void *_udata, hbool_t H5_ /* Sibling pointers */ if (H5_IS_BUFFER_OVERFLOW(image, H5F_sizeof_addr(udata->f), p_end)) HGOTO_ERROR(H5E_BTREE, H5E_OVERFLOW, NULL, "ran off end of input buffer while decoding"); - H5F_addr_decode(udata->f, (const uint8_t **)&image, &(bt->left)); + H5_addr_decode(udata->f, (const uint8_t **)&image, &(bt->left)); if (H5_IS_BUFFER_OVERFLOW(image, H5F_sizeof_addr(udata->f), p_end)) HGOTO_ERROR(H5E_BTREE, H5E_OVERFLOW, NULL, "ran off end of input buffer while decoding"); - H5F_addr_decode(udata->f, (const uint8_t **)&image, &(bt->right)); + H5_addr_decode(udata->f, (const uint8_t **)&image, &(bt->right)); /* Child/key pairs */ native = bt->native; @@ -201,7 +201,7 @@ H5B__cache_deserialize(const void *_image, size_t len, void *_udata, hbool_t H5_ /* Decode address value */ if (H5_IS_BUFFER_OVERFLOW(image, H5F_sizeof_addr(udata->f), p_end)) HGOTO_ERROR(H5E_BTREE, H5E_OVERFLOW, NULL, "ran off end of input buffer while decoding"); - H5F_addr_decode(udata->f, (const uint8_t **)&image, bt->child + u); + H5_addr_decode(udata->f, (const uint8_t **)&image, bt->child + u); } /* Final key */ @@ -299,8 +299,8 @@ H5B__cache_serialize(const H5F_t *f, void *_image, size_t H5_ATTR_UNUSED len, vo UINT16ENCODE(image, bt->nchildren); /* sibling pointers */ - H5F_addr_encode(f, &image, bt->left); - H5F_addr_encode(f, &image, bt->right); + H5_addr_encode(f, &image, bt->left); + H5_addr_encode(f, &image, bt->right); /* child keys and pointers */ native = bt->native; @@ -312,7 +312,7 @@ H5B__cache_serialize(const H5F_t *f, void *_image, size_t H5_ATTR_UNUSED len, vo native += shared->type->sizeof_nkey; /* encode the child address */ - H5F_addr_encode(f, &image, bt->child[u]); + H5_addr_encode(f, &image, bt->child[u]); } /* end for */ if (bt->nchildren > 0) { /* Encode the final key */ diff --git a/src/H5Bdbg.c b/src/H5Bdbg.c index b8e3d30..d54e041 100644 --- a/src/H5Bdbg.c +++ b/src/H5Bdbg.c @@ -58,7 +58,7 @@ H5B_debug(H5F_t *f, haddr_t addr, FILE *stream, int indent, int fwidth, const H5 * Check arguments. */ assert(f); - assert(H5F_addr_defined(addr)); + assert(H5_addr_defined(addr)); assert(stream); assert(indent >= 0); assert(fwidth >= 0); @@ -204,13 +204,13 @@ H5B__assert(H5F_t *f, haddr_t addr, const H5B_class_t *type, void *udata) /* Check node header */ assert(bt->level == cur->level); if (cur->next && cur->next->level == bt->level) - assert(H5F_addr_eq(bt->right, cur->next->addr)); + assert(H5_addr_eq(bt->right, cur->next->addr)); else - assert(!H5F_addr_defined(bt->right)); + assert(!H5_addr_defined(bt->right)); if (prev && prev->level == bt->level) - assert(H5F_addr_eq(bt->left, prev->addr)); + assert(H5_addr_eq(bt->left, prev->addr)); else - assert(!H5F_addr_defined(bt->left)); + assert(!H5_addr_defined(bt->left)); if (cur->level > 0) { unsigned u; @@ -221,7 +221,7 @@ H5B__assert(H5F_t *f, haddr_t addr, const H5B_class_t *type, void *udata) * have then the tree has a cycle. */ for (tmp = head; tmp; tmp = tmp->next) - assert(H5F_addr_ne(tmp->addr, bt->child[u])); + assert(H5_addr_ne(tmp->addr, bt->child[u])); /* Add the child node to the end of the queue */ tmp = (struct child_t *)H5MM_calloc(sizeof(struct child_t)); diff --git a/src/H5C.c b/src/H5C.c index ec17bd42..00c4563 100644 --- a/src/H5C.c +++ b/src/H5C.c @@ -804,7 +804,7 @@ H5C_expunge_entry(H5F_t *f, const H5C_class_t *type, haddr_t addr, unsigned flag assert(cache_ptr); assert(cache_ptr->magic == H5C__H5C_T_MAGIC); assert(type); - assert(H5F_addr_defined(addr)); + assert(H5_addr_defined(addr)); #ifdef H5C_DO_EXTREME_SANITY_CHECKS if (H5C__validate_lru_list(cache_ptr) < 0) @@ -1082,7 +1082,7 @@ H5C_insert_entry(H5F_t *f, const H5C_class_t *type, haddr_t addr, void *thing, u assert(type); assert(type->mem_type == cache_ptr->class_table_ptr[type->id]->mem_type); assert(type->image_len); - assert(H5F_addr_defined(addr)); + assert(H5_addr_defined(addr)); assert(thing); #ifdef H5C_DO_EXTREME_SANITY_CHECKS @@ -1358,7 +1358,7 @@ H5C_mark_entry_dirty(void *thing) /* Sanity checks */ assert(entry_ptr); - assert(H5F_addr_defined(entry_ptr->addr)); + assert(H5_addr_defined(entry_ptr->addr)); cache_ptr = entry_ptr->cache_ptr; assert(cache_ptr); assert(cache_ptr->magic == H5C__H5C_T_MAGIC); @@ -1456,7 +1456,7 @@ H5C_mark_entry_clean(void *_thing) /* Sanity checks */ assert(entry_ptr); - assert(H5F_addr_defined(entry_ptr->addr)); + assert(H5_addr_defined(entry_ptr->addr)); cache_ptr = entry_ptr->cache_ptr; assert(cache_ptr); assert(cache_ptr->magic == H5C__H5C_T_MAGIC); @@ -1531,7 +1531,7 @@ H5C_mark_entry_unserialized(void *thing) /* Sanity checks */ assert(entry); - assert(H5F_addr_defined(entry->addr)); + assert(H5_addr_defined(entry->addr)); if (entry->is_protected || entry->is_pinned) { assert(!entry->is_read_only); @@ -1577,7 +1577,7 @@ H5C_mark_entry_serialized(void *_thing) /* Sanity checks */ assert(entry); - assert(H5F_addr_defined(entry->addr)); + assert(H5_addr_defined(entry->addr)); /* Operate on pinned entry */ if (entry->is_protected) @@ -1628,9 +1628,9 @@ H5C_move_entry(H5C_t *cache_ptr, const H5C_class_t *type, haddr_t old_addr, hadd assert(cache_ptr); assert(cache_ptr->magic == H5C__H5C_T_MAGIC); assert(type); - assert(H5F_addr_defined(old_addr)); - assert(H5F_addr_defined(new_addr)); - assert(H5F_addr_ne(old_addr, new_addr)); + assert(H5_addr_defined(old_addr)); + assert(H5_addr_defined(new_addr)); + assert(H5_addr_ne(old_addr, new_addr)); #ifdef H5C_DO_EXTREME_SANITY_CHECKS if (H5C__validate_protected_entry_list(cache_ptr) < 0 || H5C__validate_pinned_entry_list(cache_ptr) < 0 || @@ -1774,7 +1774,7 @@ H5C_resize_entry(void *thing, size_t new_size) /* Sanity checks */ assert(entry_ptr); - assert(H5F_addr_defined(entry_ptr->addr)); + assert(H5_addr_defined(entry_ptr->addr)); cache_ptr = entry_ptr->cache_ptr; assert(cache_ptr); assert(cache_ptr->magic == H5C__H5C_T_MAGIC); @@ -1907,7 +1907,7 @@ H5C_pin_protected_entry(void *thing) /* Sanity checks */ assert(entry_ptr); - assert(H5F_addr_defined(entry_ptr->addr)); + assert(H5_addr_defined(entry_ptr->addr)); cache_ptr = entry_ptr->cache_ptr; assert(cache_ptr); assert(cache_ptr->magic == H5C__H5C_T_MAGIC); @@ -1989,7 +1989,7 @@ H5C_protect(H5F_t *f, const H5C_class_t *type, haddr_t addr, void *udata, unsign assert(cache_ptr->magic == H5C__H5C_T_MAGIC); assert(type); assert(type->mem_type == cache_ptr->class_table_ptr[type->id]->mem_type); - assert(H5F_addr_defined(addr)); + assert(H5_addr_defined(addr)); #ifdef H5C_DO_EXTREME_SANITY_CHECKS if (H5C__validate_protected_entry_list(cache_ptr) < 0 || H5C__validate_pinned_entry_list(cache_ptr) < 0 || @@ -2843,7 +2843,7 @@ H5C_unprotect(H5F_t *f, haddr_t addr, void *thing, unsigned flags) assert(cache_ptr); assert(cache_ptr->magic == H5C__H5C_T_MAGIC); - assert(H5F_addr_defined(addr)); + assert(H5_addr_defined(addr)); assert(thing); assert(!(pin_entry && unpin_entry)); @@ -3383,10 +3383,10 @@ H5C_create_flush_dependency(void *parent_thing, void *child_thing) /* Sanity checks */ assert(parent_entry); assert(parent_entry->magic == H5C__H5C_CACHE_ENTRY_T_MAGIC); - assert(H5F_addr_defined(parent_entry->addr)); + assert(H5_addr_defined(parent_entry->addr)); assert(child_entry); assert(child_entry->magic == H5C__H5C_CACHE_ENTRY_T_MAGIC); - assert(H5F_addr_defined(child_entry->addr)); + assert(H5_addr_defined(child_entry->addr)); cache_ptr = parent_entry->cache_ptr; assert(cache_ptr); assert(cache_ptr->magic == H5C__H5C_T_MAGIC); @@ -3525,10 +3525,10 @@ H5C_destroy_flush_dependency(void *parent_thing, void *child_thing) /* Sanity checks */ assert(parent_entry); assert(parent_entry->magic == H5C__H5C_CACHE_ENTRY_T_MAGIC); - assert(H5F_addr_defined(parent_entry->addr)); + assert(H5_addr_defined(parent_entry->addr)); assert(child_entry); assert(child_entry->magic == H5C__H5C_CACHE_ENTRY_T_MAGIC); - assert(H5F_addr_defined(child_entry->addr)); + assert(H5_addr_defined(child_entry->addr)); cache_ptr = parent_entry->cache_ptr; assert(cache_ptr); assert(cache_ptr->magic == H5C__H5C_T_MAGIC); @@ -5958,7 +5958,7 @@ H5C__flush_single_entry(H5F_t *f, H5C_cache_entry_t *entry_ptr, unsigned flags) hsize_t fsf_size; /* Sanity checks */ - assert(H5F_addr_defined(entry_ptr->addr)); + assert(H5_addr_defined(entry_ptr->addr)); assert(!H5F_IS_TMP_ADDR(f, entry_ptr->addr)); #ifndef NDEBUG { @@ -6113,15 +6113,15 @@ H5C__verify_len_eoa(H5F_t *f, const H5C_class_t *type, haddr_t addr, size_t *len /* Get the file's end-of-allocation value */ eoa = H5F_get_eoa(f, cooked_type); - if (!H5F_addr_defined(eoa)) + if (!H5_addr_defined(eoa)) HGOTO_ERROR(H5E_CACHE, H5E_BADVALUE, FAIL, "invalid EOA address for file") /* Check for bad address in general */ - if (H5F_addr_gt(addr, eoa)) + if (H5_addr_gt(addr, eoa)) HGOTO_ERROR(H5E_CACHE, H5E_BADVALUE, FAIL, "address of object past end of allocation") /* Check if the amount of data to read will be past the EOA */ - if (H5F_addr_gt((addr + *len), eoa)) { + if (H5_addr_gt((addr + *len), eoa)) { if (actual) HGOTO_ERROR(H5E_CACHE, H5E_BADVALUE, FAIL, "actual len exceeds EOA") else @@ -6180,7 +6180,7 @@ H5C__load_entry(H5F_t *f, assert(f->shared); assert(f->shared->cache); assert(type); - assert(H5F_addr_defined(addr)); + assert(H5_addr_defined(addr)); assert(type->get_initial_load_size); if (type->flags & H5C__CLASS_SPECULATIVE_LOAD_FLAG) assert(type->get_final_load_size); @@ -7131,7 +7131,7 @@ H5C_cork(H5C_t *cache_ptr, haddr_t obj_addr, unsigned action, hbool_t *corked) /* Assertions */ assert(cache_ptr != NULL); - assert(H5F_addr_defined(obj_addr)); + assert(H5_addr_defined(obj_addr)); assert(action == H5C__SET_CORK || action == H5C__UNCORK || action == H5C__GET_CORKED); /* Search the list of corked object addresses in the cache */ diff --git a/src/H5Cdbg.c b/src/H5Cdbg.c index 3ad67a1..0411e8e 100644 --- a/src/H5Cdbg.c +++ b/src/H5Cdbg.c @@ -846,8 +846,8 @@ H5C_flush_dependency_exists(H5C_t *cache_ptr, haddr_t parent_addr, haddr_t child /* Sanity checks */ assert(cache_ptr); assert(cache_ptr->magic == H5C__H5C_T_MAGIC); - assert(H5F_addr_defined(parent_addr)); - assert(H5F_addr_defined(child_addr)); + assert(H5_addr_defined(parent_addr)); + assert(H5_addr_defined(child_addr)); assert(fd_exists_ptr); H5C__SEARCH_INDEX(cache_ptr, parent_addr, parent_ptr, FAIL) @@ -1044,7 +1044,7 @@ H5C_get_entry_ptr_from_addr(H5C_t *cache_ptr, haddr_t addr, void **entry_ptr_ptr /* Sanity checks */ assert(cache_ptr); assert(cache_ptr->magic == H5C__H5C_T_MAGIC); - assert(H5F_addr_defined(addr)); + assert(H5_addr_defined(addr)); assert(entry_ptr_ptr); H5C__SEARCH_INDEX(cache_ptr, addr, entry_ptr, FAIL) @@ -1175,7 +1175,7 @@ H5C_verify_entry_type(H5C_t *cache_ptr, haddr_t addr, const H5C_class_t *expecte /* Sanity checks */ assert(cache_ptr); assert(cache_ptr->magic == H5C__H5C_T_MAGIC); - assert(H5F_addr_defined(addr)); + assert(H5_addr_defined(addr)); assert(expected_type); assert(in_cache_ptr); assert(type_ok_ptr); diff --git a/src/H5Cimage.c b/src/H5Cimage.c index 5f5c93d..0d0e42b 100644 --- a/src/H5Cimage.c +++ b/src/H5Cimage.c @@ -535,7 +535,7 @@ H5C__deserialize_prefetched_entry(H5F_t *f, H5C_t *cache_ptr, H5C_cache_entry_t * either the speculative read flag. Hence disallow. */ assert(!((type->flags & H5C__CLASS_SKIP_READS) && (type->flags & H5C__CLASS_SPECULATIVE_LOAD_FLAG))); - assert(H5F_addr_defined(addr)); + assert(H5_addr_defined(addr)); assert(type->get_initial_load_size); assert(type->deserialize); @@ -993,7 +993,7 @@ H5C__read_cache_image(H5F_t *f, H5C_t *cache_ptr) /* Sanity checks */ assert(f); assert(cache_ptr); - assert(H5F_addr_defined(cache_ptr->image_addr)); + assert(H5_addr_defined(cache_ptr->image_addr)); assert(cache_ptr->image_len > 0); assert(cache_ptr->image_buffer); @@ -1075,7 +1075,7 @@ H5C__load_cache_image(H5F_t *f) * no image exists, and that the load operation should be skipped * silently. */ - if (H5F_addr_defined(cache_ptr->image_addr)) { + if (H5_addr_defined(cache_ptr->image_addr)) { /* Sanity checks */ assert(cache_ptr->image_len > 0); assert(cache_ptr->image_buffer == NULL); @@ -1893,8 +1893,8 @@ H5C__decode_cache_image_entry(const H5F_t *f, const H5C_t *cache_ptr, const uint assert((in_lru && lru_rank >= 0) || (!in_lru && lru_rank == -1)); /* Decode entry offset */ - H5F_addr_decode(f, &p, &addr); - if (!H5F_addr_defined(addr)) + H5_addr_decode(f, &p, &addr); + if (!H5_addr_defined(addr)) HGOTO_ERROR(H5E_CACHE, H5E_BADVALUE, FAIL, "invalid entry offset") /* Decode entry length */ @@ -1916,8 +1916,8 @@ H5C__decode_cache_image_entry(const H5F_t *f, const H5C_t *cache_ptr, const uint HGOTO_ERROR(H5E_CACHE, H5E_CANTALLOC, FAIL, "memory allocation failed for fd parent addrs buffer") for (i = 0; i < fd_parent_count; i++) { - H5F_addr_decode(f, &p, &(fd_parent_addrs[i])); - if (!H5F_addr_defined(fd_parent_addrs[i])) + H5_addr_decode(f, &p, &(fd_parent_addrs[i])); + if (!H5_addr_defined(fd_parent_addrs[i])) HGOTO_ERROR(H5E_CACHE, H5E_BADVALUE, FAIL, "invalid flush dependency parent offset") } /* end for */ } /* end if */ @@ -2238,7 +2238,7 @@ H5C__encode_cache_image_entry(H5F_t *f, H5C_t *cache_ptr, uint8_t **buf, unsigne INT32ENCODE(p, ie_ptr->lru_rank); /* Encode entry offset */ - H5F_addr_encode(f, &p, ie_ptr->addr); + H5_addr_encode(f, &p, ie_ptr->addr); /* Encode entry length */ H5F_ENCODE_LENGTH(f, p, ie_ptr->size); @@ -2249,7 +2249,7 @@ H5C__encode_cache_image_entry(H5F_t *f, H5C_t *cache_ptr, uint8_t **buf, unsigne /* Encode dependency parent offsets -- if any */ for (u = 0; u < ie_ptr->fd_parent_count; u++) - H5F_addr_encode(f, &p, ie_ptr->fd_parent_addrs[u]); + H5_addr_encode(f, &p, ie_ptr->fd_parent_addrs[u]); /* Copy entry image */ H5MM_memcpy(p, ie_ptr->image_ptr, ie_ptr->size); @@ -2803,7 +2803,7 @@ H5C__prep_for_file_close__scan_entries(const H5F_t *f, H5C_t *cache_ptr) for (int i = 0; i < (int)(entry_ptr->fd_parent_count); i++) { entry_ptr->fd_parent_addrs[i] = entry_ptr->flush_dep_parent[i]->addr; - assert(H5F_addr_defined(entry_ptr->fd_parent_addrs[i])); + assert(H5_addr_defined(entry_ptr->fd_parent_addrs[i])); } /* end for */ } /* end if */ else if (entry_ptr->fd_parent_count > 0) { @@ -3020,7 +3020,7 @@ H5C__reconstruct_cache_contents(H5F_t *f, H5C_t *cache_ptr) for (v = 0; v < pf_entry_ptr->fd_parent_count; v++) { /* Sanity checks */ assert(pf_entry_ptr->fd_parent_addrs); - assert(H5F_addr_defined(pf_entry_ptr->fd_parent_addrs[v])); + assert(H5_addr_defined(pf_entry_ptr->fd_parent_addrs[v])); /* Find the parent entry */ parent_ptr = NULL; @@ -3243,8 +3243,8 @@ H5C__reconstruct_cache_entry(const H5F_t *f, H5C_t *cache_ptr, const uint8_t **b assert((in_lru && pf_entry_ptr->lru_rank >= 0) || (!in_lru && pf_entry_ptr->lru_rank == -1)); /* Decode entry offset */ - H5F_addr_decode(f, &p, &pf_entry_ptr->addr); - if (!H5F_addr_defined(pf_entry_ptr->addr)) + H5_addr_decode(f, &p, &pf_entry_ptr->addr); + if (!H5_addr_defined(pf_entry_ptr->addr)) HGOTO_ERROR(H5E_CACHE, H5E_BADVALUE, NULL, "invalid entry offset") /* Decode entry length */ @@ -3267,8 +3267,8 @@ H5C__reconstruct_cache_entry(const H5F_t *f, H5C_t *cache_ptr, const uint8_t **b HGOTO_ERROR(H5E_CACHE, H5E_CANTALLOC, NULL, "memory allocation failed for fd parent addrs buffer") for (u = 0; u < pf_entry_ptr->fd_parent_count; u++) { - H5F_addr_decode(f, &p, &(pf_entry_ptr->fd_parent_addrs[u])); - if (!H5F_addr_defined(pf_entry_ptr->fd_parent_addrs[u])) + H5_addr_decode(f, &p, &(pf_entry_ptr->fd_parent_addrs[u])); + if (!H5_addr_defined(pf_entry_ptr->fd_parent_addrs[u])) HGOTO_ERROR(H5E_CACHE, H5E_BADVALUE, NULL, "invalid flush dependency parent offset") } /* end for */ } /* end if */ @@ -3390,7 +3390,7 @@ H5C__write_cache_image(H5F_t *f, const H5C_t *cache_ptr) /* Sanity checks */ assert(f); assert(cache_ptr); - assert(H5F_addr_defined(cache_ptr->image_addr)); + assert(H5_addr_defined(cache_ptr->image_addr)); assert(cache_ptr->image_len > 0); assert(cache_ptr->image_buffer); diff --git a/src/H5Cmpio.c b/src/H5Cmpio.c index 86a266d..9d453b9 100644 --- a/src/H5Cmpio.c +++ b/src/H5Cmpio.c @@ -273,7 +273,7 @@ H5C_apply_candidate_list(H5F_t *f, H5C_t *cache_ptr, unsigned num_candidates, ha for (u = 0; u < num_candidates; u++) { addr = candidates_list_ptr[u]; - assert(H5F_addr_defined(addr)); + assert(H5_addr_defined(addr)); #ifdef H5C_DO_SANITY_CHECKS if (u > 0) { @@ -665,7 +665,7 @@ H5C_mark_entries_as_clean(H5F_t *f, unsigned ce_array_len, haddr_t *ce_array_ptr #endif /* H5C_DO_EXTREME_SANITY_CHECKS */ #endif /* H5C_DO_SANITY_CHECKS */ - assert(H5F_addr_defined(addr)); + assert(H5_addr_defined(addr)); H5C__SEARCH_INDEX(cache_ptr, addr, entry_ptr, FAIL) diff --git a/src/H5Cpkg.h b/src/H5Cpkg.h index 095dc8b..e337a88 100644 --- a/src/H5Cpkg.h +++ b/src/H5Cpkg.h @@ -828,7 +828,7 @@ if ( ( ( ( (head_ptr) == NULL ) || ( (tail_ptr) == NULL ) ) && \ if ( ( (cache_ptr) == NULL ) || \ ( (cache_ptr)->magic != H5C__H5C_T_MAGIC ) || \ ( (entry_ptr) == NULL ) || \ - ( ! H5F_addr_defined((entry_ptr)->addr) ) || \ + ( ! H5_addr_defined((entry_ptr)->addr) ) || \ ( (entry_ptr)->ht_next != NULL ) || \ ( (entry_ptr)->ht_prev != NULL ) || \ ( (entry_ptr)->size <= 0 ) || \ @@ -880,7 +880,7 @@ if ( ( (cache_ptr) == NULL ) || \ ( (cache_ptr)->index_len < 1 ) || \ ( (entry_ptr) == NULL ) || \ ( (cache_ptr)->index_size < (entry_ptr)->size ) || \ - ( ! H5F_addr_defined((entry_ptr)->addr) ) || \ + ( ! H5_addr_defined((entry_ptr)->addr) ) || \ ( (entry_ptr)->size <= 0 ) || \ ( H5C__HASH_FCN((entry_ptr)->addr) < 0 ) || \ ( H5C__HASH_FCN((entry_ptr)->addr) >= H5C__HASH_TABLE_LEN ) || \ @@ -918,7 +918,7 @@ if ( ( (cache_ptr) == NULL ) || \ if ( ( (cache_ptr) == NULL ) || \ ( (cache_ptr)->magic != H5C__H5C_T_MAGIC ) || \ ( (entry_ptr) == NULL ) || \ - ( ! H5F_addr_defined((entry_ptr)->addr) ) || \ + ( ! H5_addr_defined((entry_ptr)->addr) ) || \ ( (entry_ptr)->size <= 0 ) || \ ( (entry_ptr)->ht_prev != NULL ) || \ ( (entry_ptr)->ht_prev != NULL ) || \ @@ -945,7 +945,7 @@ if ( ( (cache_ptr) == NULL ) || \ ( (cache_ptr)->magic != H5C__H5C_T_MAGIC ) || \ ( (cache_ptr)->index_size != \ ((cache_ptr)->clean_index_size + (cache_ptr)->dirty_index_size) ) || \ - ( ! H5F_addr_defined(entry_addr) ) || \ + ( ! H5_addr_defined(entry_addr) ) || \ ( H5C__HASH_FCN(entry_addr) < 0 ) || \ ( H5C__HASH_FCN(entry_addr) >= H5C__HASH_TABLE_LEN ) ) { \ HGOTO_ERROR(H5E_CACHE, H5E_SYSTEM, (fail_val), "pre HT search SC failed") \ @@ -1228,7 +1228,7 @@ if ( ( (cache_ptr)->index_size != \ k = H5C__HASH_FCN(entry_addr); \ entry_ptr = ((cache_ptr)->index)[k]; \ while(entry_ptr) { \ - if(H5F_addr_eq(entry_addr, (entry_ptr)->addr)) { \ + if(H5_addr_eq(entry_addr, (entry_ptr)->addr)) { \ H5C__POST_SUC_HT_SEARCH_SC(cache_ptr, entry_ptr, k, fail_val) \ if(entry_ptr != ((cache_ptr)->index)[k]) { \ if((entry_ptr)->ht_next) \ @@ -1360,7 +1360,7 @@ if ( ( (cache_ptr)->index_size != \ \ assert( (entry_ptr) ); \ assert( (entry_ptr)->size > 0 ); \ - assert( H5F_addr_defined((entry_ptr)->addr) ); \ + assert( H5_addr_defined((entry_ptr)->addr) ); \ assert( !((entry_ptr)->in_slist) ); \ assert( ! H5C_ENTRY_IN_SLIST((cache_ptr), (entry_ptr)) ); \ assert( (entry_ptr)->ring > H5C_RING_UNDEFINED ); \ @@ -1406,7 +1406,7 @@ if ( ( (cache_ptr)->index_size != \ assert( (entry_ptr) ); \ assert( (entry_ptr)->size > 0 ); \ assert( ! H5C_ENTRY_IN_SLIST((cache_ptr), (entry_ptr)) ); \ - assert( H5F_addr_defined((entry_ptr)->addr) ); \ + assert( H5_addr_defined((entry_ptr)->addr) ); \ assert( !((entry_ptr)->in_slist) ); \ assert( (entry_ptr)->ring > H5C_RING_UNDEFINED ); \ assert( (entry_ptr)->ring < H5C_RING_NTYPES ); \ diff --git a/src/H5Cquery.c b/src/H5Cquery.c index 36e1edb..d0c65af 100644 --- a/src/H5Cquery.c +++ b/src/H5Cquery.c @@ -234,7 +234,7 @@ H5C_get_entry_status(const H5F_t *f, haddr_t addr, size_t *size_ptr, hbool_t *in assert(cache_ptr != NULL); assert(cache_ptr->magic == H5C__H5C_T_MAGIC); - assert(H5F_addr_defined(addr)); + assert(H5_addr_defined(addr)); assert(in_cache_ptr != NULL); /* this test duplicates two of the above asserts, but we need an @@ -355,7 +355,7 @@ H5C_get_entry_ring(const H5F_t *f, haddr_t addr, H5C_ring_t *ring) cache_ptr = f->shared->cache; assert(cache_ptr); assert(cache_ptr->magic == H5C__H5C_T_MAGIC); - assert(H5F_addr_defined(addr)); + assert(H5_addr_defined(addr)); /* Locate the entry at the address */ H5C__SEARCH_INDEX(cache_ptr, addr, entry_ptr, FAIL) diff --git a/src/H5Ctag.c b/src/H5Ctag.c index 4fbc5d4..b37c851 100644 --- a/src/H5Ctag.c +++ b/src/H5Ctag.c @@ -227,7 +227,7 @@ H5C__tag_entry(H5C_t *cache, H5C_cache_entry_t *entry) arbitrarily set it to something for the sake of passing the tests. If the tag value is set, then we'll just let it get assigned without additional checking for correctness. */ - if (!H5F_addr_defined(tag)) + if (!H5_addr_defined(tag)) tag = H5AC__IGNORE_TAG; } #ifdef H5C_DO_TAGGING_SANITY_CHECKS diff --git a/src/H5Dbtree.c b/src/H5Dbtree.c index c95a827..2ddd84b 100644 --- a/src/H5Dbtree.c +++ b/src/H5Dbtree.c @@ -245,7 +245,7 @@ H5D__btree_new_node(H5F_t H5_ATTR_NDEBUG_UNUSED *f, H5B_ins_t op, void *_lt_key, assert(addr_p); /* Set address */ - assert(H5F_addr_defined(udata->chunk_block.offset)); + assert(H5_addr_defined(udata->chunk_block.offset)); assert(udata->chunk_block.length > 0); *addr_p = udata->chunk_block.offset; @@ -408,7 +408,7 @@ H5D__btree_found(H5F_t H5_ATTR_UNUSED *f, haddr_t addr, const void *_lt_key, hbo /* Check arguments */ assert(f); - assert(H5F_addr_defined(addr)); + assert(H5_addr_defined(addr)); assert(lt_key); assert(found); assert(udata); @@ -507,7 +507,7 @@ H5D__btree_insert(H5F_t H5_ATTR_NDEBUG_UNUSED *f, haddr_t H5_ATTR_NDEBUG_UNUSED /* check args */ assert(f); - assert(H5F_addr_defined(addr)); + assert(H5_addr_defined(addr)); assert(lt_key); assert(lt_key_changed); assert(md_key); @@ -530,7 +530,7 @@ H5D__btree_insert(H5F_t H5_ATTR_NDEBUG_UNUSED *f, haddr_t H5_ATTR_NDEBUG_UNUSED */ if (lt_key->nbytes != udata->chunk_block.length) { /* Set node's address (already re-allocated by main chunk routines) */ - assert(H5F_addr_defined(udata->chunk_block.offset)); + assert(H5_addr_defined(udata->chunk_block.offset)); *new_node_p = udata->chunk_block.offset; H5_CHECKED_ASSIGN(lt_key->nbytes, uint32_t, udata->chunk_block.length, hsize_t); lt_key->filter_mask = udata->filter_mask; @@ -539,7 +539,7 @@ H5D__btree_insert(H5F_t H5_ATTR_NDEBUG_UNUSED *f, haddr_t H5_ATTR_NDEBUG_UNUSED } else { /* Already have address in udata, from main chunk routines */ - assert(H5F_addr_defined(udata->chunk_block.offset)); + assert(H5_addr_defined(udata->chunk_block.offset)); ret_value = H5B_INS_NOOP; } } @@ -554,7 +554,7 @@ H5D__btree_insert(H5F_t H5_ATTR_NDEBUG_UNUSED *f, haddr_t H5_ATTR_NDEBUG_UNUSED for (u = 0; u < udata->common.layout->ndims; u++) md_key->scaled[u] = udata->common.scaled[u]; - assert(H5F_addr_defined(udata->chunk_block.offset)); + assert(H5_addr_defined(udata->chunk_block.offset)); *new_node_p = udata->chunk_block.offset; ret_value = H5B_INS_RIGHT; } @@ -810,7 +810,7 @@ H5D__btree_idx_init(const H5D_chk_idx_info_t *idx_info, const H5S_t H5_ATTR_UNUS assert(idx_info->pline); assert(idx_info->layout); assert(idx_info->storage); - assert(H5F_addr_defined(dset_ohdr_addr)); + assert(H5_addr_defined(dset_ohdr_addr)); idx_info->storage->u.btree.dset_ohdr_addr = dset_ohdr_addr; @@ -851,7 +851,7 @@ H5D__btree_idx_create(const H5D_chk_idx_info_t *idx_info) assert(idx_info->pline); assert(idx_info->layout); assert(idx_info->storage); - assert(!H5F_addr_defined(idx_info->storage->idx_addr)); + assert(!H5_addr_defined(idx_info->storage->idx_addr)); /* Initialize "user" data for B-tree callbacks, etc. */ udata.layout = idx_info->layout; @@ -882,7 +882,7 @@ H5D__btree_idx_is_space_alloc(const H5O_storage_chunk_t *storage) /* Check args */ assert(storage); - FUNC_LEAVE_NOAPI((hbool_t)H5F_addr_defined(storage->idx_addr)) + FUNC_LEAVE_NOAPI((hbool_t)H5_addr_defined(storage->idx_addr)) } /* end H5D__btree_idx_is_space_alloc() */ /*------------------------------------------------------------------------- @@ -907,7 +907,7 @@ H5D__btree_idx_insert(const H5D_chk_idx_info_t *idx_info, H5D_chunk_ud_t *udata, assert(idx_info->pline); assert(idx_info->layout); assert(idx_info->storage); - assert(H5F_addr_defined(idx_info->storage->idx_addr)); + assert(H5_addr_defined(idx_info->storage->idx_addr)); assert(udata); /* @@ -946,7 +946,7 @@ H5D__btree_idx_get_addr(const H5D_chk_idx_info_t *idx_info, H5D_chunk_ud_t *udat assert(idx_info->layout); assert(idx_info->layout->ndims > 0); assert(idx_info->storage); - assert(H5F_addr_defined(idx_info->storage->idx_addr)); + assert(H5_addr_defined(idx_info->storage->idx_addr)); assert(udata); /* Go get the chunk information from the B-tree */ @@ -1023,7 +1023,7 @@ H5D__btree_idx_iterate(const H5D_chk_idx_info_t *idx_info, H5D_chunk_cb_func_t c assert(idx_info->pline); assert(idx_info->layout); assert(idx_info->storage); - assert(H5F_addr_defined(idx_info->storage->idx_addr)); + assert(H5_addr_defined(idx_info->storage->idx_addr)); assert(chunk_cb); assert(chunk_udata); @@ -1063,7 +1063,7 @@ H5D__btree_idx_remove(const H5D_chk_idx_info_t *idx_info, H5D_chunk_common_ud_t assert(idx_info->pline); assert(idx_info->layout); assert(idx_info->storage); - assert(H5F_addr_defined(idx_info->storage->idx_addr)); + assert(H5_addr_defined(idx_info->storage->idx_addr)); assert(udata); /* Remove the chunk from the v1 B-tree index and release the space for the @@ -1102,7 +1102,7 @@ H5D__btree_idx_delete(const H5D_chk_idx_info_t *idx_info) assert(idx_info->storage); /* Check if the index data structure has been allocated */ - if (H5F_addr_defined(idx_info->storage->idx_addr)) { + if (H5_addr_defined(idx_info->storage->idx_addr)) { H5O_storage_chunk_t tmp_storage; /* Local copy of storage info */ H5D_chunk_common_ud_t udata; /* User data for B-tree operations */ @@ -1159,7 +1159,7 @@ H5D__btree_idx_copy_setup(const H5D_chk_idx_info_t *idx_info_src, const H5D_chk_ assert(idx_info_dst->pline); assert(idx_info_dst->layout); assert(idx_info_dst->storage); - assert(!H5F_addr_defined(idx_info_dst->storage->idx_addr)); + assert(!H5_addr_defined(idx_info_dst->storage->idx_addr)); /* Create shared B-tree info for each file */ if (H5D__btree_shared_create(idx_info_src->f, idx_info_src->storage, idx_info_src->layout) < 0) @@ -1171,7 +1171,7 @@ H5D__btree_idx_copy_setup(const H5D_chk_idx_info_t *idx_info_src, const H5D_chk_ /* Create the root of the B-tree that describes chunked storage in the dest. file */ if (H5D__btree_idx_create(idx_info_dst) < 0) HGOTO_ERROR(H5E_IO, H5E_CANTINIT, FAIL, "unable to initialize chunked storage") - assert(H5F_addr_defined(idx_info_dst->storage->idx_addr)); + assert(H5_addr_defined(idx_info_dst->storage->idx_addr)); done: FUNC_LEAVE_NOAPI_TAG(ret_value) diff --git a/src/H5Dbtree2.c b/src/H5Dbtree2.c index 9f6d4ed..ff420e1 100644 --- a/src/H5Dbtree2.c +++ b/src/H5Dbtree2.c @@ -361,7 +361,7 @@ H5D__bt2_unfilt_encode(uint8_t *raw, const void *_record, void *_ctx) assert(ctx); /* Encode the record's fields */ - H5F_addr_encode_len(ctx->sizeof_addr, &raw, record->chunk_addr); + H5_addr_encode_len(ctx->sizeof_addr, &raw, record->chunk_addr); /* (Don't encode the chunk size & filter mask for non-filtered B-tree records) */ for (u = 0; u < ctx->ndims; u++) UINT64ENCODE(raw, record->scaled[u]); @@ -393,7 +393,7 @@ H5D__bt2_unfilt_decode(const uint8_t *raw, void *_record, void *_ctx) assert(ctx); /* Decode the record's fields */ - H5F_addr_decode_len(ctx->sizeof_addr, &raw, &record->chunk_addr); + H5_addr_decode_len(ctx->sizeof_addr, &raw, &record->chunk_addr); record->nbytes = ctx->chunk_size; record->filter_mask = 0; for (u = 0; u < ctx->ndims; u++) @@ -459,11 +459,11 @@ H5D__bt2_filt_encode(uint8_t *raw, const void *_record, void *_ctx) /* Sanity check */ assert(ctx); assert(record); - assert(H5F_addr_defined(record->chunk_addr)); + assert(H5_addr_defined(record->chunk_addr)); assert(0 != record->nbytes); /* Encode the record's fields */ - H5F_addr_encode_len(ctx->sizeof_addr, &raw, record->chunk_addr); + H5_addr_encode_len(ctx->sizeof_addr, &raw, record->chunk_addr); UINT64ENCODE_VAR(raw, record->nbytes, ctx->chunk_size_len); UINT32ENCODE(raw, record->filter_mask); for (u = 0; u < ctx->ndims; u++) @@ -497,14 +497,14 @@ H5D__bt2_filt_decode(const uint8_t *raw, void *_record, void *_ctx) assert(record); /* Decode the record's fields */ - H5F_addr_decode_len(ctx->sizeof_addr, &raw, &record->chunk_addr); + H5_addr_decode_len(ctx->sizeof_addr, &raw, &record->chunk_addr); UINT64DECODE_VAR(raw, record->nbytes, ctx->chunk_size_len); UINT32DECODE(raw, record->filter_mask); for (u = 0; u < ctx->ndims; u++) UINT64DECODE(raw, record->scaled[u]); /* Sanity checks */ - assert(H5F_addr_defined(record->chunk_addr)); + assert(H5_addr_defined(record->chunk_addr)); assert(0 != record->nbytes); FUNC_LEAVE_NOAPI(SUCCEED) @@ -531,7 +531,7 @@ H5D__bt2_filt_debug(FILE *stream, int indent, int fwidth, const void *_record, c /* Sanity checks */ assert(record); - assert(H5F_addr_defined(record->chunk_addr)); + assert(H5_addr_defined(record->chunk_addr)); assert(0 != record->nbytes); fprintf(stream, "%*s%-*s %" PRIuHADDR "\n", indent, "", fwidth, "Chunk address:", record->chunk_addr); @@ -562,7 +562,7 @@ H5D__bt2_idx_init(const H5D_chk_idx_info_t H5_ATTR_UNUSED *idx_info, const H5S_t FUNC_ENTER_PACKAGE_NOERR /* Check args */ - assert(H5F_addr_defined(dset_ohdr_addr)); + assert(H5_addr_defined(dset_ohdr_addr)); idx_info->storage->u.btree2.dset_ohdr_addr = dset_ohdr_addr; @@ -599,7 +599,7 @@ H5D__btree2_idx_depend(const H5D_chk_idx_info_t *idx_info) assert(H5D_CHUNK_IDX_BT2 == idx_info->layout->idx_type); assert(idx_info->storage); assert(H5D_CHUNK_IDX_BT2 == idx_info->storage->idx_type); - assert(H5F_addr_defined(idx_info->storage->idx_addr)); + assert(H5_addr_defined(idx_info->storage->idx_addr)); assert(idx_info->storage->u.btree2.bt2); /* Set up object header location for dataset */ @@ -658,7 +658,7 @@ H5D__bt2_idx_open(const H5D_chk_idx_info_t *idx_info) assert(idx_info->layout); assert(H5D_CHUNK_IDX_BT2 == idx_info->layout->idx_type); assert(idx_info->storage); - assert(H5F_addr_defined(idx_info->storage->idx_addr)); + assert(H5_addr_defined(idx_info->storage->idx_addr)); assert(NULL == idx_info->storage->u.btree2.bt2); /* Set up the user data */ @@ -706,7 +706,7 @@ H5D__bt2_idx_create(const H5D_chk_idx_info_t *idx_info) assert(idx_info->pline); assert(idx_info->layout); assert(idx_info->storage); - assert(!H5F_addr_defined(idx_info->storage->idx_addr)); + assert(!H5_addr_defined(idx_info->storage->idx_addr)); bt2_cparam.rrec_size = H5F_SIZEOF_ADDR(idx_info->f) /* Address of chunk */ + (idx_info->layout->ndims - 1) * 8; /* # of dimensions x 64-bit chunk offsets */ @@ -774,7 +774,7 @@ H5D__bt2_idx_is_space_alloc(const H5O_storage_chunk_t *storage) /* Check args */ assert(storage); - FUNC_LEAVE_NOAPI((hbool_t)H5F_addr_defined(storage->idx_addr)) + FUNC_LEAVE_NOAPI((hbool_t)H5_addr_defined(storage->idx_addr)) } /* end H5D__bt2_idx_is_space_alloc() */ /*------------------------------------------------------------------------- @@ -849,9 +849,9 @@ H5D__bt2_idx_insert(const H5D_chk_idx_info_t *idx_info, H5D_chunk_ud_t *udata, assert(idx_info->pline); assert(idx_info->layout); assert(idx_info->storage); - assert(H5F_addr_defined(idx_info->storage->idx_addr)); + assert(H5_addr_defined(idx_info->storage->idx_addr)); assert(udata); - assert(H5F_addr_defined(udata->chunk_block.offset)); + assert(H5_addr_defined(udata->chunk_block.offset)); /* Check if the v2 B-tree is open yet */ if (NULL == idx_info->storage->u.btree2.bt2) { @@ -940,7 +940,7 @@ H5D__bt2_idx_get_addr(const H5D_chk_idx_info_t *idx_info, H5D_chunk_ud_t *udata) assert(idx_info->layout); assert(idx_info->layout->ndims > 0); assert(idx_info->storage); - assert(H5F_addr_defined(idx_info->storage->idx_addr)); + assert(H5_addr_defined(idx_info->storage->idx_addr)); assert(udata); /* Check if the v2 B-tree is open yet */ @@ -1057,7 +1057,7 @@ H5D__bt2_idx_iterate(const H5D_chk_idx_info_t *idx_info, H5D_chunk_cb_func_t chu assert(idx_info->pline); assert(idx_info->layout); assert(idx_info->storage); - assert(H5F_addr_defined(idx_info->storage->idx_addr)); + assert(H5_addr_defined(idx_info->storage->idx_addr)); assert(chunk_cb); assert(chunk_udata); @@ -1145,7 +1145,7 @@ H5D__bt2_idx_remove(const H5D_chk_idx_info_t *idx_info, H5D_chunk_common_ud_t *u assert(idx_info->pline); assert(idx_info->layout); assert(idx_info->storage); - assert(H5F_addr_defined(idx_info->storage->idx_addr)); + assert(H5_addr_defined(idx_info->storage->idx_addr)); assert(udata); /* Check if the v2 B-tree is open yet */ @@ -1207,7 +1207,7 @@ H5D__bt2_idx_delete(const H5D_chk_idx_info_t *idx_info) assert(idx_info->storage); /* Check if the index data structure has been allocated */ - if (H5F_addr_defined(idx_info->storage->idx_addr)) { + if (H5_addr_defined(idx_info->storage->idx_addr)) { /* Set up user data for creating context */ u_ctx.f = idx_info->f; u_ctx.ndims = idx_info->layout->ndims - 1; @@ -1261,7 +1261,7 @@ H5D__bt2_idx_copy_setup(const H5D_chk_idx_info_t *idx_info_src, const H5D_chk_id assert(idx_info_dst->pline); assert(idx_info_dst->layout); assert(idx_info_dst->storage); - assert(!H5F_addr_defined(idx_info_dst->storage->idx_addr)); + assert(!H5_addr_defined(idx_info_dst->storage->idx_addr)); /* Check if the source v2 B-tree is open yet */ if (NULL == idx_info_src->storage->u.btree2.bt2) @@ -1274,7 +1274,7 @@ H5D__bt2_idx_copy_setup(const H5D_chk_idx_info_t *idx_info_src, const H5D_chk_id /* Create v2 B-tree that describes the chunked dataset in the destination file */ if (H5D__bt2_idx_create(idx_info_dst) < 0) HGOTO_ERROR(H5E_DATASET, H5E_CANTINIT, FAIL, "unable to initialize chunked storage") - assert(H5F_addr_defined(idx_info_dst->storage->idx_addr)); + assert(H5_addr_defined(idx_info_dst->storage->idx_addr)); /* Reset metadata tag */ H5_END_TAG @@ -1343,7 +1343,7 @@ H5D__bt2_idx_size(const H5D_chk_idx_info_t *idx_info, hsize_t *index_size) assert(idx_info->pline); assert(idx_info->layout); assert(idx_info->storage); - assert(H5F_addr_defined(idx_info->storage->idx_addr)); + assert(H5_addr_defined(idx_info->storage->idx_addr)); assert(index_size); /* Open v2 B-tree */ diff --git a/src/H5Dchunk.c b/src/H5Dchunk.c index 465094c..3da5d98 100644 --- a/src/H5Dchunk.c +++ b/src/H5Dchunk.c @@ -405,8 +405,8 @@ H5D__chunk_direct_write(H5D_t *dset, uint32_t filters, hsize_t *offset, uint32_t HGOTO_ERROR(H5E_DATASET, H5E_CANTGET, FAIL, "error looking up chunk address") /* Sanity check */ - assert((H5F_addr_defined(udata.chunk_block.offset) && udata.chunk_block.length > 0) || - (!H5F_addr_defined(udata.chunk_block.offset) && udata.chunk_block.length == 0)); + assert((H5_addr_defined(udata.chunk_block.offset) && udata.chunk_block.length > 0) || + (!H5_addr_defined(udata.chunk_block.offset) && udata.chunk_block.length == 0)); /* Set the file block information for the old chunk */ /* (Which is only defined when overwriting an existing chunk) */ @@ -426,7 +426,7 @@ H5D__chunk_direct_write(H5D_t *dset, uint32_t filters, hsize_t *offset, uint32_t /* Set up the size of chunk for user data */ udata.chunk_block.length = data_size; - if (0 == idx_info.pline->nused && H5F_addr_defined(old_chunk.offset)) + if (0 == idx_info.pline->nused && H5_addr_defined(old_chunk.offset)) /* If there are no filters and we are overwriting the chunk we can just set values */ need_insert = FALSE; else { @@ -441,7 +441,7 @@ H5D__chunk_direct_write(H5D_t *dset, uint32_t filters, hsize_t *offset, uint32_t } /* end else */ /* Make sure the address of the chunk is returned. */ - if (!H5F_addr_defined(udata.chunk_block.offset)) + if (!H5_addr_defined(udata.chunk_block.offset)) HGOTO_ERROR(H5E_DATASET, H5E_BADVALUE, FAIL, "chunk address isn't defined") /* Evict the (old) entry from the cache if present, but do not flush @@ -518,8 +518,8 @@ H5D__chunk_direct_read(const H5D_t *dset, hsize_t *offset, uint32_t *filters, vo HGOTO_ERROR(H5E_DATASET, H5E_CANTGET, FAIL, "error looking up chunk address") /* Sanity check */ - assert((H5F_addr_defined(udata.chunk_block.offset) && udata.chunk_block.length > 0) || - (!H5F_addr_defined(udata.chunk_block.offset) && udata.chunk_block.length == 0)); + assert((H5_addr_defined(udata.chunk_block.offset) && udata.chunk_block.length > 0) || + (!H5_addr_defined(udata.chunk_block.offset) && udata.chunk_block.length == 0)); /* Check if the requested chunk exists in the chunk cache */ if (UINT_MAX != udata.idx_hint) { @@ -548,7 +548,7 @@ H5D__chunk_direct_read(const H5D_t *dset, hsize_t *offset, uint32_t *filters, vo } /* Make sure the address of the chunk is returned. */ - if (!H5F_addr_defined(udata.chunk_block.offset)) + if (!H5_addr_defined(udata.chunk_block.offset)) HGOTO_ERROR(H5E_DATASET, H5E_CANTGET, FAIL, "chunk address isn't defined") /* Read the chunk data into the supplied buffer */ @@ -606,11 +606,11 @@ H5D__get_chunk_storage_size(H5D_t *dset, const hsize_t *offset, hsize_t *storage HGOTO_ERROR(H5E_DATASET, H5E_CANTGET, FAIL, "error looking up chunk address") /* Sanity check */ - assert((H5F_addr_defined(udata.chunk_block.offset) && udata.chunk_block.length > 0) || - (!H5F_addr_defined(udata.chunk_block.offset) && udata.chunk_block.length == 0)); + assert((H5_addr_defined(udata.chunk_block.offset) && udata.chunk_block.length > 0) || + (!H5_addr_defined(udata.chunk_block.offset) && udata.chunk_block.length == 0)); /* The requested chunk is not in cache or on disk */ - if (!H5F_addr_defined(udata.chunk_block.offset) && UINT_MAX == udata.idx_hint) + if (!H5_addr_defined(udata.chunk_block.offset) && UINT_MAX == udata.idx_hint) HGOTO_ERROR(H5E_DATASET, H5E_CANTGET, FAIL, "chunk storage is not allocated") /* Check if there are filters registered to the dataset */ @@ -641,7 +641,7 @@ H5D__get_chunk_storage_size(H5D_t *dset, const hsize_t *offset, hsize_t *storage } /* Make sure the address of the chunk is returned. */ - if (!H5F_addr_defined(udata.chunk_block.offset)) + if (!H5_addr_defined(udata.chunk_block.offset)) HGOTO_ERROR(H5E_DATASET, H5E_CANTGET, FAIL, "chunk address isn't defined") /* Return the chunk size on disk */ @@ -2400,7 +2400,7 @@ H5D__chunk_mdio_init(H5D_io_info_t *io_info, H5D_dset_io_info_t *dinfo) piece_info->faddr = udata.chunk_block.offset; /* Add piece to MDIO operation if it has a file address */ - if (H5F_addr_defined(piece_info->faddr)) { + if (H5_addr_defined(piece_info->faddr)) { assert(io_info->sel_pieces); assert(io_info->pieces_added < io_info->piece_count); @@ -2473,7 +2473,7 @@ H5D__chunk_cacheable(const H5D_io_info_t H5_ATTR_PARALLEL_USED *io_info, H5D_dse */ H5_CHECK_OVERFLOW(dataset->shared->layout.u.chunk.size, uint32_t, size_t); if ((size_t)dataset->shared->layout.u.chunk.size > dataset->shared->cache.chunk.nbytes_max) { - if (write_op && !H5F_addr_defined(caddr)) { + if (write_op && !H5_addr_defined(caddr)) { const H5O_fill_t *fill = &(dataset->shared->dcpl_cache.fill); /* Fill value info */ H5D_fill_value_t fill_status; /* Fill value status */ @@ -2688,11 +2688,11 @@ H5D__chunk_read(H5D_io_info_t *io_info, H5D_dset_io_info_t *dset_info) assert(UINT_MAX == udata.idx_hint); /* Sanity check */ - assert((H5F_addr_defined(udata.chunk_block.offset) && udata.chunk_block.length > 0) || - (!H5F_addr_defined(udata.chunk_block.offset) && udata.chunk_block.length == 0)); + assert((H5_addr_defined(udata.chunk_block.offset) && udata.chunk_block.length > 0) || + (!H5_addr_defined(udata.chunk_block.offset) && udata.chunk_block.length == 0)); /* Check for non-existent chunk & skip it if appropriate */ - if (H5F_addr_defined(udata.chunk_block.offset)) { + if (H5_addr_defined(udata.chunk_block.offset)) { /* Add chunk to list for selection I/O, if not performing multi dataset I/O */ if (H5D_LAYOUT_CB_PERFORM_IO(io_info)) { chunk_mem_spaces[num_chunks] = chunk_info->mspace; @@ -2806,11 +2806,11 @@ H5D__chunk_read(H5D_io_info_t *io_info, H5D_dset_io_info_t *dset_info) HGOTO_ERROR(H5E_DATASET, H5E_CANTGET, FAIL, "error looking up chunk address") /* Sanity check */ - assert((H5F_addr_defined(udata.chunk_block.offset) && udata.chunk_block.length > 0) || - (!H5F_addr_defined(udata.chunk_block.offset) && udata.chunk_block.length == 0)); + assert((H5_addr_defined(udata.chunk_block.offset) && udata.chunk_block.length > 0) || + (!H5_addr_defined(udata.chunk_block.offset) && udata.chunk_block.length == 0)); /* Check for non-existent chunk & skip it if appropriate */ - if (H5F_addr_defined(udata.chunk_block.offset) || UINT_MAX != udata.idx_hint || + if (H5_addr_defined(udata.chunk_block.offset) || UINT_MAX != udata.idx_hint || !skip_missing_chunks) { H5D_io_info_t *chk_io_info; /* Pointer to I/O info object for this chunk */ void *chunk = NULL; /* Pointer to locked chunk buffer */ @@ -2841,7 +2841,7 @@ H5D__chunk_read(H5D_io_info_t *io_info, H5D_dset_io_info_t *dset_info) /* Point I/O info at contiguous I/O info for this chunk */ chk_io_info = &cpt_io_info; } /* end if */ - else if (H5F_addr_defined(udata.chunk_block.offset)) { + else if (H5_addr_defined(udata.chunk_block.offset)) { /* Set up the storage address information for this chunk */ ctg_store.contig.dset_addr = udata.chunk_block.offset; @@ -3009,8 +3009,8 @@ H5D__chunk_write(H5D_io_info_t *io_info, H5D_dset_io_info_t *dset_info) assert(UINT_MAX == udata.idx_hint); /* Sanity check */ - assert((H5F_addr_defined(udata.chunk_block.offset) && udata.chunk_block.length > 0) || - (!H5F_addr_defined(udata.chunk_block.offset) && udata.chunk_block.length == 0)); + assert((H5_addr_defined(udata.chunk_block.offset) && udata.chunk_block.length > 0) || + (!H5_addr_defined(udata.chunk_block.offset) && udata.chunk_block.length == 0)); /* Set chunk's [scaled] coordinates */ dset_info->store->chunk.scaled = chunk_info->scaled; @@ -3057,7 +3057,7 @@ H5D__chunk_write(H5D_io_info_t *io_info, H5D_dset_io_info_t *dset_info) } /* end if */ else { /* If the chunk hasn't been allocated on disk, do so now. */ - if (!H5F_addr_defined(udata.chunk_block.offset)) { + if (!H5_addr_defined(udata.chunk_block.offset)) { /* Compose chunked index info struct */ idx_info.f = dset_info->dset->oloc.file; idx_info.pline = &(dset_info->dset->shared->dcpl_cache.pline); @@ -3074,7 +3074,7 @@ H5D__chunk_write(H5D_io_info_t *io_info, H5D_dset_io_info_t *dset_info) "unable to insert/resize chunk on chunk level") /* Make sure the address of the chunk is returned. */ - if (!H5F_addr_defined(udata.chunk_block.offset)) + if (!H5_addr_defined(udata.chunk_block.offset)) HGOTO_ERROR(H5E_DATASET, H5E_CANTGET, FAIL, "chunk address isn't defined") /* Cache the new chunk information */ @@ -3167,8 +3167,8 @@ H5D__chunk_write(H5D_io_info_t *io_info, H5D_dset_io_info_t *dset_info) HGOTO_ERROR(H5E_DATASET, H5E_CANTGET, FAIL, "error looking up chunk address") /* Sanity check */ - assert((H5F_addr_defined(udata.chunk_block.offset) && udata.chunk_block.length > 0) || - (!H5F_addr_defined(udata.chunk_block.offset) && udata.chunk_block.length == 0)); + assert((H5_addr_defined(udata.chunk_block.offset) && udata.chunk_block.length > 0) || + (!H5_addr_defined(udata.chunk_block.offset) && udata.chunk_block.length == 0)); /* Set chunk's [scaled] coordinates */ dset_info->store->chunk.scaled = chunk_info->scaled; @@ -3206,7 +3206,7 @@ H5D__chunk_write(H5D_io_info_t *io_info, H5D_dset_io_info_t *dset_info) } /* end if */ else { /* If the chunk hasn't been allocated on disk, do so now. */ - if (!H5F_addr_defined(udata.chunk_block.offset)) { + if (!H5_addr_defined(udata.chunk_block.offset)) { /* Compose chunked index info struct */ idx_info.f = dset_info->dset->oloc.file; idx_info.pline = &(dset_info->dset->shared->dcpl_cache.pline); @@ -3223,7 +3223,7 @@ H5D__chunk_write(H5D_io_info_t *io_info, H5D_dset_io_info_t *dset_info) "unable to insert/resize chunk on chunk level") /* Make sure the address of the chunk is returned. */ - if (!H5F_addr_defined(udata.chunk_block.offset)) + if (!H5_addr_defined(udata.chunk_block.offset)) HGOTO_ERROR(H5E_DATASET, H5E_CANTGET, FAIL, "chunk address isn't defined") /* Cache the new chunk information */ @@ -3898,7 +3898,7 @@ H5D__chunk_flush_entry(const H5D_t *dset, H5D_rdcc_ent_t *ent, hbool_t reset) /* Indicate that the chunk must be allocated */ must_alloc = TRUE; } /* end if */ - else if (!H5F_addr_defined(udata.chunk_block.offset)) { + else if (!H5_addr_defined(udata.chunk_block.offset)) { /* Indicate that the chunk must be allocated */ must_alloc = TRUE; @@ -3942,7 +3942,7 @@ H5D__chunk_flush_entry(const H5D_t *dset, H5D_rdcc_ent_t *ent, hbool_t reset) } /* end if */ /* Write the data to the file */ - assert(H5F_addr_defined(udata.chunk_block.offset)); + assert(H5_addr_defined(udata.chunk_block.offset)); H5_CHECK_OVERFLOW(udata.chunk_block.length, hsize_t, size_t); if (H5F_shared_block_write(H5F_SHARED(dset->oloc.file), H5FD_MEM_DRAW, udata.chunk_block.offset, (size_t)udata.chunk_block.length, buf) < 0) @@ -4407,7 +4407,7 @@ H5D__chunk_lock(const H5D_io_info_t H5_ATTR_NDEBUG_UNUSED *io_info, const H5D_ds */ /* Check if the chunk exists on disk */ - if (H5F_addr_defined(chunk_addr)) { + if (H5_addr_defined(chunk_addr)) { size_t my_chunk_alloc = chunk_alloc; /* Allocated buffer size */ size_t buf_alloc = chunk_alloc; /* [Re-]allocated buffer size */ @@ -5029,7 +5029,7 @@ H5D__chunk_allocate(const H5D_t *dset, hbool_t full_overwrite, const hsize_t old #ifndef NDEBUG /* None of the chunks should be allocated */ if (H5D_CHUNK_IDX_NONE != sc->idx_type) - assert(!H5F_addr_defined(udata.chunk_block.offset)); + assert(!H5_addr_defined(udata.chunk_block.offset)); /* Make sure the chunk is really in the dataset and outside the * original dimensions */ @@ -5114,7 +5114,7 @@ H5D__chunk_allocate(const H5D_t *dset, hbool_t full_overwrite, const hsize_t old /* Allocate the chunk (with all processes) */ if (H5D__chunk_file_alloc(&idx_info, NULL, &udata.chunk_block, &need_insert, scaled) < 0) HGOTO_ERROR(H5E_DATASET, H5E_CANTINSERT, FAIL, "unable to insert/resize chunk on chunk level") - assert(H5F_addr_defined(udata.chunk_block.offset)); + assert(H5_addr_defined(udata.chunk_block.offset)); /* Check if fill values should be written to chunks */ if (should_fill) { @@ -5375,7 +5375,7 @@ H5D__chunk_update_old_edge_chunks(H5D_t *dset, hsize_t old_dim[]) /* If this chunk does not exist in cache or on disk, no need to do * anything */ - if (H5F_addr_defined(chk_udata.chunk_block.offset) || (UINT_MAX != chk_udata.idx_hint)) { + if (H5_addr_defined(chk_udata.chunk_block.offset) || (UINT_MAX != chk_udata.idx_hint)) { /* Lock the chunk into cache. H5D__chunk_lock will take care of * updating the chunk to no longer be an edge chunk. */ if (NULL == @@ -5690,7 +5690,7 @@ H5D__chunk_cmp_coll_fill_info(const void *_entry1, const void *_entry2) entry1 = (const struct chunk_coll_fill_info *)_entry1; entry2 = (const struct chunk_coll_fill_info *)_entry2; - FUNC_LEAVE_NOAPI(H5F_addr_cmp(entry1->addr, entry2->addr)) + FUNC_LEAVE_NOAPI(H5_addr_cmp(entry1->addr, entry2->addr)) } /* end H5D__chunk_cmp_coll_fill_info() */ #endif /* H5_HAVE_PARALLEL */ @@ -5735,7 +5735,7 @@ H5D__chunk_prune_fill(H5D_chunk_it_ud1_t *udata, hbool_t new_unfilt_chunk) chk_udata.new_unfilt_chunk = new_unfilt_chunk; /* If this chunk does not exist in cache or on disk, no need to do anything */ - if (!H5F_addr_defined(chk_udata.chunk_block.offset) && UINT_MAX == chk_udata.idx_hint) + if (!H5_addr_defined(chk_udata.chunk_block.offset) && UINT_MAX == chk_udata.idx_hint) HGOTO_DONE(SUCCEED) /* Initialize the fill value buffer, if necessary */ @@ -6175,7 +6175,7 @@ H5D__chunk_prune_by_extent(H5D_t *dset, const hsize_t *old_dim) HGOTO_ERROR(H5E_DATASET, H5E_CANTREMOVE, FAIL, "unable to evict chunk") /* Remove the chunk from disk, if present */ - if (H5F_addr_defined(chk_udata.chunk_block.offset)) { + if (H5_addr_defined(chk_udata.chunk_block.offset)) { /* Update the offset in idx_udata */ idx_udata.scaled = udata.common.scaled; @@ -6590,7 +6590,7 @@ H5D__chunk_copy_cb(const H5D_chunk_rec_t *chunk_rec, void *_udata) } /* end if */ if (udata->chunk_in_cache && udata->chunk) { - assert(!H5F_addr_defined(chunk_rec->chunk_addr)); + assert(!H5_addr_defined(chunk_rec->chunk_addr)); H5MM_memcpy(buf, udata->chunk, nbytes); udata->chunk = NULL; } @@ -6625,8 +6625,8 @@ H5D__chunk_copy_cb(const H5D_chunk_rec_t *chunk_rec, void *_udata) if (NULL == ent) HGOTO_ERROR(H5E_IO, H5E_BADVALUE, H5_ITER_ERROR, "NULL chunk entry pointer") - assert(H5F_addr_defined(chunk_rec->chunk_addr)); - assert(H5F_addr_defined(ent->chunk_block.offset)); + assert(H5_addr_defined(chunk_rec->chunk_addr)); + assert(H5_addr_defined(ent->chunk_block.offset)); H5_CHECKED_ASSIGN(nbytes, size_t, shared_fo->layout.u.chunk.size, uint32_t); H5MM_memcpy(buf, ent->chunk, nbytes); @@ -6729,7 +6729,7 @@ H5D__chunk_copy_cb(const H5D_chunk_rec_t *chunk_rec, void *_udata) HGOTO_ERROR(H5E_DATASET, H5E_CANTINSERT, FAIL, "unable to insert/resize chunk on chunk level") /* Write chunk data to destination file */ - assert(H5F_addr_defined(udata_dst.chunk_block.offset)); + assert(H5_addr_defined(udata_dst.chunk_block.offset)); if (H5F_block_write(udata->idx_info_dst->f, H5FD_MEM_DRAW, udata_dst.chunk_block.offset, nbytes, buf) < 0) HGOTO_ERROR(H5E_DATASET, H5E_WRITEERROR, H5_ITER_ERROR, "unable to write raw data to file") @@ -6989,7 +6989,7 @@ H5D__chunk_copy(H5F_t *f_src, H5O_storage_chunk_t *storage_src, H5O_layout_chunk chunk_rec.chunk_addr = HADDR_UNDEF; for (ent = shared_fo->cache.chunk.head; ent; ent = next) { - if (!H5F_addr_defined(ent->chunk_block.offset)) { + if (!H5_addr_defined(ent->chunk_block.offset)) { H5MM_memcpy(chunk_rec.scaled, ent->scaled, sizeof(chunk_rec.scaled)); udata.chunk = ent->chunk; udata.chunk_in_cache = TRUE; @@ -7056,7 +7056,7 @@ H5D__chunk_bh_info(const H5O_loc_t *loc, H5O_t *oh, H5O_layout_t *layout, hsize_ /* Check args */ assert(loc); assert(loc->file); - assert(H5F_addr_defined(loc->addr)); + assert(H5_addr_defined(loc->addr)); assert(layout); H5D_CHUNK_STORAGE_INDEX_CHK(sc); assert(index_size); @@ -7450,9 +7450,9 @@ H5D__chunk_file_alloc(const H5D_chk_idx_info_t *idx_info, const H5F_block_t *old HGOTO_ERROR(H5E_DATASET, H5E_BADRANGE, FAIL, "chunk size can't be encoded") } /* end block */ - if (old_chunk && H5F_addr_defined(old_chunk->offset)) { + if (old_chunk && H5_addr_defined(old_chunk->offset)) { /* Sanity check */ - assert(!H5F_addr_defined(new_chunk->offset) || H5F_addr_eq(new_chunk->offset, old_chunk->offset)); + assert(!H5_addr_defined(new_chunk->offset) || H5_addr_eq(new_chunk->offset, old_chunk->offset)); /* Check for chunk being same size */ if (new_chunk->length != old_chunk->length) { @@ -7468,17 +7468,17 @@ H5D__chunk_file_alloc(const H5D_chk_idx_info_t *idx_info, const H5F_block_t *old } /* end if */ else { /* Don't need to reallocate chunk, but send its address back up */ - if (!H5F_addr_defined(new_chunk->offset)) + if (!H5_addr_defined(new_chunk->offset)) new_chunk->offset = old_chunk->offset; } /* end else */ } /* end if */ else { - assert(!H5F_addr_defined(new_chunk->offset)); + assert(!H5_addr_defined(new_chunk->offset)); alloc_chunk = TRUE; } /* end else */ } /* end if */ else { - assert(!H5F_addr_defined(new_chunk->offset)); + assert(!H5_addr_defined(new_chunk->offset)); assert(new_chunk->length == idx_info->layout->size); alloc_chunk = TRUE; } /* end else */ @@ -7505,7 +7505,7 @@ H5D__chunk_file_alloc(const H5D_chk_idx_info_t *idx_info, const H5F_block_t *old assert(new_chunk->length > 0); H5_CHECK_OVERFLOW(new_chunk->length, /*From: */ uint32_t, /*To: */ hsize_t); new_chunk->offset = H5MF_alloc(idx_info->f, H5FD_MEM_DRAW, (hsize_t)new_chunk->length); - if (!H5F_addr_defined(new_chunk->offset)) + if (!H5_addr_defined(new_chunk->offset)) HGOTO_ERROR(H5E_DATASET, H5E_CANTALLOC, FAIL, "file allocation failed") *need_insert = TRUE; break; @@ -7517,7 +7517,7 @@ H5D__chunk_file_alloc(const H5D_chk_idx_info_t *idx_info, const H5F_block_t *old } /* end switch */ } /* end if */ - assert(H5F_addr_defined(new_chunk->offset)); + assert(H5_addr_defined(new_chunk->offset)); done: FUNC_LEAVE_NOAPI(ret_value) @@ -7593,7 +7593,7 @@ H5D__chunk_format_convert_cb(const H5D_chunk_rec_t *chunk_rec, void *_udata) /* Allocate space for the filtered chunk */ if ((chunk_addr = H5MF_alloc(new_idx_info->f, H5FD_MEM_DRAW, (hsize_t)nbytes)) == HADDR_UNDEF) HGOTO_ERROR(H5E_DATASET, H5E_NOSPACE, H5_ITER_ERROR, "file allocation failed for filtered chunk") - assert(H5F_addr_defined(chunk_addr)); + assert(H5_addr_defined(chunk_addr)); /* Write the filtered chunk to disk */ if (H5F_block_write(new_idx_info->f, H5FD_MEM_DRAW, chunk_addr, nbytes, buf) < 0) @@ -7725,7 +7725,7 @@ H5D__chunk_index_empty(const H5D_t *dset, hbool_t *empty) *empty = TRUE; - if (H5F_addr_defined(idx_info.storage->idx_addr)) { + if (H5_addr_defined(idx_info.storage->idx_addr)) { /* Iterate over the allocated chunks */ if ((dset->shared->layout.storage.u.chunk.ops->iterate)(&idx_info, H5D__chunk_index_empty_cb, empty) < 0) @@ -7810,7 +7810,7 @@ H5D__get_num_chunks(const H5D_t *dset, const H5S_t H5_ATTR_UNUSED *space, hsize_ idx_info.storage = &dset->shared->layout.storage.u.chunk; /* If the dataset is not written, number of chunks will be 0 */ - if (!H5F_addr_defined(idx_info.storage->idx_addr)) + if (!H5_addr_defined(idx_info.storage->idx_addr)) *nchunks = 0; else { /* Iterate over the allocated chunks */ @@ -7924,7 +7924,7 @@ H5D__get_chunk_info(const H5D_t *dset, const H5S_t H5_ATTR_UNUSED *space, hsize_ *size = 0; /* If the chunk is written, get its info, otherwise, return without error */ - if (H5F_addr_defined(idx_info.storage->idx_addr)) { + if (H5_addr_defined(idx_info.storage->idx_addr)) { /* Initialize before iteration */ udata.chunk_idx = chk_index; udata.curr_idx = 0; @@ -7952,7 +7952,7 @@ H5D__get_chunk_info(const H5D_t *dset, const H5S_t H5_ATTR_UNUSED *space, hsize_ for (ii = 0; ii < udata.ndims; ii++) offset[ii] = udata.scaled[ii] * dset->shared->layout.u.chunk.dim[ii]; } /* end if */ - } /* end if H5F_addr_defined */ + } /* end if H5_addr_defined */ done: FUNC_LEAVE_NOAPI_TAG(ret_value) @@ -8057,7 +8057,7 @@ H5D__get_chunk_info_by_coord(const H5D_t *dset, const hsize_t *offset, unsigned idx_info.storage = &dset->shared->layout.storage.u.chunk; /* If the dataset is not written, return without errors */ - if (H5F_addr_defined(idx_info.storage->idx_addr)) { + if (H5_addr_defined(idx_info.storage->idx_addr)) { /* Calculate the scaled of this chunk */ H5VM_chunk_scaled(dset->shared->ndims, offset, layout->u.chunk.dim, udata.scaled); udata.scaled[dset->shared->ndims] = 0; @@ -8084,7 +8084,7 @@ H5D__get_chunk_info_by_coord(const H5D_t *dset, const hsize_t *offset, unsigned if (size) *size = udata.nbytes; } /* end if */ - } /* end if H5F_addr_defined */ + } /* end if H5_addr_defined */ done: FUNC_LEAVE_NOAPI_TAG(ret_value) @@ -8170,7 +8170,7 @@ H5D__chunk_iter(H5D_t *dset, H5D_chunk_iter_op_t op, void *op_data) idx_info.storage = &layout->storage.u.chunk; /* If the dataset is not written, return without errors */ - if (H5F_addr_defined(idx_info.storage->idx_addr)) { + if (H5_addr_defined(idx_info.storage->idx_addr)) { H5D_chunk_iter_ud_t ud; /* Set up info for iteration callback */ @@ -8181,7 +8181,7 @@ H5D__chunk_iter(H5D_t *dset, H5D_chunk_iter_op_t op, void *op_data) /* Iterate over the allocated chunks calling the iterator callback */ if ((ret_value = (layout->storage.u.chunk.ops->iterate)(&idx_info, H5D__chunk_iter_cb, &ud)) < 0) HERROR(H5E_DATASET, H5E_CANTNEXT, "chunk iteration failed"); - } /* end if H5F_addr_defined */ + } /* end if H5_addr_defined */ done: FUNC_LEAVE_NOAPI_TAG(ret_value) diff --git a/src/H5Dcontig.c b/src/H5Dcontig.c index 53d02d3..27f903c 100644 --- a/src/H5Dcontig.c +++ b/src/H5Dcontig.c @@ -203,7 +203,7 @@ H5D__contig_fill(H5D_t *dset) /* Check args */ assert(dset && H5D_CONTIGUOUS == dset->shared->layout.type); - assert(H5F_addr_defined(dset->shared->layout.storage.u.contig.addr)); + assert(H5_addr_defined(dset->shared->layout.storage.u.contig.addr)); assert(dset->shared->layout.storage.u.contig.size > 0); assert(dset->shared->space); assert(dset->shared->type); @@ -517,7 +517,7 @@ H5D__contig_is_space_alloc(const H5O_storage_t *storage) assert(storage); /* Set return value */ - ret_value = (hbool_t)H5F_addr_defined(storage->u.contig.addr); + ret_value = (hbool_t)H5_addr_defined(storage->u.contig.addr); FUNC_LEAVE_NOAPI(ret_value) } /* end H5D__contig_is_space_alloc() */ diff --git a/src/H5Dearray.c b/src/H5Dearray.c index a080596..aa2f047 100644 --- a/src/H5Dearray.c +++ b/src/H5Dearray.c @@ -321,7 +321,7 @@ H5D__earray_encode(void *raw, const void *_elmt, size_t nelmts, void *_ctx) while (nelmts) { /* Encode element */ /* (advances 'raw' pointer) */ - H5F_addr_encode_len(ctx->file_addr_len, (uint8_t **)&raw, *elmt); + H5_addr_encode_len(ctx->file_addr_len, (uint8_t **)&raw, *elmt); /* Advance native element pointer */ elmt++; @@ -361,7 +361,7 @@ H5D__earray_decode(const void *_raw, void *_elmt, size_t nelmts, void *_ctx) while (nelmts) { /* Decode element */ /* (advances 'raw' pointer) */ - H5F_addr_decode_len(ctx->file_addr_len, &raw, elmt); + H5_addr_decode_len(ctx->file_addr_len, &raw, elmt); /* Advance native element pointer */ elmt++; @@ -458,7 +458,7 @@ H5D__earray_filt_encode(void *_raw, const void *_elmt, size_t nelmts, void *_ctx while (nelmts) { /* Encode element */ /* (advances 'raw' pointer) */ - H5F_addr_encode_len(ctx->file_addr_len, &raw, elmt->addr); + H5_addr_encode_len(ctx->file_addr_len, &raw, elmt->addr); UINT64ENCODE_VAR(raw, elmt->nbytes, ctx->chunk_size_len); UINT32ENCODE(raw, elmt->filter_mask); @@ -501,7 +501,7 @@ H5D__earray_filt_decode(const void *_raw, void *_elmt, size_t nelmts, void *_ctx while (nelmts) { /* Decode element */ /* (advances 'raw' pointer) */ - H5F_addr_decode_len(ctx->file_addr_len, &raw, &elmt->addr); + H5_addr_decode_len(ctx->file_addr_len, &raw, &elmt->addr); UINT64DECODE_VAR(raw, elmt->nbytes, ctx->chunk_size_len); UINT32DECODE(raw, elmt->filter_mask); @@ -570,7 +570,7 @@ H5D__earray_crt_dbg_context(H5F_t *f, haddr_t obj_addr) /* Sanity checks */ assert(f); - assert(H5F_addr_defined(obj_addr)); + assert(H5_addr_defined(obj_addr)); /* Allocate context for debugging callback */ if (NULL == (dbg_ctx = H5FL_MALLOC(H5D_earray_ctx_ud_t))) @@ -676,7 +676,7 @@ H5D__earray_idx_depend(const H5D_chk_idx_info_t *idx_info) assert(H5D_CHUNK_IDX_EARRAY == idx_info->layout->idx_type); assert(idx_info->storage); assert(H5D_CHUNK_IDX_EARRAY == idx_info->storage->idx_type); - assert(H5F_addr_defined(idx_info->storage->idx_addr)); + assert(H5_addr_defined(idx_info->storage->idx_addr)); assert(idx_info->storage->u.earray.ea); /* Set up object header location for dataset */ @@ -736,7 +736,7 @@ H5D__earray_idx_open(const H5D_chk_idx_info_t *idx_info) assert(H5D_CHUNK_IDX_EARRAY == idx_info->layout->idx_type); assert(idx_info->storage); assert(H5D_CHUNK_IDX_EARRAY == idx_info->storage->idx_type); - assert(H5F_addr_defined(idx_info->storage->idx_addr)); + assert(H5_addr_defined(idx_info->storage->idx_addr)); assert(NULL == idx_info->storage->u.earray.ea); /* Set up the user data */ @@ -786,7 +786,7 @@ H5D__earray_idx_init(const H5D_chk_idx_info_t *idx_info, const H5S_t *space, had assert(idx_info->layout); assert(idx_info->storage); assert(space); - assert(H5F_addr_defined(dset_ohdr_addr)); + assert(H5_addr_defined(dset_ohdr_addr)); /* Get the dim info for dataset */ if ((sndims = H5S_get_simple_extent_dims(space, NULL, max_dims)) < 0) @@ -851,7 +851,7 @@ H5D__earray_idx_create(const H5D_chk_idx_info_t *idx_info) assert(idx_info->pline); assert(idx_info->layout); assert(idx_info->storage); - assert(!H5F_addr_defined(idx_info->storage->idx_addr)); + assert(!H5_addr_defined(idx_info->storage->idx_addr)); assert(NULL == idx_info->storage->u.earray.ea); /* General parameters */ @@ -922,7 +922,7 @@ H5D__earray_idx_is_space_alloc(const H5O_storage_chunk_t *storage) /* Check args */ assert(storage); - FUNC_LEAVE_NOAPI((hbool_t)H5F_addr_defined(storage->idx_addr)) + FUNC_LEAVE_NOAPI((hbool_t)H5_addr_defined(storage->idx_addr)) } /* end H5D__earray_idx_is_space_alloc() */ /*------------------------------------------------------------------------- @@ -949,7 +949,7 @@ H5D__earray_idx_insert(const H5D_chk_idx_info_t *idx_info, H5D_chunk_ud_t *udata assert(idx_info->pline); assert(idx_info->layout); assert(idx_info->storage); - assert(H5F_addr_defined(idx_info->storage->idx_addr)); + assert(H5_addr_defined(idx_info->storage->idx_addr)); assert(udata); /* Check if the extensible array is open yet */ @@ -964,7 +964,7 @@ H5D__earray_idx_insert(const H5D_chk_idx_info_t *idx_info, H5D_chunk_ud_t *udata /* Set convenience pointer to extensible array structure */ ea = idx_info->storage->u.earray.ea; - if (!H5F_addr_defined(udata->chunk_block.offset)) + if (!H5_addr_defined(udata->chunk_block.offset)) HGOTO_ERROR(H5E_DATASET, H5E_CANTALLOC, FAIL, "The chunk should have allocated already") if (udata->chunk_idx != (udata->chunk_idx & 0xffffffff)) /* negative value */ HGOTO_ERROR(H5E_ARGS, H5E_BADRANGE, FAIL, "chunk index must be less than 2^32") @@ -1017,7 +1017,7 @@ H5D__earray_idx_get_addr(const H5D_chk_idx_info_t *idx_info, H5D_chunk_ud_t *uda assert(idx_info->pline); assert(idx_info->layout); assert(idx_info->storage); - assert(H5F_addr_defined(idx_info->storage->idx_addr)); + assert(H5_addr_defined(idx_info->storage->idx_addr)); assert(udata); /* Check if the extensible array is open yet */ @@ -1079,7 +1079,7 @@ H5D__earray_idx_get_addr(const H5D_chk_idx_info_t *idx_info, H5D_chunk_ud_t *uda udata->filter_mask = 0; } /* end else */ - if (!H5F_addr_defined(udata->chunk_block.offset)) + if (!H5_addr_defined(udata->chunk_block.offset)) udata->chunk_block.length = 0; done: @@ -1164,7 +1164,7 @@ H5D__earray_idx_iterate_cb(hsize_t H5_ATTR_UNUSED idx, const void *_elmt, void * udata->chunk_rec.chunk_addr = *(const haddr_t *)_elmt; /* Make "generic chunk" callback */ - if (H5F_addr_defined(udata->chunk_rec.chunk_addr)) + if (H5_addr_defined(udata->chunk_rec.chunk_addr)) if ((ret_value = (udata->cb)(&udata->chunk_rec, udata->udata)) < 0) HERROR(H5E_DATASET, H5E_CALLBACK, "failure in generic chunk iterator callback"); @@ -1218,7 +1218,7 @@ H5D__earray_idx_iterate(const H5D_chk_idx_info_t *idx_info, H5D_chunk_cb_func_t assert(idx_info->pline); assert(idx_info->layout); assert(idx_info->storage); - assert(H5F_addr_defined(idx_info->storage->idx_addr)); + assert(H5_addr_defined(idx_info->storage->idx_addr)); assert(chunk_cb); assert(chunk_udata); @@ -1287,7 +1287,7 @@ H5D__earray_idx_remove(const H5D_chk_idx_info_t *idx_info, H5D_chunk_common_ud_t assert(idx_info->pline); assert(idx_info->layout); assert(idx_info->storage); - assert(H5F_addr_defined(idx_info->storage->idx_addr)); + assert(H5_addr_defined(idx_info->storage->idx_addr)); assert(udata); /* Check if the extensible array is open yet */ @@ -1334,7 +1334,7 @@ H5D__earray_idx_remove(const H5D_chk_idx_info_t *idx_info, H5D_chunk_common_ud_t HGOTO_ERROR(H5E_DATASET, H5E_CANTGET, FAIL, "can't get chunk info") /* Remove raw data chunk from file if not doing SWMR writes */ - assert(H5F_addr_defined(elmt.addr)); + assert(H5_addr_defined(elmt.addr)); if (!(H5F_INTENT(idx_info->f) & H5F_ACC_SWMR_WRITE)) { H5_CHECK_OVERFLOW(elmt.nbytes, /*From: */ uint32_t, /*To: */ hsize_t); if (H5MF_xfree(idx_info->f, H5FD_MEM_DRAW, elmt.addr, (hsize_t)elmt.nbytes) < 0) @@ -1356,7 +1356,7 @@ H5D__earray_idx_remove(const H5D_chk_idx_info_t *idx_info, H5D_chunk_common_ud_t HGOTO_ERROR(H5E_DATASET, H5E_CANTGET, FAIL, "can't get chunk address") /* Remove raw data chunk from file if not doing SWMR writes */ - assert(H5F_addr_defined(addr)); + assert(H5_addr_defined(addr)); if (!(H5F_INTENT(idx_info->f) & H5F_ACC_SWMR_WRITE)) { H5_CHECK_OVERFLOW(idx_info->layout->size, /*From: */ uint32_t, /*To: */ hsize_t); if (H5MF_xfree(idx_info->f, H5FD_MEM_DRAW, addr, (hsize_t)idx_info->layout->size) < 0) @@ -1393,7 +1393,7 @@ H5D__earray_idx_delete_cb(const H5D_chunk_rec_t *chunk_rec, void *_udata) /* Sanity checks */ assert(chunk_rec); - assert(H5F_addr_defined(chunk_rec->chunk_addr)); + assert(H5_addr_defined(chunk_rec->chunk_addr)); assert(chunk_rec->nbytes > 0); assert(f); @@ -1436,7 +1436,7 @@ H5D__earray_idx_delete(const H5D_chk_idx_info_t *idx_info) assert(idx_info->storage); /* Check if the index data structure has been allocated */ - if (H5F_addr_defined(idx_info->storage->idx_addr)) { + if (H5_addr_defined(idx_info->storage->idx_addr)) { H5D_earray_ctx_ud_t ctx_udata; /* User data for extensible array open call */ /* Iterate over the chunk addresses in the extensible array, deleting each chunk */ @@ -1491,7 +1491,7 @@ H5D__earray_idx_copy_setup(const H5D_chk_idx_info_t *idx_info_src, const H5D_chk assert(idx_info_dst->pline); assert(idx_info_dst->layout); assert(idx_info_dst->storage); - assert(!H5F_addr_defined(idx_info_dst->storage->idx_addr)); + assert(!H5_addr_defined(idx_info_dst->storage->idx_addr)); /* Check if the source extensible array is open yet */ if (NULL == idx_info_src->storage->u.earray.ea) @@ -1505,7 +1505,7 @@ H5D__earray_idx_copy_setup(const H5D_chk_idx_info_t *idx_info_src, const H5D_chk /* Create the extensible array that describes chunked storage in the dest. file */ if (H5D__earray_idx_create(idx_info_dst) < 0) HGOTO_ERROR(H5E_DATASET, H5E_CANTINIT, FAIL, "unable to initialize chunked storage") - assert(H5F_addr_defined(idx_info_dst->storage->idx_addr)); + assert(H5_addr_defined(idx_info_dst->storage->idx_addr)); /* Reset metadata tag */ H5_END_TAG @@ -1573,7 +1573,7 @@ H5D__earray_idx_size(const H5D_chk_idx_info_t *idx_info, hsize_t *index_size) assert(idx_info->pline); assert(idx_info->layout); assert(idx_info->storage); - assert(H5F_addr_defined(idx_info->storage->idx_addr)); + assert(H5_addr_defined(idx_info->storage->idx_addr)); assert(index_size); /* Open the extensible array in file */ diff --git a/src/H5Defl.c b/src/H5Defl.c index 6aa5dad..aea37a4 100644 --- a/src/H5Defl.c +++ b/src/H5Defl.c @@ -236,7 +236,7 @@ H5D__efl_read(const H5O_efl_t *efl, const H5D_t *dset, haddr_t addr, size_t size /* Check args */ assert(efl && efl->nused > 0); - assert(H5F_addr_defined(addr)); + assert(H5_addr_defined(addr)); assert(size < SIZE_MAX); assert(buf || 0 == size); @@ -321,7 +321,7 @@ H5D__efl_write(const H5O_efl_t *efl, const H5D_t *dset, haddr_t addr, size_t siz /* Check args */ assert(efl && efl->nused > 0); - assert(H5F_addr_defined(addr)); + assert(H5_addr_defined(addr)); assert(size < SIZE_MAX); assert(buf || 0 == size); @@ -548,7 +548,7 @@ H5D__efl_bh_info(H5F_t *f, H5O_efl_t *efl, hsize_t *heap_size) /* Check args */ assert(f); assert(efl); - assert(H5F_addr_defined(efl->heap_addr)); + assert(H5_addr_defined(efl->heap_addr)); assert(heap_size); /* Get the size of the local heap for EFL's file list */ diff --git a/src/H5Dfarray.c b/src/H5Dfarray.c index 201cca8..24d9154 100644 --- a/src/H5Dfarray.c +++ b/src/H5Dfarray.c @@ -319,7 +319,7 @@ H5D__farray_encode(void *raw, const void *_elmt, size_t nelmts, void *_ctx) while (nelmts) { /* Encode element */ /* (advances 'raw' pointer) */ - H5F_addr_encode_len(ctx->file_addr_len, (uint8_t **)&raw, *elmt); + H5_addr_encode_len(ctx->file_addr_len, (uint8_t **)&raw, *elmt); /* Advance native element pointer */ elmt++; @@ -359,7 +359,7 @@ H5D__farray_decode(const void *_raw, void *_elmt, size_t nelmts, void *_ctx) while (nelmts) { /* Decode element */ /* (advances 'raw' pointer) */ - H5F_addr_decode_len(ctx->file_addr_len, &raw, elmt); + H5_addr_decode_len(ctx->file_addr_len, &raw, elmt); /* Advance native element pointer */ elmt++; @@ -423,7 +423,7 @@ H5D__farray_crt_dbg_context(H5F_t *f, haddr_t obj_addr) /* Sanity checks */ assert(f); - assert(H5F_addr_defined(obj_addr)); + assert(H5_addr_defined(obj_addr)); /* Allocate context for debugging callback */ if (NULL == (dbg_ctx = H5FL_MALLOC(H5D_farray_ctx_ud_t))) @@ -554,7 +554,7 @@ H5D__farray_filt_encode(void *_raw, const void *_elmt, size_t nelmts, void *_ctx while (nelmts) { /* Encode element */ /* (advances 'raw' pointer) */ - H5F_addr_encode_len(ctx->file_addr_len, &raw, elmt->addr); + H5_addr_encode_len(ctx->file_addr_len, &raw, elmt->addr); UINT64ENCODE_VAR(raw, elmt->nbytes, ctx->chunk_size_len); UINT32ENCODE(raw, elmt->filter_mask); @@ -597,7 +597,7 @@ H5D__farray_filt_decode(const void *_raw, void *_elmt, size_t nelmts, void *_ctx while (nelmts) { /* Decode element */ /* (advances 'raw' pointer) */ - H5F_addr_decode_len(ctx->file_addr_len, &raw, &elmt->addr); + H5_addr_decode_len(ctx->file_addr_len, &raw, &elmt->addr); UINT64DECODE_VAR(raw, elmt->nbytes, ctx->chunk_size_len); UINT32DECODE(raw, elmt->filter_mask); @@ -672,7 +672,7 @@ H5D__farray_idx_depend(const H5D_chk_idx_info_t *idx_info) assert(H5D_CHUNK_IDX_FARRAY == idx_info->layout->idx_type); assert(idx_info->storage); assert(H5D_CHUNK_IDX_FARRAY == idx_info->storage->idx_type); - assert(H5F_addr_defined(idx_info->storage->idx_addr)); + assert(H5_addr_defined(idx_info->storage->idx_addr)); assert(idx_info->storage->u.farray.fa); /* Set up object header location for dataset */ @@ -719,7 +719,7 @@ H5D__farray_idx_init(const H5D_chk_idx_info_t *idx_info, const H5S_t H5_ATTR_UNU /* Check args */ assert(idx_info); assert(idx_info->storage); - assert(H5F_addr_defined(dset_ohdr_addr)); + assert(H5_addr_defined(dset_ohdr_addr)); idx_info->storage->u.farray.dset_ohdr_addr = dset_ohdr_addr; @@ -753,7 +753,7 @@ H5D__farray_idx_open(const H5D_chk_idx_info_t *idx_info) assert(H5D_CHUNK_IDX_FARRAY == idx_info->layout->idx_type); assert(idx_info->storage); assert(H5D_CHUNK_IDX_FARRAY == idx_info->storage->idx_type); - assert(H5F_addr_defined(idx_info->storage->idx_addr)); + assert(H5_addr_defined(idx_info->storage->idx_addr)); assert(NULL == idx_info->storage->u.farray.fa); /* Set up the user data */ @@ -805,7 +805,7 @@ H5D__farray_idx_create(const H5D_chk_idx_info_t *idx_info) assert(idx_info->pline); assert(idx_info->layout); assert(idx_info->storage); - assert(!H5F_addr_defined(idx_info->storage->idx_addr)); + assert(!H5_addr_defined(idx_info->storage->idx_addr)); assert(NULL == idx_info->storage->u.farray.fa); assert(idx_info->layout->nchunks); @@ -870,7 +870,7 @@ H5D__farray_idx_is_space_alloc(const H5O_storage_chunk_t *storage) /* Check args */ assert(storage); - FUNC_LEAVE_NOAPI((hbool_t)H5F_addr_defined(storage->idx_addr)) + FUNC_LEAVE_NOAPI((hbool_t)H5_addr_defined(storage->idx_addr)) } /* end H5D__farray_idx_is_space_alloc() */ /*------------------------------------------------------------------------- @@ -897,7 +897,7 @@ H5D__farray_idx_insert(const H5D_chk_idx_info_t *idx_info, H5D_chunk_ud_t *udata assert(idx_info->pline); assert(idx_info->layout); assert(idx_info->storage); - assert(H5F_addr_defined(idx_info->storage->idx_addr)); + assert(H5_addr_defined(idx_info->storage->idx_addr)); assert(udata); /* Check if the fixed array is open yet */ @@ -912,7 +912,7 @@ H5D__farray_idx_insert(const H5D_chk_idx_info_t *idx_info, H5D_chunk_ud_t *udata /* Set convenience pointer to fixed array structure */ fa = idx_info->storage->u.farray.fa; - if (!H5F_addr_defined(udata->chunk_block.offset)) + if (!H5_addr_defined(udata->chunk_block.offset)) HGOTO_ERROR(H5E_DATASET, H5E_CANTALLOC, FAIL, "The chunk should have allocated already") if (udata->chunk_idx != (udata->chunk_idx & 0xffffffff)) /* negative value */ HGOTO_ERROR(H5E_ARGS, H5E_BADRANGE, FAIL, "chunk index must be less than 2^32") @@ -965,7 +965,7 @@ H5D__farray_idx_get_addr(const H5D_chk_idx_info_t *idx_info, H5D_chunk_ud_t *uda assert(idx_info->pline); assert(idx_info->layout); assert(idx_info->storage); - assert(H5F_addr_defined(idx_info->storage->idx_addr)); + assert(H5_addr_defined(idx_info->storage->idx_addr)); assert(udata); /* Check if the fixed array is open yet */ @@ -1009,7 +1009,7 @@ H5D__farray_idx_get_addr(const H5D_chk_idx_info_t *idx_info, H5D_chunk_ud_t *uda udata->filter_mask = 0; } /* end else */ - if (!H5F_addr_defined(udata->chunk_block.offset)) + if (!H5_addr_defined(udata->chunk_block.offset)) udata->chunk_block.length = 0; done: @@ -1047,7 +1047,7 @@ H5D__farray_idx_iterate_cb(hsize_t H5_ATTR_UNUSED idx, const void *_elmt, void * udata->chunk_rec.chunk_addr = *(const haddr_t *)_elmt; /* Make "generic chunk" callback */ - if (H5F_addr_defined(udata->chunk_rec.chunk_addr)) + if (H5_addr_defined(udata->chunk_rec.chunk_addr)) if ((ret_value = (udata->cb)(&udata->chunk_rec, udata->udata)) < 0) HERROR(H5E_DATASET, H5E_CALLBACK, "failure in generic chunk iterator callback"); @@ -1097,7 +1097,7 @@ H5D__farray_idx_iterate(const H5D_chk_idx_info_t *idx_info, H5D_chunk_cb_func_t assert(idx_info->pline); assert(idx_info->layout); assert(idx_info->storage); - assert(H5F_addr_defined(idx_info->storage->idx_addr)); + assert(H5_addr_defined(idx_info->storage->idx_addr)); assert(chunk_cb); assert(chunk_udata); @@ -1167,7 +1167,7 @@ H5D__farray_idx_remove(const H5D_chk_idx_info_t *idx_info, H5D_chunk_common_ud_t assert(idx_info->pline); assert(idx_info->layout); assert(idx_info->storage); - assert(H5F_addr_defined(idx_info->storage->idx_addr)); + assert(H5_addr_defined(idx_info->storage->idx_addr)); assert(udata); /* Check if the fixed array is open yet */ @@ -1196,7 +1196,7 @@ H5D__farray_idx_remove(const H5D_chk_idx_info_t *idx_info, H5D_chunk_common_ud_t HGOTO_ERROR(H5E_DATASET, H5E_CANTGET, FAIL, "can't get chunk info") /* Remove raw data chunk from file if not doing SWMR writes */ - assert(H5F_addr_defined(elmt.addr)); + assert(H5_addr_defined(elmt.addr)); if (!(H5F_INTENT(idx_info->f) & H5F_ACC_SWMR_WRITE)) { H5_CHECK_OVERFLOW(elmt.nbytes, /*From: */ uint32_t, /*To: */ hsize_t); if (H5MF_xfree(idx_info->f, H5FD_MEM_DRAW, elmt.addr, (hsize_t)elmt.nbytes) < 0) @@ -1218,7 +1218,7 @@ H5D__farray_idx_remove(const H5D_chk_idx_info_t *idx_info, H5D_chunk_common_ud_t HGOTO_ERROR(H5E_DATASET, H5E_CANTGET, FAIL, "can't get chunk address") /* Remove raw data chunk from file if not doing SWMR writes */ - assert(H5F_addr_defined(addr)); + assert(H5_addr_defined(addr)); if (!(H5F_INTENT(idx_info->f) & H5F_ACC_SWMR_WRITE)) { H5_CHECK_OVERFLOW(idx_info->layout->size, /*From: */ uint32_t, /*To: */ hsize_t); if (H5MF_xfree(idx_info->f, H5FD_MEM_DRAW, addr, (hsize_t)idx_info->layout->size) < 0) @@ -1255,7 +1255,7 @@ H5D__farray_idx_delete_cb(const H5D_chunk_rec_t *chunk_rec, void *_udata) /* Sanity checks */ assert(chunk_rec); - assert(H5F_addr_defined(chunk_rec->chunk_addr)); + assert(H5_addr_defined(chunk_rec->chunk_addr)); assert(chunk_rec->nbytes > 0); assert(f); @@ -1294,7 +1294,7 @@ H5D__farray_idx_delete(const H5D_chk_idx_info_t *idx_info) assert(idx_info->storage); /* Check if the index data structure has been allocated */ - if (H5F_addr_defined(idx_info->storage->idx_addr)) { + if (H5_addr_defined(idx_info->storage->idx_addr)) { H5D_farray_ctx_ud_t ctx_udata; /* User data for fixed array open call */ /* Iterate over the chunk addresses in the fixed array, deleting each chunk */ @@ -1349,7 +1349,7 @@ H5D__farray_idx_copy_setup(const H5D_chk_idx_info_t *idx_info_src, const H5D_chk assert(idx_info_dst->pline); assert(idx_info_dst->layout); assert(idx_info_dst->storage); - assert(!H5F_addr_defined(idx_info_dst->storage->idx_addr)); + assert(!H5_addr_defined(idx_info_dst->storage->idx_addr)); /* Check if the source fixed array is open yet */ if (NULL == idx_info_src->storage->u.farray.fa) @@ -1363,7 +1363,7 @@ H5D__farray_idx_copy_setup(const H5D_chk_idx_info_t *idx_info_src, const H5D_chk /* Create the fixed array that describes chunked storage in the dest. file */ if (H5D__farray_idx_create(idx_info_dst) < 0) HGOTO_ERROR(H5E_DATASET, H5E_CANTINIT, FAIL, "unable to initialize chunked storage") - assert(H5F_addr_defined(idx_info_dst->storage->idx_addr)); + assert(H5_addr_defined(idx_info_dst->storage->idx_addr)); /* Reset metadata tag */ H5_END_TAG @@ -1431,7 +1431,7 @@ H5D__farray_idx_size(const H5D_chk_idx_info_t *idx_info, hsize_t *index_size) assert(idx_info->pline); assert(idx_info->layout); assert(idx_info->storage); - assert(H5F_addr_defined(idx_info->storage->idx_addr)); + assert(H5_addr_defined(idx_info->storage->idx_addr)); assert(index_size); /* Open the fixed array in file */ diff --git a/src/H5Dint.c b/src/H5Dint.c index e498a3f..e2629e9 100644 --- a/src/H5Dint.c +++ b/src/H5Dint.c @@ -1355,7 +1355,7 @@ done: } /* end else */ } /* end if */ - if (H5F_addr_defined(new_dset->oloc.addr)) { + if (H5_addr_defined(new_dset->oloc.addr)) { if (H5O_dec_rc_by_loc(&(new_dset->oloc)) < 0) HDONE_ERROR(H5E_DATASET, H5E_CANTDEC, NULL, "unable to decrement refcount on newly created object") @@ -1819,7 +1819,7 @@ H5D__open_oid(H5D_t *dataset, hid_t dapl_id) done: if (ret_value < 0) { - if (H5F_addr_defined(dataset->oloc.addr) && H5O_close(&(dataset->oloc), NULL) < 0) + if (H5_addr_defined(dataset->oloc.addr) && H5O_close(&(dataset->oloc), NULL) < 0) HDONE_ERROR(H5E_DATASET, H5E_CLOSEERROR, FAIL, "unable to release object header") if (dataset->shared) { if (layout_init) @@ -2545,7 +2545,7 @@ H5D__get_offset(const H5D_t *dset) * an external file, the value will be HADDR_UNDEF. */ if (dset->shared->dcpl_cache.efl.nused == 0 || - H5F_addr_defined(dset->shared->layout.storage.u.contig.addr)) + H5_addr_defined(dset->shared->layout.storage.u.contig.addr)) /* Return the absolute dataset offset from the beginning of file. */ ret_value = dset->shared->layout.storage.u.contig.addr + H5F_BASE_ADDR(dset->oloc.file); break; @@ -3314,7 +3314,7 @@ H5D__format_convert(H5D_t *dataset) init_new_index = TRUE; /* If the current chunk index exists */ - if (H5F_addr_defined(idx_info.storage->idx_addr)) { + if (H5_addr_defined(idx_info.storage->idx_addr)) { /* Create v1 B-tree chunk index */ if ((new_idx_info.storage->ops->create)(&new_idx_info) < 0) @@ -3383,9 +3383,9 @@ done: /* Clean up v1 b-tree chunk index */ if (init_new_index) { - if (H5F_addr_defined(new_idx_info.storage->idx_addr)) { + if (H5_addr_defined(new_idx_info.storage->idx_addr)) { /* Check for valid address i.e. tag */ - if (!H5F_addr_defined(dataset->oloc.addr)) + if (!H5_addr_defined(dataset->oloc.addr)) HDONE_ERROR(H5E_DATASET, H5E_BADVALUE, FAIL, "address undefined") /* Expunge from cache all v1 B-tree type entries associated with tag */ diff --git a/src/H5Dmpio.c b/src/H5Dmpio.c index af2a009..83366fb 100644 --- a/src/H5Dmpio.c +++ b/src/H5Dmpio.c @@ -2623,7 +2623,7 @@ H5D__cmp_piece_addr(const void *piece_info1, const void *piece_info2) addr1 = (*((const H5D_piece_info_t *const *)piece_info1))->faddr; addr2 = (*((const H5D_piece_info_t *const *)piece_info2))->faddr; - FUNC_LEAVE_NOAPI(H5F_addr_cmp(addr1, addr2)) + FUNC_LEAVE_NOAPI(H5_addr_cmp(addr1, addr2)) } /* end H5D__cmp_chunk_addr() */ /*------------------------------------------------------------------------- @@ -2658,23 +2658,23 @@ H5D__cmp_filtered_collective_io_info_entry(const void *filtered_collective_io_in addr2 = entry2->chunk_new.offset; /* - * If both chunk addresses are defined, H5F_addr_cmp is safe to use. + * If both chunk addresses are defined, H5_addr_cmp is safe to use. * Otherwise, if both addresses aren't defined, compared chunk * entries based on their chunk index. Finally, if only one chunk * address is defined, return the appropriate value based on which * is defined. */ - if (H5F_addr_defined(addr1) && H5F_addr_defined(addr2)) { - ret_value = H5F_addr_cmp(addr1, addr2); + if (H5_addr_defined(addr1) && H5_addr_defined(addr2)) { + ret_value = H5_addr_cmp(addr1, addr2); } - else if (!H5F_addr_defined(addr1) && !H5F_addr_defined(addr2)) { + else if (!H5_addr_defined(addr1) && !H5_addr_defined(addr2)) { hsize_t chunk_idx1 = entry1->index_info.chunk_idx; hsize_t chunk_idx2 = entry2->index_info.chunk_idx; ret_value = (chunk_idx1 > chunk_idx2) - (chunk_idx1 < chunk_idx2); } else - ret_value = H5F_addr_defined(addr1) ? 1 : -1; + ret_value = H5_addr_defined(addr1) ? 1 : -1; FUNC_LEAVE_NOAPI(ret_value) } /* end H5D__cmp_filtered_collective_io_info_entry() */ @@ -2757,23 +2757,23 @@ H5D__cmp_chunk_redistribute_info_orig_owner(const void *_entry1, const void *_en haddr_t addr2 = entry2->chunk_block.offset; /* - * If both chunk addresses are defined, H5F_addr_cmp is safe to use. + * If both chunk addresses are defined, H5_addr_cmp is safe to use. * Otherwise, if both addresses aren't defined, compared chunk * entries based on their chunk index. Finally, if only one chunk * address is defined, return the appropriate value based on which * is defined. */ - if (H5F_addr_defined(addr1) && H5F_addr_defined(addr2)) { - ret_value = H5F_addr_cmp(addr1, addr2); + if (H5_addr_defined(addr1) && H5_addr_defined(addr2)) { + ret_value = H5_addr_cmp(addr1, addr2); } - else if (!H5F_addr_defined(addr1) && !H5F_addr_defined(addr2)) { + else if (!H5_addr_defined(addr1) && !H5_addr_defined(addr2)) { hsize_t chunk_idx1 = entry1->chunk_idx; hsize_t chunk_idx2 = entry2->chunk_idx; ret_value = (chunk_idx1 > chunk_idx2) - (chunk_idx1 < chunk_idx2); } else - ret_value = H5F_addr_defined(addr1) ? 1 : -1; + ret_value = H5_addr_defined(addr1) ? 1 : -1; } else ret_value = (owner1 > owner2) - (owner1 < owner2); @@ -3134,7 +3134,7 @@ H5D__mpio_collective_filtered_chunk_io_setup(const H5D_io_info_t *io_info, const haddr_t curr_chunk_offset = local_info_array[i].chunk_current.offset; haddr_t prev_chunk_offset = local_info_array[i - 1].chunk_current.offset; - if (!H5F_addr_defined(prev_chunk_offset) || !H5F_addr_defined(curr_chunk_offset) || + if (!H5_addr_defined(prev_chunk_offset) || !H5_addr_defined(curr_chunk_offset) || (curr_chunk_offset < prev_chunk_offset)) need_sort = TRUE; } @@ -4141,7 +4141,7 @@ H5D__mpio_collective_filtered_chunk_common_io(H5D_filtered_collective_io_info_t assert(chunk_list[i].buf); if (chunk_list[i].need_read) { - if (!H5F_addr_defined(base_read_offset)) + if (!H5_addr_defined(base_read_offset)) base_read_offset = chunk_list[i].chunk_current.offset; num_chunks++; @@ -4297,7 +4297,7 @@ H5D__mpio_collective_filtered_chunk_read(H5D_filtered_collective_io_info_t *chun * read it from the file. Instead, just fill the chunk buffer * with the fill value if necessary. */ - if (H5F_addr_defined(chunk_list[i].chunk_current.offset)) { + if (H5_addr_defined(chunk_list[i].chunk_current.offset)) { /* Set first read buffer */ if (!base_read_buf) base_read_buf = chunk_list[i].buf; @@ -4519,7 +4519,7 @@ H5D__mpio_collective_filtered_chunk_update(H5D_filtered_collective_io_info_t *ch * out fill values to it, make sure to 0-fill its memory buffer * so we don't use uninitialized memory. */ - if (!H5F_addr_defined(chunk_list[i].chunk_current.offset) && !should_fill) + if (!H5_addr_defined(chunk_list[i].chunk_current.offset) && !should_fill) chunk_list[i].buf = H5MM_calloc(chunk_list[i].chunk_buf_size); else chunk_list[i].buf = H5MM_malloc(chunk_list[i].chunk_buf_size); @@ -4537,7 +4537,7 @@ H5D__mpio_collective_filtered_chunk_update(H5D_filtered_collective_io_info_t *ch * read it from the file. Instead, just fill the chunk buffer * with the fill value if fill values are to be written. */ - if (H5F_addr_defined(chunk_list[i].chunk_current.offset)) { + if (H5_addr_defined(chunk_list[i].chunk_current.offset)) { /* Set first read buffer */ if (!base_read_buf) base_read_buf = chunk_list[i].buf; @@ -4919,7 +4919,7 @@ H5D__mpio_collective_filtered_chunk_reallocate(H5D_filtered_collective_io_info_t haddr_t curr_chunk_offset = local_chunk->chunk_new.offset; haddr_t prev_chunk_offset = chunk_list[num_local_chunks_processed - 1].chunk_new.offset; - assert(H5F_addr_defined(prev_chunk_offset) && H5F_addr_defined(curr_chunk_offset)); + assert(H5_addr_defined(prev_chunk_offset) && H5_addr_defined(curr_chunk_offset)); if (curr_chunk_offset < prev_chunk_offset) need_sort = TRUE; } @@ -5688,7 +5688,7 @@ H5D__mpio_collective_filtered_io_type(H5D_filtered_collective_io_info_t *chunk_l * set the base chunk offset and base chunk * data buffer if we haven't already */ - if (!H5F_addr_defined(base_offset)) { + if (!H5_addr_defined(base_offset)) { #if H5_CHECK_MPI_VERSION(3, 0) if (MPI_SUCCESS != (mpi_code = MPI_Get_address(chunk_list[i].buf, &base_buf))) HMPI_GOTO_ERROR(FAIL, "MPI_Get_address failed", mpi_code) @@ -5708,7 +5708,7 @@ H5D__mpio_collective_filtered_io_type(H5D_filtered_collective_io_info_t *chunk_l * Set the current chunk entry's offset in the file, relative to * the first chunk entry */ - assert(H5F_addr_defined(chunk_block->offset)); + assert(H5_addr_defined(chunk_block->offset)); file_offset_array[chunk_count] = (MPI_Aint)(chunk_block->offset - base_offset); /* diff --git a/src/H5Dnone.c b/src/H5Dnone.c index 0ff6ae5..6b9ed91 100644 --- a/src/H5Dnone.c +++ b/src/H5Dnone.c @@ -123,14 +123,14 @@ H5D__none_idx_create(const H5D_chk_idx_info_t *idx_info) assert(idx_info->layout); assert(idx_info->storage); assert(idx_info->layout->max_nchunks); - assert(!H5F_addr_defined(idx_info->storage->idx_addr)); /* address of data shouldn't be defined */ + assert(!H5_addr_defined(idx_info->storage->idx_addr)); /* address of data shouldn't be defined */ /* Calculate size of max dataset chunks */ nbytes = idx_info->layout->max_nchunks * idx_info->layout->size; /* Allocate space for max dataset chunks */ addr = H5MF_alloc(idx_info->f, H5FD_MEM_DRAW, nbytes); - if (!H5F_addr_defined(addr)) + if (!H5_addr_defined(addr)) HGOTO_ERROR(H5E_DATASET, H5E_CANTALLOC, FAIL, "file allocation failed") /* This is the address of the dataset chunks */ @@ -157,7 +157,7 @@ H5D__none_idx_is_space_alloc(const H5O_storage_chunk_t *storage) /* Check args */ assert(storage); - FUNC_LEAVE_NOAPI((hbool_t)H5F_addr_defined(storage->idx_addr)) + FUNC_LEAVE_NOAPI((hbool_t)H5_addr_defined(storage->idx_addr)) } /* end H5D__none_idx_is_space_alloc() */ /*------------------------------------------------------------------------- @@ -183,7 +183,7 @@ H5D__none_idx_get_addr(const H5D_chk_idx_info_t *idx_info, H5D_chunk_ud_t *udata assert(idx_info->layout); assert(idx_info->storage); assert(udata); - assert(H5F_addr_defined(idx_info->storage->idx_addr)); + assert(H5_addr_defined(idx_info->storage->idx_addr)); /* Calculate the index of this chunk */ udata->chunk_idx = H5VM_array_offset_pre((idx_info->layout->ndims - 1), idx_info->layout->max_down_chunks, @@ -230,7 +230,7 @@ H5D__none_idx_iterate(const H5D_chk_idx_info_t *idx_info, H5D_chunk_cb_func_t ch assert(idx_info->storage); assert(chunk_cb); assert(chunk_udata); - assert(H5F_addr_defined(idx_info->storage->idx_addr)); + assert(H5_addr_defined(idx_info->storage->idx_addr)); /* Initialize generic chunk record */ memset(&chunk_rec, 0, sizeof(chunk_rec)); @@ -323,7 +323,7 @@ H5D__none_idx_delete(const H5D_chk_idx_info_t *idx_info) assert(!idx_info->pline->nused); /* Shouldn't have filter defined on entering here */ assert(idx_info->layout); assert(idx_info->storage); - assert(H5F_addr_defined(idx_info->storage->idx_addr)); /* should be defined */ + assert(H5_addr_defined(idx_info->storage->idx_addr)); /* should be defined */ /* chunk size * max # of chunks */ nbytes = idx_info->layout->max_nchunks * idx_info->layout->size; @@ -360,7 +360,7 @@ H5D__none_idx_copy_setup(const H5D_chk_idx_info_t H5_ATTR_NDEBUG_UNUSED *idx_inf assert(!idx_info_src->pline->nused); assert(idx_info_src->layout); assert(idx_info_src->storage); - assert(H5F_addr_defined(idx_info_src->storage->idx_addr)); + assert(H5_addr_defined(idx_info_src->storage->idx_addr)); assert(idx_info_dst); assert(idx_info_dst->f); diff --git a/src/H5Doh.c b/src/H5Doh.c index 3d6abad..0d6f08c 100644 --- a/src/H5Doh.c +++ b/src/H5Doh.c @@ -345,7 +345,7 @@ H5O__dset_bh_info(const H5O_loc_t *loc, H5O_t *oh, H5_ih_info_t *bh_info) /* Sanity check */ assert(loc); assert(loc->file); - assert(H5F_addr_defined(loc->addr)); + assert(H5_addr_defined(loc->addr)); assert(oh); assert(bh_info); diff --git a/src/H5Dsingle.c b/src/H5Dsingle.c index 1ac4df0..40238b5 100644 --- a/src/H5Dsingle.c +++ b/src/H5Dsingle.c @@ -121,7 +121,7 @@ H5D__single_idx_init(const H5D_chk_idx_info_t *idx_info, const H5S_t H5_ATTR_UNU if (idx_info->pline->nused) { idx_info->layout->flags |= H5O_LAYOUT_CHUNK_SINGLE_INDEX_WITH_FILTER; - if (!H5F_addr_defined(idx_info->storage->idx_addr)) { + if (!H5_addr_defined(idx_info->storage->idx_addr)) { idx_info->storage->u.single.nbytes = 0; idx_info->storage->u.single.filter_mask = 0; } @@ -155,7 +155,7 @@ H5D__single_idx_create(const H5D_chk_idx_info_t *idx_info) assert(idx_info->storage); assert(idx_info->layout->max_nchunks == idx_info->layout->nchunks); assert(idx_info->layout->nchunks == 1); - assert(!H5F_addr_defined(idx_info->storage->idx_addr)); + assert(!H5_addr_defined(idx_info->storage->idx_addr)); if (idx_info->pline->nused) assert(idx_info->layout->flags & H5O_LAYOUT_CHUNK_SINGLE_INDEX_WITH_FILTER); @@ -182,7 +182,7 @@ H5D__single_idx_is_space_alloc(const H5O_storage_chunk_t *storage) /* Check args */ assert(storage); - FUNC_LEAVE_NOAPI((hbool_t)H5F_addr_defined(storage->idx_addr)) + FUNC_LEAVE_NOAPI((hbool_t)H5_addr_defined(storage->idx_addr)) } /* end H5D__single_idx_is_space_alloc() */ /*------------------------------------------------------------------------- @@ -212,7 +212,7 @@ H5D__single_idx_insert(const H5D_chk_idx_info_t *idx_info, H5D_chunk_ud_t *udata assert(udata); /* Set the address for the chunk */ - assert(H5F_addr_defined(udata->chunk_block.offset)); + assert(H5_addr_defined(udata->chunk_block.offset)); idx_info->storage->idx_addr = udata->chunk_block.offset; if (idx_info->pline->nused > 0) { @@ -264,7 +264,7 @@ H5D__single_idx_get_addr(const H5D_chk_idx_info_t *idx_info, H5D_chunk_ud_t *uda udata->chunk_block.length = idx_info->layout->size; udata->filter_mask = 0; } /* end else */ - if (!H5F_addr_defined(udata->chunk_block.offset)) + if (!H5_addr_defined(udata->chunk_block.offset)) udata->chunk_block.length = 0; FUNC_LEAVE_NOAPI(SUCCEED) @@ -295,7 +295,7 @@ H5D__single_idx_iterate(const H5D_chk_idx_info_t *idx_info, H5D_chunk_cb_func_t assert(idx_info->storage); assert(chunk_cb); assert(chunk_udata); - assert(H5F_addr_defined(idx_info->storage->idx_addr)); + assert(H5_addr_defined(idx_info->storage->idx_addr)); /* Initialize generic chunk record */ memset(&chunk_rec, 0, sizeof(chunk_rec)); @@ -340,7 +340,7 @@ H5D__single_idx_remove(const H5D_chk_idx_info_t *idx_info, H5D_chunk_common_ud_t assert(idx_info->pline); assert(idx_info->layout); assert(idx_info->storage); - assert(H5F_addr_defined(idx_info->storage->idx_addr)); + assert(H5_addr_defined(idx_info->storage->idx_addr)); if (idx_info->layout->flags & H5O_LAYOUT_CHUNK_SINGLE_INDEX_WITH_FILTER) nbytes = idx_info->storage->u.single.nbytes; @@ -380,10 +380,10 @@ H5D__single_idx_delete(const H5D_chk_idx_info_t *idx_info) assert(idx_info->layout); assert(idx_info->storage); - if (H5F_addr_defined(idx_info->storage->idx_addr)) + if (H5_addr_defined(idx_info->storage->idx_addr)) ret_value = H5D__single_idx_remove(idx_info, NULL); else - assert(!H5F_addr_defined(idx_info->storage->idx_addr)); + assert(!H5_addr_defined(idx_info->storage->idx_addr)); FUNC_LEAVE_NOAPI(ret_value) } /* end H5D__single_idx_delete() */ @@ -411,7 +411,7 @@ H5D__single_idx_copy_setup(const H5D_chk_idx_info_t H5_ATTR_NDEBUG_UNUSED *idx_i assert(idx_info_src->pline); assert(idx_info_src->layout); assert(idx_info_src->storage); - assert(H5F_addr_defined(idx_info_src->storage->idx_addr)); + assert(H5_addr_defined(idx_info_src->storage->idx_addr)); assert(idx_info_dst); assert(idx_info_dst->f); diff --git a/src/H5EA.c b/src/H5EA.c index c6d82c8..2c29473 100644 --- a/src/H5EA.c +++ b/src/H5EA.c @@ -118,7 +118,7 @@ H5EA__new(H5F_t *f, haddr_t ea_addr, hbool_t from_open, void *ctx_udata) /* Check arguments */ assert(f); - assert(H5F_addr_defined(ea_addr)); + assert(H5_addr_defined(ea_addr)); /* Allocate extensible array wrapper */ if (NULL == (ea = H5FL_CALLOC(H5EA_t))) @@ -225,7 +225,7 @@ H5EA_open(H5F_t *f, haddr_t ea_addr, void *ctx_udata) /* Check arguments */ assert(f); - assert(H5F_addr_defined(ea_addr)); + assert(H5_addr_defined(ea_addr)); /* Allocate and initialize new extensible array wrapper */ if (NULL == (ea = H5EA__new(f, ea_addr, TRUE, ctx_udata))) @@ -340,12 +340,12 @@ H5EA__lookup_elmt(const H5EA_t *ea, hsize_t idx, hbool_t will_extend, unsigned t *thing_unprot_func = (H5EA__unprotect_func_t)NULL; /* Check if we should create the index block */ - if (!H5F_addr_defined(hdr->idx_blk_addr)) { + if (!H5_addr_defined(hdr->idx_blk_addr)) { /* Check if we are allowed to create the thing */ if (0 == (thing_acc & H5AC__READ_ONLY_FLAG)) { /* i.e. r/w access */ /* Create the index block */ hdr->idx_blk_addr = H5EA__iblock_create(hdr, &stats_changed); - if (!H5F_addr_defined(hdr->idx_blk_addr)) + if (!H5_addr_defined(hdr->idx_blk_addr)) HGOTO_ERROR(H5E_EARRAY, H5E_CANTCREATE, FAIL, "unable to create index block") hdr_dirty = TRUE; } /* end if */ @@ -386,7 +386,7 @@ H5EA__lookup_elmt(const H5EA_t *ea, hsize_t idx, hbool_t will_extend, unsigned t assert(dblk_idx < iblock->ndblk_addrs); /* Check if the data block has been allocated on disk yet */ - if (!H5F_addr_defined(iblock->dblk_addrs[dblk_idx])) { + if (!H5_addr_defined(iblock->dblk_addrs[dblk_idx])) { /* Check if we are allowed to create the thing */ if (0 == (thing_acc & H5AC__READ_ONLY_FLAG)) { /* i.e. r/w access */ haddr_t dblk_addr; /* Address of data block created */ @@ -397,7 +397,7 @@ H5EA__lookup_elmt(const H5EA_t *ea, hsize_t idx, hbool_t will_extend, unsigned t (dblk_idx * hdr->sblk_info[sblk_idx].dblk_nelmts); dblk_addr = H5EA__dblock_create(hdr, iblock, &stats_changed, dblk_off, hdr->sblk_info[sblk_idx].dblk_nelmts); - if (!H5F_addr_defined(dblk_addr)) + if (!H5_addr_defined(dblk_addr)) HGOTO_ERROR(H5E_EARRAY, H5E_CANTCREATE, FAIL, "unable to create extensible array data block") @@ -442,14 +442,14 @@ H5EA__lookup_elmt(const H5EA_t *ea, hsize_t idx, hbool_t will_extend, unsigned t sblk_off = sblk_idx - iblock->nsblks; /* Check if the super block has been allocated on disk yet */ - if (!H5F_addr_defined(iblock->sblk_addrs[sblk_off])) { + if (!H5_addr_defined(iblock->sblk_addrs[sblk_off])) { /* Check if we are allowed to create the thing */ if (0 == (thing_acc & H5AC__READ_ONLY_FLAG)) { /* i.e. r/w access */ haddr_t sblk_addr; /* Address of data block created */ /* Create super block */ sblk_addr = H5EA__sblock_create(hdr, iblock, &stats_changed, sblk_idx); - if (!H5F_addr_defined(sblk_addr)) + if (!H5_addr_defined(sblk_addr)) HGOTO_ERROR(H5E_EARRAY, H5E_CANTCREATE, FAIL, "unable to create extensible array super block") @@ -473,7 +473,7 @@ H5EA__lookup_elmt(const H5EA_t *ea, hsize_t idx, hbool_t will_extend, unsigned t assert(dblk_idx < sblock->ndblks); /* Check if the data block has been allocated on disk yet */ - if (!H5F_addr_defined(sblock->dblk_addrs[dblk_idx])) { + if (!H5_addr_defined(sblock->dblk_addrs[dblk_idx])) { /* Check if we are allowed to create the thing */ if (0 == (thing_acc & H5AC__READ_ONLY_FLAG)) { /* i.e. r/w access */ haddr_t dblk_addr; /* Address of data block created */ @@ -484,7 +484,7 @@ H5EA__lookup_elmt(const H5EA_t *ea, hsize_t idx, hbool_t will_extend, unsigned t (dblk_idx * hdr->sblk_info[sblk_idx].dblk_nelmts); dblk_addr = H5EA__dblock_create(hdr, sblock, &stats_changed, dblk_off, sblock->dblk_nelmts); - if (!H5F_addr_defined(dblk_addr)) + if (!H5_addr_defined(dblk_addr)) HGOTO_ERROR(H5E_EARRAY, H5E_CANTCREATE, FAIL, "unable to create extensible array data block") @@ -920,7 +920,7 @@ H5EA_delete(H5F_t *f, haddr_t ea_addr, void *ctx_udata) /* Check arguments */ assert(f); - assert(H5F_addr_defined(ea_addr)); + assert(H5_addr_defined(ea_addr)); /* Lock the array header into memory */ if (NULL == (hdr = H5EA__hdr_protect(f, ea_addr, ctx_udata, H5AC__NO_FLAGS_SET))) diff --git a/src/H5EAcache.c b/src/H5EAcache.c index 3a2f139..b0c67f3 100644 --- a/src/H5EAcache.c +++ b/src/H5EAcache.c @@ -292,7 +292,7 @@ H5EA__cache_hdr_deserialize(const void *_image, size_t len, void *_udata, hbool_ assert(image); assert(udata); assert(udata->f); - assert(H5F_addr_defined(udata->addr)); + assert(H5_addr_defined(udata->addr)); /* Allocate space for the extensible array data structure */ if (NULL == (hdr = H5EA__hdr_alloc(udata->f))) @@ -338,10 +338,10 @@ H5EA__cache_hdr_deserialize(const void *_image, size_t len, void *_udata, hbool_ H5F_DECODE_LENGTH(udata->f, image, hdr->stats.stored.nelmts); /* Number of elements 'realized' */ /* Internal information */ - H5F_addr_decode(udata->f, &image, &hdr->idx_blk_addr); /* Address of index block */ + H5_addr_decode(udata->f, &image, &hdr->idx_blk_addr); /* Address of index block */ /* Index block statistics */ - if (H5F_addr_defined(hdr->idx_blk_addr)) { + if (H5_addr_defined(hdr->idx_blk_addr)) { H5EA_iblock_t iblock; /* Fake index block for computing size */ /* Set index block count for file */ @@ -470,7 +470,7 @@ H5EA__cache_hdr_serialize(const H5F_t *f, void *_image, size_t H5_ATTR_UNUSED le H5F_ENCODE_LENGTH(f, image, hdr->stats.stored.nelmts); /* Number of elements 'realized' */ /* Internal information */ - H5F_addr_encode(f, &image, hdr->idx_blk_addr); /* Address of index block */ + H5_addr_encode(f, &image, hdr->idx_blk_addr); /* Address of index block */ /* Compute metadata checksum */ metadata_chksum = H5_checksum_metadata(_image, (size_t)(image - (uint8_t *)_image), 0); @@ -705,8 +705,8 @@ H5EA__cache_iblock_deserialize(const void *_image, size_t len, void *_udata, hbo HGOTO_ERROR(H5E_EARRAY, H5E_BADTYPE, NULL, "incorrect extensible array class") /* Address of header for array that owns this block (just for file integrity checks) */ - H5F_addr_decode(hdr->f, &image, &arr_addr); - if (H5F_addr_ne(arr_addr, hdr->addr)) + H5_addr_decode(hdr->f, &image, &arr_addr); + if (H5_addr_ne(arr_addr, hdr->addr)) HGOTO_ERROR(H5E_EARRAY, H5E_BADVALUE, NULL, "wrong extensible array header address") /* Internal information */ @@ -724,14 +724,14 @@ H5EA__cache_iblock_deserialize(const void *_image, size_t len, void *_udata, hbo if (iblock->ndblk_addrs > 0) { /* Decode addresses of data blocks in index block */ for (u = 0; u < iblock->ndblk_addrs; u++) - H5F_addr_decode(hdr->f, &image, &iblock->dblk_addrs[u]); + H5_addr_decode(hdr->f, &image, &iblock->dblk_addrs[u]); } /* end if */ /* Decode super block addresses in index block */ if (iblock->nsblk_addrs > 0) { /* Decode addresses of super blocks in index block */ for (u = 0; u < iblock->nsblk_addrs; u++) - H5F_addr_decode(hdr->f, &image, &iblock->sblk_addrs[u]); + H5_addr_decode(hdr->f, &image, &iblock->sblk_addrs[u]); } /* end if */ /* Sanity check */ @@ -826,7 +826,7 @@ H5EA__cache_iblock_serialize(const H5F_t *f, void *_image, size_t H5_ATTR_UNUSED *image++ = (uint8_t)iblock->hdr->cparam.cls->id; /* Address of array header for array which owns this block */ - H5F_addr_encode(f, &image, iblock->hdr->addr); + H5_addr_encode(f, &image, iblock->hdr->addr); /* Internal information */ @@ -845,7 +845,7 @@ H5EA__cache_iblock_serialize(const H5F_t *f, void *_image, size_t H5_ATTR_UNUSED /* Encode addresses of data blocks in index block */ for (u = 0; u < iblock->ndblk_addrs; u++) - H5F_addr_encode(f, &image, iblock->dblk_addrs[u]); + H5_addr_encode(f, &image, iblock->dblk_addrs[u]); } /* end if */ /* Encode data block addresses in index block */ @@ -854,7 +854,7 @@ H5EA__cache_iblock_serialize(const H5F_t *f, void *_image, size_t H5_ATTR_UNUSED /* Encode addresses of super blocks in index block */ for (u = 0; u < iblock->nsblk_addrs; u++) - H5F_addr_encode(f, &image, iblock->sblk_addrs[u]); + H5_addr_encode(f, &image, iblock->sblk_addrs[u]); } /* end if */ /* Compute metadata checksum */ @@ -991,7 +991,7 @@ H5EA__cache_sblock_get_initial_load_size(void *_udata, size_t *image_len) assert(udata); assert(udata->hdr); assert(udata->sblk_idx > 0); - assert(H5F_addr_defined(udata->sblk_addr)); + assert(H5_addr_defined(udata->sblk_addr)); assert(image_len); /* Set up fake super block for computing size on disk */ @@ -1084,7 +1084,7 @@ H5EA__cache_sblock_deserialize(const void *_image, size_t len, void *_udata, hbo assert(udata->hdr); assert(udata->parent); assert(udata->sblk_idx > 0); - assert(H5F_addr_defined(udata->sblk_addr)); + assert(H5_addr_defined(udata->sblk_addr)); /* Allocate the extensible array super block */ if (NULL == (sblock = H5EA__sblock_alloc(udata->hdr, udata->parent, udata->sblk_idx))) @@ -1108,8 +1108,8 @@ H5EA__cache_sblock_deserialize(const void *_image, size_t len, void *_udata, hbo HGOTO_ERROR(H5E_EARRAY, H5E_BADTYPE, NULL, "incorrect extensible array class") /* Address of header for array that owns this block (just for file integrity checks) */ - H5F_addr_decode(udata->hdr->f, &image, &arr_addr); - if (H5F_addr_ne(arr_addr, udata->hdr->addr)) + H5_addr_decode(udata->hdr->f, &image, &arr_addr); + if (H5_addr_ne(arr_addr, udata->hdr->addr)) HGOTO_ERROR(H5E_EARRAY, H5E_BADVALUE, NULL, "wrong extensible array header address") /* Offset of block within the array's address space */ @@ -1129,7 +1129,7 @@ H5EA__cache_sblock_deserialize(const void *_image, size_t len, void *_udata, hbo /* Decode data block addresses */ for (u = 0; u < sblock->ndblks; u++) - H5F_addr_decode(udata->hdr->f, &image, &sblock->dblk_addrs[u]); + H5_addr_decode(udata->hdr->f, &image, &sblock->dblk_addrs[u]); /* Sanity check */ /* (allow for checksum not decoded yet) */ @@ -1221,7 +1221,7 @@ H5EA__cache_sblock_serialize(const H5F_t *f, void *_image, size_t H5_ATTR_UNUSED *image++ = (uint8_t)sblock->hdr->cparam.cls->id; /* Address of array header for array which owns this block */ - H5F_addr_encode(f, &image, sblock->hdr->addr); + H5_addr_encode(f, &image, sblock->hdr->addr); /* Offset of block in array */ UINT64ENCODE_VAR(image, sblock->block_off, sblock->hdr->arr_off_size); @@ -1240,7 +1240,7 @@ H5EA__cache_sblock_serialize(const H5F_t *f, void *_image, size_t H5_ATTR_UNUSED /* Encode addresses of data blocks in super block */ for (u = 0; u < sblock->ndblks; u++) - H5F_addr_encode(f, &image, sblock->dblk_addrs[u]); + H5_addr_encode(f, &image, sblock->dblk_addrs[u]); /* Compute metadata checksum */ metadata_chksum = H5_checksum_metadata(_image, (size_t)(image - (uint8_t *)_image), 0); @@ -1490,7 +1490,7 @@ H5EA__cache_dblock_deserialize(const void *_image, size_t H5_ATTR_NDEBUG_UNUSED assert(udata->hdr); assert(udata->parent); assert(udata->nelmts > 0); - assert(H5F_addr_defined(udata->dblk_addr)); + assert(H5_addr_defined(udata->dblk_addr)); /* Allocate the extensible array data block */ if (NULL == (dblock = H5EA__dblock_alloc(udata->hdr, udata->parent, udata->nelmts))) @@ -1517,8 +1517,8 @@ H5EA__cache_dblock_deserialize(const void *_image, size_t H5_ATTR_NDEBUG_UNUSED HGOTO_ERROR(H5E_EARRAY, H5E_BADTYPE, NULL, "incorrect extensible array class") /* Address of header for array that owns this block (just for file integrity checks) */ - H5F_addr_decode(udata->hdr->f, &image, &arr_addr); - if (H5F_addr_ne(arr_addr, udata->hdr->addr)) + H5_addr_decode(udata->hdr->f, &image, &arr_addr); + if (H5_addr_ne(arr_addr, udata->hdr->addr)) HGOTO_ERROR(H5E_EARRAY, H5E_BADVALUE, NULL, "wrong extensible array header address") /* Offset of block within the array's address space */ @@ -1630,7 +1630,7 @@ H5EA__cache_dblock_serialize(const H5F_t *f, void *_image, size_t H5_ATTR_UNUSED *image++ = (uint8_t)dblock->hdr->cparam.cls->id; /* Address of array header for array which owns this block */ - H5F_addr_encode(f, &image, dblock->hdr->addr); + H5_addr_encode(f, &image, dblock->hdr->addr); /* Offset of block in array */ UINT64ENCODE_VAR(image, dblock->block_off, dblock->hdr->arr_off_size); @@ -1910,7 +1910,7 @@ H5EA__cache_dblk_page_deserialize(const void *_image, size_t len, void *_udata, assert(udata); assert(udata->hdr); assert(udata->parent); - assert(H5F_addr_defined(udata->dblk_page_addr)); + assert(H5_addr_defined(udata->dblk_page_addr)); /* Allocate the extensible array data block page */ if (NULL == (dblk_page = H5EA__dblk_page_alloc(udata->hdr, udata->parent))) diff --git a/src/H5EAdbg.c b/src/H5EAdbg.c index 59403e1..90be264 100644 --- a/src/H5EAdbg.c +++ b/src/H5EAdbg.c @@ -86,8 +86,8 @@ H5EA__hdr_debug(H5F_t *f, haddr_t addr, FILE *stream, int indent, int fwidth, co /* Check arguments */ assert(f); - assert(H5F_addr_defined(addr)); - assert(H5F_addr_defined(obj_addr)); + assert(H5_addr_defined(addr)); + assert(H5_addr_defined(obj_addr)); assert(stream); assert(indent >= 0); assert(fwidth >= 0); @@ -166,13 +166,13 @@ H5EA__iblock_debug(H5F_t *f, haddr_t H5_ATTR_UNUSED addr, FILE *stream, int inde /* Check arguments */ assert(f); - assert(H5F_addr_defined(addr)); + assert(H5_addr_defined(addr)); assert(stream); assert(indent >= 0); assert(fwidth >= 0); assert(cls); - assert(H5F_addr_defined(hdr_addr)); - assert(H5F_addr_defined(obj_addr)); + assert(H5_addr_defined(hdr_addr)); + assert(H5_addr_defined(obj_addr)); /* Check for debugging context callback available */ if (cls->crt_dbg_ctx) @@ -185,7 +185,7 @@ H5EA__iblock_debug(H5F_t *f, haddr_t H5_ATTR_UNUSED addr, FILE *stream, int inde HGOTO_ERROR(H5E_EARRAY, H5E_CANTPROTECT, FAIL, "unable to load extensible array header") /* Sanity check */ - assert(H5F_addr_eq(hdr->idx_blk_addr, addr)); + assert(H5_addr_eq(hdr->idx_blk_addr, addr)); /* Protect index block */ if (NULL == (iblock = H5EA__iblock_protect(hdr, H5AC__READ_ONLY_FLAG))) @@ -283,13 +283,13 @@ H5EA__sblock_debug(H5F_t *f, haddr_t addr, FILE *stream, int indent, int fwidth, /* Check arguments */ assert(f); - assert(H5F_addr_defined(addr)); + assert(H5_addr_defined(addr)); assert(stream); assert(indent >= 0); assert(fwidth >= 0); assert(cls); - assert(H5F_addr_defined(hdr_addr)); - assert(H5F_addr_defined(obj_addr)); + assert(H5_addr_defined(hdr_addr)); + assert(H5_addr_defined(obj_addr)); /* Check for debugging context callback available */ if (cls->crt_dbg_ctx) @@ -370,13 +370,13 @@ H5EA__dblock_debug(H5F_t *f, haddr_t addr, FILE *stream, int indent, int fwidth, /* Check arguments */ assert(f); - assert(H5F_addr_defined(addr)); + assert(H5_addr_defined(addr)); assert(stream); assert(indent >= 0); assert(fwidth >= 0); assert(cls); - assert(H5F_addr_defined(hdr_addr)); - assert(H5F_addr_defined(obj_addr)); + assert(H5_addr_defined(hdr_addr)); + assert(H5_addr_defined(obj_addr)); assert(dblk_nelmts > 0); /* Check for debugging context callback available */ diff --git a/src/H5EAdblkpage.c b/src/H5EAdblkpage.c index 429582c..d6fc8f5 100644 --- a/src/H5EAdblkpage.c +++ b/src/H5EAdblkpage.c @@ -205,7 +205,7 @@ H5EA__dblk_page_protect(H5EA_hdr_t *hdr, H5EA_sblock_t *parent, haddr_t dblk_pag /* Sanity check */ assert(hdr); - assert(H5F_addr_defined(dblk_page_addr)); + assert(H5_addr_defined(dblk_page_addr)); /* only the H5AC__READ_ONLY_FLAG may be set */ assert((flags & (unsigned)(~H5AC__READ_ONLY_FLAG)) == 0); diff --git a/src/H5EAdblock.c b/src/H5EAdblock.c index 8396429..6b73df9 100644 --- a/src/H5EAdblock.c +++ b/src/H5EAdblock.c @@ -205,7 +205,7 @@ H5EA__dblock_create(H5EA_hdr_t *hdr, void *parent, hbool_t *stats_changed, hsize ret_value = dblock_addr; done: - if (!H5F_addr_defined(ret_value)) + if (!H5_addr_defined(ret_value)) if (dblock) { /* Remove from cache, if inserted */ if (inserted) @@ -214,7 +214,7 @@ done: "unable to remove extensible array data block from cache") /* Release data block's disk space */ - if (H5F_addr_defined(dblock->addr) && + if (H5_addr_defined(dblock->addr) && H5MF_xfree(hdr->f, H5FD_MEM_EARRAY_DBLOCK, dblock->addr, (hsize_t)dblock->size) < 0) HDONE_ERROR(H5E_EARRAY, H5E_CANTFREE, HADDR_UNDEF, "unable to release extensible array data block") @@ -279,7 +279,7 @@ H5EA__dblock_protect(H5EA_hdr_t *hdr, void *parent, haddr_t dblk_addr, size_t db /* Sanity check */ assert(hdr); - assert(H5F_addr_defined(dblk_addr)); + assert(H5_addr_defined(dblk_addr)); assert(dblk_nelmts); /* only the H5AC__READ_ONLY_FLAG may be set */ @@ -375,7 +375,7 @@ H5EA__dblock_delete(H5EA_hdr_t *hdr, void *parent, haddr_t dblk_addr, size_t dbl /* Sanity check */ assert(hdr); assert(parent); - assert(H5F_addr_defined(dblk_addr)); + assert(H5_addr_defined(dblk_addr)); assert(dblk_nelmts > 0); /* Protect data block */ diff --git a/src/H5EAhdr.c b/src/H5EAhdr.c index e5f06da..41ff397 100644 --- a/src/H5EAhdr.c +++ b/src/H5EAhdr.c @@ -425,7 +425,7 @@ H5EA__hdr_create(H5F_t *f, const H5EA_create_t *cparam, void *ctx_udata) ret_value = hdr->addr; done: - if (!H5F_addr_defined(ret_value)) + if (!H5_addr_defined(ret_value)) if (hdr) { /* Remove from cache, if inserted */ if (inserted) @@ -434,7 +434,7 @@ done: "unable to remove extensible array header from cache") /* Release header's disk space */ - if (H5F_addr_defined(hdr->addr) && + if (H5_addr_defined(hdr->addr) && H5MF_xfree(f, H5FD_MEM_EARRAY_HDR, hdr->addr, (hsize_t)hdr->size) < 0) HDONE_ERROR(H5E_EARRAY, H5E_CANTFREE, HADDR_UNDEF, "unable to free extensible array header") @@ -613,7 +613,7 @@ H5EA__hdr_protect(H5F_t *f, haddr_t ea_addr, void *ctx_udata, unsigned flags) /* Sanity check */ assert(f); - assert(H5F_addr_defined(ea_addr)); + assert(H5_addr_defined(ea_addr)); /* only the H5AC__READ_ONLY_FLAG may appear in flags */ assert((flags & (unsigned)(~H5AC__READ_ONLY_FLAG)) == 0); @@ -710,7 +710,7 @@ H5EA__hdr_delete(H5EA_hdr_t *hdr) #endif /* NDEBUG */ /* Check for index block */ - if (H5F_addr_defined(hdr->idx_blk_addr)) { + if (H5_addr_defined(hdr->idx_blk_addr)) { /* Delete index block */ if (H5EA__iblock_delete(hdr) < 0) HGOTO_ERROR(H5E_EARRAY, H5E_CANTDELETE, FAIL, "unable to delete extensible array index block") diff --git a/src/H5EAiblock.c b/src/H5EAiblock.c index 014dd52..da362ea 100644 --- a/src/H5EAiblock.c +++ b/src/H5EAiblock.c @@ -235,7 +235,7 @@ H5EA__iblock_create(H5EA_hdr_t *hdr, hbool_t *stats_changed) ret_value = iblock_addr; done: - if (!H5F_addr_defined(ret_value)) + if (!H5_addr_defined(ret_value)) if (iblock) { /* Remove from cache, if inserted */ if (inserted) @@ -244,7 +244,7 @@ done: "unable to remove extensible array index block from cache") /* Release index block's disk space */ - if (H5F_addr_defined(iblock->addr) && + if (H5_addr_defined(iblock->addr) && H5MF_xfree(hdr->f, H5FD_MEM_EARRAY_IBLOCK, iblock->addr, (hsize_t)iblock->size) < 0) HDONE_ERROR(H5E_EARRAY, H5E_CANTFREE, HADDR_UNDEF, "unable to release file space for extensible array index block") @@ -362,7 +362,7 @@ H5EA__iblock_delete(H5EA_hdr_t *hdr) /* Sanity check */ assert(hdr); - assert(H5F_addr_defined(hdr->idx_blk_addr)); + assert(H5_addr_defined(hdr->idx_blk_addr)); /* Protect index block */ if (NULL == (iblock = H5EA__iblock_protect(hdr, H5AC__NO_FLAGS_SET))) @@ -380,7 +380,7 @@ H5EA__iblock_delete(H5EA_hdr_t *hdr) sblk_idx = dblk_idx = 0; for (u = 0; u < iblock->ndblk_addrs; u++) { /* Check for data block existing */ - if (H5F_addr_defined(iblock->dblk_addrs[u])) { + if (H5_addr_defined(iblock->dblk_addrs[u])) { /* Delete data block */ if (H5EA__dblock_delete(hdr, iblock, iblock->dblk_addrs[u], hdr->sblk_info[sblk_idx].dblk_nelmts) < 0) @@ -407,7 +407,7 @@ H5EA__iblock_delete(H5EA_hdr_t *hdr) /* Iterate over super blocks */ for (u = 0; u < iblock->nsblk_addrs; u++) { /* Check for data block existing */ - if (H5F_addr_defined(iblock->sblk_addrs[u])) { + if (H5_addr_defined(iblock->sblk_addrs[u])) { /* Delete super block */ if (H5EA__sblock_delete(hdr, iblock, iblock->sblk_addrs[u], (unsigned)(u + iblock->nsblks)) < 0) diff --git a/src/H5EAsblock.c b/src/H5EAsblock.c index 939ac06..118941f 100644 --- a/src/H5EAsblock.c +++ b/src/H5EAsblock.c @@ -226,7 +226,7 @@ H5EA__sblock_create(H5EA_hdr_t *hdr, H5EA_iblock_t *parent, hbool_t *stats_chang ret_value = sblock_addr; done: - if (!H5F_addr_defined(ret_value)) + if (!H5_addr_defined(ret_value)) if (sblock) { /* Remove from cache, if inserted */ if (inserted) @@ -235,7 +235,7 @@ done: "unable to remove extensible array super block from cache") /* Release super block's disk space */ - if (H5F_addr_defined(sblock->addr) && + if (H5_addr_defined(sblock->addr) && H5MF_xfree(hdr->f, H5FD_MEM_EARRAY_SBLOCK, sblock->addr, (hsize_t)sblock->size) < 0) HDONE_ERROR(H5E_EARRAY, H5E_CANTFREE, HADDR_UNDEF, "unable to release extensible array super block") @@ -270,7 +270,7 @@ H5EA__sblock_protect(H5EA_hdr_t *hdr, H5EA_iblock_t *parent, haddr_t sblk_addr, /* Sanity check */ assert(hdr); - assert(H5F_addr_defined(sblk_addr)); + assert(H5_addr_defined(sblk_addr)); /* only the H5AC__READ_ONLY_FLAG may be set */ assert((flags & (unsigned)(~H5AC__READ_ONLY_FLAG)) == 0); @@ -363,7 +363,7 @@ H5EA__sblock_delete(H5EA_hdr_t *hdr, H5EA_iblock_t *parent, haddr_t sblk_addr, u /* Sanity check */ assert(hdr); - assert(H5F_addr_defined(sblk_addr)); + assert(H5_addr_defined(sblk_addr)); /* Protect super block */ if (NULL == (sblock = H5EA__sblock_protect(hdr, parent, sblk_addr, sblk_idx, H5AC__NO_FLAGS_SET))) @@ -374,7 +374,7 @@ H5EA__sblock_delete(H5EA_hdr_t *hdr, H5EA_iblock_t *parent, haddr_t sblk_addr, u /* Iterate over data blocks */ for (u = 0; u < sblock->ndblks; u++) { /* Check for data block existing */ - if (H5F_addr_defined(sblock->dblk_addrs[u])) { + if (H5_addr_defined(sblock->dblk_addrs[u])) { /* Delete data block */ if (H5EA__dblock_delete(hdr, sblock, sblock->dblk_addrs[u], sblock->dblk_nelmts) < 0) HGOTO_ERROR(H5E_EARRAY, H5E_CANTDELETE, FAIL, "unable to delete extensible array data block") diff --git a/src/H5FA.c b/src/H5FA.c index 84d6e43..3ae9c4d 100644 --- a/src/H5FA.c +++ b/src/H5FA.c @@ -107,7 +107,7 @@ H5FA__new(H5F_t *f, haddr_t fa_addr, hbool_t from_open, void *ctx_udata) /* Check arguments */ assert(f); - assert(H5F_addr_defined(fa_addr)); + assert(H5_addr_defined(fa_addr)); /* Allocate fixed array wrapper */ if (NULL == (fa = H5FL_CALLOC(H5FA_t))) @@ -213,7 +213,7 @@ H5FA_open(H5F_t *f, haddr_t fa_addr, void *ctx_udata) /* Check arguments */ assert(f); - assert(H5F_addr_defined(fa_addr)); + assert(H5_addr_defined(fa_addr)); /* Allocate and initialize new fixed array wrapper */ if (NULL == (fa = H5FA__new(f, fa_addr, TRUE, ctx_udata))) @@ -311,10 +311,10 @@ H5FA_set(const H5FA_t *fa, hsize_t idx, const void *elmt) hdr->f = fa->f; /* Check if we need to create the fixed array data block */ - if (!H5F_addr_defined(hdr->dblk_addr)) { + if (!H5_addr_defined(hdr->dblk_addr)) { /* Create the data block */ hdr->dblk_addr = H5FA__dblock_create(hdr, &hdr_dirty); - if (!H5F_addr_defined(hdr->dblk_addr)) + if (!H5_addr_defined(hdr->dblk_addr)) HGOTO_ERROR(H5E_FARRAY, H5E_CANTCREATE, FAIL, "unable to create fixed array data block") } @@ -419,14 +419,14 @@ H5FA_get(const H5FA_t *fa, hsize_t idx, void *elmt) hdr->f = fa->f; /* Check if the fixed array data block has been allocated on disk yet */ - if (!H5F_addr_defined(hdr->dblk_addr)) { + if (!H5_addr_defined(hdr->dblk_addr)) { /* Call the class's 'fill' callback */ if ((hdr->cparam.cls->fill)(elmt, (size_t)1) < 0) HGOTO_ERROR(H5E_FARRAY, H5E_CANTSET, FAIL, "can't set element to class's fill value") } /* end if */ else { /* Get the data block */ - assert(H5F_addr_defined(hdr->dblk_addr)); + assert(H5_addr_defined(hdr->dblk_addr)); if (NULL == (dblock = H5FA__dblock_protect(hdr, hdr->dblk_addr, H5AC__READ_ONLY_FLAG))) HGOTO_ERROR(H5E_FARRAY, H5E_CANTPROTECT, FAIL, "unable to protect fixed array data block, address = %llu", @@ -611,7 +611,7 @@ H5FA_delete(H5F_t *f, haddr_t fa_addr, void *ctx_udata) /* Check arguments */ assert(f); - assert(H5F_addr_defined(fa_addr)); + assert(H5_addr_defined(fa_addr)); /* Lock the array header into memory */ if (NULL == (hdr = H5FA__hdr_protect(f, fa_addr, ctx_udata, H5AC__NO_FLAGS_SET))) diff --git a/src/H5FAcache.c b/src/H5FAcache.c index 5b0a054..df7121f 100644 --- a/src/H5FAcache.c +++ b/src/H5FAcache.c @@ -238,7 +238,7 @@ H5FA__cache_hdr_deserialize(const void *_image, size_t H5_ATTR_NDEBUG_UNUSED len /* Check arguments */ assert(udata); assert(udata->f); - assert(H5F_addr_defined(udata->addr)); + assert(H5_addr_defined(udata->addr)); /* Allocate space for the fixed array data structure */ if (NULL == (hdr = H5FA__hdr_alloc(udata->f))) @@ -272,10 +272,10 @@ H5FA__cache_hdr_deserialize(const void *_image, size_t H5_ATTR_NDEBUG_UNUSED len H5F_DECODE_LENGTH(udata->f, image, hdr->cparam.nelmts); /* Number of elements */ /* Internal information */ - H5F_addr_decode(udata->f, &image, &hdr->dblk_addr); /* Address of index block */ + H5_addr_decode(udata->f, &image, &hdr->dblk_addr); /* Address of index block */ /* Check for data block */ - if (H5F_addr_defined(hdr->dblk_addr)) { + if (H5_addr_defined(hdr->dblk_addr)) { H5FA_dblock_t dblock; /* Fake data block for computing size */ size_t dblk_page_nelmts; /* # of elements per data block page */ @@ -392,7 +392,7 @@ H5FA__cache_hdr_serialize(const H5F_t *f, void *_image, size_t H5_ATTR_UNUSED le H5F_ENCODE_LENGTH(f, image, hdr->stats.nelmts); /* Number of elements for the fixed array */ /* Internal information */ - H5F_addr_encode(f, &image, hdr->dblk_addr); /* Address of fixed array data block */ + H5_addr_encode(f, &image, hdr->dblk_addr); /* Address of fixed array data block */ /* Compute metadata checksum */ metadata_chksum = H5_checksum_metadata(_image, (size_t)(image - (uint8_t *)_image), 0); @@ -645,8 +645,8 @@ H5FA__cache_dblock_deserialize(const void *_image, size_t H5_ATTR_NDEBUG_UNUSED HGOTO_ERROR(H5E_FARRAY, H5E_BADTYPE, NULL, "incorrect fixed array class") /* Address of header for array that owns this block (just for file integrity checks) */ - H5F_addr_decode(udata->hdr->f, &image, &arr_addr); - if (H5F_addr_ne(arr_addr, udata->hdr->addr)) + H5_addr_decode(udata->hdr->f, &image, &arr_addr); + if (H5_addr_ne(arr_addr, udata->hdr->addr)) HGOTO_ERROR(H5E_FARRAY, H5E_BADVALUE, NULL, "wrong fixed array header address") /* Page initialization flags */ @@ -758,7 +758,7 @@ H5FA__cache_dblock_serialize(const H5F_t *f, void *_image, size_t H5_ATTR_UNUSED *image++ = (uint8_t)dblock->hdr->cparam.cls->id; /* Address of array header for array which owns this block */ - H5F_addr_encode(f, &image, dblock->hdr->addr); + H5_addr_encode(f, &image, dblock->hdr->addr); /* Page init flags */ if (dblock->npages > 0) { @@ -1023,7 +1023,7 @@ H5FA__cache_dblk_page_deserialize(const void *_image, size_t len, void *_udata, assert(udata); assert(udata->hdr); assert(udata->nelmts > 0); - assert(H5F_addr_defined(udata->dblk_page_addr)); + assert(H5_addr_defined(udata->dblk_page_addr)); /* Allocate the fixed array data block page */ if (NULL == (dblk_page = H5FA__dblk_page_alloc(udata->hdr, udata->nelmts))) diff --git a/src/H5FAdbg.c b/src/H5FAdbg.c index f159f52..44fda03 100644 --- a/src/H5FAdbg.c +++ b/src/H5FAdbg.c @@ -88,8 +88,8 @@ H5FA__hdr_debug(H5F_t *f, haddr_t addr, FILE *stream, int indent, int fwidth, co /* Check arguments */ assert(f); - assert(H5F_addr_defined(addr)); - assert(H5F_addr_defined(obj_addr)); + assert(H5_addr_defined(addr)); + assert(H5_addr_defined(obj_addr)); assert(stream); assert(indent >= 0); assert(fwidth >= 0); @@ -158,13 +158,13 @@ H5FA__dblock_debug(H5F_t *f, haddr_t addr, FILE *stream, int indent, int fwidth, /* Check arguments */ assert(f); - assert(H5F_addr_defined(addr)); + assert(H5_addr_defined(addr)); assert(stream); assert(indent >= 0); assert(fwidth >= 0); assert(cls); - assert(H5F_addr_defined(hdr_addr)); - assert(H5F_addr_defined(obj_addr)); + assert(H5_addr_defined(hdr_addr)); + assert(H5_addr_defined(obj_addr)); /* Check for debugging context callback available */ if (cls->crt_dbg_ctx) diff --git a/src/H5FAdblkpage.c b/src/H5FAdblkpage.c index dfed386..bd714cc 100644 --- a/src/H5FAdblkpage.c +++ b/src/H5FAdblkpage.c @@ -218,7 +218,7 @@ H5FA__dblk_page_protect(H5FA_hdr_t *hdr, haddr_t dblk_page_addr, size_t dblk_pag /* Sanity check */ assert(hdr); - assert(H5F_addr_defined(dblk_page_addr)); + assert(H5_addr_defined(dblk_page_addr)); /* only the H5AC__READ_ONLY_FLAG is permitted */ assert((flags & (unsigned)(~H5AC__READ_ONLY_FLAG)) == 0); diff --git a/src/H5FAdblock.c b/src/H5FAdblock.c index 137b0bf..ccf4a72 100644 --- a/src/H5FAdblock.c +++ b/src/H5FAdblock.c @@ -222,7 +222,7 @@ H5FA__dblock_create(H5FA_hdr_t *hdr, hbool_t *hdr_dirty) done: - if (!H5F_addr_defined(ret_value)) + if (!H5_addr_defined(ret_value)) if (dblock) { /* Remove from cache, if inserted */ if (inserted) @@ -231,7 +231,7 @@ done: "unable to remove fixed array data block from cache") /* Release data block's disk space */ - if (H5F_addr_defined(dblock->addr) && + if (H5_addr_defined(dblock->addr) && H5MF_xfree(hdr->f, H5FD_MEM_FARRAY_DBLOCK, dblock->addr, (hsize_t)dblock->size) < 0) HDONE_ERROR(H5E_FARRAY, H5E_CANTFREE, HADDR_UNDEF, "unable to release fixed array data block") @@ -263,7 +263,7 @@ H5FA__dblock_protect(H5FA_hdr_t *hdr, haddr_t dblk_addr, unsigned flags) /* Sanity check */ assert(hdr); - assert(H5F_addr_defined(dblk_addr)); + assert(H5_addr_defined(dblk_addr)); /* only the H5AC__READ_ONLY_FLAG flag is permitted */ assert((flags & (unsigned)(~H5AC__READ_ONLY_FLAG)) == 0); @@ -351,7 +351,7 @@ H5FA__dblock_delete(H5FA_hdr_t *hdr, haddr_t dblk_addr) /* Sanity check */ assert(hdr); - assert(H5F_addr_defined(dblk_addr)); + assert(H5_addr_defined(dblk_addr)); /* Protect data block */ if (NULL == (dblock = H5FA__dblock_protect(hdr, dblk_addr, H5AC__NO_FLAGS_SET))) diff --git a/src/H5FAhdr.c b/src/H5FAhdr.c index bc362af..712ca15 100644 --- a/src/H5FAhdr.c +++ b/src/H5FAhdr.c @@ -221,7 +221,7 @@ H5FA__hdr_create(H5F_t *f, const H5FA_create_t *cparam, void *ctx_udata) ret_value = hdr->addr; done: - if (!H5F_addr_defined(ret_value)) + if (!H5_addr_defined(ret_value)) if (hdr) { /* Remove from cache, if inserted */ if (inserted) @@ -230,7 +230,7 @@ done: "unable to remove fixed array header from cache") /* Release header's disk space */ - if (H5F_addr_defined(hdr->addr) && + if (H5_addr_defined(hdr->addr) && H5MF_xfree(f, H5FD_MEM_FARRAY_HDR, hdr->addr, (hsize_t)hdr->size) < 0) HDONE_ERROR(H5E_FARRAY, H5E_CANTFREE, HADDR_UNDEF, "unable to free Fixed Array header") @@ -407,7 +407,7 @@ H5FA__hdr_protect(H5F_t *f, haddr_t fa_addr, void *ctx_udata, unsigned flags) /* Sanity check */ assert(f); - assert(H5F_addr_defined(fa_addr)); + assert(H5_addr_defined(fa_addr)); /* only the H5AC__READ_ONLY_FLAG is permitted */ assert((flags & (unsigned)(~H5AC__READ_ONLY_FLAG)) == 0); @@ -506,7 +506,7 @@ H5FA__hdr_delete(H5FA_hdr_t *hdr) #endif /* NDEBUG */ /* Check for Fixed Array Data block */ - if (H5F_addr_defined(hdr->dblk_addr)) { + if (H5_addr_defined(hdr->dblk_addr)) { /* Delete Fixed Array Data block */ if (H5FA__dblock_delete(hdr, hdr->dblk_addr) < 0) HGOTO_ERROR(H5E_FARRAY, H5E_CANTDELETE, FAIL, "unable to delete fixed array data block") diff --git a/src/H5FD.c b/src/H5FD.c index 9ce1718..040ded2 100644 --- a/src/H5FD.c +++ b/src/H5FD.c @@ -1217,7 +1217,7 @@ H5FDset_eoa(H5FD_t *file, H5FD_mem_t type, haddr_t addr) HGOTO_ERROR(H5E_ARGS, H5E_BADVALUE, FAIL, "file class pointer cannot be NULL") if (type < H5FD_MEM_DEFAULT || type >= H5FD_MEM_NTYPES) HGOTO_ERROR(H5E_ARGS, H5E_BADVALUE, FAIL, "invalid file type") - if (!H5F_addr_defined(addr) || addr > file->maxaddr) + if (!H5_addr_defined(addr) || addr > file->maxaddr) HGOTO_ERROR(H5E_ARGS, H5E_BADVALUE, FAIL, "invalid end-of-address value") /* Call private function */ @@ -2295,7 +2295,7 @@ H5FD_set_base_addr(H5FD_t *file, haddr_t base_addr) /* Sanity checks */ assert(file); - assert(H5F_addr_defined(base_addr)); + assert(H5_addr_defined(base_addr)); /* Set the file's base address */ file->base_addr = base_addr; diff --git a/src/H5FDcore.c b/src/H5FDcore.c index 8ad0e0e..0e07350 100644 --- a/src/H5FDcore.c +++ b/src/H5FDcore.c @@ -1515,7 +1515,7 @@ H5FD__core_truncate(H5FD_t *_file, hid_t H5_ATTR_UNUSED dxpl_id, hbool_t closing } /* end else */ /* Extend the file to make sure it's large enough */ - if (!H5F_addr_eq(file->eof, (haddr_t)new_eof)) { + if (!H5_addr_eq(file->eof, (haddr_t)new_eof)) { unsigned char *x; /* Pointer to new buffer for file data */ /* (Re)allocate memory for the file buffer, using callback if available */ diff --git a/src/H5FDint.c b/src/H5FDint.c index 306b3dd..5dece6f 100644 --- a/src/H5FDint.c +++ b/src/H5FDint.c @@ -2018,7 +2018,7 @@ H5FD_set_eoa(H5FD_t *file, H5FD_mem_t type, haddr_t addr) FUNC_ENTER_NOAPI(FAIL) assert(file && file->cls); - assert(H5F_addr_defined(addr) && addr <= file->maxaddr); + assert(H5_addr_defined(addr) && addr <= file->maxaddr); /* Dispatch to driver, convert to absolute address */ if ((file->cls->set_eoa)(file, type, addr + file->base_addr) < 0) @@ -2177,13 +2177,13 @@ H5FD__vsrt_tmp_cmp(const void *element_1, const void *element_2) FUNC_ENTER_PACKAGE_NOERR /* Sanity checks */ - assert(H5F_addr_defined(addr_1)); - assert(H5F_addr_defined(addr_2)); + assert(H5_addr_defined(addr_1)); + assert(H5_addr_defined(addr_2)); /* Compare the addresses */ - if (H5F_addr_gt(addr_1, addr_2)) + if (H5_addr_gt(addr_1, addr_2)) ret_value = 1; - else if (H5F_addr_lt(addr_1, addr_2)) + else if (H5_addr_lt(addr_1, addr_2)) ret_value = -1; FUNC_LEAVE_NOAPI(ret_value) @@ -2223,11 +2223,11 @@ H5FD_sort_vector_io_req(hbool_t *vector_was_sorted, uint32_t _count, H5FD_mem_t /* scan the addrs array to see if it is sorted */ for (i = 1; i < count; i++) { - assert(H5F_addr_defined(addrs[i - 1])); + assert(H5_addr_defined(addrs[i - 1])); - if (H5F_addr_gt(addrs[i - 1], addrs[i])) + if (H5_addr_gt(addrs[i - 1], addrs[i])) break; - else if (H5F_addr_eq(addrs[i - 1], addrs[i])) + else if (H5_addr_eq(addrs[i - 1], addrs[i])) HGOTO_ERROR(H5E_ARGS, H5E_BADVALUE, FAIL, "duplicate addr in vector") } @@ -2282,9 +2282,9 @@ H5FD_sort_vector_io_req(hbool_t *vector_was_sorted, uint32_t _count, H5FD_mem_t i = 1; for (i = 1; i < count; i++) { - assert(H5F_addr_lt(srt_tmp[i - 1].addr, srt_tmp[i].addr)); + assert(H5_addr_lt(srt_tmp[i - 1].addr, srt_tmp[i].addr)); - if (H5F_addr_eq(addrs[i - 1], addrs[i])) + if (H5_addr_eq(addrs[i - 1], addrs[i])) HGOTO_ERROR(H5E_ARGS, H5E_BADVALUE, FAIL, "duplicate addr in vector") } diff --git a/src/H5FDlog.c b/src/H5FDlog.c index 19f5ab4..62351f8 100644 --- a/src/H5FDlog.c +++ b/src/H5FDlog.c @@ -1006,7 +1006,7 @@ H5FD__log_set_eoa(H5FD_t *_file, H5FD_mem_t type, haddr_t addr) if (file->fa.flags != 0) { /* Check for increasing file size */ - if (H5F_addr_gt(addr, file->eoa) && H5F_addr_gt(addr, 0)) { + if (H5_addr_gt(addr, file->eoa) && H5_addr_gt(addr, 0)) { hsize_t size = addr - file->eoa; /* Retain the flavor of the space allocated by the extension */ @@ -1024,7 +1024,7 @@ H5FD__log_set_eoa(H5FD_t *_file, H5FD_mem_t type, haddr_t addr) } /* Check for decreasing file size */ - if (H5F_addr_lt(addr, file->eoa) && H5F_addr_gt(addr, 0)) { + if (H5_addr_lt(addr, file->eoa) && H5_addr_gt(addr, 0)) { hsize_t size = file->eoa - addr; /* Reset the flavor of the space freed by the shrink */ @@ -1131,7 +1131,7 @@ H5FD__log_read(H5FD_t *_file, H5FD_mem_t type, hid_t H5_ATTR_UNUSED dxpl_id, had H5_timer_init(&read_timer); /* Check for overflow conditions */ - if (!H5F_addr_defined(addr)) + if (!H5_addr_defined(addr)) HGOTO_ERROR(H5E_ARGS, H5E_BADVALUE, FAIL, "addr undefined, addr = %llu", (unsigned long long)addr) if (REGION_OVERFLOW(addr, size)) HGOTO_ERROR(H5E_ARGS, H5E_OVERFLOW, FAIL, "addr overflow, addr = %llu", (unsigned long long)addr) @@ -1351,7 +1351,7 @@ H5FD__log_write(H5FD_t *_file, H5FD_mem_t type, hid_t H5_ATTR_UNUSED dxpl_id, ha } /* Check for overflow conditions */ - if (!H5F_addr_defined(addr)) + if (!H5_addr_defined(addr)) HGOTO_ERROR(H5E_ARGS, H5E_BADVALUE, FAIL, "addr undefined, addr = %llu", (unsigned long long)addr) if (REGION_OVERFLOW(addr, size)) HGOTO_ERROR(H5E_ARGS, H5E_OVERFLOW, FAIL, "addr overflow, addr = %llu, size = %llu", @@ -1546,7 +1546,7 @@ H5FD__log_truncate(H5FD_t *_file, hid_t H5_ATTR_UNUSED dxpl_id, hbool_t H5_ATTR_ assert(file); /* Extend the file to make sure it's large enough */ - if (!H5F_addr_eq(file->eoa, file->eof)) { + if (!H5_addr_eq(file->eoa, file->eof)) { H5_timer_t trunc_timer; /* Timer for truncate operation */ H5_timevals_t trunc_times; /* Elapsed time for truncate operation */ diff --git a/src/H5FDmpio.c b/src/H5FDmpio.c index c06214c..555551d 100644 --- a/src/H5FDmpio.c +++ b/src/H5FDmpio.c @@ -2800,7 +2800,7 @@ H5FD__mpio_truncate(H5FD_t *_file, hid_t H5_ATTR_UNUSED dxpl_id, hbool_t H5_ATTR assert(file); assert(H5FD_MPIO == file->pub.driver_id); - if (!H5F_addr_eq(file->eoa, file->last_eoa)) { + if (!H5_addr_eq(file->eoa, file->last_eoa)) { int mpi_code; /* mpi return code */ MPI_Offset size; MPI_Offset needed_eof; diff --git a/src/H5FDsec2.c b/src/H5FDsec2.c index de88b43..cfc4f7e 100644 --- a/src/H5FDsec2.c +++ b/src/H5FDsec2.c @@ -656,7 +656,7 @@ H5FD__sec2_read(H5FD_t *_file, H5FD_mem_t H5_ATTR_UNUSED type, hid_t H5_ATTR_UNU assert(buf); /* Check for overflow conditions */ - if (!H5F_addr_defined(addr)) + if (!H5_addr_defined(addr)) HGOTO_ERROR(H5E_ARGS, H5E_BADVALUE, FAIL, "addr undefined, addr = %llu", (unsigned long long)addr) if (REGION_OVERFLOW(addr, size)) HGOTO_ERROR(H5E_ARGS, H5E_OVERFLOW, FAIL, "addr overflow, addr = %llu", (unsigned long long)addr) @@ -761,7 +761,7 @@ H5FD__sec2_write(H5FD_t *_file, H5FD_mem_t H5_ATTR_UNUSED type, hid_t H5_ATTR_UN assert(buf); /* Check for overflow conditions */ - if (!H5F_addr_defined(addr)) + if (!H5_addr_defined(addr)) HGOTO_ERROR(H5E_ARGS, H5E_BADVALUE, FAIL, "addr undefined, addr = %llu", (unsigned long long)addr) if (REGION_OVERFLOW(addr, size)) HGOTO_ERROR(H5E_ARGS, H5E_OVERFLOW, FAIL, "addr overflow, addr = %llu, size = %llu", @@ -859,7 +859,7 @@ H5FD__sec2_truncate(H5FD_t *_file, hid_t H5_ATTR_UNUSED dxpl_id, hbool_t H5_ATTR assert(file); /* Extend the file to make sure it's large enough */ - if (!H5F_addr_eq(file->eoa, file->eof)) { + if (!H5_addr_eq(file->eoa, file->eof)) { #ifdef H5_HAVE_WIN32_API LARGE_INTEGER li; /* 64-bit (union) integer for SetFilePointer() call */ DWORD dwPtrLow; /* Low-order pointer bits from SetFilePointer() diff --git a/src/H5FDspace.c b/src/H5FDspace.c index 3ca34aa..2b64b56 100644 --- a/src/H5FDspace.c +++ b/src/H5FDspace.c @@ -100,7 +100,7 @@ H5FD__extend(H5FD_t *file, H5FD_mem_t type, hsize_t size) eoa = file->cls->get_eoa(file, type); /* Check for overflow when extending */ - if (H5F_addr_overflow(eoa, size) || (eoa + size) > file->maxaddr) + if (H5_addr_overflow(eoa, size) || (eoa + size) > file->maxaddr) HGOTO_ERROR(H5E_VFL, H5E_NOSPACE, HADDR_UNDEF, "file allocation request failed") /* Set the [NOT aligned] address to return */ @@ -180,12 +180,12 @@ H5FD__alloc_real(H5FD_t *file, H5FD_mem_t type, hsize_t size, haddr_t *frag_addr * size */ if (file->cls->alloc) { ret_value = (file->cls->alloc)(file, type, H5CX_get_dxpl(), use_alloc_size ? size : size + extra); - if (!H5F_addr_defined(ret_value)) + if (!H5_addr_defined(ret_value)) HGOTO_ERROR(H5E_VFL, H5E_NOSPACE, HADDR_UNDEF, "driver allocation request failed") } /* end if */ else { ret_value = H5FD__extend(file, type, size + extra); - if (!H5F_addr_defined(ret_value)) + if (!H5_addr_defined(ret_value)) HGOTO_ERROR(H5E_VFL, H5E_NOSPACE, HADDR_UNDEF, "driver eoa update request failed") } /* end else */ @@ -237,7 +237,7 @@ H5FD_alloc(H5FD_t *file, H5FD_mem_t type, H5F_t *f, hsize_t size, haddr_t *frag_ /* Call the real 'alloc' routine */ ret_value = H5FD__alloc_real(file, type, size, frag_addr, frag_size); - if (!H5F_addr_defined(ret_value)) + if (!H5_addr_defined(ret_value)) HGOTO_ERROR(H5E_VFL, H5E_CANTALLOC, HADDR_UNDEF, "real 'alloc' request failed") /* Mark EOA info dirty in cache, so change will get encoded */ @@ -277,14 +277,14 @@ H5FD__free_real(H5FD_t *file, H5FD_mem_t type, haddr_t addr, hsize_t size) #endif /* H5FD_ALLOC_DEBUG */ /* Sanity checking */ - if (!H5F_addr_defined(addr)) + if (!H5_addr_defined(addr)) HGOTO_ERROR(H5E_VFL, H5E_BADVALUE, FAIL, "invalid file offset") /* Convert address to absolute file offset */ addr += file->base_addr; /* More sanity checking */ - if (addr > file->maxaddr || H5F_addr_overflow(addr, size) || (addr + size) > file->maxaddr) + if (addr > file->maxaddr || H5_addr_overflow(addr, size) || (addr + size) > file->maxaddr) HGOTO_ERROR(H5E_VFL, H5E_BADVALUE, FAIL, "invalid file free space region to free") /* Check for file driver 'free' callback and call it if available */ @@ -403,7 +403,7 @@ H5FD_try_extend(H5FD_t *file, H5FD_mem_t type, H5F_t *f, haddr_t blk_end, hsize_ blk_end += file->base_addr; /* Check if the block is exactly at the end of the file */ - if (H5F_addr_eq(blk_end, eoa)) { + if (H5_addr_eq(blk_end, eoa)) { /* Extend the object by extending the underlying file */ if (HADDR_UNDEF == H5FD__extend(file, type, extra_requested)) HGOTO_ERROR(H5E_VFL, H5E_CANTEXTEND, FAIL, "driver extend request failed") diff --git a/src/H5FDsplitter.c b/src/H5FDsplitter.c index edf9898..f0ed1b0 100644 --- a/src/H5FDsplitter.c +++ b/src/H5FDsplitter.c @@ -616,7 +616,7 @@ H5FD__splitter_read(H5FD_t *_file, H5FD_mem_t H5_ATTR_UNUSED type, hid_t H5_ATTR assert(buf); /* Check for overflow conditions */ - if (!H5F_addr_defined(addr)) + if (!H5_addr_defined(addr)) HGOTO_ERROR(H5E_ARGS, H5E_BADVALUE, FAIL, "addr undefined, addr = %llu", (unsigned long long)addr) if (REGION_OVERFLOW(addr, size)) HGOTO_ERROR(H5E_ARGS, H5E_OVERFLOW, FAIL, "addr overflow, addr = %llu", (unsigned long long)addr) diff --git a/src/H5FDsubfiling/H5FDioc.c b/src/H5FDsubfiling/H5FDioc.c index 2e7e8a8..6e00fdf 100644 --- a/src/H5FDsubfiling/H5FDioc.c +++ b/src/H5FDsubfiling/H5FDioc.c @@ -1226,7 +1226,7 @@ H5FD__ioc_read(H5FD_t *_file, H5FD_mem_t H5_ATTR_UNUSED type, hid_t H5_ATTR_UNUS assert(buf); /* Check for overflow conditions */ - if (!H5F_addr_defined(addr)) + if (!H5_addr_defined(addr)) H5_SUBFILING_GOTO_ERROR(H5E_ARGS, H5E_BADVALUE, FAIL, "addr undefined, addr = %" PRIuHADDR, addr); if (REGION_OVERFLOW(addr, size)) H5_SUBFILING_GOTO_ERROR(H5E_ARGS, H5E_OVERFLOW, FAIL, "addr overflow, addr = %" PRIuHADDR, addr); @@ -1385,7 +1385,7 @@ H5FD__ioc_truncate(H5FD_t *_file, hid_t H5_ATTR_UNUSED dxpl_id, hbool_t H5_ATTR_ assert(file); /* TODO: placeholder for now since Subfiling does the truncation */ - if (!H5F_addr_eq(file->eoa, file->last_eoa)) { + if (!H5_addr_eq(file->eoa, file->last_eoa)) { file->last_eoa = file->eoa; } diff --git a/src/H5FDsubfiling/H5FDsubfiling.c b/src/H5FDsubfiling/H5FDsubfiling.c index 943594c..0f86626 100644 --- a/src/H5FDsubfiling/H5FDsubfiling.c +++ b/src/H5FDsubfiling/H5FDsubfiling.c @@ -1552,7 +1552,7 @@ H5FD__subfiling_read(H5FD_t *_file, H5FD_mem_t type, hid_t H5_ATTR_UNUSED dxpl_i assert(buf); /* Check for overflow conditions */ - if (!H5F_addr_defined(addr)) + if (!H5_addr_defined(addr)) H5_SUBFILING_GOTO_ERROR(H5E_ARGS, H5E_BADVALUE, FAIL, "addr undefined, addr = %" PRIuHADDR, addr); if (REGION_OVERFLOW(addr, size)) H5_SUBFILING_GOTO_ERROR(H5E_ARGS, H5E_OVERFLOW, FAIL, @@ -1785,7 +1785,7 @@ H5FD__subfiling_write(H5FD_t *_file, H5FD_mem_t type, hid_t H5_ATTR_UNUSED dxpl_ assert(buf); /* Check for overflow conditions */ - if (!H5F_addr_defined(addr)) + if (!H5_addr_defined(addr)) H5_SUBFILING_GOTO_ERROR(H5E_ARGS, H5E_BADVALUE, FAIL, "addr undefined, addr = %" PRIuHADDR, addr); if (REGION_OVERFLOW(addr, size)) H5_SUBFILING_GOTO_ERROR(H5E_ARGS, H5E_OVERFLOW, FAIL, @@ -2348,7 +2348,7 @@ H5FD__subfiling_truncate(H5FD_t *_file, hid_t H5_ATTR_UNUSED dxpl_id, hbool_t H5 assert(file); /* Extend the file to make sure it's large enough */ - if (!H5F_addr_eq(file->eoa, file->last_eoa)) { + if (!H5_addr_eq(file->eoa, file->last_eoa)) { int64_t sf_eof; int64_t eoa; int mpi_code; diff --git a/src/H5FO.c b/src/H5FO.c index 323797c..5ebd8a9 100644 --- a/src/H5FO.c +++ b/src/H5FO.c @@ -116,7 +116,7 @@ H5FO_opened(const H5F_t *f, haddr_t addr) assert(f); assert(f->shared); assert(f->shared->open_objs); - assert(H5F_addr_defined(addr)); + assert(H5_addr_defined(addr)); /* Get the object node from the container */ if (NULL != (open_obj = (H5FO_open_obj_t *)H5SL_search(f->shared->open_objs, &addr))) { @@ -162,7 +162,7 @@ H5FO_insert(const H5F_t *f, haddr_t addr, void *obj, hbool_t delete_flag) assert(f); assert(f->shared); assert(f->shared->open_objs); - assert(H5F_addr_defined(addr)); + assert(H5_addr_defined(addr)); assert(obj); /* Allocate new opened object information structure */ @@ -213,7 +213,7 @@ H5FO_delete(H5F_t *f, haddr_t addr) assert(f); assert(f->shared); assert(f->shared->open_objs); - assert(H5F_addr_defined(addr)); + assert(H5_addr_defined(addr)); /* Remove from container */ if (NULL == (open_obj = (H5FO_open_obj_t *)H5SL_remove(f->shared->open_objs, &addr))) @@ -263,7 +263,7 @@ H5FO_mark(const H5F_t *f, haddr_t addr, hbool_t deleted) assert(f); assert(f->shared); assert(f->shared->open_objs); - assert(H5F_addr_defined(addr)); + assert(H5_addr_defined(addr)); /* Get the object node from the container */ if (NULL != (open_obj = (H5FO_open_obj_t *)H5SL_search(f->shared->open_objs, &addr))) @@ -306,7 +306,7 @@ H5FO_marked(const H5F_t *f, haddr_t addr) assert(f); assert(f->shared); assert(f->shared->open_objs); - assert(H5F_addr_defined(addr)); + assert(H5_addr_defined(addr)); /* Get the object node from the container */ if (NULL != (open_obj = (H5FO_open_obj_t *)H5SL_search(f->shared->open_objs, &addr))) @@ -425,7 +425,7 @@ H5FO_top_incr(const H5F_t *f, haddr_t addr) /* Sanity check */ assert(f); assert(f->obj_count); - assert(H5F_addr_defined(addr)); + assert(H5_addr_defined(addr)); /* Get the object node from the container */ if (NULL != (obj_count = (H5FO_obj_count_t *)H5SL_search(f->obj_count, &addr))) { @@ -479,7 +479,7 @@ H5FO_top_decr(const H5F_t *f, haddr_t addr) /* Sanity check */ assert(f); assert(f->obj_count); - assert(H5F_addr_defined(addr)); + assert(H5_addr_defined(addr)); /* Get the object node from the container */ if (NULL != (obj_count = (H5FO_obj_count_t *)H5SL_search(f->obj_count, &addr))) { @@ -532,7 +532,7 @@ H5FO_top_count(const H5F_t *f, haddr_t addr) /* Sanity check */ assert(f); assert(f->obj_count); - assert(H5F_addr_defined(addr)); + assert(H5_addr_defined(addr)); /* Get the object node from the container */ if (NULL != (obj_count = (H5FO_obj_count_t *)H5SL_search(f->obj_count, &addr))) diff --git a/src/H5FS.c b/src/H5FS.c index ee85539..c547859 100644 --- a/src/H5FS.c +++ b/src/H5FS.c @@ -175,7 +175,7 @@ H5FS_open(H5F_t *f, haddr_t fs_addr, uint16_t nclasses, const H5FS_section_class #endif /* H5FS_DEBUG */ /* Check arguments. */ - assert(H5F_addr_defined(fs_addr)); + assert(H5_addr_defined(fs_addr)); assert(nclasses); assert(classes); @@ -240,7 +240,7 @@ H5FS_delete(H5F_t *f, haddr_t fs_addr) /* Check arguments. */ assert(f); - assert(H5F_addr_defined(fs_addr)); + assert(H5_addr_defined(fs_addr)); /* Initialize user data for protecting the free space manager */ /* (no class information necessary for delete) */ @@ -255,7 +255,7 @@ H5FS_delete(H5F_t *f, haddr_t fs_addr) unsigned fspace_status = 0; /* Free space section info's status in the metadata cache */ /* Sanity check */ - assert(H5F_addr_defined(fs_addr)); + assert(H5_addr_defined(fs_addr)); /* Check the free space section info's status in the metadata cache */ if (H5AC_get_entry_status(f, fs_addr, &fspace_status) < 0) @@ -311,7 +311,7 @@ H5FS_delete(H5F_t *f, haddr_t fs_addr) unsigned sinfo_status = 0; /* Free space section info's status in the metadata cache */ /* Sanity check */ - assert(H5F_addr_defined(fspace->sect_addr)); + assert(H5_addr_defined(fspace->sect_addr)); assert(fspace->alloc_sect_size > 0); /* Check the free space section info's status in the metadata cache */ @@ -405,13 +405,13 @@ H5FS_close(H5F_t *f, H5FS_t *fspace) #endif /* H5FS_DEBUG */ /* If there are sections to serialize, update them */ /* (if the free space manager is persistent) */ - if (fspace->serial_sect_count > 0 && H5F_addr_defined(fspace->addr)) { + if (fspace->serial_sect_count > 0 && H5_addr_defined(fspace->addr)) { #ifdef H5FS_DEBUG fprintf(stderr, "%s: Real sections to store in file\n", __func__); #endif /* H5FS_DEBUG */ if (fspace->sinfo->dirty) { /* Check if the section info is "floating" */ - if (!H5F_addr_defined(fspace->sect_addr)) { + if (!H5_addr_defined(fspace->sect_addr)) { /* Sanity check */ assert(fspace->sect_size > 0); @@ -437,7 +437,7 @@ H5FS_close(H5F_t *f, H5FS_t *fspace) } /* end if */ else /* Sanity check that section info has address */ - assert(H5F_addr_defined(fspace->sect_addr)); + assert(H5_addr_defined(fspace->sect_addr)); /* Cache the free space section info */ if (H5AC_insert_entry(f, H5AC_FSPACE_SINFO, fspace->sect_addr, fspace->sinfo, @@ -449,10 +449,10 @@ H5FS_close(H5F_t *f, H5FS_t *fspace) fprintf(stderr, "%s: NOT storing section info in file\n", __func__); #endif /* H5FS_DEBUG */ /* Check if space for the section info is allocated */ - if (H5F_addr_defined(fspace->sect_addr)) { + if (H5_addr_defined(fspace->sect_addr)) { /* Sanity check */ /* (section info should only be in the file if the header is */ - assert(H5F_addr_defined(fspace->addr)); + assert(H5_addr_defined(fspace->addr)); #ifdef H5FS_DEBUG fprintf(stderr, "%s: Section info allocated though\n", __func__); @@ -549,7 +549,7 @@ H5FS_close(H5F_t *f, H5FS_t *fspace) /* Just sanity checks... */ if (fspace->serial_sect_count > 0) /* Sanity check that section info has address */ - assert(H5F_addr_defined(fspace->sect_addr)); + assert(H5_addr_defined(fspace->sect_addr)); } /* end else */ /* Decrement the reference count on the free space manager header */ @@ -692,7 +692,7 @@ H5FS__incr(H5FS_t *fspace) assert(fspace); /* Check if we should pin the header in the cache */ - if (fspace->rc == 0 && H5F_addr_defined(fspace->addr)) + if (fspace->rc == 0 && H5_addr_defined(fspace->addr)) if (H5AC_pin_protected_entry(fspace) < 0) HGOTO_ERROR(H5E_FSPACE, H5E_CANTPIN, FAIL, "unable to pin free space header") @@ -733,7 +733,7 @@ H5FS__decr(H5FS_t *fspace) /* Check if we should unpin the header in the cache */ if (fspace->rc == 0) { - if (H5F_addr_defined(fspace->addr)) { + if (H5_addr_defined(fspace->addr)) { if (H5AC_unpin_entry(fspace) < 0) HGOTO_ERROR(H5E_FSPACE, H5E_CANTUNPIN, FAIL, "unable to unpin free space header") } /* end if */ @@ -767,7 +767,7 @@ H5FS__dirty(H5FS_t *fspace) assert(fspace); /* Check if the free space manager is persistent */ - if (H5F_addr_defined(fspace->addr)) + if (H5_addr_defined(fspace->addr)) /* Mark header as dirty in cache */ if (H5AC_mark_entry_dirty(fspace) < 0) HGOTO_ERROR(H5E_FSPACE, H5E_CANTMARKDIRTY, FAIL, "unable to mark free space header as dirty") @@ -796,7 +796,7 @@ H5FS_alloc_hdr(H5F_t *f, H5FS_t *fspace, haddr_t *fs_addr) assert(f); assert(fspace); - if (!H5F_addr_defined(fspace->addr)) { + if (!H5_addr_defined(fspace->addr)) { /* Allocate space for the free space header */ if (HADDR_UNDEF == (fspace->addr = H5MF_alloc(f, H5FD_MEM_FSPACE_HDR, (hsize_t)H5FS_HEADER_SIZE(f)))) HGOTO_ERROR(H5E_RESOURCE, H5E_NOSPACE, FAIL, "file allocation failed for free space header") @@ -833,7 +833,7 @@ H5FS_alloc_sect(H5F_t *f, H5FS_t *fspace) assert(f); assert(fspace); - if (!H5F_addr_defined(fspace->sect_addr) && fspace->sinfo && fspace->serial_sect_count > 0) { + if (!H5_addr_defined(fspace->sect_addr) && fspace->sinfo && fspace->serial_sect_count > 0) { if (HADDR_UNDEF == (fspace->sect_addr = H5MF_alloc(f, H5FD_MEM_FSPACE_SINFO, fspace->sect_size))) HGOTO_ERROR(H5E_FSPACE, H5E_NOSPACE, FAIL, "file allocation failed for section info") fspace->alloc_sect_size = fspace->sect_size; @@ -883,7 +883,7 @@ H5FS_free(H5F_t *f, H5FS_t *fspace, hbool_t free_file_space) ; /* Free space for section info */ - if (H5F_addr_defined(fspace->sect_addr)) { + if (H5_addr_defined(fspace->sect_addr)) { hsize_t saved_size; /* Size of previous section info */ unsigned sinfo_status = 0; /* Section info cache status */ @@ -926,7 +926,7 @@ H5FS_free(H5F_t *f, H5FS_t *fspace, hbool_t free_file_space) } /* end if */ /* Free space for header */ - if (H5F_addr_defined(fspace->addr)) { + if (H5_addr_defined(fspace->addr)) { unsigned hdr_status = 0; /* Header entry status */ /* Check whether free-space manager header is in cache or not */ diff --git a/src/H5FScache.c b/src/H5FScache.c index c7bfab2..449628d 100644 --- a/src/H5FScache.c +++ b/src/H5FScache.c @@ -283,7 +283,7 @@ H5FS__cache_hdr_deserialize(const void *_image, size_t H5_ATTR_NDEBUG_UNUSED len H5F_DECODE_LENGTH(udata->f, image, fspace->max_sect_size); /* Address of serialized free space sections */ - H5F_addr_decode(udata->f, &image, &fspace->sect_addr); + H5_addr_decode(udata->f, &image, &fspace->sect_addr); /* Size of serialized free space sections */ H5F_DECODE_LENGTH(udata->f, image, fspace->sect_size); @@ -380,7 +380,7 @@ H5FS__cache_hdr_pre_serialize(H5F_t *f, void *_thing, haddr_t addr, size_t H5_AT assert(fspace); assert(fspace->cache_info.magic == H5C__H5C_CACHE_ENTRY_T_MAGIC); assert(fspace->cache_info.type == H5AC_FSPACE_HDR); - assert(H5F_addr_defined(addr)); + assert(H5_addr_defined(addr)); assert(new_addr); assert(new_len); assert(flags); @@ -406,7 +406,7 @@ H5FS__cache_hdr_pre_serialize(H5F_t *f, void *_thing, haddr_t addr, size_t H5_AT * * 1) The instance of H5FS_sinfo_t is not in the metadata cache. * - * This will be TRUE iff H5F_addr_defined(fspace->sect_addr) + * This will be TRUE iff H5_addr_defined(fspace->sect_addr) * is FALSE, and fspace->sinfo is not NULL. This is sometimes * referred to as "floating" section info in the comments. * @@ -417,11 +417,11 @@ H5FS__cache_hdr_pre_serialize(H5F_t *f, void *_thing, haddr_t addr, size_t H5_AT * * and * - * H5F_addr_defined(fspace->addr) + * H5_addr_defined(fspace->addr) * * will both be TRUE. If this condition does not hold, then * either the free space info is not persistent - * (!H5F_addr_defined(fspace->addr)???) or the section info + * (!H5_addr_defined(fspace->addr)???) or the section info * contains no free space data that must be written to file * ( fspace->serial_sect_count == 0 ). * @@ -441,7 +441,7 @@ H5FS__cache_hdr_pre_serialize(H5F_t *f, void *_thing, haddr_t addr, size_t H5_AT * cases 2) and 3), as the section info should not be stored on * disk if it doesn't exist. Similarly, since the section info * will not be stored to disk unless the header is, - * H5F_addr_defined(fspace->addr) must hold as well. + * H5_addr_defined(fspace->addr) must hold as well. * * As the objective is to touch up the free space manager header * so that it contains sensical data on the size and location of @@ -449,7 +449,7 @@ H5FS__cache_hdr_pre_serialize(H5F_t *f, void *_thing, haddr_t addr, size_t H5_AT * cases differently. * * Case 1) If either fspace->serial_sect_count == 0 or - * ! H5F_addr_defined(fspace->addr) do nothing as either + * ! H5_addr_defined(fspace->addr) do nothing as either * the free space manager data is not persistent, or the * section info is empty. * @@ -473,11 +473,11 @@ H5FS__cache_hdr_pre_serialize(H5F_t *f, void *_thing, haddr_t addr, size_t H5_AT * as dirty, as the metadata cache would not be attempting to * serialize the header if it thought it was clean. */ - if (fspace->serial_sect_count > 0 && H5F_addr_defined(fspace->addr)) { + if (fspace->serial_sect_count > 0 && H5_addr_defined(fspace->addr)) { /* Sanity check */ assert(fspace->sect_size > 0); - if (!H5F_addr_defined(fspace->sect_addr)) { /* case 1 */ + if (!H5_addr_defined(fspace->sect_addr)) { /* case 1 */ haddr_t tag = HADDR_UNDEF; haddr_t sect_addr; hsize_t saved_sect_size, new_sect_size; @@ -573,10 +573,10 @@ H5FS__cache_hdr_pre_serialize(H5F_t *f, void *_thing, haddr_t addr, size_t H5_AT /* for one reason or another (see comment above) there should * not be any file space allocated for the section info. */ - assert(!H5F_addr_defined(fspace->sect_addr)); + assert(!H5_addr_defined(fspace->sect_addr)); } /* end else */ } /* end if */ - else if (H5F_addr_defined(fspace->sect_addr)) { + else if (H5_addr_defined(fspace->sect_addr)) { /* Here the metadata cache is managing the section info. * * Do some sanity checks, and then test to see if the section @@ -616,7 +616,7 @@ H5FS__cache_hdr_pre_serialize(H5F_t *f, void *_thing, haddr_t addr, size_t H5_AT fspace->alloc_sect_size = (size_t)fspace->sect_size; /* Sanity check */ - assert(!H5F_addr_eq(fspace->sect_addr, new_sect_addr)); + assert(!H5_addr_eq(fspace->sect_addr, new_sect_addr)); /* Let the metadata cache know the section info moved */ if (H5AC_move_entry((H5F_t *)f, H5AC_FSPACE_SINFO, fspace->sect_addr, new_sect_addr) < 0) @@ -686,10 +686,10 @@ H5FS__cache_hdr_serialize(const H5F_t *f, void *_image, size_t H5_ATTR_NDEBUG_UN * into real file space if necessary before this function was called. * The following asserts are a cursory check on this. */ - assert((!H5F_addr_defined(fspace->sect_addr)) || (!H5F_IS_TMP_ADDR(f, fspace->sect_addr))); + assert((!H5_addr_defined(fspace->sect_addr)) || (!H5F_IS_TMP_ADDR(f, fspace->sect_addr))); if (!H5F_POINT_OF_NO_RETURN(f)) - assert((!H5F_addr_defined(fspace->sect_addr)) || + assert((!H5_addr_defined(fspace->sect_addr)) || ((fspace->sect_size > 0) && (fspace->alloc_sect_size == (size_t)fspace->sect_size))); /* Magic number */ @@ -732,7 +732,7 @@ H5FS__cache_hdr_serialize(const H5F_t *f, void *_image, size_t H5_ATTR_NDEBUG_UN H5F_ENCODE_LENGTH(f, image, fspace->max_sect_size); /* Address of serialized free space sections */ - H5F_addr_encode(f, &image, fspace->sect_addr); + H5_addr_encode(f, &image, fspace->sect_addr); /* Size of serialized free space sections */ H5F_ENCODE_LENGTH(f, image, fspace->sect_size); @@ -963,8 +963,8 @@ H5FS__cache_sinfo_deserialize(const void *_image, size_t H5_ATTR_NDEBUG_UNUSED l HGOTO_ERROR(H5E_FSPACE, H5E_CANTLOAD, NULL, "wrong free space sections version") /* Address of free space header for these sections */ - H5F_addr_decode(udata->f, &image, &fs_addr); - if (H5F_addr_ne(fs_addr, fspace->addr)) + H5_addr_decode(udata->f, &image, &fs_addr); + if (H5_addr_ne(fs_addr, fspace->addr)) HGOTO_ERROR(H5E_FSPACE, H5E_CANTLOAD, NULL, "incorrect header address for free space sections") /* Check for any serialized sections */ @@ -1134,8 +1134,8 @@ H5FS__cache_sinfo_pre_serialize(H5F_t *f, void *_thing, haddr_t addr, size_t H5_ assert(fspace->cache_info.magic == H5C__H5C_CACHE_ENTRY_T_MAGIC); assert(fspace->cache_info.type == H5AC_FSPACE_HDR); assert(fspace->cache_info.is_pinned); - assert(H5F_addr_defined(addr)); - assert(H5F_addr_eq(fspace->sect_addr, addr)); + assert(H5_addr_defined(addr)); + assert(H5_addr_eq(fspace->sect_addr, addr)); assert(fspace->sect_size == len); assert(new_addr); assert(new_len); @@ -1147,7 +1147,7 @@ H5FS__cache_sinfo_pre_serialize(H5F_t *f, void *_thing, haddr_t addr, size_t H5_ if (H5F_IS_TMP_ADDR(f, fspace->sect_addr)) { /* Sanity check */ assert(fspace->sect_size > 0); - assert(H5F_addr_eq(fspace->sect_addr, addr)); + assert(H5_addr_eq(fspace->sect_addr, addr)); /* Allocate space for the section info in file */ if (HADDR_UNDEF == (sinfo_addr = H5MF_alloc((H5F_t *)f, H5FD_MEM_FSPACE_SINFO, fspace->sect_size))) @@ -1156,7 +1156,7 @@ H5FS__cache_sinfo_pre_serialize(H5F_t *f, void *_thing, haddr_t addr, size_t H5_ fspace->alloc_sect_size = (size_t)fspace->sect_size; /* Sanity check */ - assert(!H5F_addr_eq(sinfo->fspace->sect_addr, sinfo_addr)); + assert(!H5_addr_eq(sinfo->fspace->sect_addr, sinfo_addr)); /* Let the metadata cache know the section info moved */ if (H5AC_move_entry((H5F_t *)f, H5AC_FSPACE_SINFO, sinfo->fspace->sect_addr, sinfo_addr) < 0) @@ -1170,7 +1170,7 @@ H5FS__cache_sinfo_pre_serialize(H5F_t *f, void *_thing, haddr_t addr, size_t H5_ HGOTO_ERROR(H5E_FSPACE, H5E_CANTMARKDIRTY, FAIL, "unable to mark free space header as dirty") } /* end if */ - if (!H5F_addr_eq(addr, sinfo_addr)) { + if (!H5_addr_eq(addr, sinfo_addr)) { *new_addr = sinfo_addr; *flags = H5C__SERIALIZE_MOVED_FLAG; } /* end if */ @@ -1227,7 +1227,7 @@ H5FS__cache_sinfo_serialize(const H5F_t *f, void *_image, size_t len, void *_thi *image++ = H5FS_SINFO_VERSION; /* Address of free space header for these sections */ - H5F_addr_encode(f, &image, sinfo->fspace->addr); + H5_addr_encode(f, &image, sinfo->fspace->addr); /* Set up user data for iterator */ udata.sinfo = sinfo; diff --git a/src/H5FSdbg.c b/src/H5FSdbg.c index 769e0f5..6ff7b3c 100644 --- a/src/H5FSdbg.c +++ b/src/H5FSdbg.c @@ -86,7 +86,7 @@ H5FS_debug(H5F_t *f, haddr_t addr, FILE *stream, int indent, int fwidth) * Check arguments. */ assert(f); - assert(H5F_addr_defined(addr)); + assert(H5_addr_defined(addr)); assert(stream); assert(indent >= 0); assert(fwidth >= 0); @@ -203,12 +203,12 @@ H5FS_sects_debug(H5F_t *f, haddr_t H5_ATTR_UNUSED addr, FILE *stream, int indent * Check arguments. */ assert(f); - assert(H5F_addr_defined(addr)); + assert(H5_addr_defined(addr)); assert(stream); assert(indent >= 0); assert(fwidth >= 0); - assert(H5F_addr_defined(fs_addr)); - assert(H5F_addr_defined(client_addr)); + assert(H5_addr_defined(fs_addr)); + assert(H5_addr_defined(client_addr)); /* Initialize user data for protecting the free space manager */ cache_udata.f = f; diff --git a/src/H5FSsection.c b/src/H5FSsection.c index be2d8e9..fbe07ff 100644 --- a/src/H5FSsection.c +++ b/src/H5FSsection.c @@ -237,10 +237,10 @@ H5FS__sinfo_lock(H5F_t *f, H5FS_t *fspace, unsigned accmode) } /* end if */ else { /* If the section address is defined, load it from the file */ - if (H5F_addr_defined(fspace->sect_addr)) { + if (H5_addr_defined(fspace->sect_addr)) { /* Sanity check */ assert(fspace->sinfo_protected == FALSE); - assert(H5F_addr_defined(fspace->addr)); + assert(H5_addr_defined(fspace->addr)); #ifdef H5FS_SINFO_DEBUG fprintf(stderr, "%s: Reading in existing sections, fspace->sect_addr = %" PRIuHADDR "\n", @@ -376,7 +376,7 @@ H5FS__sinfo_unlock(H5F_t *f, H5FS_t *fspace, hbool_t modified) unsigned cache_flags = H5AC__NO_FLAGS_SET; /* Flags for unprotecting heap */ /* Sanity check */ - assert(H5F_addr_defined(fspace->addr)); + assert(H5_addr_defined(fspace->addr)); /* Check if we've made new changes to the section info while locked */ if (fspace->sinfo_modified) { @@ -398,7 +398,7 @@ H5FS__sinfo_unlock(H5F_t *f, H5FS_t *fspace, hbool_t modified) } /* end if */ /* Sanity check */ - assert(H5F_addr_defined(fspace->sect_addr)); + assert(H5_addr_defined(fspace->sect_addr)); /* Unprotect section info in cache */ /* (Possibly dirty) */ @@ -432,7 +432,7 @@ H5FS__sinfo_unlock(H5F_t *f, H5FS_t *fspace, hbool_t modified) /* Check if the section info was modified */ if (fspace->sinfo_modified) { /* Check if we need to release section info in the file */ - if (H5F_addr_defined(fspace->sect_addr)) { + if (H5_addr_defined(fspace->sect_addr)) { /* Set flag to release section info space in file */ /* On file close or flushing, only need to release section info with size bigger than previous section */ @@ -451,7 +451,7 @@ H5FS__sinfo_unlock(H5F_t *f, H5FS_t *fspace, hbool_t modified) } /* end if */ else { /* Sanity checks... */ - if (H5F_addr_defined(fspace->sect_addr)) + if (H5_addr_defined(fspace->sect_addr)) assert(fspace->alloc_sect_size == fspace->sect_size); else assert(fspace->alloc_sect_size == 0); @@ -467,7 +467,7 @@ H5FS__sinfo_unlock(H5F_t *f, H5FS_t *fspace, hbool_t modified) hsize_t old_alloc_sect_size = fspace->alloc_sect_size; /* Previous size of section info in file */ /* Sanity check */ - assert(H5F_addr_defined(fspace->addr)); + assert(H5_addr_defined(fspace->addr)); /* Reset section info in header */ fspace->sect_addr = HADDR_UNDEF; @@ -923,7 +923,7 @@ H5FS__sect_link_size(H5FS_sinfo_t *sinfo, const H5FS_section_class_t *cls, H5FS_ /* Check arguments. */ assert(sinfo); assert(sect); - assert(H5F_addr_defined(sect->addr)); + assert(H5_addr_defined(sect->addr)); assert(sect->size); /* Determine correct bin which holds items of the section's size */ @@ -1104,7 +1104,7 @@ H5FS__sect_merge(H5FS_t *fspace, H5FS_section_info_t **sect, void *op_data) /* Check arguments. */ assert(fspace); assert(*sect); - assert(H5F_addr_defined((*sect)->addr)); + assert(H5_addr_defined((*sect)->addr)); assert((*sect)->size); /* Loop until no more merging */ @@ -1304,7 +1304,7 @@ H5FS_sect_add(H5F_t *f, H5FS_t *fspace, H5FS_section_info_t *sect, unsigned flag /* Check arguments. */ assert(fspace); assert(sect); - assert(H5F_addr_defined(sect->addr)); + assert(H5_addr_defined(sect->addr)); assert(sect->size); /* Get a pointer to the section info */ @@ -1387,7 +1387,7 @@ H5FS_sect_try_extend(H5F_t *f, H5FS_t *fspace, haddr_t addr, hsize_t size, hsize /* Check arguments. */ assert(f); assert(fspace); - assert(H5F_addr_defined(addr)); + assert(H5_addr_defined(addr)); assert(size > 0); assert(extra_requested > 0); @@ -1520,7 +1520,7 @@ H5FS_sect_try_merge(H5F_t *f, H5FS_t *fspace, H5FS_section_info_t *sect, unsigne assert(f); assert(fspace); assert(sect); - assert(H5F_addr_defined(sect->addr)); + assert(H5_addr_defined(sect->addr)); assert(sect->size); /* Get a pointer to the section info */ @@ -1645,7 +1645,7 @@ H5FS__sect_find_node(H5FS_t *fspace, hsize_t request, H5FS_section_info_t **node /* Get section node */ curr_sect = (H5FS_section_info_t *)H5SL_item(curr_sect_node); - assert(H5F_addr_defined(curr_sect->addr)); + assert(H5_addr_defined(curr_sect->addr)); assert(curr_fspace_node->sect_size == curr_sect->size); cls = &fspace->sect_cls[curr_sect->type]; @@ -2132,7 +2132,7 @@ H5FS__sect_assert(const H5FS_t *fspace) cls = &fspace->sect_cls[sect->type]; /* Sanity check section */ - assert(H5F_addr_defined(sect->addr)); + assert(H5_addr_defined(sect->addr)); assert(fspace_node->sect_size == sect->size); if (cls->valid) (*cls->valid)(cls, sect); @@ -2335,7 +2335,7 @@ H5FS_vfd_alloc_hdr_and_section_info_if_needed(H5F_t *f, H5FS_t *fspace, haddr_t if (fspace->serial_sect_count > 0 && fspace->sinfo) { /* the section info is floating, so space->sinfo should be defined */ - if (!H5F_addr_defined(fspace->addr)) { + if (!H5_addr_defined(fspace->addr)) { /* start by allocating file space for the header */ @@ -2364,7 +2364,7 @@ H5FS_vfd_alloc_hdr_and_section_info_if_needed(H5F_t *f, H5FS_t *fspace, haddr_t *fs_addr_ptr = fspace->addr; } - if (!H5F_addr_defined(fspace->sect_addr)) { + if (!H5_addr_defined(fspace->sect_addr)) { /* now allocate file space for the section info */ diff --git a/src/H5Faccum.c b/src/H5Faccum.c index a1b08d9..d3b318d 100644 --- a/src/H5Faccum.c +++ b/src/H5Faccum.c @@ -120,8 +120,8 @@ H5F__accum_read(H5F_shared_t *f_sh, H5FD_mem_t map_type, haddr_t addr, size_t si assert(!accum->buf || (accum->alloc_size >= accum->size)); /* Current read adjoins or overlaps with metadata accumulator */ - if (H5F_addr_defined(accum->loc) && - (H5F_addr_overlap(addr, size, accum->loc, accum->size) || ((addr + size) == accum->loc) || + if (H5_addr_defined(accum->loc) && + (H5_addr_overlap(addr, size, accum->loc, accum->size) || ((addr + size) == accum->loc) || (accum->loc + accum->size) == addr)) { size_t amount_before; /* Amount to read before current accumulator */ haddr_t new_addr; /* New address of the accumulator buffer */ @@ -208,14 +208,14 @@ H5F__accum_read(H5F_shared_t *f_sh, H5FD_mem_t map_type, haddr_t addr, size_t si * just read in. -QAK) */ if (accum->dirty && - H5F_addr_overlap(addr, size, accum->loc + accum->dirty_off, accum->dirty_len)) { + H5_addr_overlap(addr, size, accum->loc + accum->dirty_off, accum->dirty_len)) { haddr_t dirty_loc = accum->loc + accum->dirty_off; /* File offset of dirty information */ size_t buf_off; /* Offset of dirty region in buffer */ size_t dirty_off; /* Offset within dirty region */ size_t overlap_size; /* Size of overlap with dirty region */ /* Check for read starting before beginning dirty region */ - if (H5F_addr_le(addr, dirty_loc)) { + if (H5_addr_le(addr, dirty_loc)) { /* Compute offset of dirty region within buffer */ buf_off = (size_t)(dirty_loc - addr); @@ -223,7 +223,7 @@ H5F__accum_read(H5F_shared_t *f_sh, H5FD_mem_t map_type, haddr_t addr, size_t si dirty_off = 0; /* Check for read ending within dirty region */ - if (H5F_addr_lt(addr + size, dirty_loc + accum->dirty_len)) + if (H5_addr_lt(addr + size, dirty_loc + accum->dirty_len)) overlap_size = (size_t)((addr + size) - buf_off); else /* Access covers whole dirty region */ overlap_size = accum->dirty_len; @@ -428,7 +428,7 @@ H5F__accum_write(H5F_shared_t *f_sh, H5FD_mem_t map_type, haddr_t addr, size_t s /* Check if there is already metadata in the accumulator */ if (accum->size > 0) { /* Check if the new metadata adjoins the beginning of the current accumulator */ - if (H5F_addr_defined(accum->loc) && (addr + size) == accum->loc) { + if (H5_addr_defined(accum->loc) && (addr + size) == accum->loc) { /* Check if we need to adjust accumulator size */ if (H5F__accum_adjust(accum, file, H5F_ACCUM_PREPEND, size) < 0) HGOTO_ERROR(H5E_IO, H5E_CANTRESIZE, FAIL, "can't adjust metadata accumulator") @@ -453,7 +453,7 @@ H5F__accum_write(H5F_shared_t *f_sh, H5FD_mem_t map_type, haddr_t addr, size_t s accum->dirty_off = 0; } /* end if */ /* Check if the new metadata adjoins the end of the current accumulator */ - else if (H5F_addr_defined(accum->loc) && addr == (accum->loc + accum->size)) { + else if (H5_addr_defined(accum->loc) && addr == (accum->loc + accum->size)) { /* Check if we need to adjust accumulator size */ if (H5F__accum_adjust(accum, file, H5F_ACCUM_APPEND, size) < 0) HGOTO_ERROR(H5E_IO, H5E_CANTRESIZE, FAIL, "can't adjust metadata accumulator") @@ -474,8 +474,8 @@ H5F__accum_write(H5F_shared_t *f_sh, H5FD_mem_t map_type, haddr_t addr, size_t s accum->size += size; } /* end if */ /* Check if the piece of metadata being written overlaps the metadata accumulator */ - else if (H5F_addr_defined(accum->loc) && - H5F_addr_overlap(addr, size, accum->loc, accum->size)) { + else if (H5_addr_defined(accum->loc) && + H5_addr_overlap(addr, size, accum->loc, accum->size)) { size_t add_size; /* New size of the accumulator buffer */ /* Check if the new metadata is entirely within the current accumulator */ @@ -735,11 +735,11 @@ H5F__accum_write(H5F_shared_t *f_sh, H5FD_mem_t map_type, haddr_t addr, size_t s /* (Note that this could be improved by updating the accumulator * with [some of] the information just read in. -QAK) */ - if (H5F_addr_defined(accum->loc) && H5F_addr_overlap(addr, size, accum->loc, accum->size)) { + if (H5_addr_defined(accum->loc) && H5_addr_overlap(addr, size, accum->loc, accum->size)) { /* Check for write starting before beginning of accumulator */ - if (H5F_addr_le(addr, accum->loc)) { + if (H5_addr_le(addr, accum->loc)) { /* Check for write ending within accumulator */ - if (H5F_addr_le(addr + size, accum->loc + accum->size)) { + if (H5_addr_le(addr + size, accum->loc + accum->size)) { size_t overlap_size; /* Size of overlapping region */ /* Compute overlap size */ @@ -753,13 +753,13 @@ H5F__accum_write(H5F_shared_t *f_sh, H5FD_mem_t map_type, haddr_t addr, size_t s dirty_start + accum->dirty_len; /* File address of end of dirty region */ /* Check if entire dirty region is overwritten */ - if (H5F_addr_le(dirty_end, addr + size)) { + if (H5_addr_le(dirty_end, addr + size)) { accum->dirty = FALSE; accum->dirty_len = 0; } /* end if */ else { /* Check for dirty region falling after write */ - if (H5F_addr_le(addr + size, dirty_start)) + if (H5_addr_le(addr + size, dirty_start)) accum->dirty_off = overlap_size; else { /* Dirty region overlaps w/written region */ accum->dirty_off = 0; @@ -783,7 +783,7 @@ H5F__accum_write(H5F_shared_t *f_sh, H5FD_mem_t map_type, haddr_t addr, size_t s size_t overlap_size; /* Size of overlapping region */ /* Sanity check */ - assert(H5F_addr_gt(addr + size, accum->loc + accum->size)); + assert(H5_addr_gt(addr + size, accum->loc + accum->size)); /* Compute overlap size */ overlap_size = (size_t)((accum->loc + accum->size) - addr); @@ -796,13 +796,13 @@ H5F__accum_write(H5F_shared_t *f_sh, H5FD_mem_t map_type, haddr_t addr, size_t s dirty_start + accum->dirty_len; /* File address of end of dirty region */ /* Check if entire dirty region is overwritten */ - if (H5F_addr_ge(dirty_start, addr)) { + if (H5_addr_ge(dirty_start, addr)) { accum->dirty = FALSE; accum->dirty_len = 0; } /* end if */ else { /* Check for dirty region falling before write */ - if (H5F_addr_le(dirty_end, addr)) + if (H5_addr_le(dirty_end, addr)) ; /* noop */ else /* Dirty region overlaps w/written region */ accum->dirty_len = (size_t)(addr - dirty_start); @@ -854,8 +854,8 @@ H5F__accum_free(H5F_shared_t *f_sh, H5FD_mem_t H5_ATTR_UNUSED type, haddr_t addr file = f_sh->lf; /* Adjust the metadata accumulator to remove the freed block, if it overlaps */ - if ((f_sh->feature_flags & H5FD_FEAT_ACCUMULATE_METADATA) && H5F_addr_defined(accum->loc) && - H5F_addr_overlap(addr, size, accum->loc, accum->size)) { + if ((f_sh->feature_flags & H5FD_FEAT_ACCUMULATE_METADATA) && H5_addr_defined(accum->loc) && + H5_addr_overlap(addr, size, accum->loc, accum->size)) { size_t overlap_size; /* Size of overlap with accumulator */ /* Sanity check */ @@ -864,9 +864,9 @@ H5F__accum_free(H5F_shared_t *f_sh, H5FD_mem_t H5_ATTR_UNUSED type, haddr_t addr assert(H5FD_MEM_GHEAP != type); /* (global heap data is being treated as raw data currently) */ /* Check for overlapping the beginning of the accumulator */ - if (H5F_addr_le(addr, accum->loc)) { + if (H5_addr_le(addr, accum->loc)) { /* Check for completely overlapping the accumulator */ - if (H5F_addr_ge(addr + size, accum->loc + accum->size)) { + if (H5_addr_ge(addr + size, accum->loc + accum->size)) { /* Reset the accumulator, but don't free buffer */ accum->loc = HADDR_UNDEF; accum->size = 0; @@ -914,16 +914,16 @@ H5F__accum_free(H5F_shared_t *f_sh, H5FD_mem_t H5_ATTR_UNUSED type, haddr_t addr H5_CHECKED_ASSIGN(overlap_size, size_t, (accum->loc + accum->size) - addr, haddr_t); /* Check if block to free begins before end of dirty region */ - if (accum->dirty && H5F_addr_lt(addr, dirty_end)) { + if (accum->dirty && H5_addr_lt(addr, dirty_end)) { haddr_t tail_addr; /* Calculate the address of the tail to write */ tail_addr = addr + size; /* Check if the block to free begins before dirty region */ - if (H5F_addr_lt(addr, dirty_start)) { + if (H5_addr_lt(addr, dirty_start)) { /* Check if block to free is entirely before dirty region */ - if (H5F_addr_le(tail_addr, dirty_start)) { + if (H5_addr_le(tail_addr, dirty_start)) { /* Write out the entire dirty region of the accumulator */ if (H5FD_write(file, H5FD_MEM_DEFAULT, dirty_start, accum->dirty_len, accum->buf + accum->dirty_off) < 0) @@ -931,7 +931,7 @@ H5F__accum_free(H5F_shared_t *f_sh, H5FD_mem_t H5_ATTR_UNUSED type, haddr_t addr } /* end if */ /* Block to free overlaps with some/all of dirty region */ /* Check for unfreed dirty region to write */ - else if (H5F_addr_lt(tail_addr, dirty_end)) { + else if (H5_addr_lt(tail_addr, dirty_end)) { size_t write_size; size_t dirty_delta; @@ -952,7 +952,7 @@ H5F__accum_free(H5F_shared_t *f_sh, H5FD_mem_t H5_ATTR_UNUSED type, haddr_t addr /* Block to free begins at beginning of or in middle of dirty region */ else { /* Check if block to free ends before end of dirty region */ - if (H5F_addr_lt(tail_addr, dirty_end)) { + if (H5_addr_lt(tail_addr, dirty_end)) { size_t write_size; size_t dirty_delta; @@ -968,7 +968,7 @@ H5F__accum_free(H5F_shared_t *f_sh, H5FD_mem_t H5_ATTR_UNUSED type, haddr_t addr } /* end if */ /* Check for block to free beginning at same location as dirty region */ - if (H5F_addr_eq(addr, dirty_start)) { + if (H5_addr_eq(addr, dirty_start)) { /* Reset dirty flag */ accum->dirty = FALSE; } /* end if */ diff --git a/src/H5Fint.c b/src/H5Fint.c index b17441e..de9c595 100644 --- a/src/H5Fint.c +++ b/src/H5Fint.c @@ -1215,7 +1215,7 @@ H5F__new(H5F_shared_t *shared, unsigned flags, hid_t fcpl_id, hid_t fapl_id, H5F /* Get the VFD values to cache */ f->shared->maxaddr = H5FD_get_maxaddr(lf); - if (!H5F_addr_defined(f->shared->maxaddr)) + if (!H5_addr_defined(f->shared->maxaddr)) HGOTO_ERROR(H5E_FILE, H5E_BADVALUE, NULL, "bad maximum address from VFD") if (H5FD_get_feature_flags(lf, &f->shared->feature_flags) < 0) HGOTO_ERROR(H5E_FILE, H5E_CANTGET, NULL, "can't get feature flags from VFD") @@ -2799,7 +2799,7 @@ done: } /* H5F__build_actual_name() */ /*------------------------------------------------------------------------- - * Function: H5F_addr_encode_len + * Function: H5_addr_encode_len * * Purpose: Encodes an address into the buffer pointed to by *PP and * then increments the pointer to the first byte after the @@ -2809,7 +2809,7 @@ done: *------------------------------------------------------------------------- */ void -H5F_addr_encode_len(size_t addr_len, uint8_t **pp /*in,out*/, haddr_t addr) +H5_addr_encode_len(size_t addr_len, uint8_t **pp /*in,out*/, haddr_t addr) { unsigned u; /* Local index variable */ @@ -2819,7 +2819,7 @@ H5F_addr_encode_len(size_t addr_len, uint8_t **pp /*in,out*/, haddr_t addr) assert(addr_len); assert(pp && *pp); - if (H5F_addr_defined(addr)) { + if (H5_addr_defined(addr)) { for (u = 0; u < addr_len; u++) { *(*pp)++ = (uint8_t)(addr & 0xff); addr >>= 8; @@ -2832,10 +2832,10 @@ H5F_addr_encode_len(size_t addr_len, uint8_t **pp /*in,out*/, haddr_t addr) } /* end else */ FUNC_LEAVE_NOAPI_VOID -} /* end H5F_addr_encode_len() */ +} /* end H5_addr_encode_len() */ /*------------------------------------------------------------------------- - * Function: H5F_addr_encode + * Function: H5_addr_encode * * Purpose: Encodes an address into the buffer pointed to by *PP and * then increments the pointer to the first byte after the @@ -2845,20 +2845,20 @@ H5F_addr_encode_len(size_t addr_len, uint8_t **pp /*in,out*/, haddr_t addr) *------------------------------------------------------------------------- */ void -H5F_addr_encode(const H5F_t *f, uint8_t **pp /*in,out*/, haddr_t addr) +H5_addr_encode(const H5F_t *f, uint8_t **pp /*in,out*/, haddr_t addr) { /* Use FUNC_ENTER_NOAPI_NOINIT_NOERR here to avoid performance issues */ FUNC_ENTER_NOAPI_NOINIT_NOERR assert(f); - H5F_addr_encode_len(H5F_SIZEOF_ADDR(f), pp, addr); + H5_addr_encode_len(H5F_SIZEOF_ADDR(f), pp, addr); FUNC_LEAVE_NOAPI_VOID -} /* end H5F_addr_encode() */ +} /* end H5_addr_encode() */ /*------------------------------------------------------------------------- - * Function: H5F_addr_decode_len + * Function: H5_addr_decode_len * * Purpose: Decodes an address from the buffer pointed to by *PP and * updates the pointer to point to the next byte after the @@ -2871,7 +2871,7 @@ H5F_addr_encode(const H5F_t *f, uint8_t **pp /*in,out*/, haddr_t addr) *------------------------------------------------------------------------- */ void -H5F_addr_decode_len(size_t addr_len, const uint8_t **pp /*in,out*/, haddr_t *addr_p /*out*/) +H5_addr_decode_len(size_t addr_len, const uint8_t **pp /*in,out*/, haddr_t *addr_p /*out*/) { hbool_t all_zero = TRUE; /* True if address was all zeroes */ unsigned u; /* Local index variable */ @@ -2917,10 +2917,10 @@ H5F_addr_decode_len(size_t addr_len, const uint8_t **pp /*in,out*/, haddr_t *add *addr_p = HADDR_UNDEF; FUNC_LEAVE_NOAPI_VOID -} /* end H5F_addr_decode_len() */ +} /* end H5_addr_decode_len() */ /*------------------------------------------------------------------------- - * Function: H5F_addr_decode + * Function: H5_addr_decode * * Purpose: Decodes an address from the buffer pointed to by *PP and * updates the pointer to point to the next byte after the @@ -2933,17 +2933,17 @@ H5F_addr_decode_len(size_t addr_len, const uint8_t **pp /*in,out*/, haddr_t *add *------------------------------------------------------------------------- */ void -H5F_addr_decode(const H5F_t *f, const uint8_t **pp /*in,out*/, haddr_t *addr_p /*out*/) +H5_addr_decode(const H5F_t *f, const uint8_t **pp /*in,out*/, haddr_t *addr_p /*out*/) { /* Use FUNC_ENTER_NOAPI_NOINIT_NOERR here to avoid performance issues */ FUNC_ENTER_NOAPI_NOINIT_NOERR assert(f); - H5F_addr_decode_len(H5F_SIZEOF_ADDR(f), pp, addr_p); + H5_addr_decode_len(H5F_SIZEOF_ADDR(f), pp, addr_p); FUNC_LEAVE_NOAPI_VOID -} /* end H5F_addr_decode() */ +} /* end H5_addr_decode() */ /*------------------------------------------------------------------------- * Function: H5F_set_grp_btree_shared @@ -3254,7 +3254,7 @@ H5F__get_info(H5F_t *f, H5F_info2_t *finfo) HGOTO_ERROR(H5E_FILE, H5E_CANTGET, FAIL, "unable to retrieve free space information") /* Check for SOHM info */ - if (H5F_addr_defined(f->shared->sohm_addr)) + if (H5_addr_defined(f->shared->sohm_addr)) if (H5SM_ih_size(f, &finfo->sohm.hdr_size, &finfo->sohm.msgs_info) < 0) HGOTO_ERROR(H5E_FILE, H5E_CANTGET, FAIL, "unable to retrieve SOHM index & heap storage info") @@ -3932,7 +3932,7 @@ H5F__format_convert(H5F_t *f) f->shared->fs_page_size == H5F_FILE_SPACE_PAGE_SIZE_DEF)) { /* Check to remove free-space manager info message from superblock extension */ - if (H5F_addr_defined(f->shared->sblock->ext_addr)) + if (H5_addr_defined(f->shared->sblock->ext_addr)) if (H5F__super_ext_remove_msg(f, H5O_FSINFO_ID) < 0) HGOTO_ERROR(H5E_FILE, H5E_CANTRELEASE, FAIL, "error in removing message from superblock extension") diff --git a/src/H5Fio.c b/src/H5Fio.c index cd87152..6b0e9ab 100644 --- a/src/H5Fio.c +++ b/src/H5Fio.c @@ -85,10 +85,10 @@ H5F_shared_block_read(H5F_shared_t *f_sh, H5FD_mem_t type, haddr_t addr, size_t /* Sanity checks */ assert(f_sh); assert(buf); - assert(H5F_addr_defined(addr)); + assert(H5_addr_defined(addr)); /* Check for attempting I/O on 'temporary' file address */ - if (H5F_addr_le(f_sh->tmp_addr, (addr + size))) + if (H5_addr_le(f_sh->tmp_addr, (addr + size))) HGOTO_ERROR(H5E_IO, H5E_BADRANGE, FAIL, "attempting I/O in temporary file space") /* Treat global heap as raw data */ @@ -125,10 +125,10 @@ H5F_block_read(H5F_t *f, H5FD_mem_t type, haddr_t addr, size_t size, void *buf / assert(f); assert(f->shared); assert(buf); - assert(H5F_addr_defined(addr)); + assert(H5_addr_defined(addr)); /* Check for attempting I/O on 'temporary' file address */ - if (H5F_addr_le(f->shared->tmp_addr, (addr + size))) + if (H5_addr_le(f->shared->tmp_addr, (addr + size))) HGOTO_ERROR(H5E_IO, H5E_BADRANGE, FAIL, "attempting I/O in temporary file space") /* Treat global heap as raw data */ @@ -165,10 +165,10 @@ H5F_shared_block_write(H5F_shared_t *f_sh, H5FD_mem_t type, haddr_t addr, size_t assert(f_sh); assert(H5F_SHARED_INTENT(f_sh) & H5F_ACC_RDWR); assert(buf); - assert(H5F_addr_defined(addr)); + assert(H5_addr_defined(addr)); /* Check for attempting I/O on 'temporary' file address */ - if (H5F_addr_le(f_sh->tmp_addr, (addr + size))) + if (H5_addr_le(f_sh->tmp_addr, (addr + size))) HGOTO_ERROR(H5E_IO, H5E_BADRANGE, FAIL, "attempting I/O in temporary file space") /* Treat global heap as raw data */ @@ -206,10 +206,10 @@ H5F_block_write(H5F_t *f, H5FD_mem_t type, haddr_t addr, size_t size, const void assert(f->shared); assert(H5F_INTENT(f) & H5F_ACC_RDWR); assert(buf); - assert(H5F_addr_defined(addr)); + assert(H5_addr_defined(addr)); /* Check for attempting I/O on 'temporary' file address */ - if (H5F_addr_le(f->shared->tmp_addr, (addr + size))) + if (H5_addr_le(f->shared->tmp_addr, (addr + size))) HGOTO_ERROR(H5E_IO, H5E_BADRANGE, FAIL, "attempting I/O in temporary file space") /* Treat global heap as raw data */ diff --git a/src/H5Fmount.c b/src/H5Fmount.c index b2a3134..b17baea 100644 --- a/src/H5Fmount.c +++ b/src/H5Fmount.c @@ -171,7 +171,7 @@ H5F_mount(const H5G_loc_t *loc, const char *name, H5F_t *child, hid_t H5_ATTR_UN md = (lt + rt) / 2; oloc = H5G_oloc(parent->shared->mtab.child[md].group); - cmp = H5F_addr_cmp(mp_loc.oloc->addr, oloc->addr); + cmp = H5_addr_cmp(mp_loc.oloc->addr, oloc->addr); if (cmp < 0) rt = md; else if (cmp > 0) @@ -286,7 +286,7 @@ H5F_unmount(const H5G_loc_t *loc, const char *name) mnt_oloc = H5G_oloc(child->shared->root_grp); child_idx = -1; - if (child->parent && H5F_addr_eq(mp_oloc.addr, mnt_oloc->addr)) { + if (child->parent && H5_addr_eq(mp_oloc.addr, mnt_oloc->addr)) { unsigned u; /*counters */ /* @@ -317,7 +317,7 @@ H5F_unmount(const H5G_loc_t *loc, const char *name) while (lt < rt && cmp) { md = (lt + rt) / 2; mnt_oloc = H5G_oloc(parent->shared->mtab.child[md].group); - cmp = H5F_addr_cmp(mp_oloc.addr, mnt_oloc->addr); + cmp = H5_addr_cmp(mp_oloc.addr, mnt_oloc->addr); if (cmp < 0) rt = md; else @@ -594,7 +594,7 @@ H5F_traverse_mount(H5O_loc_t *oloc /*in,out*/) while (lt < rt && cmp) { md = (lt + rt) / 2; mnt_oloc = H5G_oloc(parent->shared->mtab.child[md].group); - cmp = H5F_addr_cmp(oloc->addr, mnt_oloc->addr); + cmp = H5_addr_cmp(oloc->addr, mnt_oloc->addr); if (cmp < 0) rt = md; else diff --git a/src/H5Fprivate.h b/src/H5Fprivate.h index 325bdcd..f91fa85 100644 --- a/src/H5Fprivate.h +++ b/src/H5Fprivate.h @@ -284,37 +284,6 @@ typedef struct H5F_t H5F_t; (p) += 8; \ } -/* clang-format off */ -/* Address-related macros */ -#define H5F_addr_overflow(X,Z) (HADDR_UNDEF==(X) || \ - HADDR_UNDEF==(X)+(haddr_t)(Z) || \ - (X)+(haddr_t)(Z)<(X)) -#define H5F_addr_defined(X) ((X)!=HADDR_UNDEF) -/* The H5F_addr_eq() macro guarantees that Y is not HADDR_UNDEF by making - * certain that X is not HADDR_UNDEF and then checking that X equals Y - */ -#define H5F_addr_eq(X,Y) ((X)!=HADDR_UNDEF && \ - (X)==(Y)) -#define H5F_addr_ne(X,Y) (!H5F_addr_eq((X),(Y))) -#define H5F_addr_lt(X,Y) ((X)!=HADDR_UNDEF && \ - (Y)!=HADDR_UNDEF && \ - (X)<(Y)) -#define H5F_addr_le(X,Y) ((X)!=HADDR_UNDEF && \ - (Y)!=HADDR_UNDEF && \ - (X)<=(Y)) -#define H5F_addr_gt(X,Y) ((X)!=HADDR_UNDEF && \ - (Y)!=HADDR_UNDEF && \ - (X)>(Y)) -#define H5F_addr_ge(X,Y) ((X)!=HADDR_UNDEF && \ - (Y)!=HADDR_UNDEF && \ - (X)>=(Y)) -#define H5F_addr_cmp(X,Y) (H5F_addr_eq((X), (Y)) ? 0 : \ - (H5F_addr_lt((X), (Y)) ? -1 : 1)) -#define H5F_addr_pow2(N) ((haddr_t)1<<(N)) -#define H5F_addr_overlap(O1,L1,O2,L2) (((O1) < (O2) && ((O1) + (L1)) > (O2)) || \ - ((O1) >= (O2) && (O1) < ((O2) + (L2)))) -/* clang-format on */ - /* If the module using this macro is allowed access to the private variables, access them directly */ #ifdef H5F_MODULE #define H5F_LOW_BOUND(F) ((F)->shared->low_bound) @@ -362,7 +331,7 @@ typedef struct H5F_t H5F_t; #define H5F_GRP_BTREE_SHARED(F) ((F)->shared->grp_btree_shared) #define H5F_SET_GRP_BTREE_SHARED(F, RC) (((F)->shared->grp_btree_shared = (RC)) ? SUCCEED : FAIL) #define H5F_USE_TMP_SPACE(F) ((F)->shared->fs.use_tmp_space) -#define H5F_IS_TMP_ADDR(F, ADDR) (H5F_addr_le((F)->shared->fs.tmp_addr, (ADDR))) +#define H5F_IS_TMP_ADDR(F, ADDR) (H5_addr_le((F)->shared->fs.tmp_addr, (ADDR))) #ifdef H5_HAVE_PARALLEL #define H5F_COLL_MD_READ(F) ((F)->shared->coll_md_read) #endif /* H5_HAVE_PARALLEL */ @@ -928,10 +897,10 @@ H5_DLL herr_t H5F_get_metadata_read_retry_info(H5F_t *file, H5F_retry_info_t *in H5_DLL herr_t H5F_object_flush_cb(H5F_t *f, hid_t obj_id); /* Address-related functions */ -H5_DLL void H5F_addr_encode(const H5F_t *f, uint8_t **pp, haddr_t addr); -H5_DLL void H5F_addr_encode_len(size_t addr_len, uint8_t **pp, haddr_t addr); -H5_DLL void H5F_addr_decode(const H5F_t *f, const uint8_t **pp, haddr_t *addr_p); -H5_DLL void H5F_addr_decode_len(size_t addr_len, const uint8_t **pp, haddr_t *addr_p); +H5_DLL void H5_addr_encode(const H5F_t *f, uint8_t **pp, haddr_t addr); +H5_DLL void H5_addr_encode_len(size_t addr_len, uint8_t **pp, haddr_t addr); +H5_DLL void H5_addr_decode(const H5F_t *f, const uint8_t **pp, haddr_t *addr_p); +H5_DLL void H5_addr_decode_len(size_t addr_len, const uint8_t **pp, haddr_t *addr_p); /* Shared file list related routines */ H5_DLL void H5F_sfile_assert_num(unsigned n); diff --git a/src/H5Fquery.c b/src/H5Fquery.c index fcf7963..4d15d95 100644 --- a/src/H5Fquery.c +++ b/src/H5Fquery.c @@ -1011,7 +1011,7 @@ H5F_is_tmp_addr(const H5F_t *f, haddr_t addr) assert(f); assert(f->shared); - FUNC_LEAVE_NOAPI(H5F_addr_le(f->shared->tmp_addr, addr)) + FUNC_LEAVE_NOAPI(H5_addr_le(f->shared->tmp_addr, addr)) } /* end H5F_is_tmp_addr() */ /*------------------------------------------------------------------------- diff --git a/src/H5Fspace.c b/src/H5Fspace.c index c3fa4e6..eb0e7f9 100644 --- a/src/H5Fspace.c +++ b/src/H5Fspace.c @@ -99,14 +99,14 @@ H5F__alloc(H5F_t *f, H5F_mem_t type, hsize_t size, haddr_t *frag_addr, hsize_t * HGOTO_ERROR(H5E_FILE, H5E_CANTGET, HADDR_UNDEF, "Unable to get eoa") /* Check for overlapping into file's temporary allocation space */ - if (H5F_addr_gt((eoa + size), f->shared->tmp_addr)) + if (H5_addr_gt((eoa + size), f->shared->tmp_addr)) HGOTO_ERROR(H5E_FILE, H5E_BADRANGE, HADDR_UNDEF, "'normal' file space allocation request will overlap into 'temporary' file space") } /* end if */ /* Call the file driver 'alloc' routine */ ret_value = H5FD_alloc(f->shared->lf, type, f, size, frag_addr, frag_size); - if (!H5F_addr_defined(ret_value)) + if (!H5_addr_defined(ret_value)) HGOTO_ERROR(H5E_FILE, H5E_CANTALLOC, HADDR_UNDEF, "file driver 'alloc' request failed") /* Mark EOA dirty */ diff --git a/src/H5Fsuper.c b/src/H5Fsuper.c index 8e604ab..fff70ac 100644 --- a/src/H5Fsuper.c +++ b/src/H5Fsuper.c @@ -94,7 +94,7 @@ H5F__super_ext_create(H5F_t *f, H5O_loc_t *ext_ptr) assert(f); assert(f->shared); assert(f->shared->sblock); - assert(!H5F_addr_defined(f->shared->sblock->ext_addr)); + assert(!H5_addr_defined(f->shared->sblock->ext_addr)); assert(ext_ptr); /* Check for older version of superblock format that can't support superblock extensions */ @@ -102,7 +102,7 @@ H5F__super_ext_create(H5F_t *f, H5O_loc_t *ext_ptr) HGOTO_ERROR(H5E_FILE, H5E_CANTCREATE, FAIL, "superblock extension not permitted with version %u of superblock", f->shared->sblock->super_vers) - else if (H5F_addr_defined(f->shared->sblock->ext_addr)) + else if (H5_addr_defined(f->shared->sblock->ext_addr)) HGOTO_ERROR(H5E_FILE, H5E_CANTCREATE, FAIL, "superblock extension already exists?!?!") else { /* The superblock extension isn't actually a group, but the @@ -144,7 +144,7 @@ H5F__super_ext_open(H5F_t *f, haddr_t ext_addr, H5O_loc_t *ext_ptr) /* Sanity check */ assert(f); - assert(H5F_addr_defined(ext_addr)); + assert(H5_addr_defined(ext_addr)); assert(ext_ptr); /* Set up "fake" object location for superblock extension */ @@ -245,7 +245,7 @@ H5F__update_super_ext_driver_msg(H5F_t *f) * if appropriate. */ if (sblock->super_vers >= HDF5_SUPERBLOCK_VERSION_2) { - if (H5F_addr_defined(sblock->ext_addr)) { + if (H5_addr_defined(sblock->ext_addr)) { /* Check for ignoring the driver info for this file */ if (!H5F_HAS_FEATURE(f, H5FD_FEAT_IGNORE_DRVRINFO)) { size_t driver_size; /* Size of driver info block (bytes)*/ @@ -389,11 +389,11 @@ H5F__super_read(H5F_t *f, H5P_genplist_t *fa_plist, hbool_t initial_read) #ifdef H5_HAVE_PARALLEL } /* end else */ #endif /* H5_HAVE_PARALLEL */ - if (!H5F_addr_defined(super_addr)) + if (!H5_addr_defined(super_addr)) HGOTO_ERROR(H5E_FILE, H5E_NOTHDF5, FAIL, "file signature not found") /* Check for userblock present */ - if (H5F_addr_gt(super_addr, 0)) { + if (H5_addr_gt(super_addr, 0)) { /* Set the base address for the file in the VFD now */ if (H5F__set_base_addr(f, super_addr) < 0) HGOTO_ERROR(H5E_FILE, H5E_CANTSET, FAIL, "failed to set base address for file driver") @@ -496,7 +496,7 @@ H5F__super_read(H5F_t *f, H5P_genplist_t *fa_plist, hbool_t initial_read) /* Check if superblock address is different from base address and adjust * base address and "end of file" address if so. */ - if (!H5F_addr_eq(super_addr, sblock->base_addr)) { + if (!H5_addr_eq(super_addr, sblock->base_addr)) { /* If the superblock moved in the file, adjust the EOF */ /* (Handles moving earlier & later) */ udata.stored_eof -= (sblock->base_addr - super_addr); @@ -614,7 +614,7 @@ H5F__super_read(H5F_t *f, H5P_genplist_t *fa_plist, hbool_t initial_read) H5AC_set_ring(H5AC_RING_SBE, NULL); /* Decode the optional driver information block */ - if (H5F_addr_defined(sblock->driver_addr)) { + if (H5_addr_defined(sblock->driver_addr)) { H5O_drvinfo_t *drvinfo; /* Driver info */ H5F_drvrinfo_cache_ud_t drvrinfo_udata; /* User data for metadata callbacks */ unsigned drvinfo_flags = H5AC__NO_FLAGS_SET; /* Flags used in driver info block unprotect call */ @@ -664,7 +664,7 @@ H5F__super_read(H5F_t *f, H5P_genplist_t *fa_plist, hbool_t initial_read) HGOTO_ERROR(H5E_FILE, H5E_CANTSET, FAIL, "unable to set end-of-address marker for file") /* Decode the optional superblock extension info */ - if (H5F_addr_defined(sblock->ext_addr)) { + if (H5_addr_defined(sblock->ext_addr)) { H5O_loc_t ext_loc; /* "Object location" for superblock extension */ H5O_btreek_t btreek; /* v1 B-tree 'K' value message from superblock extension */ H5O_drvinfo_t drvinfo; /* Driver info message from superblock extension */ @@ -681,7 +681,7 @@ H5F__super_read(H5F_t *f, H5P_genplist_t *fa_plist, hbool_t initial_read) /* Check for superblock extension being located "outside" the stored * 'eoa' value, which can occur with the split/multi VFD. */ - if (H5F_addr_gt(sblock->ext_addr, udata.stored_eof)) { + if (H5_addr_gt(sblock->ext_addr, udata.stored_eof)) { /* Set the 'eoa' for the object header memory type large enough * to give some room for a reasonably sized superblock extension. * (This is _rather_ a kludge -QAK) @@ -949,7 +949,7 @@ H5F__super_read(H5F_t *f, H5P_genplist_t *fa_plist, hbool_t initial_read) * earlier in this routine. */ if (((rw_flags & H5AC__READ_ONLY_FLAG) == 0) && sblock->super_vers >= HDF5_SUPERBLOCK_VERSION_2 && - H5F_addr_defined(sblock->ext_addr)) { + H5_addr_defined(sblock->ext_addr)) { /* Check for modifying the driver info when opening the file */ if (H5F_HAS_FEATURE(f, H5FD_FEAT_DIRTY_DRVRINFO_LOAD)) { size_t driver_size; /* Size of driver info block (bytes) */ @@ -1001,7 +1001,7 @@ H5F__super_read(H5F_t *f, H5P_genplist_t *fa_plist, hbool_t initial_read) "error in removing message from superblock extension") /* Check if the superblock extension was removed */ - if (!H5F_addr_defined(sblock->ext_addr)) + if (!H5_addr_defined(sblock->ext_addr)) sblock_flags |= H5AC__DIRTIED_FLAG; } /* end if */ } /* end if */ @@ -1413,7 +1413,7 @@ H5F__super_init(H5F_t *f) /* Check for creating an "old-style" driver info block */ if (driver_size > 0) { /* Sanity check */ - assert(H5F_addr_defined(sblock->driver_addr)); + assert(H5_addr_defined(sblock->driver_addr)); /* Allocate space for the driver info */ if (NULL == (drvinfo = (H5O_drvinfo_t *)H5MM_calloc(sizeof(H5O_drvinfo_t)))) @@ -1436,7 +1436,7 @@ H5F__super_init(H5F_t *f) f->shared->drvinfo = drvinfo; } /* end if */ else - assert(!H5F_addr_defined(sblock->driver_addr)); + assert(!H5_addr_defined(sblock->driver_addr)); } /* end if */ done: @@ -1622,7 +1622,7 @@ H5F__super_size(H5F_t *f, hsize_t *super_size, hsize_t *super_ext_size) /* Set the superblock extension size */ if (super_ext_size) { - if (H5F_addr_defined(f->shared->sblock->ext_addr)) { + if (H5_addr_defined(f->shared->sblock->ext_addr)) { H5O_loc_t ext_loc; /* "Object location" for superblock extension */ H5O_hdr_info_t hdr_info; /* Object info for superblock extension */ @@ -1684,7 +1684,7 @@ H5F__super_ext_write_msg(H5F_t *f, unsigned id, void *mesg, hbool_t may_create, H5AC_set_ring(H5AC_RING_SBE, &orig_ring); /* Open/create the superblock extension object header */ - if (H5F_addr_defined(f->shared->sblock->ext_addr)) { + if (H5_addr_defined(f->shared->sblock->ext_addr)) { if (H5F__super_ext_open(f, f->shared->sblock->ext_addr, &ext_loc) < 0) HGOTO_ERROR(H5E_FILE, H5E_CANTOPENOBJ, FAIL, "unable to open file's superblock extension") } /* end if */ @@ -1694,7 +1694,7 @@ H5F__super_ext_write_msg(H5F_t *f, unsigned id, void *mesg, hbool_t may_create, HGOTO_ERROR(H5E_FILE, H5E_CANTCREATE, FAIL, "unable to create file's superblock extension") ext_created = TRUE; } /* end else */ - assert(H5F_addr_defined(ext_loc.addr)); + assert(H5_addr_defined(ext_loc.addr)); ext_opened = TRUE; /* Check if message with ID does not exist in the object header */ @@ -1758,7 +1758,7 @@ H5F__super_ext_remove_msg(H5F_t *f, unsigned id) FUNC_ENTER_PACKAGE /* Make sure that the superblock extension object header exists */ - assert(H5F_addr_defined(f->shared->sblock->ext_addr)); + assert(H5_addr_defined(f->shared->sblock->ext_addr)); /* Set the ring type in the API context */ H5AC_set_ring(H5AC_RING_SBE, &orig_ring); @@ -1788,7 +1788,7 @@ H5F__super_ext_remove_msg(H5F_t *f, unsigned id) if ((null_count = H5O_msg_count(&ext_loc, H5O_NULL_ID)) < 0) HGOTO_ERROR(H5E_SYM, H5E_CANTCOUNT, FAIL, "unable to count messages") else if ((unsigned)null_count == hdr_info.nmesgs) { - assert(H5F_addr_defined(ext_loc.addr)); + assert(H5_addr_defined(ext_loc.addr)); if (H5O_delete(f, ext_loc.addr) < 0) HGOTO_ERROR(H5E_SYM, H5E_CANTCOUNT, FAIL, "unable to count messages") f->shared->sblock->ext_addr = HADDR_UNDEF; diff --git a/src/H5Fsuper_cache.c b/src/H5Fsuper_cache.c index 9345f66..b199451 100644 --- a/src/H5Fsuper_cache.c +++ b/src/H5Fsuper_cache.c @@ -273,14 +273,14 @@ H5F__drvrinfo_prefix_decode(H5O_drvinfo_t *drvrinfo, char *drv_name, const uint8 /* Get current EOA... */ eoa = H5FD_get_eoa(udata->f->shared->lf, H5FD_MEM_SUPER); - if (!H5F_addr_defined(eoa)) + if (!H5_addr_defined(eoa)) HGOTO_ERROR(H5E_FILE, H5E_CANTGET, FAIL, "driver get_eoa request failed") /* ... if it is too small, extend it. */ min_eoa = udata->driver_addr + H5F_DRVINFOBLOCK_HDR_SIZE + drvrinfo->len; /* If it grew, set it */ - if (H5F_addr_gt(min_eoa, eoa)) + if (H5_addr_gt(min_eoa, eoa)) if (H5FD_set_eoa(udata->f->shared->lf, H5FD_MEM_SUPER, min_eoa) < 0) HGOTO_ERROR(H5E_FILE, H5E_CANTINIT, FAIL, "set end of space allocation request failed") } @@ -524,10 +524,10 @@ H5F__cache_superblock_deserialize(const void *_image, size_t len, void *_udata, /* Remainder of "variable-sized" portion of superblock */ if (H5_IS_BUFFER_OVERFLOW(image, H5F_sizeof_addr(udata->f) * 4, end)) HGOTO_ERROR(H5E_FILE, H5E_OVERFLOW, NULL, "image pointer is out of bounds") - H5F_addr_decode(udata->f, (const uint8_t **)&image, &sblock->base_addr /*out*/); - H5F_addr_decode(udata->f, (const uint8_t **)&image, &sblock->ext_addr /*out*/); - H5F_addr_decode(udata->f, (const uint8_t **)&image, &udata->stored_eof /*out*/); - H5F_addr_decode(udata->f, (const uint8_t **)&image, &sblock->driver_addr /*out*/); + H5_addr_decode(udata->f, (const uint8_t **)&image, &sblock->base_addr /*out*/); + H5_addr_decode(udata->f, (const uint8_t **)&image, &sblock->ext_addr /*out*/); + H5_addr_decode(udata->f, (const uint8_t **)&image, &udata->stored_eof /*out*/); + H5_addr_decode(udata->f, (const uint8_t **)&image, &sblock->driver_addr /*out*/); /* Allocate space for the root group symbol table entry */ if (sblock->root_ent) @@ -548,7 +548,7 @@ H5F__cache_superblock_deserialize(const void *_image, size_t len, void *_udata, * undefined to let the library ignore the family driver information saved * in the superblock. */ - if (udata->ignore_drvrinfo && H5F_addr_defined(sblock->driver_addr)) { + if (udata->ignore_drvrinfo && H5_addr_defined(sblock->driver_addr)) { /* Eliminate the driver info */ sblock->driver_addr = HADDR_UNDEF; udata->drvrinfo_removed = TRUE; @@ -580,10 +580,10 @@ H5F__cache_superblock_deserialize(const void *_image, size_t len, void *_udata, HGOTO_ERROR(H5E_FILE, H5E_OVERFLOW, NULL, "image pointer is out of bounds") /* Base, superblock extension, end of file & root group object header addresses */ - H5F_addr_decode(udata->f, (const uint8_t **)&image, &sblock->base_addr /*out*/); - H5F_addr_decode(udata->f, (const uint8_t **)&image, &sblock->ext_addr /*out*/); - H5F_addr_decode(udata->f, (const uint8_t **)&image, &udata->stored_eof /*out*/); - H5F_addr_decode(udata->f, (const uint8_t **)&image, &sblock->root_addr /*out*/); + H5_addr_decode(udata->f, (const uint8_t **)&image, &sblock->base_addr /*out*/); + H5_addr_decode(udata->f, (const uint8_t **)&image, &sblock->ext_addr /*out*/); + H5_addr_decode(udata->f, (const uint8_t **)&image, &udata->stored_eof /*out*/); + H5_addr_decode(udata->f, (const uint8_t **)&image, &sblock->root_addr /*out*/); /* checksum verification already done in verify_chksum cb */ @@ -702,10 +702,10 @@ H5F__cache_superblock_serialize(const H5F_t *f, void *_image, size_t H5_ATTR_UNU } /* end if */ /* Encode the base address */ - H5F_addr_encode(f, &image, sblock->base_addr); + H5_addr_encode(f, &image, sblock->base_addr); /* Encode the address of global free-space index */ - H5F_addr_encode(f, &image, sblock->ext_addr); + H5_addr_encode(f, &image, sblock->ext_addr); /* Encode the end-of-file address. Note that at this point in time, * the EOF value itself may not be reflective of the file's size, as @@ -714,10 +714,10 @@ H5F__cache_superblock_serialize(const H5F_t *f, void *_image, size_t H5_ATTR_UNU * value will ultimately match it. */ if ((rel_eof = H5FD_get_eoa(f->shared->lf, H5FD_MEM_SUPER)) == HADDR_UNDEF) HGOTO_ERROR(H5E_RESOURCE, H5E_CANTGET, FAIL, "driver get_eoa request failed") - H5F_addr_encode(f, &image, (rel_eof + sblock->base_addr)); + H5_addr_encode(f, &image, (rel_eof + sblock->base_addr)); /* Encode the driver information block address */ - H5F_addr_encode(f, &image, sblock->driver_addr); + H5_addr_encode(f, &image, sblock->driver_addr); /* Encode the root group object entry, including the cached stab info */ if (H5G_ent_encode(f, &image, sblock->root_ent) < 0) @@ -736,10 +736,10 @@ H5F__cache_superblock_serialize(const H5F_t *f, void *_image, size_t H5_ATTR_UNU *image++ = sblock->status_flags; /* Encode the base address */ - H5F_addr_encode(f, &image, sblock->base_addr); + H5_addr_encode(f, &image, sblock->base_addr); /* Encode the address of the superblock extension */ - H5F_addr_encode(f, &image, sblock->ext_addr); + H5_addr_encode(f, &image, sblock->ext_addr); /* At this point in time, the EOF value itself may * not be reflective of the file's size, since we'll eventually @@ -748,14 +748,14 @@ H5F__cache_superblock_serialize(const H5F_t *f, void *_image, size_t H5_ATTR_UNU * ultimately match it. */ if ((rel_eof = H5FD_get_eoa(f->shared->lf, H5FD_MEM_SUPER)) == HADDR_UNDEF) HGOTO_ERROR(H5E_RESOURCE, H5E_CANTGET, FAIL, "driver get_eoa request failed") - H5F_addr_encode(f, &image, (rel_eof + sblock->base_addr)); + H5_addr_encode(f, &image, (rel_eof + sblock->base_addr)); /* Retrieve information for root group */ if (NULL == (root_oloc = H5G_oloc(f->shared->root_grp))) HGOTO_ERROR(H5E_FILE, H5E_CANTINIT, FAIL, "unable to retrieve root group information") /* Encode address of root group's object header */ - H5F_addr_encode(f, &image, root_oloc->addr); + H5_addr_encode(f, &image, root_oloc->addr); /* Compute superblock checksum */ chksum = H5_checksum_metadata(_image, ((size_t)H5F_SUPERBLOCK_SIZE(sblock) - H5F_SIZEOF_CHKSUM), 0); diff --git a/src/H5Gdense.c b/src/H5Gdense.c index 86855b5..7e96d16 100644 --- a/src/H5Gdense.c +++ b/src/H5Gdense.c @@ -407,7 +407,7 @@ H5G__dense_insert(H5F_t *f, const H5O_linfo_t *linfo, const H5O_link_t *lnk) /* Check if we should create a creation order index v2 B-tree record */ if (linfo->index_corder) { /* Open the creation order index v2 B-tree */ - assert(H5F_addr_defined(linfo->corder_bt2_addr)); + assert(H5_addr_defined(linfo->corder_bt2_addr)); if (NULL == (bt2_corder = H5B2_open(f, linfo->corder_bt2_addr, NULL))) HGOTO_ERROR(H5E_SYM, H5E_CANTOPENOBJ, FAIL, "unable to open v2 B-tree for creation order index") @@ -640,13 +640,13 @@ H5G__dense_lookup_by_idx(H5F_t *f, const H5O_linfo_t *linfo, H5_index_t idx_type * use the B-tree for names instead of building a table to speed up the * process. */ - if (order == H5_ITER_NATIVE && !H5F_addr_defined(bt2_addr)) { + if (order == H5_ITER_NATIVE && !H5_addr_defined(bt2_addr)) { bt2_addr = linfo->name_bt2_addr; - assert(H5F_addr_defined(bt2_addr)); + assert(H5_addr_defined(bt2_addr)); } /* end if */ /* If there is an index defined for the field, use it */ - if (H5F_addr_defined(bt2_addr)) { + if (H5_addr_defined(bt2_addr)) { H5G_bt2_ud_lbi_t udata; /* User data for v2 B-tree link lookup */ /* Open the fractal heap */ @@ -920,8 +920,8 @@ H5G__dense_iterate(H5F_t *f, const H5O_linfo_t *linfo, H5_index_t idx_type, H5_i * use the B-tree for names instead of building a table to speed up the * process. */ - if (order == H5_ITER_NATIVE && !H5F_addr_defined(bt2_addr)) { - assert(H5F_addr_defined(linfo->name_bt2_addr)); + if (order == H5_ITER_NATIVE && !H5_addr_defined(bt2_addr)) { + assert(H5_addr_defined(linfo->name_bt2_addr)); bt2_addr = linfo->name_bt2_addr; } /* end if */ @@ -930,7 +930,7 @@ H5G__dense_iterate(H5F_t *f, const H5O_linfo_t *linfo, H5_index_t idx_type, H5_i H5G_bt2_ud_it_t udata; /* User data for iterator callback */ /* Sanity check */ - assert(H5F_addr_defined(bt2_addr)); + assert(H5_addr_defined(bt2_addr)); /* Open the fractal heap */ if (NULL == (fheap = H5HF_open(f, linfo->fheap_addr))) @@ -1106,13 +1106,13 @@ H5G__dense_get_name_by_idx(H5F_t *f, H5O_linfo_t *linfo, H5_index_t idx_type, H5 * use the B-tree for names instead of building a table to speed up the * process. */ - if (order == H5_ITER_NATIVE && !H5F_addr_defined(bt2_addr)) { + if (order == H5_ITER_NATIVE && !H5_addr_defined(bt2_addr)) { bt2_addr = linfo->name_bt2_addr; - assert(H5F_addr_defined(bt2_addr)); + assert(H5_addr_defined(bt2_addr)); } /* end if */ /* If there is an index defined for the field, use it */ - if (H5F_addr_defined(bt2_addr)) { + if (H5_addr_defined(bt2_addr)) { H5G_bt2_ud_gnbi_t udata; /* User data for v2 B-tree callback */ /* Open the fractal heap */ @@ -1193,7 +1193,7 @@ H5G__dense_remove_fh_cb(const void *obj, size_t obj_len, void *_udata) HGOTO_ERROR(H5E_SYM, H5E_CANTDECODE, FAIL, "can't decode link") /* Check for removing the link from the creation order index */ - if (H5F_addr_defined(udata->corder_bt2_addr)) { + if (H5_addr_defined(udata->corder_bt2_addr)) { H5G_bt2_ud_common_t bt2_udata; /* Info for B-tree callbacks */ /* Open the creation order index v2 B-tree */ @@ -1402,7 +1402,7 @@ H5G__dense_remove_by_idx_bt2_cb(const void *_record, void *_bt2_udata) assert(fh_udata.lnk); /* Check for removing the link from the "other" index (creation order, when name used and vice versa) */ - if (H5F_addr_defined(bt2_udata->other_bt2_addr)) { + if (H5_addr_defined(bt2_udata->other_bt2_addr)) { H5G_bt2_ud_common_t other_bt2_udata; /* Info for B-tree callbacks */ /* Determine the index being used */ @@ -1510,13 +1510,13 @@ H5G__dense_remove_by_idx(H5F_t *f, const H5O_linfo_t *linfo, H5RS_str_t *grp_ful * use the B-tree for names instead of building a table to speed up the * process. */ - if (order == H5_ITER_NATIVE && !H5F_addr_defined(bt2_addr)) { + if (order == H5_ITER_NATIVE && !H5_addr_defined(bt2_addr)) { bt2_addr = linfo->name_bt2_addr; - assert(H5F_addr_defined(bt2_addr)); + assert(H5_addr_defined(bt2_addr)); } /* end if */ /* If there is an index defined for the field, use it */ - if (H5F_addr_defined(bt2_addr)) { + if (H5_addr_defined(bt2_addr)) { H5G_bt2_ud_rmbi_t udata; /* User data for v2 B-tree record removal */ /* Open the fractal heap */ @@ -1628,13 +1628,13 @@ H5G__dense_delete(H5F_t *f, H5O_linfo_t *linfo, hbool_t adj_link) /* Check if we should delete the creation order index v2 B-tree */ if (linfo->index_corder) { /* Delete the creation order index, without adjusting the ref. count on the links */ - assert(H5F_addr_defined(linfo->corder_bt2_addr)); + assert(H5_addr_defined(linfo->corder_bt2_addr)); if (H5B2_delete(f, linfo->corder_bt2_addr, NULL, NULL, NULL) < 0) HGOTO_ERROR(H5E_SYM, H5E_CANTDELETE, FAIL, "unable to delete v2 B-tree for creation order index") linfo->corder_bt2_addr = HADDR_UNDEF; } /* end if */ else - assert(!H5F_addr_defined(linfo->corder_bt2_addr)); + assert(!H5_addr_defined(linfo->corder_bt2_addr)); /* Delete the fractal heap */ if (H5HF_delete(f, linfo->fheap_addr) < 0) diff --git a/src/H5Gent.c b/src/H5Gent.c index c0ee495..74b83f9 100644 --- a/src/H5Gent.c +++ b/src/H5Gent.c @@ -128,7 +128,7 @@ H5G_ent_decode(const H5F_t *f, const uint8_t **pp, H5G_entry_t *ent, const uint8 if (H5_IS_BUFFER_OVERFLOW(*pp, H5F_SIZEOF_ADDR(f) + sizeof(uint32_t), p_end)) HGOTO_ERROR(H5E_FILE, H5E_OVERFLOW, FAIL, "image pointer is out of bounds") - H5F_addr_decode(f, pp, &(ent->header)); + H5_addr_decode(f, pp, &(ent->header)); UINT32DECODE(*pp, tmp); *pp += 4; /*reserved*/ @@ -146,8 +146,8 @@ H5G_ent_decode(const H5F_t *f, const uint8_t **pp, H5G_entry_t *ent, const uint8 assert(2 * H5F_SIZEOF_ADDR(f) <= H5G_SIZEOF_SCRATCH); if (H5_IS_BUFFER_OVERFLOW(*pp, H5F_SIZEOF_ADDR(f) * 2, p_end)) HGOTO_ERROR(H5E_FILE, H5E_OVERFLOW, FAIL, "image pointer is out of bounds") - H5F_addr_decode(f, pp, &(ent->cache.stab.btree_addr)); - H5F_addr_decode(f, pp, &(ent->cache.stab.heap_addr)); + H5_addr_decode(f, pp, &(ent->cache.stab.btree_addr)); + H5_addr_decode(f, pp, &(ent->cache.stab.heap_addr)); break; case H5G_CACHED_SLINK: @@ -232,7 +232,7 @@ H5G_ent_encode(const H5F_t *f, uint8_t **pp, const H5G_entry_t *ent) if (ent) { /* encode header */ H5F_ENCODE_LENGTH(f, *pp, ent->name_off); - H5F_addr_encode(f, pp, ent->header); + H5_addr_encode(f, pp, ent->header); UINT32ENCODE(*pp, ent->type); UINT32ENCODE(*pp, 0); /*reserved*/ @@ -243,8 +243,8 @@ H5G_ent_encode(const H5F_t *f, uint8_t **pp, const H5G_entry_t *ent) case H5G_CACHED_STAB: assert(2 * H5F_SIZEOF_ADDR(f) <= H5G_SIZEOF_SCRATCH); - H5F_addr_encode(f, pp, ent->cache.stab.btree_addr); - H5F_addr_encode(f, pp, ent->cache.stab.heap_addr); + H5_addr_encode(f, pp, ent->cache.stab.btree_addr); + H5_addr_encode(f, pp, ent->cache.stab.heap_addr); break; case H5G_CACHED_SLINK: @@ -259,7 +259,7 @@ H5G_ent_encode(const H5F_t *f, uint8_t **pp, const H5G_entry_t *ent) } /* end if */ else { H5F_ENCODE_LENGTH(f, *pp, 0); - H5F_addr_encode(f, pp, HADDR_UNDEF); + H5_addr_encode(f, pp, HADDR_UNDEF); UINT32ENCODE(*pp, H5G_NOTHING_CACHED); UINT32ENCODE(*pp, 0); /*reserved*/ } /* end else */ diff --git a/src/H5Gnode.c b/src/H5Gnode.c index 21cbcb5..33708d6 100644 --- a/src/H5Gnode.c +++ b/src/H5Gnode.c @@ -457,7 +457,7 @@ H5G__node_found(H5F_t *f, haddr_t addr, const void H5_ATTR_UNUSED *_lt_key, hboo * Check arguments. */ assert(f); - assert(H5F_addr_defined(addr)); + assert(H5_addr_defined(addr)); assert(found); assert(udata && udata->common.heap); @@ -552,7 +552,7 @@ H5G__node_insert(H5F_t *f, haddr_t addr, void H5_ATTR_UNUSED *_lt_key, hbool_t H * Check arguments. */ assert(f); - assert(H5F_addr_defined(addr)); + assert(H5_addr_defined(addr)); assert(md_key); assert(rt_key); assert(udata && udata->common.heap); @@ -705,7 +705,7 @@ H5G__node_remove(H5F_t *f, haddr_t addr, void H5_ATTR_NDEBUG_UNUSED *_lt_key /*i /* Check arguments */ assert(f); - assert(H5F_addr_defined(addr)); + assert(H5_addr_defined(addr)); assert((H5G_node_key_t *)_lt_key); assert(rt_key); assert(udata && udata->common.heap); @@ -754,7 +754,7 @@ H5G__node_remove(H5F_t *f, haddr_t addr, void H5_ATTR_NDEBUG_UNUSED *_lt_key /*i } /* end if */ else { lnk.type = H5L_TYPE_HARD; - assert(H5F_addr_defined(sn->entry[idx].header)); + assert(H5_addr_defined(sn->entry[idx].header)); lnk.u.hard.addr = sn->entry[idx].header; } /* end else */ @@ -847,7 +847,7 @@ H5G__node_remove(H5F_t *f, haddr_t addr, void H5_ATTR_NDEBUG_UNUSED *_lt_key /*i for (idx = 0; idx < sn->nsyms; idx++) { if (!(H5G_CACHED_SLINK == sn->entry[idx].type)) { /* Decrement the reference count */ - assert(H5F_addr_defined(sn->entry[idx].header)); + assert(H5_addr_defined(sn->entry[idx].header)); tmp_oloc.addr = sn->entry[idx].header; if (H5O_link(&tmp_oloc, -1) < 0) @@ -898,7 +898,7 @@ H5G__node_iterate(H5F_t *f, const void H5_ATTR_UNUSED *_lt_key, haddr_t addr, * Check arguments. */ assert(f); - assert(H5F_addr_defined(addr)); + assert(H5_addr_defined(addr)); assert(udata && udata->heap); /* Protect the symbol table node & local heap while we iterate over entries */ @@ -972,7 +972,7 @@ H5G__node_sumup(H5F_t *f, const void H5_ATTR_UNUSED *_lt_key, haddr_t addr, * Check arguments. */ assert(f); - assert(H5F_addr_defined(addr)); + assert(H5_addr_defined(addr)); assert(num_objs); /* Find the object node and add the number of symbol entries. */ @@ -1013,7 +1013,7 @@ H5G__node_by_idx(H5F_t *f, const void H5_ATTR_UNUSED *_lt_key, haddr_t addr, * Check arguments. */ assert(f); - assert(H5F_addr_defined(addr)); + assert(H5_addr_defined(addr)); assert(udata); /* Get a pointer to the symbol table node */ @@ -1139,7 +1139,7 @@ H5G__node_copy(H5F_t *f, const void H5_ATTR_UNUSED *_lt_key, haddr_t addr, const /* Check arguments. */ assert(f); - assert(H5F_addr_defined(addr)); + assert(H5_addr_defined(addr)); assert(udata); /* load the symbol table into memory from the source file */ @@ -1192,7 +1192,7 @@ H5G__node_copy(H5F_t *f, const void H5_ATTR_UNUSED *_lt_key, haddr_t addr, const } /* if ((H5G_CACHED_SLINK == src_ent->type)... */ /* Check if object in source group is a hard link */ - if (H5F_addr_defined(src_ent->header)) { + if (H5_addr_defined(src_ent->header)) { H5O_loc_t new_dst_oloc; /* Copied object location in destination */ H5O_loc_t tmp_src_oloc; /* Temporary object location for source object */ @@ -1222,7 +1222,7 @@ H5G__node_copy(H5F_t *f, const void H5_ATTR_UNUSED *_lt_key, haddr_t addr, const /* Construct link information for eventual insertion */ lnk.type = H5L_TYPE_HARD; lnk.u.hard.addr = new_dst_oloc.addr; - } /* ( H5F_addr_defined(src_ent->header)) */ + } /* ( H5_addr_defined(src_ent->header)) */ else if (H5G_CACHED_SLINK == src_ent->type) { /* it is a soft link */ /* Set object type to unknown */ @@ -1294,7 +1294,7 @@ H5G__node_build_table(H5F_t *f, const void H5_ATTR_UNUSED *_lt_key, haddr_t addr * Check arguments. */ assert(f); - assert(H5F_addr_defined(addr)); + assert(H5_addr_defined(addr)); assert(udata && udata->heap); /* @@ -1393,13 +1393,13 @@ H5G_node_debug(H5F_t *f, haddr_t addr, FILE *stream, int indent, int fwidth, had * Check arguments. */ assert(f); - assert(H5F_addr_defined(addr)); + assert(H5_addr_defined(addr)); assert(stream); assert(indent >= 0); assert(fwidth >= 0); /* Pin the heap down in memory */ - if (heap_addr > 0 && H5F_addr_defined(heap_addr)) + if (heap_addr > 0 && H5_addr_defined(heap_addr)) if (NULL == (heap = H5HL_protect(f, heap_addr, H5AC__READ_ONLY_FLAG))) HGOTO_ERROR(H5E_SYM, H5E_CANTLOAD, FAIL, "unable to protect symbol table heap") diff --git a/src/H5Gobj.c b/src/H5Gobj.c index e8610e0..209b8b0 100644 --- a/src/H5Gobj.c +++ b/src/H5Gobj.c @@ -299,7 +299,7 @@ H5G__obj_get_linfo(const H5O_loc_t *grp_oloc, H5O_linfo_t *linfo) /* Check if we don't know how many links there are */ if (linfo->nlinks == HSIZET_MAX) { /* Check if we are using "dense" link storage */ - if (H5F_addr_defined(linfo->fheap_addr)) { + if (H5_addr_defined(linfo->fheap_addr)) { /* Open the name index v2 B-tree */ if (NULL == (bt2_name = H5B2_open(grp_oloc->file, linfo->name_bt2_addr, NULL))) HGOTO_ERROR(H5E_SYM, H5E_CANTOPENOBJ, FAIL, "unable to open v2 B-tree for name index") @@ -453,7 +453,7 @@ H5G_obj_insert(const H5O_loc_t *grp_oloc, const char *name, H5O_link_t *obj_lnk, /* (If the encoded form of the link is too large to fit into an object * header message, convert to using dense link storage instead of link messages) */ - if (H5F_addr_defined(linfo.fheap_addr)) + if (H5_addr_defined(linfo.fheap_addr)) use_new_dense = TRUE; else if (linfo.nlinks < ginfo.max_compact && link_msg_size < H5O_MESG_MAX_SIZE) use_new_dense = FALSE; @@ -626,7 +626,7 @@ H5G__obj_iterate(const H5O_loc_t *grp_oloc, H5_index_t idx_type, H5_iter_order_t HGOTO_ERROR(H5E_SYM, H5E_NOTFOUND, FAIL, "creation order not tracked for links in group") } /* end if */ - if (H5F_addr_defined(linfo.fheap_addr)) { + if (H5_addr_defined(linfo.fheap_addr)) { /* Iterate over the links in the group, building a table of the link messages */ if ((ret_value = H5G__dense_iterate(grp_oloc->file, &linfo, idx_type, order, skip, last_lnk, op, op_data)) < 0) @@ -704,7 +704,7 @@ H5G__obj_info(const H5O_loc_t *oloc, H5G_info_t *grp_info) grp_info->max_corder = linfo.max_corder; /* Check if the group is using compact or dense storage for its links */ - if (H5F_addr_defined(linfo.fheap_addr)) + if (H5_addr_defined(linfo.fheap_addr)) grp_info->storage_type = H5G_STORAGE_TYPE_DENSE; else grp_info->storage_type = H5G_STORAGE_TYPE_COMPACT; @@ -761,7 +761,7 @@ H5G_obj_get_name_by_idx(const H5O_loc_t *oloc, H5_index_t idx_type, H5_iter_orde HGOTO_ERROR(H5E_SYM, H5E_NOTFOUND, FAIL, "creation order not tracked for links in group") /* Check for dense link storage */ - if (H5F_addr_defined(linfo.fheap_addr)) { + if (H5_addr_defined(linfo.fheap_addr)) { /* Get the object's name from the dense link storage */ if (H5G__dense_get_name_by_idx(oloc->file, &linfo, idx_type, order, n, name, name_size, name_len) < 0) @@ -816,7 +816,7 @@ H5G__obj_remove_update_linfo(const H5O_loc_t *oloc, H5O_linfo_t *linfo) linfo->max_corder = 0; /* Check for transitioning out of dense storage, if we are using it */ - if (H5F_addr_defined(linfo->fheap_addr)) { + if (H5_addr_defined(linfo->fheap_addr)) { /* Check if there's no more links */ if (linfo->nlinks == 0) { /* Delete the dense storage */ @@ -927,7 +927,7 @@ H5G_obj_remove(const H5O_loc_t *oloc, H5RS_str_t *grp_full_path_r, const char *n use_old_format = FALSE; /* Check for dense or compact storage */ - if (H5F_addr_defined(linfo.fheap_addr)) { + if (H5_addr_defined(linfo.fheap_addr)) { /* Remove object from the dense link storage */ if (H5G__dense_remove(oloc->file, &linfo, grp_full_path_r, name) < 0) HGOTO_ERROR(H5E_SYM, H5E_NOTFOUND, FAIL, "can't remove object") @@ -994,7 +994,7 @@ H5G_obj_remove_by_idx(const H5O_loc_t *grp_oloc, H5RS_str_t *grp_full_path_r, H5 use_old_format = FALSE; /* Check for dense or compact storage */ - if (H5F_addr_defined(linfo.fheap_addr)) { + if (H5_addr_defined(linfo.fheap_addr)) { /* Remove object from the dense link storage */ if (H5G__dense_remove_by_idx(grp_oloc->file, &linfo, grp_full_path_r, idx_type, order, n) < 0) HGOTO_ERROR(H5E_SYM, H5E_NOTFOUND, FAIL, "can't remove object") @@ -1054,7 +1054,7 @@ H5G__obj_lookup(const H5O_loc_t *grp_oloc, const char *name, hbool_t *found, H5O HGOTO_ERROR(H5E_SYM, H5E_CANTGET, FAIL, "can't check for link info message") if (linfo_exists) { /* Check for dense link storage */ - if (H5F_addr_defined(linfo.fheap_addr)) { + if (H5_addr_defined(linfo.fheap_addr)) { /* Get the object's info from the dense link storage */ if (H5G__dense_lookup(grp_oloc->file, &linfo, name, found, lnk) < 0) HGOTO_ERROR(H5E_SYM, H5E_NOTFOUND, FAIL, "can't locate object") @@ -1109,7 +1109,7 @@ H5G_obj_lookup_by_idx(const H5O_loc_t *grp_oloc, H5_index_t idx_type, H5_iter_or } /* end if */ /* Check for dense link storage */ - if (H5F_addr_defined(linfo.fheap_addr)) { + if (H5_addr_defined(linfo.fheap_addr)) { /* Get the link from the dense storage */ if (H5G__dense_lookup_by_idx(grp_oloc->file, &linfo, idx_type, order, n, lnk) < 0) HGOTO_ERROR(H5E_SYM, H5E_NOTFOUND, FAIL, "can't locate object") diff --git a/src/H5Goh.c b/src/H5Goh.c index d9b48b4..84ad254 100644 --- a/src/H5Goh.c +++ b/src/H5Goh.c @@ -306,7 +306,7 @@ H5O__group_bh_info(const H5O_loc_t *loc, H5O_t *oh, H5_ih_info_t *bh_info) /* Sanity check */ assert(loc); assert(loc->file); - assert(H5F_addr_defined(loc->addr)); + assert(H5_addr_defined(loc->addr)); assert(oh); assert(bh_info); @@ -321,7 +321,7 @@ H5O__group_bh_info(const H5O_loc_t *loc, H5O_t *oh, H5_ih_info_t *bh_info) HGOTO_ERROR(H5E_SYM, H5E_CANTGET, FAIL, "can't read LINFO message") /* Check if name index available */ - if (H5F_addr_defined(linfo.name_bt2_addr)) { + if (H5_addr_defined(linfo.name_bt2_addr)) { /* Open the name index v2 B-tree */ if (NULL == (bt2_name = H5B2_open(loc->file, linfo.name_bt2_addr, NULL))) HGOTO_ERROR(H5E_SYM, H5E_CANTOPENOBJ, FAIL, "unable to open v2 B-tree for name index") @@ -332,7 +332,7 @@ H5O__group_bh_info(const H5O_loc_t *loc, H5O_t *oh, H5_ih_info_t *bh_info) } /* end if */ /* Check if creation order index available */ - if (H5F_addr_defined(linfo.corder_bt2_addr)) { + if (H5_addr_defined(linfo.corder_bt2_addr)) { /* Open the creation order index v2 B-tree */ if (NULL == (bt2_corder = H5B2_open(loc->file, linfo.corder_bt2_addr, NULL))) HGOTO_ERROR(H5E_SYM, H5E_CANTOPENOBJ, FAIL, @@ -345,7 +345,7 @@ H5O__group_bh_info(const H5O_loc_t *loc, H5O_t *oh, H5_ih_info_t *bh_info) } /* end if */ /* Get fractal heap size, if available */ - if (H5F_addr_defined(linfo.fheap_addr)) { + if (H5_addr_defined(linfo.fheap_addr)) { /* Open the fractal heap for links */ if (NULL == (fheap = H5HF_open(loc->file, linfo.fheap_addr))) HGOTO_ERROR(H5E_SYM, H5E_CANTOPENOBJ, FAIL, "unable to open fractal heap") diff --git a/src/H5Gstab.c b/src/H5Gstab.c index d345fea..45b1be9 100644 --- a/src/H5Gstab.c +++ b/src/H5Gstab.c @@ -426,8 +426,8 @@ H5G__stab_delete(H5F_t *f, const H5O_stab_t *stab) assert(f); assert(stab); - assert(H5F_addr_defined(stab->btree_addr)); - assert(H5F_addr_defined(stab->heap_addr)); + assert(H5_addr_defined(stab->btree_addr)); + assert(H5_addr_defined(stab->heap_addr)); /* Pin the heap down in memory */ if (NULL == (heap = H5HL_protect(f, stab->heap_addr, H5AC__NO_FLAGS_SET))) diff --git a/src/H5Gtest.c b/src/H5Gtest.c index 7a6dcf3..ed22174 100644 --- a/src/H5Gtest.c +++ b/src/H5Gtest.c @@ -132,11 +132,11 @@ H5G__is_empty_test(hid_t gid) HGOTO_ERROR(H5E_SYM, H5E_BADMESG, FAIL, "can't get link info") /* Check for 'dense' link storage file addresses being defined */ - if (H5F_addr_defined(linfo.fheap_addr)) + if (H5_addr_defined(linfo.fheap_addr)) HGOTO_DONE(FALSE) - if (H5F_addr_defined(linfo.name_bt2_addr)) + if (H5_addr_defined(linfo.name_bt2_addr)) HGOTO_DONE(FALSE) - if (H5F_addr_defined(linfo.corder_bt2_addr)) + if (H5_addr_defined(linfo.corder_bt2_addr)) HGOTO_DONE(FALSE) /* Check for link count */ @@ -366,9 +366,9 @@ H5G__is_new_dense_test(hid_t gid) HGOTO_ERROR(H5E_SYM, H5E_BADMESG, FAIL, "can't get link info") /* Check for 'dense' link storage file addresses being defined */ - if (!H5F_addr_defined(linfo.fheap_addr)) + if (!H5_addr_defined(linfo.fheap_addr)) HGOTO_DONE(FALSE) - if (!H5F_addr_defined(linfo.name_bt2_addr)) + if (!H5_addr_defined(linfo.name_bt2_addr)) HGOTO_DONE(FALSE) } /* end if */ @@ -429,9 +429,9 @@ H5G__new_dense_info_test(hid_t gid, hsize_t *name_count, hsize_t *corder_count) HGOTO_ERROR_TAG(H5E_SYM, H5E_BADMESG, FAIL, "can't get link info") /* Check for 'dense' link storage file addresses being defined */ - if (!H5F_addr_defined(linfo.fheap_addr)) + if (!H5_addr_defined(linfo.fheap_addr)) HGOTO_DONE_TAG(FAIL) - if (!H5F_addr_defined(linfo.name_bt2_addr)) + if (!H5_addr_defined(linfo.name_bt2_addr)) HGOTO_DONE_TAG(FAIL) /* Open the name index v2 B-tree */ @@ -443,7 +443,7 @@ H5G__new_dense_info_test(hid_t gid, hsize_t *name_count, hsize_t *corder_count) HGOTO_ERROR_TAG(H5E_SYM, H5E_CANTCOUNT, FAIL, "unable to retrieve # of records from name index") /* Check if there is a creation order index */ - if (H5F_addr_defined(linfo.corder_bt2_addr)) { + if (H5_addr_defined(linfo.corder_bt2_addr)) { /* Open the creation order index v2 B-tree */ if (NULL == (bt2_corder = H5B2_open(grp->oloc.file, linfo.corder_bt2_addr, NULL))) HGOTO_ERROR_TAG(H5E_SYM, H5E_CANTOPENOBJ, FAIL, @@ -716,7 +716,7 @@ H5G__verify_cached_stabs_test_cb(H5F_t *f, const void H5_ATTR_UNUSED *_lt_key, h /* Check arguments */ assert(f); - assert(H5F_addr_defined(addr)); + assert(H5_addr_defined(addr)); /* Load the node */ if (NULL == (sn = (H5G_node_t *)H5AC_protect(f, H5AC_SNODE, addr, f, H5AC__READ_ONLY_FLAG))) diff --git a/src/H5Gtraverse.c b/src/H5Gtraverse.c index 35d5da2..bad168c 100644 --- a/src/H5Gtraverse.c +++ b/src/H5Gtraverse.c @@ -406,7 +406,7 @@ H5G__traverse_special(const H5G_loc_t *grp_loc, const H5O_link_t *lnk, unsigned * the status of the object (into a hard link), so don't use an 'else' * statement here. -QAK) */ - if (H5F_addr_defined(obj_loc->oloc->addr) && (0 == (target & H5G_TARGET_MOUNT) || !last_comp)) { + if (H5_addr_defined(obj_loc->oloc->addr) && (0 == (target & H5G_TARGET_MOUNT) || !last_comp)) { if (H5F_traverse_mount(obj_loc->oloc /*in,out*/) < 0) HGOTO_ERROR(H5E_SYM, H5E_NOTFOUND, FAIL, "mount point traversal failed") } /* end if */ diff --git a/src/H5HF.c b/src/H5HF.c index 08ade12..953cb69 100644 --- a/src/H5HF.c +++ b/src/H5HF.c @@ -203,7 +203,7 @@ H5HF_open(H5F_t *f, haddr_t fh_addr) * Check arguments. */ assert(f); - assert(H5F_addr_defined(fh_addr)); + assert(H5_addr_defined(fh_addr)); /* Load the heap header into memory */ if (NULL == (hdr = H5HF__hdr_protect(f, fh_addr, H5AC__READ_ONLY_FLAG))) @@ -846,7 +846,7 @@ H5HF_delete(H5F_t *f, haddr_t fh_addr) * Check arguments. */ assert(f); - assert(H5F_addr_defined(fh_addr)); + assert(H5_addr_defined(fh_addr)); /* Lock the heap header into memory */ if (NULL == (hdr = H5HF__hdr_protect(f, fh_addr, H5AC__NO_FLAGS_SET))) diff --git a/src/H5HFbtree2.c b/src/H5HFbtree2.c index 5c4b670..c18817e 100644 --- a/src/H5HFbtree2.c +++ b/src/H5HFbtree2.c @@ -352,7 +352,7 @@ H5HF__huge_bt2_indir_encode(uint8_t *raw, const void *_nrecord, void *_ctx) assert(ctx); /* Encode the record's fields */ - H5F_addr_encode_len(ctx->sizeof_addr, &raw, nrecord->addr); + H5_addr_encode_len(ctx->sizeof_addr, &raw, nrecord->addr); H5F_ENCODE_LENGTH_LEN(raw, nrecord->len, ctx->sizeof_size); H5F_ENCODE_LENGTH_LEN(raw, nrecord->id, ctx->sizeof_size); @@ -381,7 +381,7 @@ H5HF__huge_bt2_indir_decode(const uint8_t *raw, void *_nrecord, void *_ctx) assert(ctx); /* Decode the record's fields */ - H5F_addr_decode_len(ctx->sizeof_addr, &raw, &nrecord->addr); + H5_addr_decode_len(ctx->sizeof_addr, &raw, &nrecord->addr); H5F_DECODE_LENGTH_LEN(raw, nrecord->len, ctx->sizeof_size); H5F_DECODE_LENGTH_LEN(raw, nrecord->id, ctx->sizeof_size); @@ -529,7 +529,7 @@ H5HF__huge_bt2_filt_indir_encode(uint8_t *raw, const void *_nrecord, void *_ctx) assert(ctx); /* Encode the record's fields */ - H5F_addr_encode_len(ctx->sizeof_addr, &raw, nrecord->addr); + H5_addr_encode_len(ctx->sizeof_addr, &raw, nrecord->addr); H5F_ENCODE_LENGTH_LEN(raw, nrecord->len, ctx->sizeof_size); UINT32ENCODE(raw, nrecord->filter_mask); H5F_ENCODE_LENGTH_LEN(raw, nrecord->obj_size, ctx->sizeof_size); @@ -560,7 +560,7 @@ H5HF__huge_bt2_filt_indir_decode(const uint8_t *raw, void *_nrecord, void *_ctx) assert(ctx); /* Decode the record's fields */ - H5F_addr_decode_len(ctx->sizeof_addr, &raw, &nrecord->addr); + H5_addr_decode_len(ctx->sizeof_addr, &raw, &nrecord->addr); H5F_DECODE_LENGTH_LEN(raw, nrecord->len, ctx->sizeof_size); UINT32DECODE(raw, nrecord->filter_mask); H5F_DECODE_LENGTH_LEN(raw, nrecord->obj_size, ctx->sizeof_size); @@ -700,7 +700,7 @@ H5HF__huge_bt2_dir_encode(uint8_t *raw, const void *_nrecord, void *_ctx) assert(ctx); /* Encode the record's fields */ - H5F_addr_encode_len(ctx->sizeof_addr, &raw, nrecord->addr); + H5_addr_encode_len(ctx->sizeof_addr, &raw, nrecord->addr); H5F_ENCODE_LENGTH_LEN(raw, nrecord->len, ctx->sizeof_size); FUNC_LEAVE_NOAPI(SUCCEED) @@ -728,7 +728,7 @@ H5HF__huge_bt2_dir_decode(const uint8_t *raw, void *_nrecord, void *_ctx) assert(ctx); /* Decode the record's fields */ - H5F_addr_decode_len(ctx->sizeof_addr, &raw, &nrecord->addr); + H5_addr_decode_len(ctx->sizeof_addr, &raw, &nrecord->addr); H5F_DECODE_LENGTH_LEN(raw, nrecord->len, ctx->sizeof_size); FUNC_LEAVE_NOAPI(SUCCEED) @@ -886,7 +886,7 @@ H5HF__huge_bt2_filt_dir_encode(uint8_t *raw, const void *_nrecord, void *_ctx) assert(ctx); /* Encode the record's fields */ - H5F_addr_encode_len(ctx->sizeof_addr, &raw, nrecord->addr); + H5_addr_encode_len(ctx->sizeof_addr, &raw, nrecord->addr); H5F_ENCODE_LENGTH_LEN(raw, nrecord->len, ctx->sizeof_size); UINT32ENCODE(raw, nrecord->filter_mask); H5F_ENCODE_LENGTH_LEN(raw, nrecord->obj_size, ctx->sizeof_size); @@ -916,7 +916,7 @@ H5HF__huge_bt2_filt_dir_decode(const uint8_t *raw, void *_nrecord, void *_ctx) assert(ctx); /* Decode the record's fields */ - H5F_addr_decode_len(ctx->sizeof_addr, &raw, &nrecord->addr); + H5_addr_decode_len(ctx->sizeof_addr, &raw, &nrecord->addr); H5F_DECODE_LENGTH_LEN(raw, nrecord->len, ctx->sizeof_size); UINT32DECODE(raw, nrecord->filter_mask); H5F_DECODE_LENGTH_LEN(raw, nrecord->obj_size, ctx->sizeof_size); diff --git a/src/H5HFcache.c b/src/H5HFcache.c index fccf123..9aa1251 100644 --- a/src/H5HFcache.c +++ b/src/H5HFcache.c @@ -261,7 +261,7 @@ H5HF__dtable_decode(H5F_t *f, const uint8_t **pp, H5HF_dtable_t *dtable) UINT16DECODE(*pp, dtable->cparam.start_root_rows); /* Address of table */ - H5F_addr_decode(f, pp, &(dtable->table_addr)); + H5_addr_decode(f, pp, &(dtable->table_addr)); /* Current # of rows in root indirect block */ UINT16DECODE(*pp, dtable->curr_root_rows); @@ -306,7 +306,7 @@ H5HF__dtable_encode(H5F_t *f, uint8_t **pp, const H5HF_dtable_t *dtable) UINT16ENCODE(*pp, dtable->cparam.start_root_rows); /* Address of root direct/indirect block */ - H5F_addr_encode(f, pp, dtable->table_addr); + H5_addr_encode(f, pp, dtable->table_addr); /* Current # of rows in root indirect block */ UINT16ENCODE(*pp, dtable->curr_root_rows); @@ -476,14 +476,14 @@ H5HF__cache_hdr_deserialize(const void *_image, size_t len, void *_udata, hbool_ hdr->checksum_dblocks = heap_flags & H5HF_HDR_FLAGS_CHECKSUM_DBLOCKS; /* "Huge" object information */ - UINT32DECODE(image, hdr->max_man_size); /* Max. size of "managed" objects */ - H5F_DECODE_LENGTH(udata->f, image, hdr->huge_next_id); /* Next ID to use for "huge" object */ - H5F_addr_decode(udata->f, &image, &hdr->huge_bt2_addr); /* Address of "huge" object tracker B-tree */ + UINT32DECODE(image, hdr->max_man_size); /* Max. size of "managed" objects */ + H5F_DECODE_LENGTH(udata->f, image, hdr->huge_next_id); /* Next ID to use for "huge" object */ + H5_addr_decode(udata->f, &image, &hdr->huge_bt2_addr); /* Address of "huge" object tracker B-tree */ /* "Managed" object free space information */ H5F_DECODE_LENGTH(udata->f, image, - hdr->total_man_free); /* Internal free space in managed direct blocks */ - H5F_addr_decode(udata->f, &image, &hdr->fs_addr); /* Address of free section header */ + hdr->total_man_free); /* Internal free space in managed direct blocks */ + H5_addr_decode(udata->f, &image, &hdr->fs_addr); /* Address of free section header */ /* Heap statistics */ H5F_DECODE_LENGTH(udata->f, image, hdr->man_size); @@ -624,7 +624,7 @@ H5HF__cache_hdr_pre_serialize(H5F_t *f, void *_thing, haddr_t addr, size_t len, assert(hdr); assert(hdr->cache_info.magic == H5C__H5C_CACHE_ENTRY_T_MAGIC); assert(hdr->cache_info.type == H5AC_FHEAP_HDR); - assert(H5F_addr_defined(addr)); + assert(H5_addr_defined(addr)); assert(addr == hdr->heap_addr); assert(new_addr); assert(new_len); @@ -740,11 +740,11 @@ H5HF__cache_hdr_serialize(const H5F_t *f, void *_image, size_t H5_ATTR_NDEBUG_UN /* "Huge" object information */ UINT32ENCODE(image, hdr->max_man_size); /* Max. size of "managed" objects */ H5F_ENCODE_LENGTH(f, image, hdr->huge_next_id); /* Next ID to use for "huge" object */ - H5F_addr_encode(f, &image, hdr->huge_bt2_addr); /* Address of "huge" object tracker B-tree */ + H5_addr_encode(f, &image, hdr->huge_bt2_addr); /* Address of "huge" object tracker B-tree */ /* "Managed" object free space information */ H5F_ENCODE_LENGTH(f, image, hdr->total_man_free); /* Internal free space in managed direct blocks */ - H5F_addr_encode(f, &image, hdr->fs_addr); /* Address of free section header */ + H5_addr_encode(f, &image, hdr->fs_addr); /* Address of free section header */ /* Heap statistics */ H5F_ENCODE_LENGTH(f, image, hdr->man_size); @@ -964,8 +964,8 @@ H5HF__cache_iblock_deserialize(const void *_image, size_t H5_ATTR_NDEBUG_UNUSED HGOTO_ERROR(H5E_HEAP, H5E_VERSION, NULL, "wrong fractal heap direct block version") /* Address of heap that owns this block */ - H5F_addr_decode(udata->f, &image, &heap_addr); - if (H5F_addr_ne(heap_addr, hdr->heap_addr)) + H5_addr_decode(udata->f, &image, &heap_addr); + if (H5_addr_ne(heap_addr, hdr->heap_addr)) HGOTO_ERROR(H5E_HEAP, H5E_CANTLOAD, NULL, "incorrect heap header address for direct block") /* Address of parent block */ @@ -1017,7 +1017,7 @@ H5HF__cache_iblock_deserialize(const void *_image, size_t H5_ATTR_NDEBUG_UNUSED for (u = 0; u < (iblock->nrows * hdr->man_dtable.cparam.width); u++) { /* Decode child block address */ - H5F_addr_decode(udata->f, &image, &(iblock->ents[u].addr)); + H5_addr_decode(udata->f, &image, &(iblock->ents[u].addr)); /* Check for heap with I/O filters */ if (hdr->filter_len > 0) { @@ -1033,8 +1033,8 @@ H5HF__cache_iblock_deserialize(const void *_image, size_t H5_ATTR_NDEBUG_UNUSED /* (either both the address & size are defined or both are * not defined) */ - assert((H5F_addr_defined(iblock->ents[u].addr) && iblock->filt_ents[u].size) || - (!H5F_addr_defined(iblock->ents[u].addr) && iblock->filt_ents[u].size == 0)); + assert((H5_addr_defined(iblock->ents[u].addr) && iblock->filt_ents[u].size) || + (!H5_addr_defined(iblock->ents[u].addr) && iblock->filt_ents[u].size == 0)); /* I/O filter mask for filtered direct block */ UINT32DECODE(image, iblock->filt_ents[u].filter_mask); @@ -1042,7 +1042,7 @@ H5HF__cache_iblock_deserialize(const void *_image, size_t H5_ATTR_NDEBUG_UNUSED } /* end if */ /* Count child blocks */ - if (H5F_addr_defined(iblock->ents[u].addr)) { + if (H5_addr_defined(iblock->ents[u].addr)) { iblock->nchildren++; iblock->max_child = u; } /* end if */ @@ -1146,8 +1146,8 @@ H5HF__cache_iblock_pre_serialize(H5F_t *f, void *_thing, haddr_t addr, size_t H5 assert(iblock->cache_info.magic == H5C__H5C_CACHE_ENTRY_T_MAGIC); assert(iblock->cache_info.type == H5AC_FHEAP_IBLOCK); assert(iblock->cache_info.size == iblock->size); - assert(H5F_addr_defined(addr)); - assert(H5F_addr_eq(iblock->addr, addr)); + assert(H5_addr_defined(addr)); + assert(H5_addr_eq(iblock->addr, addr)); assert(new_addr); assert(new_len); assert(flags); @@ -1193,7 +1193,7 @@ H5HF__cache_iblock_pre_serialize(H5F_t *f, void *_thing, haddr_t addr, size_t H5 HGOTO_ERROR(H5E_HEAP, H5E_NOSPACE, FAIL, "file allocation failed for fractal heap indirect block") /* Sanity check */ - assert(!H5F_addr_eq(iblock->addr, iblock_addr)); + assert(!H5_addr_eq(iblock->addr, iblock_addr)); /* Let the metadata cache know the block moved */ if (H5AC_move_entry((H5F_t *)f, H5AC_FHEAP_IBLOCK, iblock->addr, iblock_addr) < 0) @@ -1276,7 +1276,7 @@ H5HF__cache_iblock_serialize(const H5F_t *f, void *_image, size_t H5_ATTR_NDEBUG /* Indirect block must be in 'normal' file space */ assert(!H5F_IS_TMP_ADDR(f, iblock->addr)); - assert(H5F_addr_eq(iblock->addr, iblock->cache_info.addr)); + assert(H5_addr_eq(iblock->addr, iblock->cache_info.addr)); /* Get the pointer to the shared heap header */ hdr = iblock->hdr; @@ -1296,7 +1296,7 @@ H5HF__cache_iblock_serialize(const H5F_t *f, void *_image, size_t H5_ATTR_NDEBUG *image++ = H5HF_IBLOCK_VERSION; /* Address of heap header for heap which owns this block */ - H5F_addr_encode(f, &image, hdr->heap_addr); + H5_addr_encode(f, &image, hdr->heap_addr); /* Offset of block in heap */ UINT64ENCODE_VAR(image, iblock->block_off, hdr->heap_off_size); @@ -1304,7 +1304,7 @@ H5HF__cache_iblock_serialize(const H5F_t *f, void *_image, size_t H5_ATTR_NDEBUG /* Encode indirect block-specific fields */ for (u = 0; u < (iblock->nrows * hdr->man_dtable.cparam.width); u++) { /* Encode child block address */ - H5F_addr_encode(f, &image, iblock->ents[u].addr); + H5_addr_encode(f, &image, iblock->ents[u].addr); /* Check for heap with I/O filters */ if (hdr->filter_len > 0) { @@ -1317,8 +1317,8 @@ H5HF__cache_iblock_serialize(const H5F_t *f, void *_image, size_t H5_ATTR_NDEBUG /* (either both the address & size are defined or both are * not defined) */ - assert((H5F_addr_defined(iblock->ents[u].addr) && iblock->filt_ents[u].size) || - (!H5F_addr_defined(iblock->ents[u].addr) && iblock->filt_ents[u].size == 0)); + assert((H5_addr_defined(iblock->ents[u].addr) && iblock->filt_ents[u].size) || + (!H5_addr_defined(iblock->ents[u].addr) && iblock->filt_ents[u].size == 0)); /* Size of filtered direct block */ H5F_ENCODE_LENGTH(f, image, iblock->filt_ents[u].size); @@ -1330,7 +1330,7 @@ H5HF__cache_iblock_serialize(const H5F_t *f, void *_image, size_t H5_ATTR_NDEBUG #ifndef NDEBUG /* Count child blocks */ - if (H5F_addr_defined(iblock->ents[u].addr)) { + if (H5_addr_defined(iblock->ents[u].addr)) { nchildren++; if (u > max_child) max_child = u; @@ -1789,8 +1789,8 @@ H5HF__cache_dblock_deserialize(const void *_image, size_t len, void *_udata, hbo HGOTO_ERROR(H5E_HEAP, H5E_VERSION, NULL, "wrong fractal heap direct block version") /* Address of heap that owns this block (just for file integrity checks) */ - H5F_addr_decode(udata->f, &image, &heap_addr); - if (H5F_addr_ne(heap_addr, hdr->heap_addr)) + H5_addr_decode(udata->f, &image, &heap_addr); + if (H5_addr_ne(heap_addr, hdr->heap_addr)) HGOTO_ERROR(H5E_HEAP, H5E_CANTLOAD, NULL, "incorrect heap header address for direct block") /* Address of parent block */ @@ -2007,7 +2007,7 @@ H5HF__cache_dblock_pre_serialize(H5F_t *f, void *_thing, haddr_t addr, size_t le assert(dblock->write_buf == NULL); assert(dblock->write_size == 0); assert(dblock->cache_info.size == len); - assert(H5F_addr_defined(addr)); + assert(H5_addr_defined(addr)); assert(new_addr); assert(new_len); assert(flags); @@ -2035,7 +2035,7 @@ H5HF__cache_dblock_pre_serialize(H5F_t *f, void *_thing, haddr_t addr, size_t le assert(par_iblock->cache_info.magic == H5C__H5C_CACHE_ENTRY_T_MAGIC); assert(par_iblock->cache_info.type == H5AC_FHEAP_IBLOCK); - assert(H5F_addr_eq(par_iblock->ents[par_entry].addr, addr)); + assert(H5_addr_eq(par_iblock->ents[par_entry].addr, addr)); } /* end if */ else { /* the direct block is a root direct block -- just set par_iblock @@ -2063,7 +2063,7 @@ H5HF__cache_dblock_pre_serialize(H5F_t *f, void *_thing, haddr_t addr, size_t le *image++ = H5HF_DBLOCK_VERSION; /* Address of heap header for heap which owns this block */ - H5F_addr_encode(f, &image, hdr->heap_addr); + H5_addr_encode(f, &image, hdr->heap_addr); /* Offset of block in heap */ UINT64ENCODE_VAR(image, dblock->block_off, hdr->heap_off_size); @@ -2135,7 +2135,7 @@ H5HF__cache_dblock_pre_serialize(H5F_t *f, void *_thing, haddr_t addr, size_t le hbool_t hdr_changed = FALSE; /* Whether the header info changed */ /* Sanity check */ - assert(H5F_addr_eq(hdr->man_dtable.table_addr, addr)); + assert(H5_addr_eq(hdr->man_dtable.table_addr, addr)); assert(hdr->pline_root_direct_size > 0); /* Check if the filter mask changed */ @@ -2268,8 +2268,8 @@ H5HF__cache_dblock_pre_serialize(H5F_t *f, void *_thing, haddr_t addr, size_t le /* Check for root direct block */ if (NULL == dblock->parent) { /* Sanity checks */ - assert(H5F_addr_eq(hdr->man_dtable.table_addr, addr)); - assert(!H5F_addr_eq(hdr->man_dtable.table_addr, dblock_addr)); + assert(H5_addr_eq(hdr->man_dtable.table_addr, addr)); + assert(!H5_addr_eq(hdr->man_dtable.table_addr, dblock_addr)); /* Update information about direct block's location */ hdr->man_dtable.table_addr = dblock_addr; @@ -2282,8 +2282,8 @@ H5HF__cache_dblock_pre_serialize(H5F_t *f, void *_thing, haddr_t addr, size_t le /* Sanity checks */ assert(par_iblock); assert(par_iblock->ents); - assert(H5F_addr_eq(par_iblock->ents[par_entry].addr, addr)); - assert(!H5F_addr_eq(par_iblock->ents[par_entry].addr, dblock_addr)); + assert(H5_addr_eq(par_iblock->ents[par_entry].addr, addr)); + assert(!H5_addr_eq(par_iblock->ents[par_entry].addr, dblock_addr)); /* Update information about direct block's location */ par_iblock->ents[par_entry].addr = dblock_addr; @@ -2309,7 +2309,7 @@ H5HF__cache_dblock_pre_serialize(H5F_t *f, void *_thing, haddr_t addr, size_t le dblock->write_size = write_size; /* finally, pass data back to the metadata cache as appropriate */ - if (!H5F_addr_eq(addr, dblock_addr)) { + if (!H5_addr_eq(addr, dblock_addr)) { dblock_flags |= H5AC__SERIALIZE_MOVED_FLAG; *new_addr = dblock_addr; } /* end if */ @@ -2953,7 +2953,7 @@ H5HF__cache_verify_iblock_descendants_clean(H5F_t *f, haddr_t fd_parent_addr, H5 /* Sanity checks */ assert(f); - assert(H5F_addr_defined(fd_parent_addr)); + assert(H5_addr_defined(fd_parent_addr)); assert(iblock); assert(iblock->cache_info.magic == H5C__H5C_CACHE_ENTRY_T_MAGIC); assert(iblock->cache_info.type == H5AC_FHEAP_IBLOCK); @@ -3069,7 +3069,7 @@ H5HF__cache_verify_iblocks_dblocks_clean(H5F_t *f, haddr_t fd_parent_addr, H5HF_ /* Sanity checks */ assert(f); - assert(H5F_addr_defined(fd_parent_addr)); + assert(H5_addr_defined(fd_parent_addr)); assert(iblock); assert(iblock->cache_info.magic == H5C__H5C_CACHE_ENTRY_T_MAGIC); assert(iblock->cache_info.type == H5AC_FHEAP_IBLOCK); @@ -3083,13 +3083,13 @@ H5HF__cache_verify_iblocks_dblocks_clean(H5F_t *f, haddr_t fd_parent_addr, H5HF_ assert(num_direct_rows <= iblock->nrows); max_dblock_index = (num_direct_rows * iblock->hdr->man_dtable.cparam.width) - 1; iblock_addr = iblock->addr; - assert(H5F_addr_defined(iblock_addr)); + assert(H5_addr_defined(iblock_addr)); while ((*fd_clean) && (i <= max_dblock_index)) { haddr_t dblock_addr; dblock_addr = iblock->ents[i].addr; - if (H5F_addr_defined(dblock_addr)) { + if (H5_addr_defined(dblock_addr)) { hbool_t in_cache; hbool_t type_ok; @@ -3231,7 +3231,7 @@ H5HF__cache_verify_descendant_iblocks_clean(H5F_t *f, haddr_t fd_parent_addr, H5 /* Sanity checks */ assert(f); - assert(H5F_addr_defined(fd_parent_addr)); + assert(H5_addr_defined(fd_parent_addr)); assert(iblock); assert(iblock->cache_info.magic == H5C__H5C_CACHE_ENTRY_T_MAGIC); assert(iblock->cache_info.type == H5AC_FHEAP_IBLOCK); @@ -3250,7 +3250,7 @@ H5HF__cache_verify_descendant_iblocks_clean(H5F_t *f, haddr_t fd_parent_addr, H5 while ((*fd_clean) && (i <= last_iblock_index)) { haddr_t child_iblock_addr = iblock->ents[i].addr; - if (H5F_addr_defined(child_iblock_addr)) { + if (H5_addr_defined(child_iblock_addr)) { unsigned child_iblock_status = 0; if (H5AC_get_entry_status(f, child_iblock_addr, &child_iblock_status) < 0) diff --git a/src/H5HFdbg.c b/src/H5HFdbg.c index 0ed3b07..6b75812 100644 --- a/src/H5HFdbg.c +++ b/src/H5HFdbg.c @@ -323,7 +323,7 @@ H5HF_hdr_debug(H5F_t *f, haddr_t addr, FILE *stream, int indent, int fwidth) * Check arguments. */ assert(f); - assert(H5F_addr_defined(addr)); + assert(H5_addr_defined(addr)); assert(stream); assert(indent >= 0); assert(fwidth >= 0); @@ -447,11 +447,11 @@ H5HF_dblock_debug(H5F_t *f, haddr_t addr, FILE *stream, int indent, int fwidth, * Check arguments. */ assert(f); - assert(H5F_addr_defined(addr)); + assert(H5_addr_defined(addr)); assert(stream); assert(indent >= 0); assert(fwidth >= 0); - assert(H5F_addr_defined(hdr_addr)); + assert(H5_addr_defined(hdr_addr)); assert(block_size > 0); /* Load the fractal heap header */ @@ -672,11 +672,11 @@ H5HF_iblock_debug(H5F_t *f, haddr_t addr, FILE *stream, int indent, int fwidth, * Check arguments. */ assert(f); - assert(H5F_addr_defined(addr)); + assert(H5_addr_defined(addr)); assert(stream); assert(indent >= 0); assert(fwidth >= 0); - assert(H5F_addr_defined(hdr_addr)); + assert(H5_addr_defined(hdr_addr)); assert(nrows > 0); /* Load the fractal heap header */ @@ -768,7 +768,7 @@ H5HF_sects_debug(H5F_t *f, haddr_t fh_addr, FILE *stream, int indent, int fwidth * Check arguments. */ assert(f); - assert(H5F_addr_defined(fh_addr)); + assert(H5_addr_defined(fh_addr)); assert(stream); assert(indent >= 0); assert(fwidth >= 0); diff --git a/src/H5HFdblock.c b/src/H5HFdblock.c index d2197f8..d91f963 100644 --- a/src/H5HFdblock.c +++ b/src/H5HFdblock.c @@ -343,7 +343,7 @@ H5HF__man_dblock_new(H5HF_hdr_t *hdr, size_t request, H5HF_free_section_t **ret_ min_dblock_size *= 2; /* Check if this is the first block in the heap */ - if (!H5F_addr_defined(hdr->man_dtable.table_addr) && + if (!H5_addr_defined(hdr->man_dtable.table_addr) && min_dblock_size == hdr->man_dtable.cparam.start_block_size) { /* Create new direct block at starting offset */ if (H5HF__man_dblock_create(hdr, NULL, 0, &dblock_addr, ret_sec_node) < 0) @@ -425,7 +425,7 @@ H5HF__man_dblock_protect(H5HF_hdr_t *hdr, haddr_t dblock_addr, size_t dblock_siz * Check arguments. */ assert(hdr); - assert(H5F_addr_defined(dblock_addr)); + assert(H5_addr_defined(dblock_addr)); assert(dblock_size > 0); /* only H5AC__READ_ONLY_FLAG may appear in flags */ @@ -452,7 +452,7 @@ H5HF__man_dblock_protect(H5HF_hdr_t *hdr, haddr_t dblock_addr, size_t dblock_siz } /* end if */ else { /* Sanity check */ - assert(H5F_addr_eq(par_iblock->ents[par_entry].addr, dblock_addr)); + assert(H5_addr_eq(par_iblock->ents[par_entry].addr, dblock_addr)); /* Set up parameters to read filtered direct block */ udata.odi_size = par_iblock->filt_ents[par_entry].size; @@ -543,7 +543,7 @@ H5HF__man_dblock_locate(H5HF_hdr_t *hdr, hsize_t obj_off, H5HF_indirect_t **ret_ iblock_addr = iblock->ents[entry].addr; /* Check if we need to (re-)create the child indirect block */ - if (!H5F_addr_defined(iblock_addr)) { + if (!H5_addr_defined(iblock_addr)) { if (H5HF__man_iblock_create(hdr, iblock, entry, nrows, nrows, &iblock_addr) < 0) HGOTO_ERROR(H5E_HEAP, H5E_CANTALLOC, FAIL, "can't allocate fractal heap indirect block") @@ -606,7 +606,7 @@ H5HF__man_dblock_delete(H5F_t *f, haddr_t dblock_addr, hsize_t dblock_size) * Check arguments. */ assert(f); - assert(H5F_addr_defined(dblock_addr)); + assert(H5_addr_defined(dblock_addr)); assert(dblock_size > 0); /* Check the direct block's status in the metadata cache */ diff --git a/src/H5HFhdr.c b/src/H5HFhdr.c index 32935ab..ae8266e 100644 --- a/src/H5HFhdr.c +++ b/src/H5HFhdr.c @@ -471,7 +471,7 @@ H5HF__hdr_create(H5F_t *f, const H5HF_create_t *cparam) ret_value = hdr->heap_addr; done: - if (!H5F_addr_defined(ret_value) && hdr) + if (!H5_addr_defined(ret_value) && hdr) if (H5HF__hdr_free(hdr) < 0) HDONE_ERROR(H5E_HEAP, H5E_CANTRELEASE, HADDR_UNDEF, "unable to release fractal heap header") @@ -498,7 +498,7 @@ H5HF__hdr_protect(H5F_t *f, haddr_t addr, unsigned flags) /* Check arguments */ assert(f); - assert(H5F_addr_defined(addr)); + assert(H5_addr_defined(addr)); /* only H5AC__READ_ONLY_FLAG may appear in flags */ assert((flags & (unsigned)(~H5AC__READ_ONLY_FLAG)) == 0); @@ -980,7 +980,7 @@ H5HF__hdr_update_iter(H5HF_hdr_t *hdr, size_t min_dblock_size) if (next_row >= hdr->man_dtable.max_direct_rows) { unsigned child_nrows; /* Number of rows in new indirect block */ - assert(!H5F_addr_defined(iblock->ents[next_entry].addr)); + assert(!H5_addr_defined(iblock->ents[next_entry].addr)); /* Compute # of rows in next child indirect block to use */ child_nrows = @@ -1150,8 +1150,8 @@ H5HF__hdr_reverse_iter(H5HF_hdr_t *hdr, haddr_t dblock_addr) /* Walk backwards through entries, until we find one that has a child */ /* (Skip direct block that will be deleted, if we find it) */ tmp_entry = (int)curr_entry; - while (tmp_entry >= 0 && (H5F_addr_eq(iblock->ents[tmp_entry].addr, dblock_addr) || - !H5F_addr_defined(iblock->ents[tmp_entry].addr))) + while (tmp_entry >= 0 && (H5_addr_eq(iblock->ents[tmp_entry].addr, dblock_addr) || + !H5_addr_defined(iblock->ents[tmp_entry].addr))) tmp_entry--; /* Check for no earlier blocks in this indirect block */ if (tmp_entry < 0) { @@ -1372,13 +1372,13 @@ H5HF__hdr_delete(H5HF_hdr_t *hdr) /* (must occur before attempting to delete the heap, so indirect blocks * will get unpinned) */ - if (H5F_addr_defined(hdr->fs_addr)) + if (H5_addr_defined(hdr->fs_addr)) /* Delete free space manager for heap */ if (H5HF__space_delete(hdr) < 0) HGOTO_ERROR(H5E_HEAP, H5E_CANTFREE, FAIL, "unable to release fractal heap free space manager") /* Check for root direct/indirect block */ - if (H5F_addr_defined(hdr->man_dtable.table_addr)) { + if (H5_addr_defined(hdr->man_dtable.table_addr)) { if (hdr->man_dtable.curr_root_rows == 0) { hsize_t dblock_size; /* Size of direct block on disk */ @@ -1408,7 +1408,7 @@ H5HF__hdr_delete(H5HF_hdr_t *hdr) } /* end if */ /* Check for 'huge' objects in heap */ - if (H5F_addr_defined(hdr->huge_bt2_addr)) { + if (H5_addr_defined(hdr->huge_bt2_addr)) { /* Delete huge objects in heap and their tracker */ if (H5HF__huge_delete(hdr) < 0) HGOTO_ERROR(H5E_HEAP, H5E_CANTFREE, FAIL, diff --git a/src/H5HFhuge.c b/src/H5HFhuge.c index 1d8ec31..a28e367 100644 --- a/src/H5HFhuge.c +++ b/src/H5HFhuge.c @@ -294,7 +294,7 @@ H5HF__huge_insert(H5HF_hdr_t *hdr, size_t obj_size, void *obj, void *_id) assert(id); /* Check if the v2 B-tree for tracking 'huge' heap objects has been created yet */ - if (!H5F_addr_defined(hdr->huge_bt2_addr)) { + if (!H5_addr_defined(hdr->huge_bt2_addr)) { /* Go create (& open) v2 B-tree */ if (H5HF__huge_bt2_create(hdr) < 0) HGOTO_ERROR(H5E_HEAP, H5E_CANTCREATE, FAIL, @@ -372,7 +372,7 @@ H5HF__huge_insert(H5HF_hdr_t *hdr, size_t obj_size, void *obj, void *_id) /* Encode ID for user */ *id++ = H5HF_ID_VERS_CURR | H5HF_ID_TYPE_HUGE; - H5F_addr_encode(hdr->f, &id, obj_addr); + H5_addr_encode(hdr->f, &id, obj_addr); H5F_ENCODE_LENGTH(hdr->f, id, (hsize_t)write_size); UINT32ENCODE(id, filter_mask); H5F_ENCODE_LENGTH(hdr->f, id, (hsize_t)obj_size); @@ -391,7 +391,7 @@ H5HF__huge_insert(H5HF_hdr_t *hdr, size_t obj_size, void *obj, void *_id) /* Encode ID for user */ *id++ = H5HF_ID_VERS_CURR | H5HF_ID_TYPE_HUGE; - H5F_addr_encode(hdr->f, &id, obj_addr); + H5_addr_encode(hdr->f, &id, obj_addr); H5F_ENCODE_LENGTH(hdr->f, id, (hsize_t)write_size); } /* end if */ } /* end if */ @@ -467,7 +467,7 @@ H5HF__huge_get_obj_len(H5HF_hdr_t *hdr, const uint8_t *id, size_t *obj_len_p) * Check arguments. */ assert(hdr); - assert(H5F_addr_defined(hdr->huge_bt2_addr)); + assert(H5_addr_defined(hdr->huge_bt2_addr)); assert(id); assert(obj_len_p); @@ -562,7 +562,7 @@ H5HF__huge_get_obj_off(H5HF_hdr_t *hdr, const uint8_t *id, hsize_t *obj_off_p) * Check arguments. */ assert(hdr); - assert(H5F_addr_defined(hdr->huge_bt2_addr)); + assert(H5_addr_defined(hdr->huge_bt2_addr)); assert(id); assert(obj_off_p); @@ -572,13 +572,13 @@ H5HF__huge_get_obj_off(H5HF_hdr_t *hdr, const uint8_t *id, hsize_t *obj_off_p) /* Check if 'huge' object ID encodes address & length directly */ if (hdr->huge_ids_direct) { /* Retrieve the object's address (common) */ - H5F_addr_decode(hdr->f, &id, &obj_addr); + H5_addr_decode(hdr->f, &id, &obj_addr); } /* end if */ else { hbool_t found = FALSE; /* Whether entry was found */ /* Sanity check */ - assert(H5F_addr_defined(hdr->huge_bt2_addr)); + assert(H5_addr_defined(hdr->huge_bt2_addr)); /* Check if v2 B-tree is open yet */ if (NULL == hdr->huge_bt2) { @@ -663,7 +663,7 @@ H5HF__huge_op_real(H5HF_hdr_t *hdr, const uint8_t *id, hbool_t is_read, H5HF_ope /* Check for 'huge' object ID that encodes address & length directly */ if (hdr->huge_ids_direct) { /* Retrieve the object's address and length (common) */ - H5F_addr_decode(hdr->f, &id, &obj_addr); + H5_addr_decode(hdr->f, &id, &obj_addr); H5F_DECODE_LENGTH(hdr->f, id, obj_size); /* Retrieve extra information needed for filtered objects */ @@ -674,7 +674,7 @@ H5HF__huge_op_real(H5HF_hdr_t *hdr, const uint8_t *id, hbool_t is_read, H5HF_ope hbool_t found = FALSE; /* Whether entry was found */ /* Sanity check */ - assert(H5F_addr_defined(hdr->huge_bt2_addr)); + assert(H5_addr_defined(hdr->huge_bt2_addr)); /* Check if v2 B-tree is open yet */ if (NULL == hdr->huge_bt2) { @@ -822,7 +822,7 @@ H5HF__huge_write(H5HF_hdr_t *hdr, const uint8_t *id, const void *obj) /* Check for 'huge' object ID that encodes address & length directly */ if (hdr->huge_ids_direct) { /* Retrieve the object's address and length (common) */ - H5F_addr_decode(hdr->f, &id, &obj_addr); + H5_addr_decode(hdr->f, &id, &obj_addr); H5F_DECODE_LENGTH(hdr->f, id, obj_size); } /* end if */ else { @@ -831,7 +831,7 @@ H5HF__huge_write(H5HF_hdr_t *hdr, const uint8_t *id, const void *obj) hbool_t found = FALSE; /* Whether entry was found */ /* Sanity check */ - assert(H5F_addr_defined(hdr->huge_bt2_addr)); + assert(H5_addr_defined(hdr->huge_bt2_addr)); /* Check if v2 B-tree is open yet */ if (NULL == hdr->huge_bt2) { @@ -947,7 +947,7 @@ H5HF__huge_remove(H5HF_hdr_t *hdr, const uint8_t *id) * Check arguments. */ assert(hdr); - assert(H5F_addr_defined(hdr->huge_bt2_addr)); + assert(H5_addr_defined(hdr->huge_bt2_addr)); assert(id); /* Check if v2 B-tree is open yet */ @@ -971,7 +971,7 @@ H5HF__huge_remove(H5HF_hdr_t *hdr, const uint8_t *id) /* Retrieve the object's address and length */ /* (used as key in v2 B-tree record) */ - H5F_addr_decode(hdr->f, &id, &search_rec.addr); + H5_addr_decode(hdr->f, &id, &search_rec.addr); H5F_DECODE_LENGTH(hdr->f, id, search_rec.len); /* Remove the record for tracking the 'huge' object from the v2 B-tree */ @@ -984,7 +984,7 @@ H5HF__huge_remove(H5HF_hdr_t *hdr, const uint8_t *id) /* Retrieve the object's address and length */ /* (used as key in v2 B-tree record) */ - H5F_addr_decode(hdr->f, &id, &search_rec.addr); + H5_addr_decode(hdr->f, &id, &search_rec.addr); H5F_DECODE_LENGTH(hdr->f, id, search_rec.len); /* Remove the record for tracking the 'huge' object from the v2 B-tree */ @@ -1054,7 +1054,7 @@ H5HF__huge_term(H5HF_hdr_t *hdr) /* Check if v2 B-tree index is open */ if (hdr->huge_bt2) { /* Sanity check */ - assert(H5F_addr_defined(hdr->huge_bt2_addr)); + assert(H5_addr_defined(hdr->huge_bt2_addr)); /* Close v2 B-tree index */ if (H5B2_close(hdr->huge_bt2) < 0) @@ -1065,7 +1065,7 @@ H5HF__huge_term(H5HF_hdr_t *hdr) /* Check if there are no more 'huge' objects in the heap and delete the * v2 B-tree that tracks them, if so */ - if (H5F_addr_defined(hdr->huge_bt2_addr) && hdr->huge_nobjs == 0) { + if (H5_addr_defined(hdr->huge_bt2_addr) && hdr->huge_nobjs == 0) { /* Sanity check */ assert(hdr->huge_size == 0); @@ -1111,7 +1111,7 @@ H5HF__huge_delete(H5HF_hdr_t *hdr) * Check arguments. */ assert(hdr); - assert(H5F_addr_defined(hdr->huge_bt2_addr)); + assert(H5_addr_defined(hdr->huge_bt2_addr)); assert(hdr->huge_nobjs); assert(hdr->huge_size); diff --git a/src/H5HFiblock.c b/src/H5HFiblock.c index c1bb849..fd23698 100644 --- a/src/H5HFiblock.c +++ b/src/H5HFiblock.c @@ -357,7 +357,7 @@ H5HF__man_iblock_root_create(H5HF_hdr_t *hdr, size_t min_dblock_size) HGOTO_ERROR(H5E_HEAP, H5E_CANTPROTECT, FAIL, "unable to protect fractal heap indirect block") /* Check if there's already a direct block as root) */ - have_direct_block = H5F_addr_defined(hdr->man_dtable.table_addr); + have_direct_block = H5_addr_defined(hdr->man_dtable.table_addr); if (have_direct_block) { H5HF_direct_t *dblock; /* Pointer to direct block to query */ @@ -539,7 +539,7 @@ H5HF__man_iblock_root_double(H5HF_hdr_t *hdr, size_t min_dblock_size) } /* end if */ /* Move object in cache, if it actually was relocated */ - if (H5F_addr_ne(iblock->addr, new_addr)) { + if (H5_addr_ne(iblock->addr, new_addr)) { if (H5AC_move_entry(hdr->f, H5AC_FHEAP_IBLOCK, iblock->addr, new_addr) < 0) HGOTO_ERROR(H5E_HEAP, H5E_CANTMOVE, FAIL, "unable to move fractal heap root indirect block") iblock->addr = new_addr; @@ -700,7 +700,7 @@ H5HF__man_iblock_root_halve(H5HF_indirect_t *iblock) } /* end if */ /* Move object in cache, if it actually was relocated */ - if (H5F_addr_ne(iblock->addr, new_addr)) { + if (H5_addr_ne(iblock->addr, new_addr)) { if (H5AC_move_entry(hdr->f, H5AC_FHEAP_IBLOCK, iblock->addr, new_addr) < 0) HGOTO_ERROR(H5E_HEAP, H5E_CANTSPLIT, FAIL, "unable to move fractal heap root indirect block") iblock->addr = new_addr; @@ -1081,7 +1081,7 @@ H5HF__man_iblock_protect(H5HF_hdr_t *hdr, haddr_t iblock_addr, unsigned iblock_n * Check arguments. */ assert(hdr); - assert(H5F_addr_defined(iblock_addr)); + assert(H5_addr_defined(iblock_addr)); assert(iblock_nrows > 0); assert(did_protect); @@ -1109,7 +1109,7 @@ H5HF__man_iblock_protect(H5HF_hdr_t *hdr, haddr_t iblock_addr, unsigned iblock_n } /* end if */ else { /* Check for root indirect block */ - if (H5F_addr_eq(iblock_addr, hdr->man_dtable.table_addr)) { + if (H5_addr_eq(iblock_addr, hdr->man_dtable.table_addr)) { /* Check for valid pointer to pinned indirect block in root */ if (H5HF_ROOT_IBLOCK_PINNED == hdr->root_iblock_flags) { /* Sanity check */ @@ -1249,8 +1249,8 @@ H5HF__man_iblock_attach(H5HF_indirect_t *iblock, unsigned entry, haddr_t child_a * Check arguments. */ assert(iblock); - assert(H5F_addr_defined(child_addr)); - assert(!H5F_addr_defined(iblock->ents[entry].addr)); + assert(H5_addr_defined(child_addr)); + assert(!H5_addr_defined(iblock->ents[entry].addr)); /* Increment the reference count on this indirect block */ if (H5HF__iblock_incr(iblock) < 0) @@ -1362,7 +1362,7 @@ H5HF__man_iblock_detach(H5HF_indirect_t *iblock, unsigned entry) /* Reduce the max. entry used, if necessary */ if (entry == iblock->max_child) { if (iblock->nchildren > 0) - while (!H5F_addr_defined(iblock->ents[iblock->max_child].addr)) + while (!H5_addr_defined(iblock->ents[iblock->max_child].addr)) iblock->max_child--; else iblock->max_child = 0; @@ -1374,7 +1374,7 @@ H5HF__man_iblock_detach(H5HF_indirect_t *iblock, unsigned entry) * direct block in the heap, convert the heap back to using a root * direct block */ - if (iblock->nchildren == 1 && H5F_addr_defined(iblock->ents[0].addr)) + if (iblock->nchildren == 1 && H5_addr_defined(iblock->ents[0].addr)) if (H5HF__man_iblock_root_revert(iblock) < 0) HGOTO_ERROR(H5E_HEAP, H5E_CANTSHRINK, FAIL, "can't convert root indirect block back to root direct block") @@ -1559,7 +1559,7 @@ H5HF__man_iblock_delete(H5HF_hdr_t *hdr, haddr_t iblock_addr, unsigned iblock_nr * Check arguments. */ assert(hdr); - assert(H5F_addr_defined(iblock_addr)); + assert(H5_addr_defined(iblock_addr)); assert(iblock_nrows > 0); /* Lock indirect block */ @@ -1575,7 +1575,7 @@ H5HF__man_iblock_delete(H5HF_hdr_t *hdr, haddr_t iblock_addr, unsigned iblock_nr /* Iterate over entries in this row */ for (col = 0; col < hdr->man_dtable.cparam.width; col++, entry++) { /* Check for child entry at this position */ - if (H5F_addr_defined(iblock->ents[entry].addr)) { + if (H5_addr_defined(iblock->ents[entry].addr)) { /* Are we in a direct or indirect block row */ if (row < hdr->man_dtable.max_direct_rows) { hsize_t dblock_size; /* Size of direct block on disk */ @@ -1667,7 +1667,7 @@ H5HF__man_iblock_size(H5F_t *f, H5HF_hdr_t *hdr, haddr_t iblock_addr, unsigned n */ assert(f); assert(hdr); - assert(H5F_addr_defined(iblock_addr)); + assert(H5_addr_defined(iblock_addr)); assert(heap_size); /* Protect the indirect block */ @@ -1695,7 +1695,7 @@ H5HF__man_iblock_size(H5F_t *f, H5HF_hdr_t *hdr, haddr_t iblock_addr, unsigned n size_t v; /* Local index variable */ for (v = 0; v < hdr->man_dtable.cparam.width; v++, entry++) - if (H5F_addr_defined(iblock->ents[entry].addr)) + if (H5_addr_defined(iblock->ents[entry].addr)) if (H5HF__man_iblock_size(f, hdr, iblock->ents[entry].addr, num_indirect_rows, iblock, entry, heap_size) < 0) HGOTO_ERROR(H5E_HEAP, H5E_CANTLOAD, FAIL, diff --git a/src/H5HFman.c b/src/H5HFman.c index 5d3360f..b52e0fc 100644 --- a/src/H5HFman.c +++ b/src/H5HFman.c @@ -359,7 +359,7 @@ H5HF__man_op_real(H5HF_hdr_t *hdr, const uint8_t *id, H5HF_operator_t op, void * dblock_size = (size_t)hdr->man_dtable.row_block_size[entry / hdr->man_dtable.cparam.width]; /* Check for offset of invalid direct block */ - if (!H5F_addr_defined(dblock_addr)) { + if (!H5_addr_defined(dblock_addr)) { /* Unlock indirect block */ if (H5HF__man_iblock_unprotect(iblock, H5AC__NO_FLAGS_SET, did_protect) < 0) HGOTO_ERROR(H5E_HEAP, H5E_CANTUNPROTECT, FAIL, @@ -579,7 +579,7 @@ H5HF__man_remove(H5HF_hdr_t *hdr, const uint8_t *id) HGOTO_ERROR(H5E_HEAP, H5E_CANTCOMPUTE, FAIL, "can't compute row & column of section") /* Check for offset of invalid direct block */ - if (!H5F_addr_defined(iblock->ents[dblock_entry].addr)) + if (!H5_addr_defined(iblock->ents[dblock_entry].addr)) HGOTO_ERROR(H5E_HEAP, H5E_BADRANGE, FAIL, "fractal heap ID not in allocated direct block") /* Set direct block info */ diff --git a/src/H5HFsection.c b/src/H5HFsection.c index 3949eea..a31bcda 100644 --- a/src/H5HFsection.c +++ b/src/H5HFsection.c @@ -364,7 +364,7 @@ H5FS__sect_node_new(unsigned sect_type, haddr_t sect_addr, hsize_t sect_size, H5 FUNC_ENTER_PACKAGE /* Check arguments. */ - assert(H5F_addr_defined(sect_addr)); + assert(H5_addr_defined(sect_addr)); /* Create free list section node */ if (NULL == (new_sect = H5FL_MALLOC(H5HF_free_section_t))) @@ -551,7 +551,7 @@ H5HF__sect_single_revive(H5HF_hdr_t *hdr, H5HF_free_section_t *sect) /* Check for root direct block */ if (hdr->man_dtable.curr_root_rows == 0) { /* Set the information for the section */ - assert(H5F_addr_defined(hdr->man_dtable.table_addr)); + assert(H5_addr_defined(hdr->man_dtable.table_addr)); sect->u.single.parent = NULL; sect->u.single.par_entry = 0; } /* end if */ @@ -596,7 +596,7 @@ H5HF__sect_single_dblock_info(H5HF_hdr_t *hdr, const H5HF_free_section_t *sect, /* Check for root direct block */ if (hdr->man_dtable.curr_root_rows == 0) { /* Retrieve direct block info from heap header */ - assert(H5F_addr_defined(hdr->man_dtable.table_addr)); + assert(H5_addr_defined(hdr->man_dtable.table_addr)); *dblock_addr = hdr->man_dtable.table_addr; *dblock_size = hdr->man_dtable.cparam.start_block_size; } /* end if */ @@ -699,7 +699,7 @@ H5HF__sect_single_full_dblock(H5HF_hdr_t *hdr, H5HF_free_section_t *sect) if (NULL == (dblock = H5HF__man_dblock_protect(hdr, dblock_addr, dblock_size, sect->u.single.parent, sect->u.single.par_entry, H5AC__NO_FLAGS_SET))) HGOTO_ERROR(H5E_HEAP, H5E_CANTPROTECT, FAIL, "unable to load fractal heap direct block") - assert(H5F_addr_eq(dblock->block_off + dblock_overhead, sect->sect_info.addr)); + assert(H5_addr_eq(dblock->block_off + dblock_overhead, sect->sect_info.addr)); /* Convert 'single' section into 'row' section */ if (H5HF__sect_row_from_single(hdr, sect, dblock) < 0) @@ -790,7 +790,7 @@ H5HF__sect_single_deserialize(const H5FS_section_class_t H5_ATTR_UNUSED *cls, FUNC_ENTER_PACKAGE /* Check arguments. */ - assert(H5F_addr_defined(sect_addr)); + assert(H5_addr_defined(sect_addr)); assert(sect_size); /* Create free list section node */ @@ -832,14 +832,14 @@ H5HF__sect_single_can_merge(const H5FS_section_info_t *_sect1, const H5FS_sectio assert(sect1); assert(sect2); assert(sect1->sect_info.type == sect2->sect_info.type); /* Checks "MERGE_SYM" flag */ - assert(H5F_addr_lt(sect1->sect_info.addr, sect2->sect_info.addr)); + assert(H5_addr_lt(sect1->sect_info.addr, sect2->sect_info.addr)); /* Check if second section adjoins first section */ /* (This can only occur within a direct block, due to the direct block * overhead at the beginning of a block, so no need to check if sections * are actually within the same direct block) */ - if (H5F_addr_eq(sect1->sect_info.addr + sect1->sect_info.size, sect2->sect_info.addr)) + if (H5_addr_eq(sect1->sect_info.addr + sect1->sect_info.size, sect2->sect_info.addr)) HGOTO_DONE(TRUE) done: @@ -875,7 +875,7 @@ H5HF__sect_single_merge(H5FS_section_info_t **_sect1, H5FS_section_info_t *_sect assert((*sect1)->sect_info.type == H5HF_FSPACE_SECT_SINGLE); assert(sect2); assert(sect2->sect_info.type == H5HF_FSPACE_SECT_SINGLE); - assert(H5F_addr_eq((*sect1)->sect_info.addr + (*sect1)->sect_info.size, sect2->sect_info.addr)); + assert(H5_addr_eq((*sect1)->sect_info.addr + (*sect1)->sect_info.size, sect2->sect_info.addr)); /* Add second section's size to first section */ (*sect1)->sect_info.size += sect2->sect_info.size; @@ -997,7 +997,7 @@ H5HF__sect_single_shrink(H5FS_section_info_t **_sect, void *_udata) if (NULL == (dblock = H5HF__man_dblock_protect(hdr, dblock_addr, dblock_size, (*sect)->u.single.parent, (*sect)->u.single.par_entry, H5AC__NO_FLAGS_SET))) HGOTO_ERROR(H5E_HEAP, H5E_CANTPROTECT, FAIL, "unable to load fractal heap direct block") - assert(H5F_addr_eq(dblock->block_off + dblock_size, (*sect)->sect_info.addr + (*sect)->sect_info.size)); + assert(H5_addr_eq(dblock->block_off + dblock_size, (*sect)->sect_info.addr + (*sect)->sect_info.size)); /* Get rid of section */ if (H5HF__sect_single_free((H5FS_section_info_t *)*sect) < 0) @@ -1085,13 +1085,13 @@ H5HF__sect_single_valid(const H5FS_section_class_t H5_ATTR_UNUSED *cls, const H5 /* Sanity check settings for section's direct block's parent */ iblock = sect->u.single.parent; - assert(H5F_addr_defined(iblock->ents[sect->u.single.par_entry].addr)); + assert(H5_addr_defined(iblock->ents[sect->u.single.par_entry].addr)); /* Retrieve direct block address from section */ status = H5HF__sect_single_dblock_info(iblock->hdr, (const H5HF_free_section_t *)sect, &dblock_addr, &dblock_size); assert(status >= 0); - assert(H5F_addr_eq(iblock->ents[sect->u.single.par_entry].addr, dblock_addr)); + assert(H5_addr_eq(iblock->ents[sect->u.single.par_entry].addr, dblock_addr)); assert(dblock_size > 0); /* Check if the section is actually within the heap */ @@ -1120,9 +1120,9 @@ H5HF__sect_single_valid(const H5FS_section_class_t H5_ATTR_UNUSED *cls, const H5 /* Sanity check settings for section */ assert(dblock_size == dblock->size); assert(dblock->size > sect->sect_info.size); - assert(H5F_addr_lt(dblock->block_off, sect->sect_info.addr)); - assert(H5F_addr_ge((dblock->block_off + dblock->size), - (sect->sect_info.addr + sect->sect_info.size))); + assert(H5_addr_lt(dblock->block_off, sect->sect_info.addr)); + assert(H5_addr_ge((dblock->block_off + dblock->size), + (sect->sect_info.addr + sect->sect_info.size))); /* Release direct block */ status = H5AC_unprotect(iblock->hdr->f, H5AC_FHEAP_DBLOCK, dblock_addr, dblock, @@ -1585,7 +1585,7 @@ H5HF__sect_row_deserialize(const H5FS_section_class_t *cls, const uint8_t *buf, /* Check arguments. */ assert(cls); assert(buf); - assert(H5F_addr_defined(sect_addr)); + assert(H5_addr_defined(sect_addr)); assert(sect_size); /* Forward to indirect routine to deserialize underlying section */ @@ -1627,7 +1627,7 @@ H5HF__sect_row_can_merge(const H5FS_section_info_t *_sect1, const H5FS_section_i assert(sect1->sect_info.type == H5HF_FSPACE_SECT_FIRST_ROW); assert(sect2); assert(sect1->sect_info.type == sect2->sect_info.type); /* Checks "MERGE_SYM" flag */ - assert(H5F_addr_lt(sect1->sect_info.addr, sect2->sect_info.addr)); + assert(H5_addr_lt(sect1->sect_info.addr, sect2->sect_info.addr)); /* Get the top indirect section underlying each row */ top_indir_sect1 = H5HF__sect_indirect_top(sect1->u.row.under); @@ -1643,8 +1643,8 @@ H5HF__sect_row_can_merge(const H5FS_section_info_t *_sect1, const H5FS_section_i if (H5HF__sect_indirect_iblock_off(sect1->u.row.under) == H5HF__sect_indirect_iblock_off(sect2->u.row.under)) /* Check if second section adjoins first section */ - if (H5F_addr_eq((top_indir_sect1->sect_info.addr + top_indir_sect1->u.indirect.span_size), - top_indir_sect2->sect_info.addr)) + if (H5_addr_eq((top_indir_sect1->sect_info.addr + top_indir_sect1->u.indirect.span_size), + top_indir_sect2->sect_info.addr)) HGOTO_DONE(TRUE) done: @@ -2351,7 +2351,7 @@ H5HF__sect_indirect_init_rows(H5HF_hdr_t *hdr, H5HF_free_section_t *sect, hbool_ "unable to retrieve child indirect block's address") /* If the child indirect block's address is defined, protect it */ - if (H5F_addr_defined(child_iblock_addr)) { + if (H5_addr_defined(child_iblock_addr)) { if (NULL == (child_iblock = H5HF__man_iblock_protect( hdr, child_iblock_addr, child_nrows, sect->u.indirect.u.iblock, curr_entry, FALSE, H5AC__NO_FLAGS_SET, &did_protect))) @@ -3702,7 +3702,7 @@ H5HF__sect_indirect_deserialize(H5HF_hdr_t *hdr, const uint8_t *buf, haddr_t sec /* Check arguments. */ assert(hdr); assert(buf); - assert(H5F_addr_defined(sect_addr)); + assert(H5_addr_defined(sect_addr)); assert(sect_size); /* Indirect range's indirect block's block offset */ @@ -3849,7 +3849,7 @@ H5HF__sect_indirect_valid(const H5HF_hdr_t *hdr, const H5HF_free_section_t *sect tmp_row_sect2 = sect->u.indirect.dir_rows[u - 1]; assert(tmp_row_sect2->u.row.row < tmp_row_sect->u.row.row); - assert(H5F_addr_lt(tmp_row_sect2->sect_info.addr, tmp_row_sect->sect_info.addr)); + assert(H5_addr_lt(tmp_row_sect2->sect_info.addr, tmp_row_sect->sect_info.addr)); assert(tmp_row_sect2->sect_info.size <= tmp_row_sect->sect_info.size); } /* end if */ } /* end for */ @@ -3876,7 +3876,7 @@ H5HF__sect_indirect_valid(const H5HF_hdr_t *hdr, const H5HF_free_section_t *sect *tmp_child_sect2; /* Pointer to child indirect section */ tmp_child_sect2 = sect->u.indirect.indir_ents[u - 1]; - assert(H5F_addr_lt(tmp_child_sect2->sect_info.addr, tmp_child_sect->sect_info.addr)); + assert(H5_addr_lt(tmp_child_sect2->sect_info.addr, tmp_child_sect->sect_info.addr)); } /* end if */ /* Recursively check child indirect section */ diff --git a/src/H5HFspace.c b/src/H5HFspace.c index e2d9ab3..bdc0034 100644 --- a/src/H5HFspace.c +++ b/src/H5HFspace.c @@ -94,7 +94,7 @@ H5HF__space_start(H5HF_hdr_t *hdr, hbool_t may_create) assert(hdr); /* Check for creating free space info for the heap */ - if (H5F_addr_defined(hdr->fs_addr)) { + if (H5_addr_defined(hdr->fs_addr)) { /* Open an existing free space structure for the heap */ if (NULL == (hdr->fspace = H5FS_open(hdr->f, hdr->fs_addr, NELMTS(classes), classes, hdr, (hsize_t)H5HF_FSPACE_THRHD_DEF, (hsize_t)H5HF_FSPACE_ALIGN_DEF))) @@ -117,7 +117,7 @@ H5HF__space_start(H5HF_hdr_t *hdr, hbool_t may_create) (hdr->fspace = H5FS_create(hdr->f, &hdr->fs_addr, &fs_create, NELMTS(classes), classes, hdr, (hsize_t)H5HF_FSPACE_THRHD_DEF, (hsize_t)H5HF_FSPACE_ALIGN_DEF))) HGOTO_ERROR(H5E_HEAP, H5E_CANTINIT, FAIL, "can't initialize free space info") - assert(H5F_addr_defined(hdr->fs_addr)); + assert(H5_addr_defined(hdr->fs_addr)); } /* end if */ } /* end else */ diff --git a/src/H5HFstat.c b/src/H5HFstat.c index ac2f580..2899f86 100644 --- a/src/H5HFstat.c +++ b/src/H5HFstat.c @@ -128,14 +128,14 @@ H5HF_size(const H5HF_t *fh, hsize_t *heap_size) *heap_size += hdr->huge_size; /* "huge" object storage */ /* Check for indirect blocks for managed objects */ - if (H5F_addr_defined(hdr->man_dtable.table_addr) && hdr->man_dtable.curr_root_rows != 0) + if (H5_addr_defined(hdr->man_dtable.table_addr) && hdr->man_dtable.curr_root_rows != 0) if (H5HF__man_iblock_size(hdr->f, hdr, hdr->man_dtable.table_addr, hdr->man_dtable.curr_root_rows, NULL, 0, heap_size) < 0) HGOTO_ERROR(H5E_HEAP, H5E_CANTGET, FAIL, "unable to get fractal heap storage info for indirect block") /* Check for B-tree storage of huge objects in fractal heap */ - if (H5F_addr_defined(hdr->huge_bt2_addr)) { + if (H5_addr_defined(hdr->huge_bt2_addr)) { /* Open the huge object index v2 B-tree */ if (NULL == (bt2 = H5B2_open(hdr->f, hdr->huge_bt2_addr, hdr->f))) HGOTO_ERROR(H5E_HEAP, H5E_CANTOPENOBJ, FAIL, @@ -147,7 +147,7 @@ H5HF_size(const H5HF_t *fh, hsize_t *heap_size) } /* end if */ /* Get storage for free-space tracking info */ - if (H5F_addr_defined(hdr->fs_addr)) { + if (H5_addr_defined(hdr->fs_addr)) { if (H5HF__space_size(hdr, &meta_size) < 0) HGOTO_ERROR(H5E_HEAP, H5E_CANTGET, FAIL, "can't retrieve FS meta storage info") *heap_size += meta_size; diff --git a/src/H5HG.c b/src/H5HG.c index 1d8bf81..a9b3431 100644 --- a/src/H5HG.c +++ b/src/H5HG.c @@ -196,8 +196,8 @@ H5HG__create(H5F_t *f, size_t size) done: /* Cleanup on error */ - if (!H5F_addr_defined(ret_value)) { - if (H5F_addr_defined(addr)) { + if (!H5_addr_defined(ret_value)) { + if (H5_addr_defined(addr)) { /* Release the space on disk */ if (H5MF_xfree(f, H5FD_MEM_GHEAP, addr, (hsize_t)size) < 0) HDONE_ERROR(H5E_BTREE, H5E_CANTFREE, HADDR_UNDEF, "unable to free global heap") @@ -233,7 +233,7 @@ H5HG__protect(H5F_t *f, haddr_t addr, unsigned flags) /* Check arguments */ assert(f); - assert(H5F_addr_defined(addr)); + assert(H5_addr_defined(addr)); /* only H5AC__READ_ONLY_FLAG may appear in flags */ assert((flags & (unsigned)(~H5AC__READ_ONLY_FLAG)) == 0); @@ -400,7 +400,7 @@ H5HG_extend(H5F_t *f, haddr_t addr, size_t need) /* Check args */ assert(f); - assert(H5F_addr_defined(addr)); + assert(H5_addr_defined(addr)); /* Protect the heap */ if (NULL == (heap = H5HG__protect(f, addr, H5AC__NO_FLAGS_SET))) @@ -503,13 +503,13 @@ H5HG_insert(H5F_t *f, size_t size, const void *obj, H5HG_t *hobj /*out*/) * If we didn't find any collection with enough free space then allocate a * new collection large enough for the message plus the collection header. */ - if (!H5F_addr_defined(addr)) { + if (!H5_addr_defined(addr)) { addr = H5HG__create(f, need + H5HG_SIZEOF_HDR(f)); - if (!H5F_addr_defined(addr)) + if (!H5_addr_defined(addr)) HGOTO_ERROR(H5E_HEAP, H5E_CANTINIT, FAIL, "unable to allocate a global heap collection") } /* end if */ - assert(H5F_addr_defined(addr)); + assert(H5_addr_defined(addr)); if (NULL == (heap = H5HG__protect(f, addr, H5AC__NO_FLAGS_SET))) HGOTO_ERROR(H5E_HEAP, H5E_CANTPROTECT, FAIL, "unable to protect global heap") diff --git a/src/H5HGdbg.c b/src/H5HGdbg.c index 39c8bf4..3245e6f 100644 --- a/src/H5HGdbg.c +++ b/src/H5HGdbg.c @@ -79,7 +79,7 @@ H5HG_debug(H5F_t *f, haddr_t addr, FILE *stream, int indent, int fwidth) /* check arguments */ assert(f); - assert(H5F_addr_defined(addr)); + assert(H5_addr_defined(addr)); assert(stream); assert(indent >= 0); assert(fwidth >= 0); diff --git a/src/H5HL.c b/src/H5HL.c index 6b4f6e5..88e2dee 100644 --- a/src/H5HL.c +++ b/src/H5HL.c @@ -161,7 +161,7 @@ done: } else { if (heap) { - if (H5F_addr_defined(heap->prfx_addr)) + if (H5_addr_defined(heap->prfx_addr)) if (FAIL == H5MF_xfree(f, H5FD_MEM_LHEAP, heap->prfx_addr, total_size)) HDONE_ERROR(H5E_HEAP, H5E_CANTFREE, FAIL, "can't release heap data?"); if (FAIL == H5HL__dest(heap)) @@ -306,7 +306,7 @@ H5HL_protect(H5F_t *f, haddr_t addr, unsigned flags) /* Check arguments */ assert(f); - assert(H5F_addr_defined(addr)); + assert(H5_addr_defined(addr)); /* Only the H5AC__READ_ONLY_FLAG may appear in flags */ assert((flags & (unsigned)(~H5AC__READ_ONLY_FLAG)) == 0); @@ -874,7 +874,7 @@ H5HL_delete(H5F_t *f, haddr_t addr) /* Check arguments */ assert(f); - assert(H5F_addr_defined(addr)); + assert(H5_addr_defined(addr)); /* Construct the user data for protect callback */ prfx_udata.sizeof_size = H5F_SIZEOF_SIZE(f); @@ -933,7 +933,7 @@ H5HL_get_size(H5F_t *f, haddr_t addr, size_t *size) /* Check arguments */ assert(f); - assert(H5F_addr_defined(addr)); + assert(H5_addr_defined(addr)); assert(size); /* Construct the user data for protect callback */ @@ -982,7 +982,7 @@ H5HL_heapsize(H5F_t *f, haddr_t addr, hsize_t *heap_size) /* Check arguments */ assert(f); - assert(H5F_addr_defined(addr)); + assert(H5_addr_defined(addr)); assert(heap_size); /* Construct the user data for protect callback */ diff --git a/src/H5HLcache.c b/src/H5HLcache.c index 73dce73..66c4f8f 100644 --- a/src/H5HLcache.c +++ b/src/H5HLcache.c @@ -190,7 +190,7 @@ H5HL__hdr_deserialize(H5HL_t *heap, const uint8_t *image, size_t len, H5HL_cache /* Heap data address */ if (H5_IS_BUFFER_OVERFLOW(image, udata->sizeof_addr, p_end)) HGOTO_ERROR(H5E_HEAP, H5E_OVERFLOW, FAIL, "ran off end of input buffer while decoding"); - H5F_addr_decode_len(udata->sizeof_addr, &image, &(heap->dblk_addr)); + H5_addr_decode_len(udata->sizeof_addr, &image, &(heap->dblk_addr)); done: FUNC_LEAVE_NOAPI(ret_value) @@ -365,7 +365,7 @@ H5HL__cache_prefix_get_final_load_size(const void *_image, size_t image_len, voi /* Check if heap block exists */ if (heap.dblk_size) /* Check if heap data block is contiguous with header */ - if (H5F_addr_eq((heap.prfx_addr + heap.prfx_size), heap.dblk_addr)) + if (H5_addr_eq((heap.prfx_addr + heap.prfx_size), heap.dblk_addr)) /* Note that the heap should be a single object in the cache */ *actual_len += heap.dblk_size; @@ -404,7 +404,7 @@ H5HL__cache_prefix_deserialize(const void *_image, size_t len, void *_udata, hbo assert(udata->sizeof_size > 0); assert(udata->sizeof_addr > 0); assert(udata->sizeof_prfx > 0); - assert(H5F_addr_defined(udata->prfx_addr)); + assert(H5_addr_defined(udata->prfx_addr)); assert(dirty); /* Allocate space in memory for the heap */ @@ -422,7 +422,7 @@ H5HL__cache_prefix_deserialize(const void *_image, size_t len, void *_udata, hbo /* Check if heap block exists */ if (heap->dblk_size) { /* Check if heap data block is contiguous with header */ - if (H5F_addr_eq((heap->prfx_addr + heap->prfx_size), heap->dblk_addr)) { + if (H5_addr_eq((heap->prfx_addr + heap->prfx_size), heap->dblk_addr)) { /* Note that the heap should be a single object in the cache */ heap->single_cache_obj = TRUE; @@ -535,7 +535,7 @@ H5HL__cache_prefix_serialize(const H5_ATTR_NDEBUG_UNUSED H5F_t *f, void *_image, assert(prfx); assert(prfx->cache_info.magic == H5C__H5C_CACHE_ENTRY_T_MAGIC); assert(prfx->cache_info.type == H5AC_LHEAP_PRFX); - assert(H5F_addr_eq(prfx->cache_info.addr, prfx->heap->prfx_addr)); + assert(H5_addr_eq(prfx->cache_info.addr, prfx->heap->prfx_addr)); assert(prfx->heap); /* Get the pointer to the heap */ @@ -562,7 +562,7 @@ H5HL__cache_prefix_serialize(const H5_ATTR_NDEBUG_UNUSED H5F_t *f, void *_image, *image++ = 0; /*reserved*/ H5F_ENCODE_LENGTH_LEN(image, heap->dblk_size, heap->sizeof_size); H5F_ENCODE_LENGTH_LEN(image, heap->free_block, heap->sizeof_size); - H5F_addr_encode_len(heap->sizeof_addr, &image, heap->dblk_addr); + H5_addr_encode_len(heap->sizeof_addr, &image, heap->dblk_addr); /* Check if the local heap is a single object in cache */ if (heap->single_cache_obj) { @@ -629,7 +629,7 @@ H5HL__cache_prefix_free_icr(void *_thing) assert(prfx); assert(prfx->cache_info.magic == H5C__H5C_CACHE_ENTRY_T_BAD_MAGIC); assert(prfx->cache_info.type == H5AC_LHEAP_PRFX); - assert(H5F_addr_eq(prfx->cache_info.addr, prfx->heap->prfx_addr)); + assert(H5_addr_eq(prfx->cache_info.addr, prfx->heap->prfx_addr)); /* Destroy local heap prefix */ if (H5HL__prfx_dest(prfx) < 0) diff --git a/src/H5HLdbg.c b/src/H5HLdbg.c index d32621e..7f6bff1 100644 --- a/src/H5HLdbg.c +++ b/src/H5HLdbg.c @@ -52,7 +52,7 @@ H5HL_debug(H5F_t *f, haddr_t addr, FILE *stream, int indent, int fwidth) /* check arguments */ assert(f); - assert(H5F_addr_defined(addr)); + assert(H5_addr_defined(addr)); assert(stream); assert(indent >= 0); assert(fwidth >= 0); diff --git a/src/H5HLdblk.c b/src/H5HLdblk.c index b4c34cf..6b3557a 100644 --- a/src/H5HLdblk.c +++ b/src/H5HLdblk.c @@ -191,11 +191,11 @@ H5HL__dblk_realloc(H5F_t *f, H5HL_t *heap, size_t new_heap_size) heap->dblk_size = new_heap_size; /* Check if heap data block actually moved in the file */ - if (H5F_addr_eq(old_addr, new_addr)) { + if (H5_addr_eq(old_addr, new_addr)) { /* Check if heap data block is contiguous w/prefix */ if (heap->single_cache_obj) { /* Sanity check */ - assert(H5F_addr_eq(heap->prfx_addr + heap->prfx_size, old_addr)); + assert(H5_addr_eq(heap->prfx_addr + heap->prfx_size, old_addr)); assert(heap->prfx); /* Resize the heap prefix in the cache */ @@ -204,7 +204,7 @@ H5HL__dblk_realloc(H5F_t *f, H5HL_t *heap, size_t new_heap_size) } else { /* Sanity check */ - assert(H5F_addr_ne(heap->prfx_addr + heap->prfx_size, old_addr)); + assert(H5_addr_ne(heap->prfx_addr + heap->prfx_size, old_addr)); assert(heap->dblk); /* Resize the heap data block in the cache */ diff --git a/src/H5Lint.c b/src/H5Lint.c index a390609..e563bb3 100644 --- a/src/H5Lint.c +++ b/src/H5Lint.c @@ -2078,7 +2078,7 @@ H5L__link_copy_file(H5F_t *dst_file, const H5O_link_t *_src_lnk, const H5O_loc_t tmp_src_oloc.file = src_oloc->file; tmp_src_oloc.addr = src_lnk->u.hard.addr; } /* end if */ - assert(H5F_addr_defined(tmp_src_oloc.addr)); + assert(H5_addr_defined(tmp_src_oloc.addr)); /* Copy the shared object from source to destination */ /* Don't care about obj_type or udata because those are only important diff --git a/src/H5MF.c b/src/H5MF.c index 7deaa1d..a86bfef 100644 --- a/src/H5MF.c +++ b/src/H5MF.c @@ -48,7 +48,7 @@ #define H5MF_CHECK_FSM(FSM, CF) \ do { \ assert(*CF == FALSE); \ - if (!H5F_addr_defined(FSM->addr) || !H5F_addr_defined(FSM->sect_addr)) \ + if (!H5_addr_defined(FSM->addr) || !H5_addr_defined(FSM->sect_addr)) \ *CF = TRUE; \ } while (0) @@ -309,7 +309,7 @@ H5MF__open_fstype(H5F_t *f, H5F_mem_page_t type) assert((H5FD_mem_t)type != H5FD_MEM_NOLIST); } /* end else */ assert(f->shared); - assert(H5F_addr_defined(f->shared->fs_addr[type])); + assert(H5_addr_defined(f->shared->fs_addr[type])); assert(f->shared->fs_state[type] == H5F_FS_STATE_CLOSED); /* Set up the alignment and threshold to use depending on the manager type */ @@ -384,7 +384,7 @@ H5MF__create_fstype(H5F_t *f, H5F_mem_page_t type) assert((H5FD_mem_t)type != H5FD_MEM_NOLIST); } /* end else */ assert(f->shared); - assert(!H5F_addr_defined(f->shared->fs_addr[type])); + assert(!H5_addr_defined(f->shared->fs_addr[type])); assert(f->shared->fs_state[type] == H5F_FS_STATE_CLOSED); /* Set the free space creation parameters */ @@ -458,7 +458,7 @@ H5MF__start_fstype(H5F_t *f, H5F_mem_page_t type) } /* end else */ /* Check if the free space manager exists already */ - if (H5F_addr_defined(f->shared->fs_addr[type])) { + if (H5_addr_defined(f->shared->fs_addr[type])) { /* Open existing free space manager */ if (H5MF__open_fstype(f, type) < 0) HGOTO_ERROR(H5E_RESOURCE, H5E_CANTOPENOBJ, FAIL, "can't initialize file free space") @@ -500,7 +500,7 @@ H5MF__delete_fstype(H5F_t *f, H5F_mem_page_t type) assert(type < H5F_MEM_PAGE_NTYPES); else assert((H5FD_mem_t)type < H5FD_MEM_NTYPES); - assert(H5F_addr_defined(f->shared->fs_addr[type])); + assert(H5_addr_defined(f->shared->fs_addr[type])); /* Put address into temporary variable and reset it */ /* (Avoids loopback in file space freeing routine) */ @@ -532,7 +532,7 @@ H5MF__delete_fstype(H5F_t *f, H5F_mem_page_t type) f->shared->fs_state[type] = H5F_FS_STATE_CLOSED; /* Sanity check that the free space manager for this type wasn't started up again */ - assert(!H5F_addr_defined(f->shared->fs_addr[type])); + assert(!H5_addr_defined(f->shared->fs_addr[type])); done: /* Reset the ring in the API context */ @@ -781,7 +781,7 @@ H5MF_alloc(H5F_t *f, H5FD_mem_t alloc_type, hsize_t size) "attempt to notify cache that ring is unsettled failed") /* Check if the free space manager for the file has been initialized */ - if (!f->shared->fs_man[fs_type] && H5F_addr_defined(f->shared->fs_addr[fs_type])) { + if (!f->shared->fs_man[fs_type] && H5_addr_defined(f->shared->fs_addr[fs_type])) { /* Open the free-space manager */ if (H5MF__open_fstype(f, fs_type) < 0) HGOTO_ERROR(H5E_RESOURCE, H5E_CANTOPENOBJ, HADDR_UNDEF, "can't initialize file free space") @@ -795,7 +795,7 @@ H5MF_alloc(H5F_t *f, H5FD_mem_t alloc_type, hsize_t size) } /* end if */ /* If no space is found from the free-space manager, continue further action */ - if (!H5F_addr_defined(ret_value)) { + if (!H5_addr_defined(ret_value)) { #ifdef H5MF_ALLOC_DEBUG_MORE fprintf(stderr, "%s: Check 2.0\n", __func__); #endif /* H5MF_ALLOC_DEBUG_MORE */ @@ -810,7 +810,7 @@ H5MF_alloc(H5F_t *f, H5FD_mem_t alloc_type, hsize_t size) HGOTO_ERROR(H5E_RESOURCE, H5E_CANTALLOC, HADDR_UNDEF, "allocation failed from aggr/vfd") } /* end else */ } /* end if */ - assert(H5F_addr_defined(ret_value)); + assert(H5_addr_defined(ret_value)); #ifdef H5MF_ALLOC_DEBUG_MORE fprintf(stderr, "%s: Check 3.0\n", __func__); #endif /* H5MF_ALLOC_DEBUG_MORE */ @@ -1018,7 +1018,7 @@ H5MF_alloc_tmp(H5F_t *f, hsize_t size) ret_value = f->shared->tmp_addr - size; /* Check for overlap into the actual allocated space in the file */ - if (H5F_addr_le(ret_value, eoa)) + if (H5_addr_le(ret_value, eoa)) HGOTO_ERROR(H5E_RESOURCE, H5E_CANTGET, HADDR_UNDEF, "driver get_eoa request failed") /* Adjust temporary address allocator in the file */ @@ -1056,7 +1056,7 @@ H5MF_xfree(H5F_t *f, H5FD_mem_t alloc_type, haddr_t addr, hsize_t size) /* check arguments */ assert(f); - if (!H5F_addr_defined(addr) || 0 == size) + if (!H5_addr_defined(addr) || 0 == size) HGOTO_DONE(SUCCEED) assert(addr != 0); /* Can't deallocate the superblock :-) */ @@ -1080,7 +1080,7 @@ H5MF_xfree(H5F_t *f, H5FD_mem_t alloc_type, haddr_t addr, hsize_t size) "attempt to notify cache that ring is unsettled failed") /* Check for attempting to free space that's a 'temporary' file address */ - if (H5F_addr_le(f->shared->tmp_addr, addr)) + if (H5_addr_le(f->shared->tmp_addr, addr)) HGOTO_ERROR(H5E_RESOURCE, H5E_BADRANGE, FAIL, "attempting to free temporary file space") /* If it's metadata, check if the space to free intersects with the file's @@ -1102,7 +1102,7 @@ H5MF_xfree(H5F_t *f, H5FD_mem_t alloc_type, haddr_t addr, hsize_t size) #ifdef H5MF_ALLOC_DEBUG_MORE fprintf(stderr, "%s: fs_addr = %" PRIuHADDR "\n", __func__, f->shared->fs_addr[fs_type]); #endif /* H5MF_ALLOC_DEBUG_MORE */ - if (!H5F_addr_defined(f->shared->fs_addr[fs_type])) { + if (!H5_addr_defined(f->shared->fs_addr[fs_type])) { htri_t status; /* "can absorb" status for section into */ #ifdef H5MF_ALLOC_DEBUG_MORE @@ -1348,7 +1348,7 @@ H5MF_try_extend(H5F_t *f, H5FD_mem_t alloc_type, haddr_t addr, hsize_t size, hsi udata.alloc_type = alloc_type; /* Check if the free space for the file has been initialized */ - if (!f->shared->fs_man[fs_type] && H5F_addr_defined(f->shared->fs_addr[fs_type])) + if (!f->shared->fs_man[fs_type] && H5_addr_defined(f->shared->fs_addr[fs_type])) /* Open the free-space manager */ if (H5MF__open_fstype(f, fs_type) < 0) HGOTO_ERROR(H5E_RESOURCE, H5E_CANTINIT, FAIL, "can't initialize file free space") @@ -1423,7 +1423,7 @@ H5MF_try_shrink(H5F_t *f, H5FD_mem_t alloc_type, haddr_t addr, hsize_t size) assert(f); assert(f->shared); assert(f->shared->lf); - assert(H5F_addr_defined(addr)); + assert(H5_addr_defined(addr)); assert(size > 0); /* Set up free-space section class information */ @@ -1564,7 +1564,7 @@ H5MF__close_delete_fstype(H5F_t *f, H5F_mem_page_t type) #endif /* H5MF_ALLOC_DEBUG_MORE */ /* If there is free space manager info for this type, delete it */ - if (H5F_addr_defined(f->shared->fs_addr[type])) + if (H5_addr_defined(f->shared->fs_addr[type])) if (H5MF__delete_fstype(f, type) < 0) HGOTO_ERROR(H5E_RESOURCE, H5E_CANTRELEASE, FAIL, "can't delete the free space manager") @@ -1734,7 +1734,7 @@ H5MF__close_aggrfs(H5F_t *f) /* superblock extension and free space manager message should * exist at this point -- verify at least the former. */ - assert(H5F_addr_defined(f->shared->sblock->ext_addr)); + assert(H5_addr_defined(f->shared->sblock->ext_addr)); /* file space for all non-empty free space managers should be * allocated at this point, and these free space managers should @@ -1904,7 +1904,7 @@ H5MF__close_pagefs(H5F_t *f) /* superblock extension and free space manager message should * exist at this point -- verify at least the former. */ - assert(H5F_addr_defined(f->shared->sblock->ext_addr)); + assert(H5_addr_defined(f->shared->sblock->ext_addr)); /* file space for all non-empty free space managers should be * allocated at this point, and these free space managers should @@ -1982,7 +1982,7 @@ H5MF__close_pagefs(H5F_t *f) * it is ignored in the following assert. */ assert((H5F_NULL_FSM_ADDR(f)) || (final_eoa == f->shared->eoa_fsm_fsalloc) || - ((H5F_addr_defined(f->shared->eoa_post_mdci_fsalloc)) && + ((H5_addr_defined(f->shared->eoa_post_mdci_fsalloc)) && (final_eoa == f->shared->eoa_post_mdci_fsalloc))); } /* end if */ else { @@ -2196,7 +2196,7 @@ H5MF_get_freespace(H5F_t *f, hsize_t *tot_space, hsize_t *meta_size) fs_started[type] = FALSE; /* Check if the free space for the file has been initialized */ - if (!f->shared->fs_man[type] && H5F_addr_defined(f->shared->fs_addr[type])) { + if (!f->shared->fs_man[type] && H5_addr_defined(f->shared->fs_addr[type])) { if (H5MF__open_fstype(f, type) < 0) HGOTO_ERROR(H5E_RESOURCE, H5E_CANTINIT, FAIL, "can't initialize file free space") assert(f->shared->fs_man[type]); @@ -2347,7 +2347,7 @@ H5MF_get_free_sections(H5F_t *f, H5FD_mem_t type, size_t nsects, H5F_sect_info_t curr_ring = needed_ring; } /* end if */ - if (!f->shared->fs_man[ty] && H5F_addr_defined(f->shared->fs_addr[ty])) { + if (!f->shared->fs_man[ty] && H5_addr_defined(f->shared->fs_addr[ty])) { if (H5MF__open_fstype(f, ty) < 0) HGOTO_ERROR(H5E_RESOURCE, H5E_CANTRELEASE, FAIL, "can't open the free space manager") assert(f->shared->fs_man[ty]); @@ -2678,7 +2678,7 @@ H5MF_settle_raw_data_fsm(H5F_t *f, hbool_t *fsm_settled) * space. */ if (NULL == f->shared->fs_man[fsm_type]) { - if (H5F_addr_defined(f->shared->fs_addr[fsm_type])) { + if (H5_addr_defined(f->shared->fs_addr[fsm_type])) { /* Sanity check */ assert(fsm_opened[fsm_type] == FALSE); @@ -2706,7 +2706,7 @@ H5MF_settle_raw_data_fsm(H5F_t *f, hbool_t *fsm_settled) HGOTO_ERROR(H5E_RESOURCE, H5E_CANTRELEASE, FAIL, "can't get free-space info") /* Check if the free space manager has space in the file */ - if (H5F_addr_defined(fs_stat.addr) || H5F_addr_defined(fs_stat.sect_addr)) { + if (H5_addr_defined(fs_stat.addr) || H5_addr_defined(fs_stat.sect_addr)) { /* Delete the free space manager in the file. Will * reallocate later if the free space manager contains * any free space. @@ -2736,7 +2736,7 @@ H5MF_settle_raw_data_fsm(H5F_t *f, hbool_t *fsm_settled) * file space manager info message is guaranteed to exist. * Leave it in for now, but consider removing it. */ - if (H5F_addr_defined(f->shared->sblock->ext_addr)) + if (H5_addr_defined(f->shared->sblock->ext_addr)) if (H5F__super_ext_remove_msg(f, H5O_FSINFO_ID) < 0) HGOTO_ERROR(H5E_RESOURCE, H5E_CANTRELEASE, FAIL, "error in removing message from superblock extension") @@ -2855,7 +2855,7 @@ H5MF_settle_raw_data_fsm(H5F_t *f, hbool_t *fsm_settled) */ if (fs_stat.serial_sect_count > 0) { /* Sanity check */ - assert(!H5F_addr_defined(fs_stat.addr)); + assert(!H5_addr_defined(fs_stat.addr)); /* Allocate FSM header */ if (H5FS_alloc_hdr(f, f->shared->fs_man[fsm_type], @@ -2864,7 +2864,7 @@ H5MF_settle_raw_data_fsm(H5F_t *f, hbool_t *fsm_settled) "can't allocated free-space header") /* Allocate FSM section info */ - assert(!H5F_addr_defined(fs_stat.sect_addr)); + assert(!H5_addr_defined(fs_stat.sect_addr)); assert(fs_stat.alloc_sect_size == 0); if (H5FS_alloc_sect(f, f->shared->fs_man[fsm_type]) < 0) HGOTO_ERROR(H5E_RESOURCE, H5E_CANTALLOC, FAIL, @@ -2876,16 +2876,16 @@ H5MF_settle_raw_data_fsm(H5F_t *f, hbool_t *fsm_settled) HGOTO_ERROR(H5E_RESOURCE, H5E_CANTRELEASE, FAIL, "can't get free-space info") - assert(H5F_addr_defined(fs_stat.addr)); - assert(H5F_addr_defined(fs_stat.sect_addr)); + assert(H5_addr_defined(fs_stat.addr)); + assert(H5_addr_defined(fs_stat.sect_addr)); assert(fs_stat.serial_sect_count > 0); assert(fs_stat.alloc_sect_size > 0); assert(fs_stat.alloc_sect_size == fs_stat.sect_size); #endif /* NDEBUG */ } /* end if */ else { - assert(!H5F_addr_defined(fs_stat.addr)); - assert(!H5F_addr_defined(fs_stat.sect_addr)); + assert(!H5_addr_defined(fs_stat.addr)); + assert(!H5_addr_defined(fs_stat.sect_addr)); assert(fs_stat.serial_sect_count == 0); assert(fs_stat.alloc_sect_size == 0); } /* end else */ @@ -3056,8 +3056,8 @@ H5MF_settle_meta_data_fsm(H5F_t *f, hbool_t *fsm_settled) assert(sm_fssinfo_fs_type > H5F_MEM_PAGE_DEFAULT); assert(sm_fssinfo_fs_type < H5F_MEM_PAGE_LARGE_SUPER); - assert(!H5F_addr_defined(f->shared->fs_addr[sm_fshdr_fs_type])); - assert(!H5F_addr_defined(f->shared->fs_addr[sm_fssinfo_fs_type])); + assert(!H5_addr_defined(f->shared->fs_addr[sm_fshdr_fs_type])); + assert(!H5_addr_defined(f->shared->fs_addr[sm_fssinfo_fs_type])); /* Note that in most cases, sm_hdr_fspace will equal sm_sinfo_fspace. */ sm_hdr_fspace = f->shared->fs_man[sm_fshdr_fs_type]; @@ -3075,8 +3075,8 @@ H5MF_settle_meta_data_fsm(H5F_t *f, hbool_t *fsm_settled) assert(lg_fssinfo_fs_type >= H5F_MEM_PAGE_LARGE_SUPER); assert(lg_fssinfo_fs_type < H5F_MEM_PAGE_NTYPES); - assert(!H5F_addr_defined(f->shared->fs_addr[lg_fshdr_fs_type])); - assert(!H5F_addr_defined(f->shared->fs_addr[lg_fssinfo_fs_type])); + assert(!H5_addr_defined(f->shared->fs_addr[lg_fshdr_fs_type])); + assert(!H5_addr_defined(f->shared->fs_addr[lg_fssinfo_fs_type])); /* Note that in most cases, lg_hdr_fspace will equal lg_sinfo_fspace. */ lg_hdr_fspace = f->shared->fs_man[lg_fshdr_fs_type]; @@ -3095,8 +3095,8 @@ H5MF_settle_meta_data_fsm(H5F_t *f, hbool_t *fsm_settled) if (H5FS_stat_info(f, sm_hdr_fspace, &fs_stat) < 0) HGOTO_ERROR(H5E_RESOURCE, H5E_CANTGET, FAIL, "can't get free-space info") - assert(!H5F_addr_defined(fs_stat.addr)); - assert(!H5F_addr_defined(fs_stat.sect_addr)); + assert(!H5_addr_defined(fs_stat.addr)); + assert(!H5_addr_defined(fs_stat.sect_addr)); assert(fs_stat.alloc_sect_size == 0); } /* end if */ @@ -3106,8 +3106,8 @@ H5MF_settle_meta_data_fsm(H5F_t *f, hbool_t *fsm_settled) if (H5FS_stat_info(f, sm_sinfo_fspace, &fs_stat) < 0) HGOTO_ERROR(H5E_RESOURCE, H5E_CANTGET, FAIL, "can't get free-space info") - assert(!H5F_addr_defined(fs_stat.addr)); - assert(!H5F_addr_defined(fs_stat.sect_addr)); + assert(!H5_addr_defined(fs_stat.addr)); + assert(!H5_addr_defined(fs_stat.sect_addr)); assert(fs_stat.alloc_sect_size == 0); } /* end if */ @@ -3118,8 +3118,8 @@ H5MF_settle_meta_data_fsm(H5F_t *f, hbool_t *fsm_settled) if (H5FS_stat_info(f, lg_hdr_fspace, &fs_stat) < 0) HGOTO_ERROR(H5E_RESOURCE, H5E_CANTGET, FAIL, "can't get free-space info (3)") - assert(!H5F_addr_defined(fs_stat.addr)); - assert(!H5F_addr_defined(fs_stat.sect_addr)); + assert(!H5_addr_defined(fs_stat.addr)); + assert(!H5_addr_defined(fs_stat.sect_addr)); assert(fs_stat.alloc_sect_size == 0); } /* end if */ @@ -3131,8 +3131,8 @@ H5MF_settle_meta_data_fsm(H5F_t *f, hbool_t *fsm_settled) if (H5FS_stat_info(f, lg_sinfo_fspace, &fs_stat) < 0) HGOTO_ERROR(H5E_RESOURCE, H5E_CANTGET, FAIL, "can't get free-space info (4)") - assert(!H5F_addr_defined(fs_stat.addr)); - assert(!H5F_addr_defined(fs_stat.sect_addr)); + assert(!H5_addr_defined(fs_stat.addr)); + assert(!H5_addr_defined(fs_stat.sect_addr)); assert(fs_stat.alloc_sect_size == 0); } /* end if */ } /* end if */ diff --git a/src/H5MFaggr.c b/src/H5MFaggr.c index d6908ff..977d86c 100644 --- a/src/H5MFaggr.c +++ b/src/H5MFaggr.c @@ -108,7 +108,7 @@ H5MF_aggr_vfd_alloc(H5F_t *f, H5FD_mem_t alloc_type, hsize_t size) } /* end else */ /* Sanity check for overlapping into file's temporary allocation space */ - assert(H5F_addr_le((ret_value + size), f->shared->tmp_addr)); + assert(H5_addr_le((ret_value + size), f->shared->tmp_addr)); done: #ifdef H5MF_AGGR_DEBUG @@ -199,7 +199,7 @@ H5MF__aggr_alloc(H5F_t *f, H5F_blk_aggr_t *aggr, H5F_blk_aggr_t *other_aggr, H5F alignment = 0; /* no alignment */ /* Generate fragment if aggregator is mis-aligned */ - if (alignment && H5F_addr_gt(aggr->addr, 0) && + if (alignment && H5_addr_gt(aggr->addr, 0) && (aggr_mis_align = (aggr->addr + H5F_BASE_ADDR(f)) % alignment)) { aggr_frag_addr = aggr->addr; aggr_frag_size = alignment - aggr_mis_align; @@ -219,7 +219,7 @@ H5MF__aggr_alloc(H5F_t *f, H5F_blk_aggr_t *aggr, H5F_blk_aggr_t *other_aggr, H5F hsize_t ext_size = size + aggr_frag_size; /* Check for overlapping into file's temporary allocation space */ - if (H5F_addr_gt((aggr->addr + aggr->size + ext_size), f->shared->tmp_addr)) + if (H5_addr_gt((aggr->addr + aggr->size + ext_size), f->shared->tmp_addr)) HGOTO_ERROR( H5E_RESOURCE, H5E_BADRANGE, HADDR_UNDEF, "'normal' file space allocation request will overlap into 'temporary' file space") @@ -239,7 +239,7 @@ H5MF__aggr_alloc(H5F_t *f, H5F_blk_aggr_t *aggr, H5F_blk_aggr_t *other_aggr, H5F * allocation block size. */ if ((other_aggr->size > 0) && - (H5F_addr_eq((other_aggr->addr + other_aggr->size), eoa)) && + (H5_addr_eq((other_aggr->addr + other_aggr->size), eoa)) && (other_aggr->tot_size > other_aggr->size) && ((other_aggr->tot_size - other_aggr->size) >= other_aggr->alloc_size)) { if (H5MF__aggr_free(f, other_alloc_type, other_aggr) < 0) @@ -265,7 +265,7 @@ H5MF__aggr_alloc(H5F_t *f, H5F_blk_aggr_t *aggr, H5F_blk_aggr_t *other_aggr, H5F ext_size += (aggr_frag_size - (ext_size - size)); /* Check for overlapping into file's temporary allocation space */ - if (H5F_addr_gt((aggr->addr + aggr->size + ext_size), f->shared->tmp_addr)) + if (H5_addr_gt((aggr->addr + aggr->size + ext_size), f->shared->tmp_addr)) HGOTO_ERROR( H5E_RESOURCE, H5E_BADRANGE, HADDR_UNDEF, "'normal' file space allocation request will overlap into 'temporary' file space") @@ -286,7 +286,7 @@ H5MF__aggr_alloc(H5F_t *f, H5F_blk_aggr_t *aggr, H5F_blk_aggr_t *other_aggr, H5F * allocation block size. */ if ((other_aggr->size > 0) && - (H5F_addr_eq((other_aggr->addr + other_aggr->size), eoa)) && + (H5_addr_eq((other_aggr->addr + other_aggr->size), eoa)) && (other_aggr->tot_size > other_aggr->size) && ((other_aggr->tot_size - other_aggr->size) >= other_aggr->alloc_size)) { if (H5MF__aggr_free(f, other_alloc_type, other_aggr) < 0) @@ -370,7 +370,7 @@ H5MF__aggr_alloc(H5F_t *f, H5F_blk_aggr_t *aggr, H5F_blk_aggr_t *other_aggr, H5F } /* end else */ /* Sanity check for overlapping into file's temporary allocation space */ - assert(H5F_addr_le((ret_value + size), f->shared->tmp_addr)); + assert(H5_addr_le((ret_value + size), f->shared->tmp_addr)); /* Post-condition sanity check */ if (H5F_ALIGNMENT(f) && size >= H5F_THRESHOLD(f)) @@ -424,7 +424,7 @@ done: * If the block being tested adjoins the beginning of the aggregator * block, check if the aggregator can accommodate the extension. */ - if (H5F_addr_eq(blk_end, aggr->addr)) { + if (H5_addr_eq(blk_end, aggr->addr)) { haddr_t eoa; /* EOA for the file */ /* Get the EOA for the file */ @@ -432,7 +432,7 @@ done: HGOTO_ERROR(H5E_RESOURCE, H5E_CANTGET, FAIL, "Unable to get eoa") /* If the aggregator is at the end of file: */ - if (H5F_addr_eq(eoa, aggr->addr + aggr->size)) { + if (H5_addr_eq(eoa, aggr->addr + aggr->size)) { /* If extra_requested is below percentage threshold, extend block into the aggregator. */ if (extra_requested <= (hsize_t)(EXTEND_THRESHOLD * (float)aggr->size)) { aggr->size -= extra_requested; @@ -518,8 +518,8 @@ done: /* Check if this aggregator is active */ if (f->shared->feature_flags & aggr->feature_flag) { /* Check if the block adjoins the beginning or end of the aggregator */ - if (H5F_addr_eq((sect->sect_info.addr + sect->sect_info.size), aggr->addr) || - H5F_addr_eq((aggr->addr + aggr->size), sect->sect_info.addr)) { + if (H5_addr_eq((sect->sect_info.addr + sect->sect_info.size), aggr->addr) || + H5_addr_eq((aggr->addr + aggr->size), sect->sect_info.addr)) { #ifdef H5MF_AGGR_DEBUG fprintf(stderr, "%s: section {%" PRIuHADDR ", %" PRIuHSIZE "} adjoins aggr = {%" PRIuHADDR @@ -569,7 +569,7 @@ done: /* Check if aggregator would get too large and should be absorbed into section */ if ((aggr->size + sect->sect_info.size) >= aggr->alloc_size && allow_sect_absorb) { /* Check if the section adjoins the beginning or end of the aggregator */ - if (H5F_addr_eq((sect->sect_info.addr + sect->sect_info.size), aggr->addr)) { + if (H5_addr_eq((sect->sect_info.addr + sect->sect_info.size), aggr->addr)) { #ifdef H5MF_AGGR_DEBUG fprintf(stderr, "%s: aggr {%" PRIuHADDR ", %" PRIuHSIZE "} adjoins front of section = {%" PRIuHADDR @@ -582,7 +582,7 @@ done: } /* end if */ else { /* Sanity check */ - assert(H5F_addr_eq((aggr->addr + aggr->size), sect->sect_info.addr)); + assert(H5_addr_eq((aggr->addr + aggr->size), sect->sect_info.addr)); #ifdef H5MF_AGGR_DEBUG fprintf(stderr, @@ -603,7 +603,7 @@ done: } /* end if */ else { /* Check if the section adjoins the beginning or end of the aggregator */ - if (H5F_addr_eq((sect->sect_info.addr + sect->sect_info.size), aggr->addr)) { + if (H5_addr_eq((sect->sect_info.addr + sect->sect_info.size), aggr->addr)) { #ifdef H5MF_AGGR_DEBUG fprintf(stderr, "%s: section {%" PRIuHADDR ", %" PRIuHSIZE "} adjoins front of aggr = {%" PRIuHADDR @@ -622,7 +622,7 @@ done: } /* end if */ else { /* Sanity check */ - assert(H5F_addr_eq((aggr->addr + aggr->size), sect->sect_info.addr)); + assert(H5_addr_eq((aggr->addr + aggr->size), sect->sect_info.addr)); #ifdef H5MF_AGGR_DEBUG fprintf(stderr, @@ -766,8 +766,8 @@ done: /* Make certain we release the aggregator that's later in the file first */ /* (so the file shrinks properly) */ - if (H5F_addr_defined(ma_addr) && H5F_addr_defined(sda_addr)) { - if (H5F_addr_lt(ma_addr, sda_addr)) { + if (H5_addr_defined(ma_addr) && H5_addr_defined(sda_addr)) { + if (H5_addr_lt(ma_addr, sda_addr)) { first_aggr = &(f->shared->sdata_aggr); second_aggr = &(f->shared->meta_aggr); } /* end if */ @@ -820,8 +820,8 @@ done: HGOTO_ERROR(H5E_RESOURCE, H5E_CANTGET, FAIL, "Unable to get eoa") /* Check if the aggregator is at EOA */ - if (aggr->size > 0 && H5F_addr_defined(aggr->addr)) - ret_value = H5F_addr_eq(eoa, aggr->addr + aggr->size); + if (aggr->size > 0 && H5_addr_defined(aggr->addr)) + ret_value = H5_addr_eq(eoa, aggr->addr + aggr->size); done: FUNC_LEAVE_NOAPI(ret_value) @@ -849,7 +849,7 @@ done: assert(f); assert(f->shared->lf); assert(aggr); - assert(H5F_addr_defined(aggr->addr)); + assert(H5_addr_defined(aggr->addr)); assert(aggr->size > 0); assert(H5F_INTENT(f) & H5F_ACC_RDWR); assert(aggr->feature_flag == H5FD_FEAT_AGGREGATE_METADATA || diff --git a/src/H5MFdbg.c b/src/H5MFdbg.c index f5505c9..6cb5ca0 100644 --- a/src/H5MFdbg.c +++ b/src/H5MFdbg.c @@ -148,7 +148,7 @@ H5MF_sects_debug(H5F_t *f, haddr_t fs_addr, FILE *stream, int indent, int fwidth assert(fwidth >= 0); for (type = H5F_MEM_PAGE_DEFAULT; type < H5F_MEM_PAGE_NTYPES; type++) - if (H5F_addr_eq(f->shared->fs_addr[type], fs_addr)) { + if (H5_addr_eq(f->shared->fs_addr[type], fs_addr)) { if (!f->shared->fs_man[type]) if (H5MF__open_fstype(f, type) < 0) HGOTO_ERROR(H5E_RESOURCE, H5E_CANTINIT, FAIL, "can't initialize file free space") diff --git a/src/H5MFpkg.h b/src/H5MFpkg.h index b679674..cc70e3b 100644 --- a/src/H5MFpkg.h +++ b/src/H5MFpkg.h @@ -70,7 +70,7 @@ { \ hsize_t m; \ \ - if (H5F_addr_gt((E), 0) && ((m) = ((E) + H5F_BASE_ADDR(F)) % (A))) \ + if (H5_addr_gt((E), 0) && ((m) = ((E) + H5F_BASE_ADDR(F)) % (A))) \ (FR) = (A)-m; \ else \ (FR) = 0; \ diff --git a/src/H5MFsection.c b/src/H5MFsection.c index 390b5eb..ff14a44 100644 --- a/src/H5MFsection.c +++ b/src/H5MFsection.c @@ -256,7 +256,7 @@ H5MF__sect_deserialize(const H5FS_section_class_t *cls, const uint8_t H5_ATTR_UN /* Check arguments. */ assert(cls); - assert(H5F_addr_defined(sect_addr)); + assert(H5_addr_defined(sect_addr)); assert(sect_size); /* Create free space section for block */ @@ -359,10 +359,10 @@ H5MF__sect_simple_can_merge(const H5FS_section_info_t *_sect1, const H5FS_sectio assert(sect1); assert(sect2); assert(sect1->sect_info.type == sect2->sect_info.type); /* Checks "MERGE_SYM" flag */ - assert(H5F_addr_lt(sect1->sect_info.addr, sect2->sect_info.addr)); + assert(H5_addr_lt(sect1->sect_info.addr, sect2->sect_info.addr)); /* Check if second section adjoins first section */ - ret_value = H5F_addr_eq(sect1->sect_info.addr + sect1->sect_info.size, sect2->sect_info.addr); + ret_value = H5_addr_eq(sect1->sect_info.addr + sect1->sect_info.size, sect2->sect_info.addr); FUNC_LEAVE_NOAPI(ret_value) } /* H5MF__sect_simple_can_merge() */ @@ -394,7 +394,7 @@ H5MF__sect_simple_merge(H5FS_section_info_t **_sect1, H5FS_section_info_t *_sect assert((*sect1)->sect_info.type == H5MF_FSPACE_SECT_SIMPLE); assert(sect2); assert(sect2->sect_info.type == H5MF_FSPACE_SECT_SIMPLE); - assert(H5F_addr_eq((*sect1)->sect_info.addr + (*sect1)->sect_info.size, sect2->sect_info.addr)); + assert(H5_addr_eq((*sect1)->sect_info.addr + (*sect1)->sect_info.size, sect2->sect_info.addr)); /* Add second section's size to first section */ (*sect1)->sect_info.size += sect2->sect_info.size; @@ -441,7 +441,7 @@ H5MF__sect_simple_can_shrink(const H5FS_section_info_t *_sect, void *_udata) end = sect->sect_info.addr + sect->sect_info.size; /* Check if the section is exactly at the end of the allocated space in the file */ - if (H5F_addr_eq(end, eoa)) { + if (H5_addr_eq(end, eoa)) { /* Set the shrinking type */ udata->shrink = H5MF_SHRINK_EOA; #ifdef H5MF_ALLOC_DEBUG_MORE @@ -658,10 +658,10 @@ H5MF__sect_small_can_merge(const H5FS_section_info_t *_sect1, const H5FS_section assert(sect1); assert(sect2); assert(sect1->sect_info.type == sect2->sect_info.type); /* Checks "MERGE_SYM" flag */ - assert(H5F_addr_lt(sect1->sect_info.addr, sect2->sect_info.addr)); + assert(H5_addr_lt(sect1->sect_info.addr, sect2->sect_info.addr)); /* Check if second section adjoins first section */ - ret_value = H5F_addr_eq(sect1->sect_info.addr + sect1->sect_info.size, sect2->sect_info.addr); + ret_value = H5_addr_eq(sect1->sect_info.addr + sect1->sect_info.size, sect2->sect_info.addr); if (ret_value > 0) /* If they are on different pages, couldn't merge */ if ((sect1->sect_info.addr / udata->f->shared->fs_page_size) != @@ -704,7 +704,7 @@ H5MF__sect_small_merge(H5FS_section_info_t **_sect1, H5FS_section_info_t *_sect2 assert((*sect1)->sect_info.type == H5MF_FSPACE_SECT_SMALL); assert(sect2); assert(sect2->sect_info.type == H5MF_FSPACE_SECT_SMALL); - assert(H5F_addr_eq((*sect1)->sect_info.addr + (*sect1)->sect_info.size, sect2->sect_info.addr)); + assert(H5_addr_eq((*sect1)->sect_info.addr + (*sect1)->sect_info.size, sect2->sect_info.addr)); /* Add second section's size to first section */ (*sect1)->sect_info.size += sect2->sect_info.size; @@ -764,9 +764,9 @@ H5MF__sect_large_can_merge(const H5FS_section_info_t *_sect1, const H5FS_section assert(sect1); assert(sect2); assert(sect1->sect_info.type == sect2->sect_info.type); /* Checks "MERGE_SYM" flag */ - assert(H5F_addr_lt(sect1->sect_info.addr, sect2->sect_info.addr)); + assert(H5_addr_lt(sect1->sect_info.addr, sect2->sect_info.addr)); - ret_value = H5F_addr_eq(sect1->sect_info.addr + sect1->sect_info.size, sect2->sect_info.addr); + ret_value = H5_addr_eq(sect1->sect_info.addr + sect1->sect_info.size, sect2->sect_info.addr); #ifdef H5MF_ALLOC_DEBUG_MORE fprintf(stderr, "%s: Leaving: ret_value = %d\n", __func__, ret_value); @@ -801,7 +801,7 @@ H5MF__sect_large_merge(H5FS_section_info_t **_sect1, H5FS_section_info_t *_sect2 assert((*sect1)->sect_info.type == H5MF_FSPACE_SECT_LARGE); assert(sect2); assert(sect2->sect_info.type == H5MF_FSPACE_SECT_LARGE); - assert(H5F_addr_eq((*sect1)->sect_info.addr + (*sect1)->sect_info.size, sect2->sect_info.addr)); + assert(H5_addr_eq((*sect1)->sect_info.addr + (*sect1)->sect_info.size, sect2->sect_info.addr)); /* Add second section's size to first section */ (*sect1)->sect_info.size += sect2->sect_info.size; @@ -849,7 +849,7 @@ H5MF__sect_large_can_shrink(const H5FS_section_info_t *_sect, void *_udata) end = sect->sect_info.addr + sect->sect_info.size; /* Check if the section is exactly at the end of the allocated space in the file */ - if (H5F_addr_eq(end, eoa) && sect->sect_info.size >= udata->f->shared->fs_page_size) { + if (H5_addr_eq(end, eoa) && sect->sect_info.size >= udata->f->shared->fs_page_size) { /* Set the shrinking type */ udata->shrink = H5MF_SHRINK_EOA; #ifdef H5MF_ALLOC_DEBUG_MORE diff --git a/src/H5Oainfo.c b/src/H5Oainfo.c index c5c828e..0b02533 100644 --- a/src/H5Oainfo.c +++ b/src/H5Oainfo.c @@ -139,18 +139,18 @@ H5O__ainfo_decode(H5F_t *f, H5O_t H5_ATTR_UNUSED *open_oh, unsigned H5_ATTR_UNUS /* Address of fractal heap to store "dense" attributes */ if (H5_IS_BUFFER_OVERFLOW(p, sizeof_addr, p_end)) HGOTO_ERROR(H5E_OHDR, H5E_OVERFLOW, NULL, "ran off end of input buffer while decoding"); - H5F_addr_decode(f, &p, &(ainfo->fheap_addr)); + H5_addr_decode(f, &p, &(ainfo->fheap_addr)); /* Address of v2 B-tree to index names of attributes (names are always indexed) */ if (H5_IS_BUFFER_OVERFLOW(p, sizeof_addr, p_end)) HGOTO_ERROR(H5E_OHDR, H5E_OVERFLOW, NULL, "ran off end of input buffer while decoding"); - H5F_addr_decode(f, &p, &(ainfo->name_bt2_addr)); + H5_addr_decode(f, &p, &(ainfo->name_bt2_addr)); /* Address of v2 B-tree to index creation order of links, if there is one */ if (ainfo->index_corder) { if (H5_IS_BUFFER_OVERFLOW(p, sizeof_addr, p_end)) HGOTO_ERROR(H5E_OHDR, H5E_OVERFLOW, NULL, "ran off end of input buffer while decoding"); - H5F_addr_decode(f, &p, &(ainfo->corder_bt2_addr)); + H5_addr_decode(f, &p, &(ainfo->corder_bt2_addr)); } else ainfo->corder_bt2_addr = HADDR_UNDEF; @@ -200,16 +200,16 @@ H5O__ainfo_encode(H5F_t *f, hbool_t H5_ATTR_UNUSED disable_shared, uint8_t *p, c UINT16ENCODE(p, ainfo->max_crt_idx); /* Address of fractal heap to store "dense" attributes */ - H5F_addr_encode(f, &p, ainfo->fheap_addr); + H5_addr_encode(f, &p, ainfo->fheap_addr); /* Address of v2 B-tree to index names of attributes */ - H5F_addr_encode(f, &p, ainfo->name_bt2_addr); + H5_addr_encode(f, &p, ainfo->name_bt2_addr); /* Address of v2 B-tree to index creation order of attributes, if they are indexed */ if (ainfo->index_corder) - H5F_addr_encode(f, &p, ainfo->corder_bt2_addr); + H5_addr_encode(f, &p, ainfo->corder_bt2_addr); else - assert(!H5F_addr_defined(ainfo->corder_bt2_addr)); + assert(!H5_addr_defined(ainfo->corder_bt2_addr)); FUNC_LEAVE_NOAPI(SUCCEED) } /* end H5O__ainfo_encode() */ @@ -329,7 +329,7 @@ H5O__ainfo_delete(H5F_t *f, H5O_t H5_ATTR_NDEBUG_UNUSED *open_oh, void *_mesg) assert(open_oh); /* If the object is using "dense" attribute storage, delete it */ - if (H5F_addr_defined(ainfo->fheap_addr)) + if (H5_addr_defined(ainfo->fheap_addr)) /* Delete the attribute */ if (H5A__dense_delete(f, ainfo) < 0) HGOTO_ERROR(H5E_OHDR, H5E_CANTFREE, FAIL, "unable to free dense attribute storage") @@ -403,7 +403,7 @@ H5O__ainfo_copy_file(H5F_t H5_ATTR_NDEBUG_UNUSED *file_src, void *mesg_src, H5F_ /* Copy the top level of the information */ *ainfo_dst = *ainfo_src; - if (H5F_addr_defined(ainfo_src->fheap_addr)) { + if (H5_addr_defined(ainfo_src->fheap_addr)) { /* Prepare to copy dense attributes - actual copy in post_copy */ /* Set copied metadata tag */ @@ -451,7 +451,7 @@ H5O__ainfo_post_copy_file(const H5O_loc_t *src_oloc, const void *mesg_src, H5O_l assert(ainfo_src); - if (H5F_addr_defined(ainfo_src->fheap_addr)) + if (H5_addr_defined(ainfo_src->fheap_addr)) if (H5A__dense_post_copy_file_all(src_oloc, ainfo_src, dst_oloc, (H5O_ainfo_t *)mesg_dst, cpy_info) < 0) HGOTO_ERROR(H5E_ATTR, H5E_CANTCOPY, FAIL, "can't copy attribute") diff --git a/src/H5Oalloc.c b/src/H5Oalloc.c index 6f3c25c..d9cb550 100644 --- a/src/H5Oalloc.c +++ b/src/H5Oalloc.c @@ -498,7 +498,7 @@ H5O__alloc_extend_chunk(H5F_t *f, H5O_t *oh, unsigned chunkno, size_t size, size assert(chunkno < oh->nchunks); assert(size > 0); assert(msg_idx != NULL); - assert(H5F_addr_defined(oh->chunk[chunkno].addr)); + assert(H5_addr_defined(oh->chunk[chunkno].addr)); /* Test to see if the specified chunk ends with a null messages. * If successful, set the index of the null message in extend_msg. @@ -881,7 +881,7 @@ H5O__alloc_chunk(H5F_t *f, H5O_t *oh, size_t size, size_t found_null, const H5O_ /* Allocate space in file to hold the new chunk */ new_chunk_addr = H5MF_alloc(f, H5FD_MEM_OHDR, (hsize_t)size); - if (!H5F_addr_defined(new_chunk_addr)) + if (!H5_addr_defined(new_chunk_addr)) HGOTO_ERROR(H5E_OHDR, H5E_CANTALLOC, FAIL, "unable to allocate space for new chunk") /* Create the new chunk giving it a file address. */ diff --git a/src/H5Oattribute.c b/src/H5Oattribute.c index 0d611dd..2640adb 100644 --- a/src/H5Oattribute.c +++ b/src/H5Oattribute.c @@ -240,7 +240,7 @@ H5O__attr_create(const H5O_loc_t *loc, H5A_t *attr) } /* end else */ /* Check if switching to "dense" attribute storage is possible */ - if (!H5F_addr_defined(ainfo.fheap_addr)) { + if (!H5_addr_defined(ainfo.fheap_addr)) { htri_t shareable; /* Whether the attribute will be shared */ size_t raw_size = 0; /* Raw size of message */ @@ -308,7 +308,7 @@ H5O__attr_create(const H5O_loc_t *loc, H5A_t *attr) } /* end else */ /* Check for storing attribute with dense storage */ - if (H5F_addr_defined(ainfo.fheap_addr)) { + if (H5_addr_defined(ainfo.fheap_addr)) { /* Insert attribute into dense storage */ if (H5A__dense_insert(loc->file, &ainfo, attr) < 0) HGOTO_ERROR(H5E_ATTR, H5E_CANTINSERT, FAIL, "unable to add to dense storage") @@ -466,7 +466,7 @@ H5O__attr_open_by_name(const H5O_loc_t *loc, const char *name) } /* end else if */ else { /* Check for attributes in dense storage */ - if (H5F_addr_defined(ainfo.fheap_addr)) { + if (H5_addr_defined(ainfo.fheap_addr)) { /* Open attribute with dense storage */ if (NULL == (opened_attr = H5A__dense_open(loc->file, &ainfo, name))) HGOTO_ERROR(H5E_ATTR, H5E_CANTOPENOBJ, NULL, "can't open attribute") @@ -871,7 +871,7 @@ H5O__attr_write(const H5O_loc_t *loc, H5A_t *attr) } /* end if */ /* Check for attributes stored densely */ - if (H5F_addr_defined(ainfo.fheap_addr)) { + if (H5_addr_defined(ainfo.fheap_addr)) { /* Modify the attribute data in dense storage */ if (H5A__dense_write(loc->file, &ainfo, attr) < 0) HGOTO_ERROR(H5E_ATTR, H5E_CANTUPDATE, FAIL, "error updating attribute") @@ -1108,7 +1108,7 @@ H5O__attr_rename(const H5O_loc_t *loc, const char *old_name, const char *new_nam } /* end if */ /* Check for attributes stored densely */ - if (H5F_addr_defined(ainfo.fheap_addr)) { + if (H5_addr_defined(ainfo.fheap_addr)) { /* Rename the attribute data in dense storage */ if (H5A__dense_rename(loc->file, &ainfo, old_name, new_name) < 0) HGOTO_ERROR(H5E_ATTR, H5E_CANTUPDATE, FAIL, "error updating attribute") @@ -1178,7 +1178,7 @@ H5O_attr_iterate_real(hid_t loc_id, const H5O_loc_t *loc, H5_index_t idx_type, H /* Check arguments */ assert(loc); assert(loc->file); - assert(H5F_addr_defined(loc->addr)); + assert(H5_addr_defined(loc->addr)); assert(attr_op); /* Protect the object header to iterate over */ @@ -1194,7 +1194,7 @@ H5O_attr_iterate_real(hid_t loc_id, const H5O_loc_t *loc, H5_index_t idx_type, H } /* end if */ /* Check for attributes stored densely */ - if (H5F_addr_defined(ainfo.fheap_addr)) { + if (H5_addr_defined(ainfo.fheap_addr)) { /* Check for skipping too many attributes */ if (skip > 0 && skip >= ainfo.nattrs) HGOTO_ERROR(H5E_ARGS, H5E_BADVALUE, FAIL, "invalid index specified") @@ -1304,7 +1304,7 @@ H5O__attr_remove_update(const H5O_loc_t *loc, H5O_t *oh, H5O_ainfo_t *ainfo) ainfo->nattrs--; /* Check for shifting from dense storage back to compact storage */ - if (H5F_addr_defined(ainfo->fheap_addr) && ainfo->nattrs < oh->min_dense) { + if (H5_addr_defined(ainfo->fheap_addr) && ainfo->nattrs < oh->min_dense) { hbool_t can_convert = TRUE; /* Whether converting to attribute messages is possible */ size_t u; /* Local index */ @@ -1473,7 +1473,7 @@ H5O__attr_remove(const H5O_loc_t *loc, const char *name) } /* end if */ /* Check for attributes stored densely */ - if (H5F_addr_defined(ainfo.fheap_addr)) { + if (H5_addr_defined(ainfo.fheap_addr)) { /* Delete attribute from dense storage */ if (H5A__dense_remove(loc->file, &ainfo, name) < 0) HGOTO_ERROR(H5E_ATTR, H5E_CANTDELETE, FAIL, "unable to delete attribute in dense storage") @@ -1551,7 +1551,7 @@ H5O__attr_remove_by_idx(const H5O_loc_t *loc, H5_index_t idx_type, H5_iter_order } /* end if */ /* Check for attributes stored densely */ - if (H5F_addr_defined(ainfo.fheap_addr)) { + if (H5_addr_defined(ainfo.fheap_addr)) { /* Delete attribute from dense storage */ if (H5A__dense_remove_by_idx(loc->file, &ainfo, idx_type, order, n) < 0) HGOTO_ERROR(H5E_ATTR, H5E_CANTDELETE, FAIL, "unable to delete attribute in dense storage") @@ -1723,7 +1723,7 @@ H5O__attr_exists(const H5O_loc_t *loc, const char *name, hbool_t *attr_exists) } /* end if */ /* Check for attributes stored densely */ - if (H5F_addr_defined(ainfo.fheap_addr)) { + if (H5_addr_defined(ainfo.fheap_addr)) { /* Check if attribute exists in dense storage */ if (H5A__dense_exists(loc->file, &ainfo, name, attr_exists) < 0) HGOTO_ERROR(H5E_ATTR, H5E_BADITER, FAIL, "error checking for existence of attribute") @@ -1783,7 +1783,7 @@ H5O__attr_bh_info(H5F_t *f, H5O_t *oh, H5_ih_info_t *bh_info) HGOTO_ERROR(H5E_ATTR, H5E_CANTGET, FAIL, "can't check for attribute info message") else if (ainfo_exists > 0) { /* Check if name index available */ - if (H5F_addr_defined(ainfo.name_bt2_addr)) { + if (H5_addr_defined(ainfo.name_bt2_addr)) { /* Open the name index v2 B-tree */ if (NULL == (bt2_name = H5B2_open(f, ainfo.name_bt2_addr, NULL))) HGOTO_ERROR(H5E_ATTR, H5E_CANTOPENOBJ, FAIL, "unable to open v2 B-tree for name index") @@ -1794,7 +1794,7 @@ H5O__attr_bh_info(H5F_t *f, H5O_t *oh, H5_ih_info_t *bh_info) } /* end if */ /* Check if creation order index available */ - if (H5F_addr_defined(ainfo.corder_bt2_addr)) { + if (H5_addr_defined(ainfo.corder_bt2_addr)) { /* Open the creation order index v2 B-tree */ if (NULL == (bt2_corder = H5B2_open(f, ainfo.corder_bt2_addr, NULL))) HGOTO_ERROR(H5E_ATTR, H5E_CANTOPENOBJ, FAIL, @@ -1806,7 +1806,7 @@ H5O__attr_bh_info(H5F_t *f, H5O_t *oh, H5_ih_info_t *bh_info) } /* end if */ /* Get storage size of fractal heap, if it's used */ - if (H5F_addr_defined(ainfo.fheap_addr)) { + if (H5_addr_defined(ainfo.fheap_addr)) { /* Open the fractal heap for attributes */ if (NULL == (fheap = H5HF_open(f, ainfo.fheap_addr))) HGOTO_ERROR(H5E_ATTR, H5E_CANTOPENOBJ, FAIL, "unable to open fractal heap") diff --git a/src/H5Ocache.c b/src/H5Ocache.c index c893f04..e828e2d 100644 --- a/src/H5Ocache.c +++ b/src/H5Ocache.c @@ -1213,7 +1213,7 @@ H5O__chunk_deserialize(H5O_t *oh, haddr_t addr, size_t chunk_size, const uint8_t FUNC_ENTER_PACKAGE assert(oh); - assert(H5F_addr_defined(addr)); + assert(H5_addr_defined(addr)); assert(image); assert(len); assert(udata->f); diff --git a/src/H5Ocache_image.c b/src/H5Ocache_image.c index 546a475..ac2630a 100644 --- a/src/H5Ocache_image.c +++ b/src/H5Ocache_image.c @@ -109,7 +109,7 @@ H5O__mdci_decode(H5F_t *f, H5O_t H5_ATTR_UNUSED *open_oh, unsigned H5_ATTR_UNUSE if (H5_IS_BUFFER_OVERFLOW(p, H5F_sizeof_addr(f), p_end)) HGOTO_ERROR(H5E_OHDR, H5E_OVERFLOW, NULL, "ran off end of input buffer while decoding"); - H5F_addr_decode(f, &p, &(mesg->addr)); + H5_addr_decode(f, &p, &(mesg->addr)); if (H5_IS_BUFFER_OVERFLOW(p, H5F_sizeof_size(f), p_end)) HGOTO_ERROR(H5E_OHDR, H5E_OVERFLOW, NULL, "ran off end of input buffer while decoding"); @@ -148,7 +148,7 @@ H5O__mdci_encode(H5F_t *f, hbool_t H5_ATTR_UNUSED disable_shared, uint8_t *p, co /* encode */ *p++ = H5O_MDCI_VERSION_0; - H5F_addr_encode(f, &p, mesg->addr); + H5_addr_encode(f, &p, mesg->addr); H5F_ENCODE_LENGTH(f, p, mesg->size); FUNC_LEAVE_NOAPI(SUCCEED) @@ -263,7 +263,7 @@ H5O__mdci_delete(H5F_t *f, H5O_t H5_ATTR_UNUSED *open_oh, void *_mesg) assert(mesg); /* Free file space for cache image */ - if (H5F_addr_defined(mesg->addr)) { + if (H5_addr_defined(mesg->addr)) { /* The space for the cache image block was allocated directly * from the VFD layer at the end of file. As this was the * last file space allocation before shutdown, the cache image @@ -274,7 +274,7 @@ H5O__mdci_delete(H5F_t *f, H5O_t H5_ATTR_UNUSED *open_oh, void *_mesg) if (HADDR_UNDEF == (final_eoa = H5FD_get_eoa(f->shared->lf, H5FD_MEM_DEFAULT))) HGOTO_ERROR(H5E_CACHE, H5E_CANTGET, FAIL, "unable to get file size") - assert(H5F_addr_eq(final_eoa, mesg->addr + mesg->size)); + assert(H5_addr_eq(final_eoa, mesg->addr + mesg->size)); if (H5FD_free(f->shared->lf, H5FD_MEM_SUPER, f, mesg->addr, mesg->size) < 0) HGOTO_ERROR(H5E_CACHE, H5E_CANTFREE, FAIL, "can't free MDC image") diff --git a/src/H5Ocont.c b/src/H5Ocont.c index 999fca0..1dfaf46 100644 --- a/src/H5Ocont.c +++ b/src/H5Ocont.c @@ -95,7 +95,7 @@ H5O__cont_decode(H5F_t *f, H5O_t H5_ATTR_UNUSED *open_oh, unsigned H5_ATTR_UNUSE /* Decode */ if (H5_IS_BUFFER_OVERFLOW(p, H5F_sizeof_addr(f), p_end)) HGOTO_ERROR(H5E_OHDR, H5E_OVERFLOW, NULL, "ran off end of input buffer while decoding"); - H5F_addr_decode(f, &p, &(cont->addr)); + H5_addr_decode(f, &p, &(cont->addr)); if (H5_IS_BUFFER_OVERFLOW(p, H5F_sizeof_size(f), p_end)) HGOTO_ERROR(H5E_OHDR, H5E_OVERFLOW, NULL, "ran off end of input buffer while decoding"); @@ -132,11 +132,11 @@ H5O__cont_encode(H5F_t *f, hbool_t H5_ATTR_UNUSED disable_shared, uint8_t *p, co assert(f); assert(p); assert(cont); - assert(H5F_addr_defined(cont->addr)); + assert(H5_addr_defined(cont->addr)); assert(cont->size > 0); /* encode */ - H5F_addr_encode(f, &p, cont->addr); + H5_addr_encode(f, &p, cont->addr); H5F_ENCODE_LENGTH(f, p, cont->size); FUNC_LEAVE_NOAPI(SUCCEED) diff --git a/src/H5Ocopy.c b/src/H5Ocopy.c index 74e73d1..ae37259 100644 --- a/src/H5Ocopy.c +++ b/src/H5Ocopy.c @@ -219,7 +219,7 @@ H5O__copy_header_real(const H5O_loc_t *oloc_src, H5O_loc_t *oloc_dst /*out*/, H5 assert(oloc_src); assert(oloc_src->file); - assert(H5F_addr_defined(oloc_src->addr)); + assert(H5_addr_defined(oloc_src->addr)); assert(oloc_dst->file); assert(cpy_info); @@ -644,7 +644,7 @@ H5O__copy_header_real(const H5O_loc_t *oloc_src, H5O_loc_t *oloc_dst /*out*/, H5 (size_t)dst_oh_size + oh_dst->chunk[0].image); /* Set the dest. object location to the first chunk address */ - assert(H5F_addr_defined(addr_new)); + assert(H5_addr_defined(addr_new)); oloc_dst->addr = addr_new; /* If we are merging committed datatypes and this is a committed datatype, insert @@ -940,7 +940,7 @@ H5O__copy_header(const H5O_loc_t *oloc_src, H5O_loc_t *oloc_dst /*out */, hid_t /* Sanity check */ assert(oloc_src); assert(oloc_src->file); - assert(H5F_addr_defined(oloc_src->addr)); + assert(H5_addr_defined(oloc_src->addr)); assert(oloc_dst->file); /* Initialize copy info before errors can be thrown */ @@ -1162,7 +1162,7 @@ H5O__copy_search_comm_dt_attr_cb(const H5A_t *attr, void *_udata) assert(attr); assert(udata); assert(udata->dst_dt_list); - assert(H5F_addr_defined(udata->obj_oloc.addr)); + assert(H5_addr_defined(udata->obj_oloc.addr)); /* Get attribute datatype */ if (NULL == (dt = H5A_type(attr))) diff --git a/src/H5Ocopy_ref.c b/src/H5Ocopy_ref.c index 100bea5..431a1aa 100644 --- a/src/H5Ocopy_ref.c +++ b/src/H5Ocopy_ref.c @@ -107,7 +107,7 @@ H5O__copy_obj_by_ref(H5O_loc_t *src_oloc, H5O_loc_t *dst_oloc, H5G_loc_t *dst_ro HGOTO_ERROR(H5E_OHDR, H5E_CANTCOPY, FAIL, "unable to copy object") /* Check if a new valid object is copied to the destination */ - if (H5F_addr_defined(dst_oloc->addr) && (ret_value > SUCCEED)) { + if (H5_addr_defined(dst_oloc->addr) && (ret_value > SUCCEED)) { char tmp_obj_name[80]; H5G_name_t new_path; H5O_loc_t new_oloc; @@ -134,7 +134,7 @@ H5O__copy_obj_by_ref(H5O_loc_t *src_oloc, H5O_loc_t *dst_oloc, H5G_loc_t *dst_ro HGOTO_ERROR(H5E_DATATYPE, H5E_CANTINIT, FAIL, "unable to insert link") H5G_loc_free(&new_loc); - } /* if (H5F_addr_defined(dst_oloc.addr)) */ + } /* if (H5_addr_defined(dst_oloc.addr)) */ done: FUNC_LEAVE_NOAPI(ret_value) @@ -180,7 +180,7 @@ H5O__copy_expand_ref_object1(H5O_loc_t *src_oloc, const void *buf_src, H5O_loc_t HGOTO_ERROR(H5E_OHDR, H5E_CANTUNSERIALIZE, FAIL, "can't deserialize object token into address") - if (!H5F_addr_defined(src_oloc->addr) || src_oloc->addr == 0) + if (!H5_addr_defined(src_oloc->addr) || src_oloc->addr == 0) HGOTO_ERROR(H5E_ARGS, H5E_BADVALUE, FAIL, "undefined reference pointer") dst_oloc->addr = HADDR_UNDEF; @@ -242,8 +242,8 @@ H5O__copy_expand_ref_region1(H5O_loc_t *src_oloc, const void *buf_src, H5O_loc_t /* Get object address */ p = (const uint8_t *)data; - H5F_addr_decode(src_oloc->file, &p, &src_oloc->addr); - if (!H5F_addr_defined(src_oloc->addr) || src_oloc->addr == 0) { + H5_addr_decode(src_oloc->file, &p, &src_oloc->addr); + if (!H5_addr_defined(src_oloc->addr) || src_oloc->addr == 0) { H5MM_free(data); HGOTO_ERROR(H5E_ARGS, H5E_BADVALUE, FAIL, "undefined reference pointer") } @@ -257,7 +257,7 @@ H5O__copy_expand_ref_region1(H5O_loc_t *src_oloc, const void *buf_src, H5O_loc_t /* Serialize object addr */ q = (uint8_t *)data; - H5F_addr_encode(dst_oloc->file, &q, dst_oloc->addr); + H5_addr_encode(dst_oloc->file, &q, dst_oloc->addr); /* Write to heap */ if (H5R__encode_heap(dst_oloc->file, dst_buf, &buf_size, data, (size_t)data_size) < 0) { diff --git a/src/H5Odbg.c b/src/H5Odbg.c index 53e793e..6fd7b32 100644 --- a/src/H5Odbg.c +++ b/src/H5Odbg.c @@ -107,7 +107,7 @@ H5O__assert(const H5O_t *oh) assert(oh->chunk[u].size > (size_t)H5O_SIZEOF_CHKHDR_OH(oh)); /* All chunks must be allocated on disk */ - assert(H5F_addr_defined(oh->chunk[u].addr)); + assert(H5_addr_defined(oh->chunk[u].addr)); /* Version specific checks */ if (oh->version > H5O_VERSION_1) { @@ -159,7 +159,7 @@ H5O__assert(const H5O_t *oh) /* Sanity check that every continuation message has a matching chunk */ /* (and only one) */ for (v = 0; v < oh->nchunks; v++) { - if (H5F_addr_eq(cont->addr, oh->chunk[v].addr) && cont->size == oh->chunk[v].size) { + if (H5_addr_eq(cont->addr, oh->chunk[v].addr) && cont->size == oh->chunk[v].size) { assert(cont->chunkno == v); assert(!found_chunk); found_chunk = TRUE; @@ -274,7 +274,7 @@ H5O__debug_real(H5F_t *f, H5O_t *oh, haddr_t addr, FILE *stream, int indent, int /* check args */ assert(f); assert(oh); - assert(H5F_addr_defined(addr)); + assert(H5_addr_defined(addr)); assert(stream); assert(indent >= 0); assert(fwidth >= 0); @@ -347,7 +347,7 @@ H5O__debug_real(H5F_t *f, H5O_t *oh, haddr_t addr, FILE *stream, int indent, int /* Decrement chunk 0's size by the object header prefix size */ if (0 == i) { - if (H5F_addr_ne(oh->chunk[i].addr, addr)) + if (H5_addr_ne(oh->chunk[i].addr, addr)) fprintf(stream, "*** WRONG ADDRESS FOR CHUNK #0!\n"); chunk_size = oh->chunk[i].size - (size_t)H5O_SIZEOF_HDR(oh); } /* end if */ @@ -503,7 +503,7 @@ H5O_debug(H5F_t *f, haddr_t addr, FILE *stream, int indent, int fwidth) /* check args */ assert(f); - assert(H5F_addr_defined(addr)); + assert(H5_addr_defined(addr)); assert(stream); assert(indent >= 0); assert(fwidth >= 0); diff --git a/src/H5Oefl.c b/src/H5Oefl.c index 3f0b5ea..9018540 100644 --- a/src/H5Oefl.c +++ b/src/H5Oefl.c @@ -118,8 +118,8 @@ H5O__efl_decode(H5F_t *f, H5O_t H5_ATTR_UNUSED *open_oh, unsigned H5_ATTR_UNUSED /* Heap address */ if (H5_IS_BUFFER_OVERFLOW(p, H5F_sizeof_addr(f), p_end)) HGOTO_ERROR(H5E_OHDR, H5E_OVERFLOW, NULL, "ran off end of input buffer while decoding"); - H5F_addr_decode(f, &p, &(mesg->heap_addr)); - if (H5F_addr_defined(mesg->heap_addr) == FALSE) + H5_addr_decode(f, &p, &(mesg->heap_addr)); + if (H5_addr_defined(mesg->heap_addr) == FALSE) HGOTO_ERROR(H5E_OHDR, H5E_CANTLOAD, NULL, "bad local heap address when parsing efl msg") /* Decode the file list */ @@ -225,8 +225,8 @@ H5O__efl_encode(H5F_t *f, hbool_t H5_ATTR_UNUSED disable_shared, uint8_t *p, con UINT16ENCODE(p, mesg->nused); /* Heap address */ - assert(H5F_addr_defined(mesg->heap_addr)); - H5F_addr_encode(f, &p, mesg->heap_addr); + assert(H5_addr_defined(mesg->heap_addr)); + H5_addr_encode(f, &p, mesg->heap_addr); /* Encode file list */ for (u = 0; u < mesg->nused; u++) { diff --git a/src/H5Ofsinfo.c b/src/H5Ofsinfo.c index 428bcb8..f9528fd 100644 --- a/src/H5Ofsinfo.c +++ b/src/H5Ofsinfo.c @@ -138,7 +138,7 @@ H5O__fsinfo_decode(H5F_t *f, H5O_t H5_ATTR_UNUSED *open_oh, unsigned H5_ATTR_UNU if (H5_IS_BUFFER_OVERFLOW(p, H5F_sizeof_addr(f), p_end)) HGOTO_ERROR(H5E_OHDR, H5E_OVERFLOW, NULL, "ran off end of input buffer while decoding"); - H5F_addr_decode(f, &p, &(fsinfo->fs_addr[type - 1])); + H5_addr_decode(f, &p, &(fsinfo->fs_addr[type - 1])); } break; @@ -188,15 +188,15 @@ H5O__fsinfo_decode(H5F_t *f, H5O_t H5_ATTR_UNUSED *open_oh, unsigned H5_ATTR_UNU if (H5_IS_BUFFER_OVERFLOW(p, H5F_sizeof_addr(f), p_end)) HGOTO_ERROR(H5E_OHDR, H5E_OVERFLOW, NULL, "ran off end of input buffer while decoding"); - H5F_addr_decode(f, &p, - &(fsinfo->eoa_pre_fsm_fsalloc)); /* EOA before free-space header and section info */ + H5_addr_decode(f, &p, + &(fsinfo->eoa_pre_fsm_fsalloc)); /* EOA before free-space header and section info */ /* Decode addresses of free space managers, if persisting */ if (fsinfo->persist) for (ptype = H5F_MEM_PAGE_SUPER; ptype < H5F_MEM_PAGE_NTYPES; ptype++) { if (H5_IS_BUFFER_OVERFLOW(p, H5F_sizeof_addr(f), p_end)) HGOTO_ERROR(H5E_OHDR, H5E_OVERFLOW, NULL, "ran off end of input buffer while decoding"); - H5F_addr_decode(f, &p, &(fsinfo->fs_addr[ptype - 1])); + H5_addr_decode(f, &p, &(fsinfo->fs_addr[ptype - 1])); } fsinfo->mapped = FALSE; } @@ -238,15 +238,15 @@ H5O__fsinfo_encode(H5F_t *f, hbool_t H5_ATTR_UNUSED disable_shared, uint8_t *p, *p++ = (unsigned char)fsinfo->persist; /* Free-space persist or not */ H5F_ENCODE_LENGTH(f, p, fsinfo->threshold); /* Free-space section size threshold */ - H5F_ENCODE_LENGTH(f, p, fsinfo->page_size); /* File space page size */ - UINT16ENCODE(p, fsinfo->pgend_meta_thres); /* Page end metadata threshold */ - H5F_addr_encode(f, &p, fsinfo->eoa_pre_fsm_fsalloc); /* EOA before free-space header and section info */ + H5F_ENCODE_LENGTH(f, p, fsinfo->page_size); /* File space page size */ + UINT16ENCODE(p, fsinfo->pgend_meta_thres); /* Page end metadata threshold */ + H5_addr_encode(f, &p, fsinfo->eoa_pre_fsm_fsalloc); /* EOA before free-space header and section info */ /* Store addresses of free-space managers, if persisting */ if (fsinfo->persist) /* Addresses of free-space managers */ for (ptype = H5F_MEM_PAGE_SUPER; ptype < H5F_MEM_PAGE_NTYPES; ptype++) - H5F_addr_encode(f, &p, fsinfo->fs_addr[ptype - 1]); + H5_addr_encode(f, &p, fsinfo->fs_addr[ptype - 1]); FUNC_LEAVE_NOAPI(SUCCEED) } /* end H5O__fsinfo_encode() */ diff --git a/src/H5Oint.c b/src/H5Oint.c index 7efda31..ce15a33 100644 --- a/src/H5Oint.c +++ b/src/H5Oint.c @@ -925,7 +925,7 @@ H5O_link(const H5O_loc_t *loc, int adjust) /* check args */ assert(loc); assert(loc->file); - assert(H5F_addr_defined(loc->addr)); + assert(H5_addr_defined(loc->addr)); /* Pin the object header */ if (NULL == (oh = H5O_pin(loc))) @@ -976,7 +976,7 @@ H5O_protect(const H5O_loc_t *loc, unsigned prot_flags, hbool_t pin_all_chunks) assert((prot_flags & (unsigned)(~H5AC__READ_ONLY_FLAG)) == 0); /* Check for valid address */ - if (!H5F_addr_defined(loc->addr)) + if (!H5_addr_defined(loc->addr)) HGOTO_ERROR(H5E_ARGS, H5E_BADVALUE, NULL, "address undefined") /* Check for write access on the file */ @@ -1485,7 +1485,7 @@ H5O_delete(H5F_t *f, haddr_t addr) /* Check args */ assert(f); - assert(H5F_addr_defined(addr)); + assert(H5_addr_defined(addr)); /* Set up the object location */ loc.file = f; diff --git a/src/H5Olayout.c b/src/H5Olayout.c index e0f66c3..d501895 100644 --- a/src/H5Olayout.c +++ b/src/H5Olayout.c @@ -136,7 +136,7 @@ H5O__layout_decode(H5F_t *f, H5O_t H5_ATTR_UNUSED *open_oh, unsigned H5_ATTR_UNU if (mesg->type == H5D_CONTIGUOUS) { if (H5_IS_BUFFER_OVERFLOW(p, H5F_sizeof_addr(f), p_end)) HGOTO_ERROR(H5E_OHDR, H5E_OVERFLOW, NULL, "ran off end of input buffer while decoding") - H5F_addr_decode(f, &p, &(mesg->storage.u.contig.addr)); + H5_addr_decode(f, &p, &(mesg->storage.u.contig.addr)); /* Set the layout operations */ mesg->ops = H5D_LOPS_CONTIG; @@ -144,7 +144,7 @@ H5O__layout_decode(H5F_t *f, H5O_t H5_ATTR_UNUSED *open_oh, unsigned H5_ATTR_UNU else if (mesg->type == H5D_CHUNKED) { if (H5_IS_BUFFER_OVERFLOW(p, H5F_sizeof_addr(f), p_end)) HGOTO_ERROR(H5E_OHDR, H5E_OVERFLOW, NULL, "ran off end of input buffer while decoding") - H5F_addr_decode(f, &p, &(mesg->storage.u.chunk.idx_addr)); + H5_addr_decode(f, &p, &(mesg->storage.u.chunk.idx_addr)); /* Set the layout operations */ mesg->ops = H5D_LOPS_CHUNK; @@ -255,7 +255,7 @@ H5O__layout_decode(H5F_t *f, H5O_t H5_ATTR_UNUSED *open_oh, unsigned H5_ATTR_UNU /* Contiguous storage address */ if (H5_IS_BUFFER_OVERFLOW(p, H5F_sizeof_addr(f), p_end)) HGOTO_ERROR(H5E_OHDR, H5E_OVERFLOW, NULL, "ran off end of input buffer while decoding") - H5F_addr_decode(f, &p, &(mesg->storage.u.contig.addr)); + H5_addr_decode(f, &p, &(mesg->storage.u.contig.addr)); /* Contiguous storage size */ if (H5_IS_BUFFER_OVERFLOW(p, H5F_sizeof_size(f), p_end)) @@ -286,7 +286,7 @@ H5O__layout_decode(H5F_t *f, H5O_t H5_ATTR_UNUSED *open_oh, unsigned H5_ATTR_UNU if (H5_IS_BUFFER_OVERFLOW(p, H5F_sizeof_addr(f), p_end)) HGOTO_ERROR(H5E_OHDR, H5E_OVERFLOW, NULL, "ran off end of input buffer while decoding") - H5F_addr_decode(f, &p, &(mesg->storage.u.chunk.idx_addr)); + H5_addr_decode(f, &p, &(mesg->storage.u.chunk.idx_addr)); if (H5_IS_BUFFER_OVERFLOW(p, (mesg->u.chunk.ndims * 4), p_end)) HGOTO_ERROR(H5E_OHDR, H5E_OVERFLOW, NULL, @@ -512,7 +512,7 @@ H5O__layout_decode(H5F_t *f, H5O_t H5_ATTR_UNUSED *open_oh, unsigned H5_ATTR_UNU if (H5_IS_BUFFER_OVERFLOW(p, H5F_sizeof_addr(f), p_end)) HGOTO_ERROR(H5E_OHDR, H5E_OVERFLOW, NULL, "ran off end of input buffer while decoding") - H5F_addr_decode(f, &p, &(mesg->storage.u.chunk.idx_addr)); + H5_addr_decode(f, &p, &(mesg->storage.u.chunk.idx_addr)); } /* Set the layout operations */ @@ -527,7 +527,7 @@ H5O__layout_decode(H5F_t *f, H5O_t H5_ATTR_UNUSED *open_oh, unsigned H5_ATTR_UNU /* Heap information */ if (H5_IS_BUFFER_OVERFLOW(p, H5F_sizeof_addr(f), p_end)) HGOTO_ERROR(H5E_OHDR, H5E_OVERFLOW, NULL, "ran off end of input buffer while decoding") - H5F_addr_decode(f, &p, &(mesg->storage.u.virt.serial_list_hobjid.addr)); + H5_addr_decode(f, &p, &(mesg->storage.u.virt.serial_list_hobjid.addr)); /* NOTE: virtual mapping global heap entry address could be undefined */ if (H5_IS_BUFFER_OVERFLOW(p, 4, p_end)) @@ -822,7 +822,7 @@ H5O__layout_encode(H5F_t *f, hbool_t H5_ATTR_UNUSED disable_shared, uint8_t *p, case H5D_CONTIGUOUS: /* Contiguous storage address */ - H5F_addr_encode(f, &p, mesg->storage.u.contig.addr); + H5_addr_encode(f, &p, mesg->storage.u.contig.addr); /* Contiguous storage size */ H5F_ENCODE_LENGTH(f, p, mesg->storage.u.contig.size); @@ -835,7 +835,7 @@ H5O__layout_encode(H5F_t *f, hbool_t H5_ATTR_UNUSED disable_shared, uint8_t *p, *p++ = (uint8_t)mesg->u.chunk.ndims; /* B-tree address */ - H5F_addr_encode(f, &p, mesg->storage.u.chunk.idx_addr); + H5_addr_encode(f, &p, mesg->storage.u.chunk.idx_addr); /* Dimension sizes */ for (u = 0; u < mesg->u.chunk.ndims; u++) @@ -907,13 +907,13 @@ H5O__layout_encode(H5F_t *f, hbool_t H5_ATTR_UNUSED disable_shared, uint8_t *p, * Single chunk index: address of the single chunk * Other indexes: chunk index address */ - H5F_addr_encode(f, &p, mesg->storage.u.chunk.idx_addr); + H5_addr_encode(f, &p, mesg->storage.u.chunk.idx_addr); } /* end else */ break; case H5D_VIRTUAL: /* Encode heap ID for VDS info */ - H5F_addr_encode(f, &p, mesg->storage.u.virt.serial_list_hobjid.addr); + H5_addr_encode(f, &p, mesg->storage.u.virt.serial_list_hobjid.addr); UINT32ENCODE(p, mesg->storage.u.virt.serial_list_hobjid.idx); break; diff --git a/src/H5Olinfo.c b/src/H5Olinfo.c index 0e8c862..4a1fc9f 100644 --- a/src/H5Olinfo.c +++ b/src/H5Olinfo.c @@ -148,16 +148,16 @@ H5O__linfo_decode(H5F_t *f, H5O_t H5_ATTR_UNUSED *open_oh, unsigned H5_ATTR_UNUS HGOTO_ERROR(H5E_OHDR, H5E_OVERFLOW, NULL, "ran off end of input buffer while decoding") /* Address of fractal heap to store "dense" links */ - H5F_addr_decode(f, &p, &(linfo->fheap_addr)); + H5_addr_decode(f, &p, &(linfo->fheap_addr)); /* Address of v2 B-tree to index names of links (names are always indexed) */ - H5F_addr_decode(f, &p, &(linfo->name_bt2_addr)); + H5_addr_decode(f, &p, &(linfo->name_bt2_addr)); /* Address of v2 B-tree to index creation order of links, if there is one */ if (linfo->index_corder) { if (H5_IS_BUFFER_OVERFLOW(p, addr_size, p_end)) HGOTO_ERROR(H5E_OHDR, H5E_OVERFLOW, NULL, "ran off end of input buffer while decoding") - H5F_addr_decode(f, &p, &(linfo->corder_bt2_addr)); + H5_addr_decode(f, &p, &(linfo->corder_bt2_addr)); } else linfo->corder_bt2_addr = HADDR_UNDEF; @@ -208,16 +208,16 @@ H5O__linfo_encode(H5F_t *f, hbool_t H5_ATTR_UNUSED disable_shared, uint8_t *p, c INT64ENCODE(p, linfo->max_corder) /* Address of fractal heap to store "dense" links */ - H5F_addr_encode(f, &p, linfo->fheap_addr); + H5_addr_encode(f, &p, linfo->fheap_addr); /* Address of v2 B-tree to index names of links */ - H5F_addr_encode(f, &p, linfo->name_bt2_addr); + H5_addr_encode(f, &p, linfo->name_bt2_addr); /* Address of v2 B-tree to index creation order of links, if they are indexed */ if (linfo->index_corder) - H5F_addr_encode(f, &p, linfo->corder_bt2_addr); + H5_addr_encode(f, &p, linfo->corder_bt2_addr); else - assert(!H5F_addr_defined(linfo->corder_bt2_addr)); + assert(!H5_addr_defined(linfo->corder_bt2_addr)); FUNC_LEAVE_NOAPI(SUCCEED) } /* end H5O__linfo_encode() */ @@ -333,7 +333,7 @@ H5O__linfo_delete(H5F_t *f, H5O_t H5_ATTR_UNUSED *open_oh, void *_mesg) assert(linfo); /* If the group is using "dense" link storage, delete it */ - if (H5F_addr_defined(linfo->fheap_addr)) + if (H5_addr_defined(linfo->fheap_addr)) if (H5G__dense_delete(f, linfo, TRUE) < 0) HGOTO_ERROR(H5E_OHDR, H5E_CANTFREE, FAIL, "unable to free dense link storage") @@ -388,7 +388,7 @@ H5O__linfo_copy_file(H5F_t H5_ATTR_UNUSED *file_src, void *native_src, H5F_t *fi /* (XXX: should probably get the "creation" parameters for the source group's * dense link storage components and use those - QAK) */ - if (H5F_addr_defined(linfo_src->fheap_addr)) { + if (H5_addr_defined(linfo_src->fheap_addr)) { /* Create the dense link storage */ if (H5G__dense_create(file_dst, linfo_dst, udata->common.src_pline) < 0) HGOTO_ERROR(H5E_SYM, H5E_CANTINIT, NULL, "unable to create 'dense' form of new format group") @@ -478,7 +478,7 @@ H5O__linfo_post_copy_file(const H5O_loc_t *src_oloc, const void *mesg_src, H5O_l assert(src_oloc && src_oloc->file); assert(linfo_src); assert(dst_oloc && dst_oloc->file); - assert(H5F_addr_defined(dst_oloc->addr)); + assert(H5_addr_defined(dst_oloc->addr)); assert(linfo_dst); assert(cpy_info); @@ -487,7 +487,7 @@ H5O__linfo_post_copy_file(const H5O_loc_t *src_oloc, const void *mesg_src, H5O_l HGOTO_DONE(SUCCEED) /* Check for copying dense link storage */ - if (H5F_addr_defined(linfo_src->fheap_addr)) { + if (H5_addr_defined(linfo_src->fheap_addr)) { H5O_linfo_postcopy_ud_t udata; /* User data for iteration callback */ /* Set up dense link iteration user data */ diff --git a/src/H5Olink.c b/src/H5Olink.c index e8569bb..b42f2c0 100644 --- a/src/H5Olink.c +++ b/src/H5Olink.c @@ -216,7 +216,7 @@ H5O__link_decode(H5F_t *f, H5O_t H5_ATTR_UNUSED *open_oh, unsigned H5_ATTR_UNUSE /* Get the address of the object the link points to */ if (H5_IS_BUFFER_OVERFLOW(p, H5F_sizeof_addr(f), p_end)) HGOTO_ERROR(H5E_OHDR, H5E_OVERFLOW, NULL, "ran off end of input buffer while decoding") - H5F_addr_decode(f, &p, &(lnk->u.hard.addr)); + H5_addr_decode(f, &p, &(lnk->u.hard.addr)); break; case H5L_TYPE_SOFT: @@ -365,7 +365,7 @@ H5O__link_encode(H5F_t *f, hbool_t H5_ATTR_UNUSED disable_shared, uint8_t *p, co switch (lnk->type) { case H5L_TYPE_HARD: /* Store the address of the object the link points to */ - H5F_addr_encode(f, &p, lnk->u.hard.addr); + H5_addr_encode(f, &p, lnk->u.hard.addr); break; case H5L_TYPE_SOFT: @@ -615,7 +615,7 @@ H5O_link_delete(H5F_t *f, H5O_t H5_ATTR_UNUSED *open_oh, void *_mesg) /* Construct object location for object, in order to decrement it's ref count */ H5O_loc_reset(&oloc); oloc.file = f; - assert(H5F_addr_defined(lnk->u.hard.addr)); + assert(H5_addr_defined(lnk->u.hard.addr)); oloc.addr = lnk->u.hard.addr; /* Decrement the ref count for the object */ @@ -744,7 +744,7 @@ H5O__link_post_copy_file(const H5O_loc_t *src_oloc, const void *mesg_src, H5O_lo /* check args */ assert(link_src); assert(dst_oloc); - assert(H5F_addr_defined(dst_oloc->addr)); + assert(H5_addr_defined(dst_oloc->addr)); assert(dst_oloc->file); assert(link_dst); assert(cpy_info); diff --git a/src/H5Omessage.c b/src/H5Omessage.c index c759005..c26a0ff 100644 --- a/src/H5Omessage.c +++ b/src/H5Omessage.c @@ -231,7 +231,7 @@ H5O_msg_write(const H5O_loc_t *loc, unsigned type_id, unsigned mesg_flags, unsig /* check args */ assert(loc); assert(loc->file); - assert(H5F_addr_defined(loc->addr)); + assert(H5_addr_defined(loc->addr)); assert(H5O_ATTR_ID != type_id); /* Attributes are modified in another routine */ assert(type_id < NELMTS(H5O_msg_class_g)); type = H5O_msg_class_g[type_id]; /* map the type ID to the actual type object */ @@ -420,7 +420,7 @@ H5O_msg_read(const H5O_loc_t *loc, unsigned type_id, void *mesg) /* check args */ assert(loc); assert(loc->file); - assert(H5F_addr_defined(loc->addr)); + assert(H5_addr_defined(loc->addr)); assert(type_id < NELMTS(H5O_msg_class_g)); /* Get the object header */ @@ -707,7 +707,7 @@ H5O_msg_count(const H5O_loc_t *loc, unsigned type_id) /* Check args */ assert(loc); assert(loc->file); - assert(H5F_addr_defined(loc->addr)); + assert(H5_addr_defined(loc->addr)); assert(type_id < NELMTS(H5O_msg_class_g)); type = H5O_msg_class_g[type_id]; /* map the type ID to the actual type object */ assert(type); @@ -867,7 +867,7 @@ H5O_msg_remove(const H5O_loc_t *loc, unsigned type_id, int sequence, hbool_t adj /* check args */ assert(loc); assert(loc->file); - assert(H5F_addr_defined(loc->addr)); + assert(H5_addr_defined(loc->addr)); assert(H5O_ATTR_ID != type_id); /* Attributes are modified in another routine */ assert(type_id < NELMTS(H5O_msg_class_g)); type = H5O_msg_class_g[type_id]; /* map the type ID to the actual type object */ @@ -914,7 +914,7 @@ H5O_msg_remove_op(const H5O_loc_t *loc, unsigned type_id, int sequence, H5O_oper /* check args */ assert(loc); assert(loc->file); - assert(H5F_addr_defined(loc->addr)); + assert(H5_addr_defined(loc->addr)); assert(H5O_ATTR_ID != type_id); /* Attributes are modified in another routine */ assert(type_id < NELMTS(H5O_msg_class_g)); type = H5O_msg_class_g[type_id]; /* map the type ID to the actual type object */ @@ -1088,7 +1088,7 @@ H5O_msg_iterate(const H5O_loc_t *loc, unsigned type_id, const H5O_mesg_operator_ /* check args */ assert(loc); assert(loc->file); - assert(H5F_addr_defined(loc->addr)); + assert(H5_addr_defined(loc->addr)); assert(type_id < NELMTS(H5O_msg_class_g)); type = H5O_msg_class_g[type_id]; /* map the type ID to the actual type object */ assert(type); @@ -2050,7 +2050,7 @@ H5O_msg_get_flags(const H5O_loc_t *loc, unsigned type_id, uint8_t *flags) /* check args */ assert(loc); assert(loc->file); - assert(H5F_addr_defined(loc->addr)); + assert(H5_addr_defined(loc->addr)); assert(type_id < NELMTS(H5O_msg_class_g)); type = H5O_msg_class_g[type_id]; /* map the type ID to the actual type object */ assert(type); diff --git a/src/H5Oshared.c b/src/H5Oshared.c index e1c440b..d80ab9d 100644 --- a/src/H5Oshared.c +++ b/src/H5Oshared.c @@ -327,7 +327,7 @@ H5O__shared_decode(H5F_t *f, H5O_t *open_oh, unsigned *ioflags, const uint8_t *b /* Decode stored "symbol table entry" into message location */ buf += H5F_SIZEOF_SIZE(f); /* Skip over local heap address */ - H5F_addr_decode(f, &buf, &(sh_mesg.u.loc.oh_addr)); + H5_addr_decode(f, &buf, &(sh_mesg.u.loc.oh_addr)); } /* end if */ else if (version >= H5O_SHARED_VERSION_2) { /* If this message is in the heap, copy a heap ID. @@ -345,7 +345,7 @@ H5O__shared_decode(H5F_t *f, H5O_t *open_oh, unsigned *ioflags, const uint8_t *b sh_mesg.type = H5O_SHARE_TYPE_COMMITTED; sh_mesg.u.loc.index = 0; - H5F_addr_decode(f, &buf, &sh_mesg.u.loc.oh_addr); + H5_addr_decode(f, &buf, &sh_mesg.u.loc.oh_addr); } /* end else */ } /* end else if */ @@ -401,7 +401,7 @@ H5O__shared_encode(const H5F_t *f, uint8_t *buf /*out*/, const H5O_shared_t *sh_ if (sh_mesg->type == H5O_SHARE_TYPE_SOHM) H5MM_memcpy(buf, &(sh_mesg->u.heap_id), sizeof(sh_mesg->u.heap_id)); else - H5F_addr_encode(f, &buf, sh_mesg->u.loc.oh_addr); + H5_addr_encode(f, &buf, sh_mesg->u.loc.oh_addr); FUNC_LEAVE_NOAPI(SUCCEED) } /* end H5O__shared_encode() */ diff --git a/src/H5Oshmesg.c b/src/H5Oshmesg.c index d5303b7..d044f97 100644 --- a/src/H5Oshmesg.c +++ b/src/H5Oshmesg.c @@ -87,7 +87,7 @@ H5O__shmesg_decode(H5F_t *f, H5O_t H5_ATTR_UNUSED *open_oh, unsigned H5_ATTR_UNU if (H5_IS_BUFFER_OVERFLOW(p, H5F_sizeof_addr(f), p_end)) HGOTO_ERROR(H5E_OHDR, H5E_OVERFLOW, NULL, "ran off end of input buffer while decoding"); - H5F_addr_decode(f, &p, &(mesg->addr)); + H5_addr_decode(f, &p, &(mesg->addr)); if (H5_IS_BUFFER_OVERFLOW(p, 1, p_end)) HGOTO_ERROR(H5E_OHDR, H5E_OVERFLOW, NULL, "ran off end of input buffer while decoding"); @@ -126,7 +126,7 @@ H5O__shmesg_encode(H5F_t *f, hbool_t H5_ATTR_UNUSED disable_shared, uint8_t *p, /* Store version, table address, and number of indexes */ *p++ = (uint8_t)mesg->version; - H5F_addr_encode(f, &p, mesg->addr); + H5_addr_encode(f, &p, mesg->addr); *p++ = (uint8_t)mesg->nindexes; FUNC_LEAVE_NOAPI(SUCCEED) diff --git a/src/H5Ostab.c b/src/H5Ostab.c index 5f765bf..66ffe56 100644 --- a/src/H5Ostab.c +++ b/src/H5Ostab.c @@ -98,11 +98,11 @@ H5O__stab_decode(H5F_t *f, H5O_t H5_ATTR_UNUSED *open_oh, unsigned H5_ATTR_UNUSE if (H5_IS_BUFFER_OVERFLOW(p, H5F_sizeof_addr(f), p_end)) HGOTO_ERROR(H5E_OHDR, H5E_OVERFLOW, NULL, "ran off end of input buffer while decoding"); - H5F_addr_decode(f, &p, &(stab->btree_addr)); + H5_addr_decode(f, &p, &(stab->btree_addr)); if (H5_IS_BUFFER_OVERFLOW(p, H5F_sizeof_addr(f), p_end)) HGOTO_ERROR(H5E_OHDR, H5E_OVERFLOW, NULL, "ran off end of input buffer while decoding"); - H5F_addr_decode(f, &p, &(stab->heap_addr)); + H5_addr_decode(f, &p, &(stab->heap_addr)); ret_value = stab; @@ -135,8 +135,8 @@ H5O__stab_encode(H5F_t *f, hbool_t H5_ATTR_UNUSED disable_shared, uint8_t *p, co assert(stab); /* encode */ - H5F_addr_encode(f, &p, stab->btree_addr); - H5F_addr_encode(f, &p, stab->heap_addr); + H5_addr_encode(f, &p, stab->btree_addr); + H5_addr_encode(f, &p, stab->heap_addr); FUNC_LEAVE_NOAPI(SUCCEED) } /* end H5O__stab_encode() */ @@ -336,7 +336,7 @@ H5O__stab_post_copy_file(const H5O_loc_t *src_oloc, const void *mesg_src, H5O_lo /* check args */ assert(stab_src); - assert(H5F_addr_defined(dst_oloc->addr)); + assert(H5_addr_defined(dst_oloc->addr)); assert(dst_oloc->file); assert(stab_dst); assert(cpy_info); diff --git a/src/H5Otest.c b/src/H5Otest.c index 07fef18..e42af5c 100644 --- a/src/H5Otest.c +++ b/src/H5Otest.c @@ -113,7 +113,7 @@ H5O__is_attr_dense_test(hid_t oid) } /* end if */ /* Check if dense storage is being used */ - if (H5F_addr_defined(ainfo.fheap_addr)) { + if (H5_addr_defined(ainfo.fheap_addr)) { /* Check for any messages in object header */ assert(H5O__msg_count_real(oh, H5O_MSG_ATTR) == 0); @@ -190,7 +190,7 @@ H5O__is_attr_empty_test(hid_t oid) if (oh->version > H5O_VERSION_1) { if (ainfo_exists) { /* Check for using dense storage */ - if (H5F_addr_defined(ainfo.fheap_addr)) { + if (H5_addr_defined(ainfo.fheap_addr)) { /* Check for any messages in object header */ assert(nattrs == 0); @@ -292,7 +292,7 @@ H5O__num_attrs_test(hid_t oid, hsize_t *nattrs) /* Check for later version of object header format */ if (oh->version > H5O_VERSION_1) { /* Check for using dense storage */ - if (H5F_addr_defined(ainfo.fheap_addr)) { + if (H5_addr_defined(ainfo.fheap_addr)) { /* Check for any messages in object header */ assert(obj_nattrs == 0); @@ -389,9 +389,9 @@ H5O__attr_dense_info_test(hid_t oid, hsize_t *name_count, hsize_t *corder_count) } /* end if */ /* Check for 'dense' attribute storage file addresses being defined */ - if (!H5F_addr_defined(ainfo.fheap_addr)) + if (!H5_addr_defined(ainfo.fheap_addr)) HGOTO_DONE_TAG(FAIL) - if (!H5F_addr_defined(ainfo.name_bt2_addr)) + if (!H5_addr_defined(ainfo.name_bt2_addr)) HGOTO_DONE_TAG(FAIL) /* Open the name index v2 B-tree */ @@ -403,7 +403,7 @@ H5O__attr_dense_info_test(hid_t oid, hsize_t *name_count, hsize_t *corder_count) HGOTO_ERROR_TAG(H5E_OHDR, H5E_CANTCOUNT, FAIL, "unable to retrieve # of records from name index") /* Check if there is a creation order index */ - if (H5F_addr_defined(ainfo.corder_bt2_addr)) { + if (H5_addr_defined(ainfo.corder_bt2_addr)) { /* Open the creation order index v2 B-tree */ if (NULL == (bt2_corder = H5B2_open(loc->file, ainfo.corder_bt2_addr, NULL))) HGOTO_ERROR_TAG(H5E_OHDR, H5E_CANTOPENOBJ, FAIL, diff --git a/src/H5Rint.c b/src/H5Rint.c index a14d4b3..ab3b82e 100644 --- a/src/H5Rint.c +++ b/src/H5Rint.c @@ -1341,7 +1341,7 @@ H5R__encode_heap(H5F_t *f, unsigned char *buf, size_t *nalloc, const unsigned ch HGOTO_ERROR(H5E_REFERENCE, H5E_WRITEERROR, FAIL, "Unable to write reference information") /* Encode the heap information */ - H5F_addr_encode(f, &p, hobjid.addr); + H5_addr_encode(f, &p, hobjid.addr); UINT32ENCODE(p, hobjid.idx); } /* end if */ *nalloc = buf_size; @@ -1381,8 +1381,8 @@ H5R__decode_heap(H5F_t *f, const unsigned char *buf, size_t *nbytes, unsigned ch HGOTO_ERROR(H5E_REFERENCE, H5E_CANTDECODE, FAIL, "Buffer size is too small") /* Get the heap information */ - H5F_addr_decode(f, &p, &(hobjid.addr)); - if (!H5F_addr_defined(hobjid.addr) || hobjid.addr == 0) + H5_addr_decode(f, &p, &(hobjid.addr)); + if (!H5_addr_defined(hobjid.addr) || hobjid.addr == 0) HGOTO_ERROR(H5E_ARGS, H5E_BADVALUE, FAIL, "Undefined reference pointer") UINT32DECODE(p, hobjid.idx); diff --git a/src/H5SM.c b/src/H5SM.c index a5bfe15..9c01f04 100644 --- a/src/H5SM.c +++ b/src/H5SM.c @@ -119,7 +119,7 @@ H5SM_init(H5F_t *f, H5P_genplist_t *fc_plist, const H5O_loc_t *ext_loc) assert(f); /* File should not already have a SOHM table */ - assert(!H5F_addr_defined(H5F_SOHM_ADDR(f))); + assert(!H5_addr_defined(H5F_SOHM_ADDR(f))); /* Set the ring type in the DXPL */ H5AC_set_ring(H5AC_RING_USER, &orig_ring); @@ -339,7 +339,7 @@ H5SM_type_shared(H5F_t *f, unsigned type_id) HGOTO_ERROR(H5E_SOHM, H5E_CANTGET, FAIL, "can't map message type to flag") /* Look up the master SOHM table */ - if (H5F_addr_defined(H5F_SOHM_ADDR(f))) { + if (H5_addr_defined(H5F_SOHM_ADDR(f))) { H5SM_table_cache_ud_t cache_udata; /* User-data for callback */ /* Set up user data for callback */ @@ -875,7 +875,7 @@ H5SM__can_share_common(const H5F_t *f, unsigned type_id, const void *mesg) /* Check whether this message ought to be shared or not */ /* If sharing is disabled in this file, don't share the message */ - if (!H5F_addr_defined(H5F_SOHM_ADDR(f))) + if (!H5_addr_defined(H5F_SOHM_ADDR(f))) HGOTO_DONE(FALSE) /* Type-specific check */ @@ -1520,7 +1520,7 @@ H5SM_delete(H5F_t *f, H5O_t *open_oh, H5O_shared_t *sh_mesg) FUNC_ENTER_NOAPI_TAG(H5AC__SOHM_TAG, FAIL) assert(f); - assert(H5F_addr_defined(H5F_SOHM_ADDR(f))); + assert(H5_addr_defined(H5F_SOHM_ADDR(f))); assert(sh_mesg); /* Get message type */ @@ -1940,7 +1940,7 @@ H5SM_get_info(const H5O_loc_t *ext_loc, H5P_genplist_t *fc_plist) H5F_SET_SOHM_ADDR(f, sohm_table.addr); H5F_SET_SOHM_VERS(f, sohm_table.version); H5F_SET_SOHM_NINDEXES(f, sohm_table.nindexes); - assert(H5F_addr_defined(H5F_SOHM_ADDR(f))); + assert(H5_addr_defined(H5F_SOHM_ADDR(f))); assert(H5F_SOHM_NINDEXES(f) > 0 && H5F_SOHM_NINDEXES(f) <= H5O_SHMESG_MAX_NINDEXES); /* Set up user data for callback */ @@ -2557,7 +2557,7 @@ H5SM_list_debug(H5F_t *f, haddr_t list_addr, FILE *stream, int indent, int fwidt /* Determine which index the list is part of */ index_num = table->num_indexes; for (x = 0; x < table->num_indexes; x++) { - if (H5F_addr_eq(table->indexes[x].index_addr, list_addr)) { + if (H5_addr_eq(table->indexes[x].index_addr, list_addr)) { index_num = x; break; } /* end if */ @@ -2576,7 +2576,7 @@ H5SM_list_debug(H5F_t *f, haddr_t list_addr, FILE *stream, int indent, int fwidt HGOTO_ERROR(H5E_SOHM, H5E_CANTPROTECT, FAIL, "unable to load SOHM index") /* Open the heap, if one exists */ - if (H5F_addr_defined(table->indexes[index_num].heap_addr)) + if (H5_addr_defined(table->indexes[index_num].heap_addr)) if (NULL == (fh = H5HF_open(f, table->indexes[index_num].heap_addr))) HGOTO_ERROR(H5E_SOHM, H5E_CANTOPENOBJ, FAIL, "unable to open SOHM heap") @@ -2645,7 +2645,7 @@ H5SM_ih_size(H5F_t *f, hsize_t *hdr_size, H5_ih_info_t *ih_info) /* Sanity check */ assert(f); - assert(H5F_addr_defined(H5F_SOHM_ADDR(f))); + assert(H5_addr_defined(H5F_SOHM_ADDR(f))); assert(hdr_size); assert(ih_info); @@ -2664,7 +2664,7 @@ H5SM_ih_size(H5F_t *f, hsize_t *hdr_size, H5_ih_info_t *ih_info) for (u = 0; u < table->num_indexes; u++) { /* Get index storage size (for either B-tree or list) */ if (table->indexes[u].index_type == H5SM_BTREE) { - if (H5F_addr_defined(table->indexes[u].index_addr)) { + if (H5_addr_defined(table->indexes[u].index_addr)) { /* Open the index v2 B-tree */ if (NULL == (bt2 = H5B2_open(f, table->indexes[u].index_addr, f))) HGOTO_ERROR(H5E_SOHM, H5E_CANTOPENOBJ, FAIL, "unable to open v2 B-tree for SOHM index") @@ -2684,7 +2684,7 @@ H5SM_ih_size(H5F_t *f, hsize_t *hdr_size, H5_ih_info_t *ih_info) } /* end else */ /* Check for heap for this index */ - if (H5F_addr_defined(table->indexes[u].heap_addr)) { + if (H5_addr_defined(table->indexes[u].heap_addr)) { /* Open the fractal heap for this index */ if (NULL == (fheap = H5HF_open(f, table->indexes[u].heap_addr))) HGOTO_ERROR(H5E_SOHM, H5E_CANTOPENOBJ, FAIL, "unable to open fractal heap") diff --git a/src/H5SMcache.c b/src/H5SMcache.c index c9737e2..cb95232 100644 --- a/src/H5SMcache.c +++ b/src/H5SMcache.c @@ -261,10 +261,10 @@ H5SM__cache_table_deserialize(const void *_image, size_t H5_ATTR_NDEBUG_UNUSED l UINT16DECODE(image, table->indexes[u].num_messages); /* Address of the actual index */ - H5F_addr_decode(f, &image, &(table->indexes[u].index_addr)); + H5_addr_decode(f, &image, &(table->indexes[u].index_addr)); /* Address of the index's heap */ - H5F_addr_decode(f, &image, &(table->indexes[u].heap_addr)); + H5_addr_decode(f, &image, &(table->indexes[u].heap_addr)); /* Compute the size of a list index for this SOHM index */ table->indexes[u].list_size = H5SM_LIST_SIZE(f, table->indexes[u].list_max); @@ -382,10 +382,10 @@ H5SM__cache_table_serialize(const H5F_t *f, void *_image, size_t H5_ATTR_NDEBUG_ UINT16ENCODE(image, table->indexes[u].num_messages); /* Address of the actual index */ - H5F_addr_encode(f, &image, table->indexes[u].index_addr); + H5_addr_encode(f, &image, table->indexes[u].index_addr); /* Address of the index's heap */ - H5F_addr_encode(f, &image, table->indexes[u].heap_addr); + H5_addr_encode(f, &image, table->indexes[u].heap_addr); } /* end for */ /* Compute checksum on buffer */ diff --git a/src/H5SMmessage.c b/src/H5SMmessage.c index 26c8341..93b0024 100644 --- a/src/H5SMmessage.c +++ b/src/H5SMmessage.c @@ -287,7 +287,7 @@ H5SM__message_encode(uint8_t *raw, const void *_nrecord, void *_ctx) *raw++ = 0; /* reserved (possible flags byte) */ *raw++ = (uint8_t)message->msg_type_id; UINT16ENCODE(raw, message->u.mesg_loc.index); - H5F_addr_encode_len((size_t)ctx->sizeof_addr, &raw, message->u.mesg_loc.oh_addr); + H5_addr_encode_len((size_t)ctx->sizeof_addr, &raw, message->u.mesg_loc.oh_addr); } /* end else */ FUNC_LEAVE_NOAPI(SUCCEED) @@ -324,7 +324,7 @@ H5SM__message_decode(const uint8_t *raw, void *_nrecord, void *_ctx) raw++; /* reserved */ message->msg_type_id = *raw++; UINT16DECODE(raw, message->u.mesg_loc.index); - H5F_addr_decode_len((size_t)ctx->sizeof_addr, &raw, &message->u.mesg_loc.oh_addr); + H5_addr_decode_len((size_t)ctx->sizeof_addr, &raw, &message->u.mesg_loc.oh_addr); } /* end else */ FUNC_LEAVE_NOAPI(SUCCEED) diff --git a/src/H5SMtest.c b/src/H5SMtest.c index ab333b5..3ed479d 100644 --- a/src/H5SMtest.c +++ b/src/H5SMtest.c @@ -73,7 +73,7 @@ H5SM__get_mesg_count_test(H5F_t *f, unsigned type_id, size_t *mesg_count) assert(mesg_count); /* Check for shared messages being enabled */ - if (H5F_addr_defined(H5F_SOHM_ADDR(f))) { + if (H5_addr_defined(H5F_SOHM_ADDR(f))) { H5SM_index_header_t *header; /* Index header for message type */ H5SM_table_cache_ud_t cache_udata; /* User-data for callback */ ssize_t index_num; /* Table index for message type */ diff --git a/src/H5T.c b/src/H5T.c index 9b21321..3ed0a5a 100644 --- a/src/H5T.c +++ b/src/H5T.c @@ -4019,8 +4019,8 @@ H5T_close(H5T_t *dt) /* Sanity checks */ assert(dt->sh_loc.type == H5O_SHARE_TYPE_COMMITTED); - assert(H5F_addr_defined(dt->sh_loc.u.loc.oh_addr)); - assert(H5F_addr_defined(dt->oloc.addr)); + assert(H5_addr_defined(dt->sh_loc.u.loc.oh_addr)); + assert(H5_addr_defined(dt->oloc.addr)); /* If a named type is being closed then close the object header and * remove from the list of open objects in the file. diff --git a/src/H5Tcommit.c b/src/H5Tcommit.c index dfbef83..2a612f8 100644 --- a/src/H5Tcommit.c +++ b/src/H5Tcommit.c @@ -984,7 +984,7 @@ H5T__open_name(const H5G_loc_t *loc, const char *name) done: /* Error cleanup */ if (NULL == ret_value) - if (obj_found && H5F_addr_defined(type_loc.oloc->addr)) + if (obj_found && H5_addr_defined(type_loc.oloc->addr)) if (H5G_loc_free(&type_loc) < 0) HDONE_ERROR(H5E_DATATYPE, H5E_CANTRELEASE, NULL, "can't free location") diff --git a/src/H5Tref.c b/src/H5Tref.c index 0f59715..8313cfb 100644 --- a/src/H5Tref.c +++ b/src/H5Tref.c @@ -1063,7 +1063,7 @@ H5T__ref_obj_disk_isnull(const H5VL_object_t *src_file, const void *src_buf, hbo HGOTO_ERROR(H5E_ARGS, H5E_BADTYPE, FAIL, "invalid VOL object") /* Get the object address */ - H5F_addr_decode(src_f, &p, &addr); + H5_addr_decode(src_f, &p, &addr); /* Check if heap address is 'nil' */ *isnull = (addr == 0) ? TRUE : FALSE; @@ -1215,7 +1215,7 @@ H5T__ref_dsetreg_disk_isnull(const H5VL_object_t *src_file, const void *src_buf, HGOTO_ERROR(H5E_ARGS, H5E_BADTYPE, FAIL, "invalid VOL object") /* Get the heap address */ - H5F_addr_decode(src_f, &p, &addr); + H5_addr_decode(src_f, &p, &addr); /* Check if heap address is 'nil' */ *isnull = (addr == 0) ? TRUE : FALSE; diff --git a/src/H5VLnative.c b/src/H5VLnative.c index 679edb6..20e00f8 100644 --- a/src/H5VLnative.c +++ b/src/H5VLnative.c @@ -445,7 +445,7 @@ H5VL_native_addr_to_token(void *obj, H5I_type_t obj_type, haddr_t addr, H5O_toke /* Encode token */ p = (uint8_t *)token; - H5F_addr_encode_len(addr_len, &p, addr); + H5_addr_encode_len(addr_len, &p, addr); done: FUNC_LEAVE_NOAPI(ret_value) @@ -536,7 +536,7 @@ H5VL_native_token_to_addr(void *obj, H5I_type_t obj_type, H5O_token_t token, had /* Decode token */ p = (const uint8_t *)&token; - H5F_addr_decode_len(addr_len, &p, addr); + H5_addr_decode_len(addr_len, &p, addr); done: FUNC_LEAVE_NOAPI(ret_value) diff --git a/src/H5VLnative_blob.c b/src/H5VLnative_blob.c index 6793bcb..fbc11be 100644 --- a/src/H5VLnative_blob.c +++ b/src/H5VLnative_blob.c @@ -76,7 +76,7 @@ H5VL__native_blob_put(void *obj, const void *buf, size_t size, void *blob_id, vo HGOTO_ERROR(H5E_VOL, H5E_WRITEERROR, FAIL, "unable to write blob information") /* Encode the heap information */ - H5F_addr_encode(f, &id, hobjid.addr); + H5_addr_encode(f, &id, hobjid.addr); UINT32ENCODE(id, hobjid.idx); done: @@ -109,7 +109,7 @@ H5VL__native_blob_get(void *obj, const void *blob_id, void *buf, size_t size, vo assert(buf); /* Get the heap information */ - H5F_addr_decode(f, &id, &hobjid.addr); + H5_addr_decode(f, &id, &hobjid.addr); UINT32DECODE(id, hobjid.idx); /* Check if this sequence actually has any data */ @@ -153,7 +153,7 @@ H5VL__native_blob_specific(void *obj, void *blob_id, H5VL_blob_specific_args_t * haddr_t addr; /* Sequence's heap address */ /* Get the heap address */ - H5F_addr_decode(f, &id, &addr); + H5_addr_decode(f, &id, &addr); /* Check if heap address is 'nil' */ *args->args.is_null.isnull = (addr == 0 ? TRUE : FALSE); @@ -165,7 +165,7 @@ H5VL__native_blob_specific(void *obj, void *blob_id, H5VL_blob_specific_args_t * uint8_t *id = (uint8_t *)blob_id; /* Pointer to the blob ID */ /* Encode the 'nil' heap pointer information */ - H5F_addr_encode(f, &id, (haddr_t)0); + H5_addr_encode(f, &id, (haddr_t)0); UINT32ENCODE(id, 0); break; @@ -176,7 +176,7 @@ H5VL__native_blob_specific(void *obj, void *blob_id, H5VL_blob_specific_args_t * H5HG_t hobjid; /* VL sequence's heap ID */ /* Get heap information */ - H5F_addr_decode(f, &id, &hobjid.addr); + H5_addr_decode(f, &id, &hobjid.addr); UINT32DECODE(id, hobjid.idx); /* Free heap object */ diff --git a/src/H5private.h b/src/H5private.h index 91a4780..327e2c9 100644 --- a/src/H5private.h +++ b/src/H5private.h @@ -413,6 +413,35 @@ */ #define H5_REQUEST_NULL NULL +/* clang-format off */ +/* Address-related macros */ +#define H5_addr_overflow(X,Z) (HADDR_UNDEF == (X) || \ + HADDR_UNDEF == (X) + (haddr_t)(Z) || \ + (X) + (haddr_t)(Z) < (X)) +#define H5_addr_defined(X) ((X) != HADDR_UNDEF) +/* The H5_addr_eq() macro guarantees that Y is not HADDR_UNDEF by making + * certain that X is not HADDR_UNDEF and then checking that X equals Y + */ +#define H5_addr_eq(X,Y) ((X) != HADDR_UNDEF && (X) == (Y)) +#define H5_addr_ne(X,Y) (!H5_addr_eq((X),(Y))) +#define H5_addr_lt(X,Y) ((X) != HADDR_UNDEF && \ + (Y) != HADDR_UNDEF && \ + (X) < (Y)) +#define H5_addr_le(X,Y) ((X) != HADDR_UNDEF && \ + (Y) != HADDR_UNDEF && \ + (X) <= (Y)) +#define H5_addr_gt(X,Y) ((X) != HADDR_UNDEF && \ + (Y) != HADDR_UNDEF && \ + (X) > (Y)) +#define H5_addr_ge(X,Y) ((X) != HADDR_UNDEF && \ + (Y) != HADDR_UNDEF && \ + (X) >= (Y)) +#define H5_addr_cmp(X,Y) (H5_addr_eq((X), (Y)) ? 0 : \ + (H5_addr_lt((X), (Y)) ? -1 : 1)) +#define H5_addr_overlap(O1,L1,O2,L2) (((O1) < (O2) && ((O1) + (L1)) > (O2)) || \ + ((O1) >= (O2) && (O1) < ((O2) + (L2)))) +/* clang-format on */ + /* * Methods to compare the equality of floating-point values: * diff --git a/src/H5trace.c b/src/H5trace.c index 022a355..fb9a27c 100644 --- a/src/H5trace.c +++ b/src/H5trace.c @@ -429,7 +429,7 @@ H5_trace_args(H5RS_str_t *rs, const char *type, va_list ap) { haddr_t addr = va_arg(ap, haddr_t); - if (H5F_addr_defined(addr)) + if (H5_addr_defined(addr)) H5RS_asprintf_cat(rs, "%" PRIuHADDR, addr); else H5RS_acat(rs, "UNDEF"); diff --git a/test/btree2.c b/test/btree2.c index a9393b3..b56e238 100644 --- a/test/btree2.c +++ b/test/btree2.c @@ -133,7 +133,7 @@ create_btree(H5F_t *f, const H5B2_create_t *cparam, H5B2_t **bt2, haddr_t *bt2_a FAIL_STACK_ERROR; if (H5B2_get_addr(*bt2, bt2_addr /*out*/) < 0) FAIL_STACK_ERROR; - if (!H5F_addr_defined(*bt2_addr)) + if (!H5_addr_defined(*bt2_addr)) FAIL_STACK_ERROR; /* Success */ @@ -5271,7 +5271,7 @@ test_remove_basic(hid_t fapl, const H5B2_create_t *cparam, const bt2_test_param_ FAIL_STACK_ERROR; /* Make certain that the address of the root node is defined */ - if (!H5F_addr_defined(root_addr)) + if (!H5_addr_defined(root_addr)) TEST_ERROR; /* Attempt to remove a non-existent record from a B-tree with 1 record */ @@ -5316,7 +5316,7 @@ test_remove_basic(hid_t fapl, const H5B2_create_t *cparam, const bt2_test_param_ FAIL_STACK_ERROR; /* Make certain that the root node has been freed */ - if (H5F_addr_defined(root_addr)) + if (H5_addr_defined(root_addr)) TEST_ERROR; PASSED(); @@ -5400,7 +5400,7 @@ test_remove_basic(hid_t fapl, const H5B2_create_t *cparam, const bt2_test_param_ FAIL_STACK_ERROR; /* Make certain that the root node has not been freed */ - if (!H5F_addr_defined(root_addr)) + if (!H5_addr_defined(root_addr)) TEST_ERROR; record = 34; @@ -5425,7 +5425,7 @@ test_remove_basic(hid_t fapl, const H5B2_create_t *cparam, const bt2_test_param_ FAIL_STACK_ERROR; /* Make certain that the root node has not been freed */ - if (!H5F_addr_defined(root_addr)) + if (!H5_addr_defined(root_addr)) TEST_ERROR; record = 56; @@ -5450,7 +5450,7 @@ test_remove_basic(hid_t fapl, const H5B2_create_t *cparam, const bt2_test_param_ FAIL_STACK_ERROR; /* Make certain that the root node has not been freed */ - if (!H5F_addr_defined(root_addr)) + if (!H5_addr_defined(root_addr)) TEST_ERROR; record = 38; @@ -5475,7 +5475,7 @@ test_remove_basic(hid_t fapl, const H5B2_create_t *cparam, const bt2_test_param_ FAIL_STACK_ERROR; /* Make certain that the root node has been freed */ - if (H5F_addr_defined(root_addr)) + if (H5_addr_defined(root_addr)) TEST_ERROR; /* Close the v2 B-tree */ @@ -5557,7 +5557,7 @@ test_remove_level1_noredistrib(hid_t fapl, const H5B2_create_t *cparam, const bt FAIL_STACK_ERROR; /* Make certain that the address of the root node is defined */ - if (!H5F_addr_defined(root_addr)) + if (!H5_addr_defined(root_addr)) TEST_ERROR; /* Attempt to remove a non-existent record from a B-tree with 1 record */ @@ -5785,7 +5785,7 @@ test_remove_level1_redistrib(hid_t fapl, const H5B2_create_t *cparam, const bt2_ FAIL_STACK_ERROR; /* Make certain that the address of the root node is defined */ - if (!H5F_addr_defined(root_addr)) + if (!H5_addr_defined(root_addr)) TEST_ERROR; /* Check for closing & re-opening the B-tree */ @@ -5980,7 +5980,7 @@ test_remove_level1_2leaf_merge(hid_t fapl, const H5B2_create_t *cparam, const bt FAIL_STACK_ERROR; /* Make certain that the address of the root node is defined */ - if (!H5F_addr_defined(root_addr)) + if (!H5_addr_defined(root_addr)) TEST_ERROR; /* Check for closing & re-opening the B-tree */ @@ -6155,7 +6155,7 @@ test_remove_level1_3leaf_merge(hid_t fapl, const H5B2_create_t *cparam, const bt FAIL_STACK_ERROR; /* Make certain that the address of the root node is defined */ - if (!H5F_addr_defined(root_addr)) + if (!H5_addr_defined(root_addr)) TEST_ERROR; /* Check for closing & re-opening the B-tree */ @@ -6283,7 +6283,7 @@ test_remove_level1_promote(hid_t fapl, const H5B2_create_t *cparam, const bt2_te FAIL_STACK_ERROR; /* Make certain that the address of the root node is defined */ - if (!H5F_addr_defined(root_addr)) + if (!H5_addr_defined(root_addr)) TEST_ERROR; /* Check for closing & re-opening the B-tree */ @@ -6501,7 +6501,7 @@ test_remove_level1_promote_2leaf_redistrib(hid_t fapl, const H5B2_create_t *cpar FAIL_STACK_ERROR; /* Make certain that the address of the root node is defined */ - if (!H5F_addr_defined(root_addr)) + if (!H5_addr_defined(root_addr)) TEST_ERROR; /* Check for closing & re-opening the B-tree */ @@ -6646,7 +6646,7 @@ test_remove_level1_promote_3leaf_redistrib(hid_t fapl, const H5B2_create_t *cpar FAIL_STACK_ERROR; /* Make certain that the address of the root node is defined */ - if (!H5F_addr_defined(root_addr)) + if (!H5_addr_defined(root_addr)) TEST_ERROR; /* Check for closing & re-opening the B-tree */ @@ -6791,7 +6791,7 @@ test_remove_level1_promote_2leaf_merge(hid_t fapl, const H5B2_create_t *cparam, FAIL_STACK_ERROR; /* Make certain that the address of the root node is defined */ - if (!H5F_addr_defined(root_addr)) + if (!H5_addr_defined(root_addr)) TEST_ERROR; /* Check for closing & re-opening the B-tree */ @@ -6933,7 +6933,7 @@ test_remove_level1_promote_3leaf_merge(hid_t fapl, const H5B2_create_t *cparam, FAIL_STACK_ERROR; /* Make certain that the address of the root node is defined */ - if (!H5F_addr_defined(root_addr)) + if (!H5_addr_defined(root_addr)) TEST_ERROR; /* Check for closing & re-opening the B-tree */ @@ -7071,7 +7071,7 @@ test_remove_level1_collapse(hid_t fapl, const H5B2_create_t *cparam, const bt2_t FAIL_STACK_ERROR; /* Make certain that the address of the root node is defined */ - if (!H5F_addr_defined(root_addr)) + if (!H5_addr_defined(root_addr)) TEST_ERROR; /* Check for closing & re-opening the B-tree */ @@ -7118,7 +7118,7 @@ test_remove_level1_collapse(hid_t fapl, const H5B2_create_t *cparam, const bt2_t FAIL_STACK_ERROR; /* Make certain that the address of the root node is defined */ - if (!H5F_addr_defined(root_addr)) + if (!H5_addr_defined(root_addr)) TEST_ERROR; /* Close the v2 B-tree */ @@ -7209,7 +7209,7 @@ test_remove_level2_promote(hid_t fapl, const H5B2_create_t *cparam, const bt2_te FAIL_STACK_ERROR; /* Make certain that the address of the root node is defined */ - if (!H5F_addr_defined(root_addr)) + if (!H5_addr_defined(root_addr)) TEST_ERROR; /* Check for closing & re-opening the B-tree */ @@ -7492,7 +7492,7 @@ test_remove_level2_promote_2internal_redistrib(hid_t fapl, const H5B2_create_t * FAIL_STACK_ERROR; /* Make certain that the address of the root node is defined */ - if (!H5F_addr_defined(root_addr)) + if (!H5_addr_defined(root_addr)) TEST_ERROR; /* Check for closing & re-opening the B-tree */ @@ -7640,7 +7640,7 @@ test_remove_level2_promote_3internal_redistrib(hid_t fapl, const H5B2_create_t * FAIL_STACK_ERROR; /* Make certain that the address of the root node is defined */ - if (!H5F_addr_defined(root_addr)) + if (!H5_addr_defined(root_addr)) TEST_ERROR; /* Check for closing & re-opening the B-tree */ @@ -7788,7 +7788,7 @@ test_remove_level2_promote_2internal_merge(hid_t fapl, const H5B2_create_t *cpar FAIL_STACK_ERROR; /* Make certain that the address of the root node is defined */ - if (!H5F_addr_defined(root_addr)) + if (!H5_addr_defined(root_addr)) TEST_ERROR; /* Check for closing & re-opening the B-tree */ @@ -7937,7 +7937,7 @@ test_remove_level2_promote_3internal_merge(hid_t fapl, const H5B2_create_t *cpar FAIL_STACK_ERROR; /* Make certain that the address of the root node is defined */ - if (!H5F_addr_defined(root_addr)) + if (!H5_addr_defined(root_addr)) TEST_ERROR; /* Check for closing & re-opening the B-tree */ @@ -8086,7 +8086,7 @@ test_remove_level2_2internal_merge_left(hid_t fapl, const H5B2_create_t *cparam, FAIL_STACK_ERROR; /* Make certain that the address of the root node is defined */ - if (!H5F_addr_defined(root_addr)) + if (!H5_addr_defined(root_addr)) TEST_ERROR; /* Check for closing & re-opening the B-tree */ @@ -8209,7 +8209,7 @@ test_remove_level2_2internal_merge_right(hid_t fapl, const H5B2_create_t *cparam FAIL_STACK_ERROR; /* Make certain that the address of the root node is defined */ - if (!H5F_addr_defined(root_addr)) + if (!H5_addr_defined(root_addr)) TEST_ERROR; /* Check for closing & re-opening the B-tree */ @@ -8331,7 +8331,7 @@ test_remove_level2_3internal_merge(hid_t fapl, const H5B2_create_t *cparam, cons FAIL_STACK_ERROR; /* Make certain that the address of the root node is defined */ - if (!H5F_addr_defined(root_addr)) + if (!H5_addr_defined(root_addr)) TEST_ERROR; /* Check for closing & re-opening the B-tree */ @@ -8455,7 +8455,7 @@ test_remove_level2_collapse_right(hid_t fapl, const H5B2_create_t *cparam, const FAIL_STACK_ERROR; /* Make certain that the address of the root node is defined */ - if (!H5F_addr_defined(root_addr)) + if (!H5_addr_defined(root_addr)) TEST_ERROR; /* Check for closing & re-opening the B-tree */ @@ -8737,7 +8737,7 @@ fprintf(stderr, "curr_time = %lu\n", (unsigned long)curr_time); FAIL_STACK_ERROR; /* Make certain that the address of the root node is defined */ - if (H5F_addr_defined(root_addr)) + if (H5_addr_defined(root_addr)) TEST_ERROR; /* Close the v2 B-tree */ @@ -8821,7 +8821,7 @@ fprintf(stderr, "curr_time = %lu\n", (unsigned long)curr_time); FAIL_STACK_ERROR; /* Make certain that the address of the root node is defined */ - if (H5F_addr_defined(root_addr)) + if (H5_addr_defined(root_addr)) TEST_ERROR; /* Close the v2 B-tree */ @@ -8903,7 +8903,7 @@ fprintf(stderr, "curr_time = %lu\n", (unsigned long)curr_time); FAIL_STACK_ERROR; /* Make certain that the address of the root node is defined */ - if (H5F_addr_defined(root_addr)) + if (H5_addr_defined(root_addr)) TEST_ERROR; /* Close the v2 B-tree */ @@ -8985,7 +8985,7 @@ fprintf(stderr, "curr_time = %lu\n", (unsigned long)curr_time); FAIL_STACK_ERROR; /* Make certain that the address of the root node is defined */ - if (H5F_addr_defined(root_addr)) + if (H5_addr_defined(root_addr)) TEST_ERROR; /* Close the v2 B-tree */ diff --git a/test/cache.c b/test/cache.c index 970a999..48f10f2 100644 --- a/test/cache.c +++ b/test/cache.c @@ -33812,7 +33812,7 @@ takedown_cache(H5F_t *file_ptr, hbool_t dump_stats, hbool_t dump_detailed_stats) if (saved_fid != -1) { - if (H5F_addr_defined(saved_actual_base_addr)) { + if (H5_addr_defined(saved_actual_base_addr)) { if (NULL == file_ptr) { file_ptr = (H5F_t *)H5VL_object_verify(saved_fid, H5I_FILE); diff --git a/test/cache_common.h b/test/cache_common.h index 5b3cc2b..53f783e 100644 --- a/test/cache_common.h +++ b/test/cache_common.h @@ -408,7 +408,7 @@ typedef struct test_entry_t { #define H5C_TEST__PRE_HT_SEARCH_SC(cache_ptr, Addr) \ if (((cache_ptr) == NULL) || ((cache_ptr)->magic != H5C__H5C_T_MAGIC) || \ ((cache_ptr)->index_size != ((cache_ptr)->clean_index_size + (cache_ptr)->dirty_index_size)) || \ - (!H5F_addr_defined(Addr)) || (H5C__HASH_FCN(Addr) < 0) || \ + (!H5_addr_defined(Addr)) || (H5C__HASH_FCN(Addr) < 0) || \ (H5C__HASH_FCN(Addr) >= H5C__HASH_TABLE_LEN)) { \ HDfprintf(stdout, "Pre HT search SC failed.\n"); \ } @@ -438,7 +438,7 @@ typedef struct test_entry_t { k = H5C__HASH_FCN(Addr); \ entry_ptr = ((cache_ptr)->index)[k]; \ while (entry_ptr) { \ - if (H5F_addr_eq(Addr, (entry_ptr)->addr)) { \ + if (H5_addr_eq(Addr, (entry_ptr)->addr)) { \ H5C_TEST__POST_SUC_HT_SEARCH_SC(cache_ptr, entry_ptr, k) \ if (entry_ptr != ((cache_ptr)->index)[k]) { \ if ((entry_ptr)->ht_next) \ diff --git a/test/cache_image.c b/test/cache_image.c index 70da799..ccf516d 100644 --- a/test/cache_image.c +++ b/test/cache_image.c @@ -7142,9 +7142,9 @@ get_free_sections_test(hbool_t single_file_vfd) /* file_ptr->shared->first_alloc_dealloc is set to FALSE if the * file is opened R/O. */ - if ((!H5F_addr_defined(file_ptr->shared->eoa_fsm_fsalloc)) || - (!H5F_addr_defined(file_ptr->shared->cache->image_addr)) || - (H5F_addr_gt(file_ptr->shared->eoa_fsm_fsalloc, file_ptr->shared->cache->image_addr))) { + if ((!H5_addr_defined(file_ptr->shared->eoa_fsm_fsalloc)) || + (!H5_addr_defined(file_ptr->shared->cache->image_addr)) || + (H5_addr_gt(file_ptr->shared->eoa_fsm_fsalloc, file_ptr->shared->cache->image_addr))) { pass = FALSE; failure_mssg = "unexpected cache image status (1).\n"; @@ -7247,9 +7247,9 @@ get_free_sections_test(hbool_t single_file_vfd) */ if (pass) { - if ((!H5F_addr_defined(file_ptr->shared->eoa_fsm_fsalloc)) || - (!H5F_addr_defined(file_ptr->shared->cache->image_addr)) || - (H5F_addr_gt(file_ptr->shared->eoa_fsm_fsalloc, file_ptr->shared->cache->image_addr))) { + if ((!H5_addr_defined(file_ptr->shared->eoa_fsm_fsalloc)) || + (!H5_addr_defined(file_ptr->shared->cache->image_addr)) || + (H5_addr_gt(file_ptr->shared->eoa_fsm_fsalloc, file_ptr->shared->cache->image_addr))) { pass = FALSE; failure_mssg = "unexpected cache image status (2).\n"; diff --git a/test/earray.c b/test/earray.c index c2b5273..ad85281 100644 --- a/test/earray.c +++ b/test/earray.c @@ -465,7 +465,7 @@ create_array(H5F_t *f, const H5EA_create_t *cparam, H5EA_t **ea, haddr_t *ea_add TEST_ERROR; if (H5EA_get_addr(*ea, ea_addr) < 0) FAIL_STACK_ERROR; - if (!H5F_addr_defined(*ea_addr)) + if (!H5_addr_defined(*ea_addr)) TEST_ERROR; memset(&state, 0, sizeof(state)); state.hdr_size = EA_HDR_SIZE; diff --git a/test/farray.c b/test/farray.c index 8f46e70..ff5685a 100644 --- a/test/farray.c +++ b/test/farray.c @@ -316,7 +316,7 @@ create_array(H5F_t *f, const H5FA_create_t *cparam, H5FA_t **fa, haddr_t *fa_add /* Check status of array */ if (H5FA_get_addr(*fa, fa_addr) < 0) FAIL_STACK_ERROR; - if (!H5F_addr_defined(*fa_addr)) + if (!H5_addr_defined(*fa_addr)) TEST_ERROR; /* Check array stats */ diff --git a/test/fheap.c b/test/fheap.c index 5ece28b..6c6a003 100644 --- a/test/fheap.c +++ b/test/fheap.c @@ -629,7 +629,7 @@ open_heap(char *filename, hid_t fapl, const H5HF_create_t *cparam, const fheap_t TEST_ERROR; if (H5HF_get_heap_addr(*fh, fh_addr) < 0) FAIL_STACK_ERROR; - if (!H5F_addr_defined(*fh_addr)) + if (!H5_addr_defined(*fh_addr)) TEST_ERROR; memset(state, 0, sizeof(fheap_heap_state_t)); if (check_stats(*fh, state)) @@ -674,7 +674,7 @@ open_heap(char *filename, hid_t fapl, const H5HF_create_t *cparam, const fheap_t TEST_ERROR; if (H5HF_get_heap_addr(*fh, fh_addr) < 0) FAIL_STACK_ERROR; - if (!H5F_addr_defined(*fh_addr)) + if (!H5_addr_defined(*fh_addr)) TEST_ERROR; memset(state, 0, sizeof(fheap_heap_state_t)); if (check_stats(*fh, state)) @@ -818,7 +818,7 @@ del_objs_half_refill(H5F_t *f, H5HF_t **fh, fheap_test_param_t *tparam, fheap_he if (tparam->reopen_heap) { if (H5HF_get_heap_addr(*fh, &fh_addr) < 0) FAIL_STACK_ERROR; - if (!H5F_addr_defined(fh_addr)) + if (!H5_addr_defined(fh_addr)) TEST_ERROR; } /* end if */ @@ -912,7 +912,7 @@ del_objs(H5F_t *f, H5HF_t **fh, fheap_test_param_t *tparam, fheap_heap_state_t * if (tparam->reopen_heap) { if (H5HF_get_heap_addr(*fh, &fh_addr) < 0) FAIL_STACK_ERROR; - if (!H5F_addr_defined(fh_addr)) + if (!H5_addr_defined(fh_addr)) TEST_ERROR; } /* end if */ @@ -1770,7 +1770,7 @@ test_create(hid_t fapl, H5HF_create_t *cparam, fheap_test_param_t *tparam) TEST_ERROR; if (H5HF_get_heap_addr(fh, &fh_addr) < 0) FAIL_STACK_ERROR; - if (!H5F_addr_defined(fh_addr)) + if (!H5_addr_defined(fh_addr)) TEST_ERROR; memset(&state, 0, sizeof(fheap_heap_state_t)); if (check_stats(fh, &state)) @@ -1892,7 +1892,7 @@ test_reopen(hid_t fapl, H5HF_create_t *cparam, fheap_test_param_t *tparam) TEST_ERROR; if (H5HF_get_heap_addr(fh, &fh_addr) < 0) FAIL_STACK_ERROR; - if (!H5F_addr_defined(fh_addr)) + if (!H5_addr_defined(fh_addr)) TEST_ERROR; memset(&state, 0, sizeof(fheap_heap_state_t)); if (check_stats(fh, &state)) @@ -2044,7 +2044,7 @@ test_open_twice(hid_t fapl, H5HF_create_t *cparam, fheap_test_param_t *tparam) TEST_ERROR; if (H5HF_get_heap_addr(fh, &fh_addr) < 0) FAIL_STACK_ERROR; - if (!H5F_addr_defined(fh_addr)) + if (!H5_addr_defined(fh_addr)) TEST_ERROR; memset(&state, 0, sizeof(fheap_heap_state_t)); if (check_stats(fh, &state)) @@ -2211,7 +2211,7 @@ test_delete_open(hid_t fapl, H5HF_create_t *cparam, fheap_test_param_t *tparam) TEST_ERROR; if (H5HF_get_heap_addr(fh, &fh_addr) < 0) FAIL_STACK_ERROR; - if (!H5F_addr_defined(fh_addr)) + if (!H5_addr_defined(fh_addr)) TEST_ERROR; memset(&state, 0, sizeof(fheap_heap_state_t)); if (check_stats(fh, &state)) @@ -2712,7 +2712,7 @@ test_filtered_create(hid_t fapl, H5HF_create_t *cparam, hid_t fcpl) /* Get heap's address */ if (H5HF_get_heap_addr(fh, &fh_addr) < 0) FAIL_STACK_ERROR; - if (!H5F_addr_defined(fh_addr)) + if (!H5_addr_defined(fh_addr)) TEST_ERROR; /* Close the fractal heap */ @@ -2823,7 +2823,7 @@ test_size(hid_t fapl, H5HF_create_t *cparam, hid_t fcpl) /* Get heap's address */ if (H5HF_get_heap_addr(fh, &fh_addr) < 0) FAIL_STACK_ERROR; - if (!H5F_addr_defined(fh_addr)) + if (!H5_addr_defined(fh_addr)) TEST_ERROR; /* Get an empty heap's size */ @@ -2961,7 +2961,7 @@ test_reopen_hdr(hid_t fapl, H5HF_create_t *cparam, hid_t fcpl) /* Get heap's address */ if (H5HF_get_heap_addr(fh, &fh_addr) < 0) FAIL_STACK_ERROR; - if (!H5F_addr_defined(fh_addr)) + if (!H5_addr_defined(fh_addr)) TEST_ERROR; /* Insert an object */ @@ -3091,7 +3091,7 @@ test_man_insert_weird(hid_t fapl, H5HF_create_t *cparam, fheap_test_param_t *tpa TEST_ERROR; if (H5HF_get_heap_addr(fh, &fh_addr) < 0) FAIL_STACK_ERROR; - if (!H5F_addr_defined(fh_addr)) + if (!H5_addr_defined(fh_addr)) TEST_ERROR; memset(&state, 0, sizeof(fheap_heap_state_t)); if (check_stats(fh, &state)) @@ -3201,7 +3201,7 @@ test_man_insert_first(hid_t fapl, H5HF_create_t *cparam, fheap_test_param_t *tpa TEST_ERROR; if (H5HF_get_heap_addr(fh, &fh_addr) < 0) FAIL_STACK_ERROR; - if (!H5F_addr_defined(fh_addr)) + if (!H5_addr_defined(fh_addr)) TEST_ERROR; memset(&state, 0, sizeof(fheap_heap_state_t)); if (check_stats(fh, &state)) @@ -3299,7 +3299,7 @@ test_man_insert_second(hid_t fapl, H5HF_create_t *cparam, fheap_test_param_t *tp FAIL_STACK_ERROR; if (H5HF_get_heap_addr(fh, &fh_addr) < 0) FAIL_STACK_ERROR; - if (!H5F_addr_defined(fh_addr)) + if (!H5_addr_defined(fh_addr)) FAIL_STACK_ERROR; memset(&state, 0, sizeof(fheap_heap_state_t)); @@ -3393,7 +3393,7 @@ test_man_insert_root_mult(hid_t fapl, H5HF_create_t *cparam, fheap_test_param_t FAIL_STACK_ERROR; if (H5HF_get_heap_addr(fh, &fh_addr) < 0) FAIL_STACK_ERROR; - if (!H5F_addr_defined(fh_addr)) + if (!H5_addr_defined(fh_addr)) FAIL_STACK_ERROR; memset(&state, 0, sizeof(fheap_heap_state_t)); @@ -3489,7 +3489,7 @@ test_man_insert_force_indirect(hid_t fapl, H5HF_create_t *cparam, fheap_test_par FAIL_STACK_ERROR; if (H5HF_get_heap_addr(fh, &fh_addr) < 0) FAIL_STACK_ERROR; - if (!H5F_addr_defined(fh_addr)) + if (!H5_addr_defined(fh_addr)) FAIL_STACK_ERROR; memset(&state, 0, sizeof(fheap_heap_state_t)); @@ -3592,7 +3592,7 @@ test_man_insert_fill_second(hid_t fapl, H5HF_create_t *cparam, fheap_test_param_ FAIL_STACK_ERROR; if (H5HF_get_heap_addr(fh, &fh_addr) < 0) FAIL_STACK_ERROR; - if (!H5F_addr_defined(fh_addr)) + if (!H5_addr_defined(fh_addr)) FAIL_STACK_ERROR; memset(&state, 0, sizeof(fheap_heap_state_t)); @@ -3696,7 +3696,7 @@ test_man_insert_third_direct(hid_t fapl, H5HF_create_t *cparam, fheap_test_param FAIL_STACK_ERROR; if (H5HF_get_heap_addr(fh, &fh_addr) < 0) FAIL_STACK_ERROR; - if (!H5F_addr_defined(fh_addr)) + if (!H5_addr_defined(fh_addr)) FAIL_STACK_ERROR; memset(&state, 0, sizeof(fheap_heap_state_t)); @@ -3804,7 +3804,7 @@ test_man_fill_first_row(hid_t fapl, H5HF_create_t *cparam, fheap_test_param_t *t FAIL_STACK_ERROR; if (H5HF_get_heap_addr(fh, &fh_addr) < 0) FAIL_STACK_ERROR; - if (!H5F_addr_defined(fh_addr)) + if (!H5_addr_defined(fh_addr)) FAIL_STACK_ERROR; memset(&state, 0, sizeof(fheap_heap_state_t)); @@ -3897,7 +3897,7 @@ test_man_start_second_row(hid_t fapl, H5HF_create_t *cparam, fheap_test_param_t FAIL_STACK_ERROR; if (H5HF_get_heap_addr(fh, &fh_addr) < 0) FAIL_STACK_ERROR; - if (!H5F_addr_defined(fh_addr)) + if (!H5_addr_defined(fh_addr)) FAIL_STACK_ERROR; memset(&state, 0, sizeof(fheap_heap_state_t)); @@ -3997,7 +3997,7 @@ test_man_fill_second_row(hid_t fapl, H5HF_create_t *cparam, fheap_test_param_t * FAIL_STACK_ERROR; if (H5HF_get_heap_addr(fh, &fh_addr) < 0) FAIL_STACK_ERROR; - if (!H5F_addr_defined(fh_addr)) + if (!H5_addr_defined(fh_addr)) FAIL_STACK_ERROR; memset(&state, 0, sizeof(fheap_heap_state_t)); @@ -4095,7 +4095,7 @@ test_man_start_third_row(hid_t fapl, H5HF_create_t *cparam, fheap_test_param_t * FAIL_STACK_ERROR; if (H5HF_get_heap_addr(fh, &fh_addr) < 0) FAIL_STACK_ERROR; - if (!H5F_addr_defined(fh_addr)) + if (!H5_addr_defined(fh_addr)) FAIL_STACK_ERROR; memset(&state, 0, sizeof(fheap_heap_state_t)); @@ -4203,7 +4203,7 @@ test_man_fill_fourth_row(hid_t fapl, H5HF_create_t *cparam, fheap_test_param_t * FAIL_STACK_ERROR; if (H5HF_get_heap_addr(fh, &fh_addr) < 0) FAIL_STACK_ERROR; - if (!H5F_addr_defined(fh_addr)) + if (!H5_addr_defined(fh_addr)) FAIL_STACK_ERROR; memset(&state, 0, sizeof(fheap_heap_state_t)); @@ -4297,7 +4297,7 @@ test_man_fill_all_root_direct(hid_t fapl, H5HF_create_t *cparam, fheap_test_para FAIL_STACK_ERROR; if (H5HF_get_heap_addr(fh, &fh_addr) < 0) FAIL_STACK_ERROR; - if (!H5F_addr_defined(fh_addr)) + if (!H5_addr_defined(fh_addr)) FAIL_STACK_ERROR; memset(&state, 0, sizeof(fheap_heap_state_t)); @@ -4390,7 +4390,7 @@ test_man_first_recursive_indirect(hid_t fapl, H5HF_create_t *cparam, fheap_test_ FAIL_STACK_ERROR; if (H5HF_get_heap_addr(fh, &fh_addr) < 0) FAIL_STACK_ERROR; - if (!H5F_addr_defined(fh_addr)) + if (!H5_addr_defined(fh_addr)) FAIL_STACK_ERROR; memset(&state, 0, sizeof(fheap_heap_state_t)); @@ -4489,7 +4489,7 @@ test_man_second_direct_recursive_indirect(hid_t fapl, H5HF_create_t *cparam, fhe FAIL_STACK_ERROR; if (H5HF_get_heap_addr(fh, &fh_addr) < 0) FAIL_STACK_ERROR; - if (!H5F_addr_defined(fh_addr)) + if (!H5_addr_defined(fh_addr)) FAIL_STACK_ERROR; memset(&state, 0, sizeof(fheap_heap_state_t)); @@ -4596,7 +4596,7 @@ test_man_fill_first_recursive_indirect(hid_t fapl, H5HF_create_t *cparam, fheap_ FAIL_STACK_ERROR; if (H5HF_get_heap_addr(fh, &fh_addr) < 0) FAIL_STACK_ERROR; - if (!H5F_addr_defined(fh_addr)) + if (!H5_addr_defined(fh_addr)) FAIL_STACK_ERROR; memset(&state, 0, sizeof(fheap_heap_state_t)); @@ -4696,7 +4696,7 @@ test_man_second_recursive_indirect(hid_t fapl, H5HF_create_t *cparam, fheap_test FAIL_STACK_ERROR; if (H5HF_get_heap_addr(fh, &fh_addr) < 0) FAIL_STACK_ERROR; - if (!H5F_addr_defined(fh_addr)) + if (!H5_addr_defined(fh_addr)) FAIL_STACK_ERROR; memset(&state, 0, sizeof(fheap_heap_state_t)); @@ -4804,7 +4804,7 @@ test_man_fill_second_recursive_indirect(hid_t fapl, H5HF_create_t *cparam, fheap FAIL_STACK_ERROR; if (H5HF_get_heap_addr(fh, &fh_addr) < 0) FAIL_STACK_ERROR; - if (!H5F_addr_defined(fh_addr)) + if (!H5_addr_defined(fh_addr)) FAIL_STACK_ERROR; memset(&state, 0, sizeof(fheap_heap_state_t)); @@ -4905,7 +4905,7 @@ test_man_fill_recursive_indirect_row(hid_t fapl, H5HF_create_t *cparam, fheap_te FAIL_STACK_ERROR; if (H5HF_get_heap_addr(fh, &fh_addr) < 0) FAIL_STACK_ERROR; - if (!H5F_addr_defined(fh_addr)) + if (!H5_addr_defined(fh_addr)) FAIL_STACK_ERROR; memset(&state, 0, sizeof(fheap_heap_state_t)); @@ -5004,7 +5004,7 @@ test_man_start_2nd_recursive_indirect(hid_t fapl, H5HF_create_t *cparam, fheap_t FAIL_STACK_ERROR; if (H5HF_get_heap_addr(fh, &fh_addr) < 0) FAIL_STACK_ERROR; - if (!H5F_addr_defined(fh_addr)) + if (!H5_addr_defined(fh_addr)) FAIL_STACK_ERROR; memset(&state, 0, sizeof(fheap_heap_state_t)); @@ -5110,7 +5110,7 @@ test_man_recursive_indirect_two_deep(hid_t fapl, H5HF_create_t *cparam, fheap_te FAIL_STACK_ERROR; if (H5HF_get_heap_addr(fh, &fh_addr) < 0) FAIL_STACK_ERROR; - if (!H5F_addr_defined(fh_addr)) + if (!H5_addr_defined(fh_addr)) FAIL_STACK_ERROR; memset(&state, 0, sizeof(fheap_heap_state_t)); @@ -5210,7 +5210,7 @@ test_man_start_3rd_recursive_indirect(hid_t fapl, H5HF_create_t *cparam, fheap_t FAIL_STACK_ERROR; if (H5HF_get_heap_addr(fh, &fh_addr) < 0) FAIL_STACK_ERROR; - if (!H5F_addr_defined(fh_addr)) + if (!H5_addr_defined(fh_addr)) FAIL_STACK_ERROR; memset(&state, 0, sizeof(fheap_heap_state_t)); @@ -5317,7 +5317,7 @@ test_man_fill_first_3rd_recursive_indirect(hid_t fapl, H5HF_create_t *cparam, fh FAIL_STACK_ERROR; if (H5HF_get_heap_addr(fh, &fh_addr) < 0) FAIL_STACK_ERROR; - if (!H5F_addr_defined(fh_addr)) + if (!H5_addr_defined(fh_addr)) FAIL_STACK_ERROR; memset(&state, 0, sizeof(fheap_heap_state_t)); @@ -5425,7 +5425,7 @@ test_man_fill_3rd_recursive_indirect_row(hid_t fapl, H5HF_create_t *cparam, fhea FAIL_STACK_ERROR; if (H5HF_get_heap_addr(fh, &fh_addr) < 0) FAIL_STACK_ERROR; - if (!H5F_addr_defined(fh_addr)) + if (!H5_addr_defined(fh_addr)) FAIL_STACK_ERROR; memset(&state, 0, sizeof(fheap_heap_state_t)); @@ -5530,7 +5530,7 @@ test_man_fill_all_3rd_recursive_indirect(hid_t fapl, H5HF_create_t *cparam, fhea FAIL_STACK_ERROR; if (H5HF_get_heap_addr(fh, &fh_addr) < 0) FAIL_STACK_ERROR; - if (!H5F_addr_defined(fh_addr)) + if (!H5_addr_defined(fh_addr)) FAIL_STACK_ERROR; memset(&state, 0, sizeof(fheap_heap_state_t)); @@ -5636,7 +5636,7 @@ test_man_start_4th_recursive_indirect(hid_t fapl, H5HF_create_t *cparam, fheap_t FAIL_STACK_ERROR; if (H5HF_get_heap_addr(fh, &fh_addr) < 0) FAIL_STACK_ERROR; - if (!H5F_addr_defined(fh_addr)) + if (!H5_addr_defined(fh_addr)) FAIL_STACK_ERROR; memset(&state, 0, sizeof(fheap_heap_state_t)); @@ -5748,7 +5748,7 @@ test_man_fill_first_4th_recursive_indirect(hid_t fapl, H5HF_create_t *cparam, fh FAIL_STACK_ERROR; if (H5HF_get_heap_addr(fh, &fh_addr) < 0) FAIL_STACK_ERROR; - if (!H5F_addr_defined(fh_addr)) + if (!H5_addr_defined(fh_addr)) FAIL_STACK_ERROR; memset(&state, 0, sizeof(fheap_heap_state_t)); @@ -5866,7 +5866,7 @@ test_man_fill_4th_recursive_indirect_row(hid_t fapl, H5HF_create_t *cparam, fhea FAIL_STACK_ERROR; if (H5HF_get_heap_addr(fh, &fh_addr) < 0) FAIL_STACK_ERROR; - if (!H5F_addr_defined(fh_addr)) + if (!H5_addr_defined(fh_addr)) FAIL_STACK_ERROR; memset(&state, 0, sizeof(fheap_heap_state_t)); @@ -5975,7 +5975,7 @@ test_man_fill_all_4th_recursive_indirect(hid_t fapl, H5HF_create_t *cparam, fhea FAIL_STACK_ERROR; if (H5HF_get_heap_addr(fh, &fh_addr) < 0) FAIL_STACK_ERROR; - if (!H5F_addr_defined(fh_addr)) + if (!H5_addr_defined(fh_addr)) FAIL_STACK_ERROR; memset(&state, 0, sizeof(fheap_heap_state_t)); @@ -6086,7 +6086,7 @@ test_man_start_5th_recursive_indirect(hid_t fapl, H5HF_create_t *cparam, fheap_t FAIL_STACK_ERROR; if (H5HF_get_heap_addr(fh, &fh_addr) < 0) FAIL_STACK_ERROR; - if (!H5F_addr_defined(fh_addr)) + if (!H5_addr_defined(fh_addr)) FAIL_STACK_ERROR; memset(&state, 0, sizeof(fheap_heap_state_t)); @@ -6215,7 +6215,7 @@ test_man_remove_bogus(hid_t fapl, H5HF_create_t *cparam, fheap_test_param_t *tpa FAIL_STACK_ERROR; if (H5HF_get_heap_addr(fh, &fh_addr) < 0) FAIL_STACK_ERROR; - if (!H5F_addr_defined(fh_addr)) + if (!H5_addr_defined(fh_addr)) FAIL_STACK_ERROR; memset(&state, 0, sizeof(fheap_heap_state_t)); if (check_stats(fh, &state)) @@ -6371,7 +6371,7 @@ test_man_remove_one(hid_t fapl, H5HF_create_t *cparam, fheap_test_param_t *tpara FAIL_STACK_ERROR; if (H5HF_get_heap_addr(fh, &fh_addr) < 0) FAIL_STACK_ERROR; - if (!H5F_addr_defined(fh_addr)) + if (!H5_addr_defined(fh_addr)) FAIL_STACK_ERROR; memset(&state, 0, sizeof(fheap_heap_state_t)); if (check_stats(fh, &state)) @@ -6533,7 +6533,7 @@ test_man_remove_two(hid_t fapl, H5HF_create_t *cparam, fheap_test_param_t *tpara FAIL_STACK_ERROR; if (H5HF_get_heap_addr(fh, &fh_addr) < 0) FAIL_STACK_ERROR; - if (!H5F_addr_defined(fh_addr)) + if (!H5_addr_defined(fh_addr)) FAIL_STACK_ERROR; memset(&state, 0, sizeof(fheap_heap_state_t)); if (check_stats(fh, &state)) @@ -6724,7 +6724,7 @@ test_man_remove_one_larger(hid_t fapl, H5HF_create_t *cparam, fheap_test_param_t FAIL_STACK_ERROR; if (H5HF_get_heap_addr(fh, &fh_addr) < 0) FAIL_STACK_ERROR; - if (!H5F_addr_defined(fh_addr)) + if (!H5_addr_defined(fh_addr)) FAIL_STACK_ERROR; memset(&state, 0, sizeof(fheap_heap_state_t)); if (check_stats(fh, &state)) @@ -6891,7 +6891,7 @@ test_man_remove_two_larger(hid_t fapl, H5HF_create_t *cparam, fheap_test_param_t FAIL_STACK_ERROR; if (H5HF_get_heap_addr(fh, &fh_addr) < 0) FAIL_STACK_ERROR; - if (!H5F_addr_defined(fh_addr)) + if (!H5_addr_defined(fh_addr)) FAIL_STACK_ERROR; memset(&state, 0, sizeof(fheap_heap_state_t)); if (check_stats(fh, &state)) @@ -7129,7 +7129,7 @@ test_man_remove_three_larger(hid_t fapl, H5HF_create_t *cparam, fheap_test_param FAIL_STACK_ERROR; if (H5HF_get_heap_addr(fh, &fh_addr) < 0) FAIL_STACK_ERROR; - if (!H5F_addr_defined(fh_addr)) + if (!H5_addr_defined(fh_addr)) FAIL_STACK_ERROR; memset(&state, 0, sizeof(fheap_heap_state_t)); if (check_stats(fh, &state)) @@ -7431,7 +7431,7 @@ test_man_incr_insert_remove(hid_t fapl, H5HF_create_t *cparam, fheap_test_param_ FAIL_STACK_ERROR; if (H5HF_get_heap_addr(fh, &fh_addr) < 0) FAIL_STACK_ERROR; - if (!H5F_addr_defined(fh_addr)) + if (!H5_addr_defined(fh_addr)) FAIL_STACK_ERROR; memset(&state, 0, sizeof(fheap_heap_state_t)); if (check_stats(fh, &state)) diff --git a/test/freespace.c b/test/freespace.c index 9c9a2f2..b00540b 100644 --- a/test/freespace.c +++ b/test/freespace.c @@ -223,10 +223,10 @@ TEST_sect_can_merge(const H5FS_section_info_t *_sect1, const H5FS_section_info_t assert(sect1); assert(sect2); assert(sect1->sect_info.type == sect2->sect_info.type); /* Checks "MERGE_SYM" flag */ - assert(H5F_addr_lt(sect1->sect_info.addr, sect2->sect_info.addr)); + assert(H5_addr_lt(sect1->sect_info.addr, sect2->sect_info.addr)); /* Check if second section adjoins first section */ - ret_value = H5F_addr_eq(sect1->sect_info.addr + sect1->sect_info.size, sect2->sect_info.addr); + ret_value = H5_addr_eq(sect1->sect_info.addr + sect1->sect_info.size, sect2->sect_info.addr); return ret_value; } /* TEST_sect_can_merge() */ @@ -250,7 +250,7 @@ TEST_sect_merging(H5FS_section_info_t **_sect1, H5FS_section_info_t *_sect2, voi assert((sect2->sect_info.type == TEST_FSPACE_SECT_TYPE) || (sect2->sect_info.type == TEST_FSPACE_SECT_TYPE_NEW) || (sect2->sect_info.type == TEST_FSPACE_SECT_TYPE_NONE)); - assert(H5F_addr_eq((*sect1)->sect_info.addr + (*sect1)->sect_info.size, sect2->sect_info.addr)); + assert(H5_addr_eq((*sect1)->sect_info.addr + (*sect1)->sect_info.size, sect2->sect_info.addr)); /* Add second section's size to first section */ (*sect1)->sect_info.size += sect2->sect_info.size; @@ -487,7 +487,7 @@ test_fs_create(hid_t fapl) (hsize_t)FSPACE_THRHD_DEF, (hsize_t)FSPACE_ALIGN_DEF))) FAIL_STACK_ERROR; - if (!H5F_addr_defined(fs_addr)) + if (!H5_addr_defined(fs_addr)) TEST_ERROR; if (frsp->nclasses != nclasses) TEST_ERROR; @@ -512,7 +512,7 @@ test_fs_create(hid_t fapl) (hsize_t)FSPACE_ALIGN_DEF))) FAIL_STACK_ERROR; - if (!H5F_addr_defined(fs_addr)) + if (!H5_addr_defined(fs_addr)) TEST_ERROR; if (frsp->nclasses != nclasses) TEST_ERROR; @@ -629,7 +629,7 @@ test_fs_sect_add(hid_t fapl) (hsize_t)FSPACE_THRHD_DEF, (hsize_t)FSPACE_ALIGN_DEF))) FAIL_STACK_ERROR; - if (!H5F_addr_defined(fs_addr)) + if (!H5_addr_defined(fs_addr)) TEST_ERROR; if (NULL == (sect_node = (TEST_free_section_t *)malloc(sizeof(TEST_free_section_t)))) @@ -694,7 +694,7 @@ test_fs_sect_add(hid_t fapl) (hsize_t)FSPACE_THRHD_DEF, (hsize_t)FSPACE_ALIGN_DEF))) FAIL_STACK_ERROR; - if (!H5F_addr_defined(fs_addr)) + if (!H5_addr_defined(fs_addr)) TEST_ERROR; /* Create free list section node */ @@ -769,7 +769,7 @@ test_fs_sect_add(hid_t fapl) (hsize_t)FSPACE_THRHD_DEF, (hsize_t)FSPACE_ALIGN_DEF))) FAIL_STACK_ERROR; - if (!H5F_addr_defined(fs_addr)) + if (!H5_addr_defined(fs_addr)) TEST_ERROR; if (NULL == (sect_node = (TEST_free_section_t *)malloc(sizeof(TEST_free_section_t)))) @@ -839,7 +839,7 @@ test_fs_sect_add(hid_t fapl) (hsize_t)FSPACE_THRHD_DEF, (hsize_t)FSPACE_ALIGN_DEF))) FAIL_STACK_ERROR; - if (!H5F_addr_defined(fs_addr)) + if (!H5_addr_defined(fs_addr)) TEST_ERROR; if (NULL == (sect_node = (TEST_free_section_t *)malloc(sizeof(TEST_free_section_t)))) @@ -962,7 +962,7 @@ test_fs_sect_find(hid_t fapl) (hsize_t)FSPACE_THRHD_DEF, (hsize_t)FSPACE_ALIGN_DEF))) FAIL_STACK_ERROR; - if (!H5F_addr_defined(fs_addr)) + if (!H5_addr_defined(fs_addr)) TEST_ERROR; memset(&state, 0, sizeof(frspace_state_t)); @@ -993,7 +993,7 @@ test_fs_sect_find(hid_t fapl) (hsize_t)FSPACE_ALIGN_DEF))) FAIL_STACK_ERROR; - if (!H5F_addr_defined(fs_addr)) + if (!H5_addr_defined(fs_addr)) TEST_ERROR; if (frsp->nclasses != nclasses) TEST_ERROR; @@ -1120,7 +1120,7 @@ test_fs_sect_find(hid_t fapl) (hsize_t)FSPACE_ALIGN_DEF))) FAIL_STACK_ERROR; - if (!H5F_addr_defined(fs_addr)) + if (!H5_addr_defined(fs_addr)) TEST_ERROR; if (frsp->nclasses != nclasses) TEST_ERROR; @@ -1199,7 +1199,7 @@ test_fs_sect_find(hid_t fapl) (hsize_t)FSPACE_ALIGN_DEF))) FAIL_STACK_ERROR; - if (!H5F_addr_defined(fs_addr)) + if (!H5_addr_defined(fs_addr)) TEST_ERROR; if (frsp->nclasses != nclasses) TEST_ERROR; @@ -1349,7 +1349,7 @@ test_fs_sect_merge(hid_t fapl) (hsize_t)FSPACE_THRHD_DEF, (hsize_t)FSPACE_ALIGN_DEF))) FAIL_STACK_ERROR; - if (!H5F_addr_defined(fs_addr)) + if (!H5_addr_defined(fs_addr)) TEST_ERROR; /* @@ -1478,7 +1478,7 @@ test_fs_sect_merge(hid_t fapl) (hsize_t)FSPACE_THRHD_DEF, (hsize_t)FSPACE_ALIGN_DEF))) FAIL_STACK_ERROR; - if (!H5F_addr_defined(fs_addr)) + if (!H5_addr_defined(fs_addr)) TEST_ERROR; /* @@ -1581,7 +1581,7 @@ test_fs_sect_merge(hid_t fapl) (hsize_t)FSPACE_THRHD_DEF, (hsize_t)FSPACE_ALIGN_DEF))) FAIL_STACK_ERROR; - if (!H5F_addr_defined(fs_addr)) + if (!H5_addr_defined(fs_addr)) TEST_ERROR; /* @@ -1827,7 +1827,7 @@ test_fs_sect_shrink(hid_t fapl) (hsize_t)FSPACE_THRHD_DEF, (hsize_t)FSPACE_ALIGN_DEF))) FAIL_STACK_ERROR; - if (!H5F_addr_defined(fs_addr)) + if (!H5_addr_defined(fs_addr)) TEST_ERROR; /* @@ -1929,7 +1929,7 @@ test_fs_sect_shrink(hid_t fapl) (hsize_t)FSPACE_THRHD_DEF, (hsize_t)FSPACE_ALIGN_DEF))) FAIL_STACK_ERROR; - if (!H5F_addr_defined(fs_addr)) + if (!H5_addr_defined(fs_addr)) TEST_ERROR; /* @@ -2029,7 +2029,7 @@ test_fs_sect_shrink(hid_t fapl) (hsize_t)FSPACE_THRHD_DEF, (hsize_t)FSPACE_ALIGN_DEF))) FAIL_STACK_ERROR; - if (!H5F_addr_defined(fs_addr)) + if (!H5_addr_defined(fs_addr)) TEST_ERROR; /* @@ -2171,7 +2171,7 @@ test_fs_sect_change_class(hid_t fapl) (hsize_t)FSPACE_THRHD_DEF, (hsize_t)FSPACE_ALIGN_DEF))) FAIL_STACK_ERROR; - if (!H5F_addr_defined(fs_addr)) + if (!H5_addr_defined(fs_addr)) TEST_ERROR; /* @@ -2275,7 +2275,7 @@ test_fs_sect_change_class(hid_t fapl) (hsize_t)FSPACE_THRHD_DEF, (hsize_t)FSPACE_ALIGN_DEF))) FAIL_STACK_ERROR; - if (!H5F_addr_defined(fs_addr)) + if (!H5_addr_defined(fs_addr)) TEST_ERROR; /* @@ -2459,7 +2459,7 @@ test_fs_sect_extend(hid_t fapl) (hsize_t)FSPACE_THRHD_DEF, (hsize_t)FSPACE_ALIGN_DEF))) FAIL_STACK_ERROR; - if (!H5F_addr_defined(fs_addr)) + if (!H5_addr_defined(fs_addr)) TEST_ERROR; /* @@ -2536,7 +2536,7 @@ test_fs_sect_extend(hid_t fapl) (hsize_t)FSPACE_THRHD_DEF, (hsize_t)FSPACE_ALIGN_DEF))) FAIL_STACK_ERROR; - if (!H5F_addr_defined(fs_addr)) + if (!H5_addr_defined(fs_addr)) TEST_ERROR; /* @@ -2610,7 +2610,7 @@ test_fs_sect_extend(hid_t fapl) (hsize_t)FSPACE_THRHD_DEF, (hsize_t)FSPACE_ALIGN_DEF))) FAIL_STACK_ERROR; - if (!H5F_addr_defined(fs_addr)) + if (!H5_addr_defined(fs_addr)) TEST_ERROR; /* @@ -2685,7 +2685,7 @@ test_fs_sect_extend(hid_t fapl) (hsize_t)FSPACE_THRHD_DEF, (hsize_t)FSPACE_ALIGN_DEF))) FAIL_STACK_ERROR; - if (!H5F_addr_defined(fs_addr)) + if (!H5_addr_defined(fs_addr)) TEST_ERROR; /* @@ -2818,7 +2818,7 @@ test_fs_sect_iterate(hid_t fapl) (hsize_t)FSPACE_THRHD_DEF, (hsize_t)FSPACE_ALIGN_DEF))) FAIL_STACK_ERROR; - if (!H5F_addr_defined(fs_addr)) + if (!H5_addr_defined(fs_addr)) TEST_ERROR; for (i = 1; i <= NUM_SECTIONS; i++) { diff --git a/test/gheap.c b/test/gheap.c index 071c44b..6b02c98 100644 --- a/test/gheap.c +++ b/test/gheap.c @@ -103,7 +103,7 @@ test_1(hid_t fapl) HDputs(" Unable to insert object into global heap"); nerrors++; } - else if (u && H5F_addr_gt(obj[u - 1].addr, obj[u].addr)) { + else if (u && H5_addr_gt(obj[u - 1].addr, obj[u].addr)) { H5_FAILED(); HDputs(" Collection addresses are not monotonically increasing"); nerrors++; diff --git a/test/links.c b/test/links.c index e137945..154ae30 100644 --- a/test/links.c +++ b/test/links.c @@ -2165,7 +2165,7 @@ cklinks_deprec(hid_t fapl, hbool_t new_format) printf(" %d: Unexpected object type should have been a dataset\n", __LINE__); TEST_ERROR; } /* end if */ - if (H5F_addr_ne(oinfo1.addr, oinfo2.addr)) { + if (H5_addr_ne(oinfo1.addr, oinfo2.addr)) { H5_FAILED(); HDputs(" Hard link test failed. Link seems not to point to the "); HDputs(" expected file location."); @@ -2210,7 +2210,7 @@ cklinks_deprec(hid_t fapl, hbool_t new_format) printf(" %d: Unexpected object type should have been a dataset\n", __LINE__); TEST_ERROR; } /* end if */ - if (H5F_addr_ne(oinfo1.addr, oinfo2.addr)) { + if (H5_addr_ne(oinfo1.addr, oinfo2.addr)) { H5_FAILED(); HDputs(" Soft link test failed. Link seems not to point to the "); HDputs(" expected file location."); @@ -5377,7 +5377,7 @@ link_info_by_idx_old_deprec(hid_t fapl) if (H5Lget_info_by_idx1(group_id, ".", H5_INDEX_NAME, H5_ITER_INC, (hsize_t)u, &linfo, H5P_DEFAULT) < 0) TEST_ERROR; - if (H5F_addr_ne(linfo.u.address, objno[u])) + if (H5_addr_ne(linfo.u.address, objno[u])) TEST_ERROR; } /* end if */ else { @@ -5400,7 +5400,7 @@ link_info_by_idx_old_deprec(hid_t fapl) if (H5Lget_info_by_idx1(group_id, ".", H5_INDEX_NAME, H5_ITER_NATIVE, (hsize_t)u, &linfo, H5P_DEFAULT) < 0) TEST_ERROR; - if (H5F_addr_ne(linfo.u.address, objno[u])) + if (H5_addr_ne(linfo.u.address, objno[u])) TEST_ERROR; } /* end if */ else { @@ -5429,7 +5429,7 @@ link_info_by_idx_old_deprec(hid_t fapl) if (H5Lget_info_by_idx1(group_id, ".", H5_INDEX_NAME, H5_ITER_DEC, (hsize_t)u, &linfo, H5P_DEFAULT) < 0) TEST_ERROR; - if (H5F_addr_ne(linfo.u.address, objno[dec_u])) + if (H5_addr_ne(linfo.u.address, objno[dec_u])) TEST_ERROR; } /* end if */ else { @@ -6007,11 +6007,11 @@ delete_by_idx_old_deprec(hid_t fapl) if (H5Lget_info_by_idx1(group_id, ".", H5_INDEX_NAME, order, (hsize_t)0, &linfo, H5P_DEFAULT) < 0) TEST_ERROR; if (order == H5_ITER_INC) { - if (H5F_addr_ne(linfo.u.address, objno[u + 1])) + if (H5_addr_ne(linfo.u.address, objno[u + 1])) TEST_ERROR; } /* end if */ else { - if (H5F_addr_ne(linfo.u.address, objno[dec_u])) + if (H5_addr_ne(linfo.u.address, objno[dec_u])) TEST_ERROR; } /* end else */ @@ -6081,11 +6081,11 @@ delete_by_idx_old_deprec(hid_t fapl) if (H5Lget_info_by_idx1(group_id, ".", H5_INDEX_NAME, order, (hsize_t)u, &linfo, H5P_DEFAULT) < 0) TEST_ERROR; if (order == H5_ITER_INC) { - if (H5F_addr_ne(linfo.u.address, objno[(u * 2) + 1])) + if (H5_addr_ne(linfo.u.address, objno[(u * 2) + 1])) TEST_ERROR; } /* end if */ else { - if (H5F_addr_ne(linfo.u.address, objno[dec_u])) + if (H5_addr_ne(linfo.u.address, objno[dec_u])) TEST_ERROR; } /* end else */ @@ -6115,11 +6115,11 @@ delete_by_idx_old_deprec(hid_t fapl) if (H5Lget_info_by_idx1(group_id, ".", H5_INDEX_NAME, order, (hsize_t)0, &linfo, H5P_DEFAULT) < 0) TEST_ERROR; if (order == H5_ITER_INC) { - if (H5F_addr_ne(linfo.u.address, objno[(u * 2) + 3])) + if (H5_addr_ne(linfo.u.address, objno[(u * 2) + 3])) TEST_ERROR; } /* end if */ else { - if (H5F_addr_ne(linfo.u.address, objno[dec_u])) + if (H5_addr_ne(linfo.u.address, objno[dec_u])) TEST_ERROR; } /* end else */ @@ -6208,7 +6208,7 @@ link_iterate_deprec_cb(hid_t group_id, const char *link_name, const H5L_info1_t return H5_ITER_ERROR; if (info->cset != my_info.cset) return H5_ITER_ERROR; - if (H5F_addr_ne(info->u.address, my_info.u.address)) + if (H5_addr_ne(info->u.address, my_info.u.address)) return H5_ITER_ERROR; } /* end if */ @@ -6704,7 +6704,7 @@ link_iterate_old_deprec_cb(hid_t group_id, const char *link_name, const H5L_info return H5_ITER_ERROR; if (info->cset != my_info.cset) return H5_ITER_ERROR; - if (H5F_addr_ne(info->u.address, my_info.u.address)) + if (H5_addr_ne(info->u.address, my_info.u.address)) return H5_ITER_ERROR; } /* end if */ diff --git a/test/mf.c b/test/mf.c index 315295d..9dfdcb9 100644 --- a/test/mf.c +++ b/test/mf.c @@ -999,7 +999,7 @@ test_mf_tmp(const char *env_h5_drvr, hid_t fapl, hbool_t new_format) check_addr = H5MF_alloc_tmp(f, (hsize_t)(maxaddr / 3)); } H5E_END_TRY; - if (H5F_addr_defined(check_addr)) + if (H5_addr_defined(check_addr)) TEST_ERROR; /* Test that pushing normal space allocation into temporary space fails */ @@ -1008,7 +1008,7 @@ test_mf_tmp(const char *env_h5_drvr, hid_t fapl, hbool_t new_format) check_addr = H5MF_alloc(f, H5FD_MEM_DRAW, (hsize_t)(maxaddr / 3)); } H5E_END_TRY; - if (H5F_addr_defined(check_addr)) + if (H5_addr_defined(check_addr)) TEST_ERROR; /* Free the normal block (so the file doesn't blow up to a huge size) */ @@ -6401,7 +6401,7 @@ test_mf_fs_persist_split(void) FAIL_STACK_ERROR; /* Verify that the H5FD_MEM_SUPER free-space manager is there */ - if (!H5F_addr_defined(f->shared->fs_addr[type])) + if (!H5_addr_defined(f->shared->fs_addr[type])) TEST_ERROR; /* Start up H5FD_MEM_SUPER free-space manager */ @@ -6425,7 +6425,7 @@ test_mf_fs_persist_split(void) TEST_ERROR; /* Verify that the free-space manager for H5FD_MEM_DRAW is there */ - if (!H5F_addr_defined(f->shared->fs_addr[stype])) + if (!H5_addr_defined(f->shared->fs_addr[stype])) TEST_ERROR; /* Start up H5FD_MEM_DRAW free-space manager */ @@ -6485,11 +6485,11 @@ test_mf_fs_persist_split(void) FAIL_STACK_ERROR; /* Verify that the free-space manager for H5FD_MEM_DRAW is not there */ - if (H5F_addr_defined(f->shared->fs_addr[stype])) + if (H5_addr_defined(f->shared->fs_addr[stype])) TEST_ERROR; /* Verify that the free-space manager for H5FD_MEM_SUPER is there */ - if (!H5F_addr_defined(f->shared->fs_addr[type])) + if (!H5_addr_defined(f->shared->fs_addr[type])) TEST_ERROR; /* Start up H5FD_MEM_SUPER free-space manager */ @@ -6529,7 +6529,7 @@ test_mf_fs_persist_split(void) FAIL_STACK_ERROR; /* Verify that the H5FD_MEM_SUPER free-space manager is there */ - if (!H5F_addr_defined(f->shared->fs_addr[type])) + if (!H5_addr_defined(f->shared->fs_addr[type])) TEST_ERROR; /* Start up H5FD_MEM_SUPER free-space manager */ @@ -6719,7 +6719,7 @@ test_mf_fs_persist_multi(void) FAIL_STACK_ERROR; /* Verify that the H5FD_MEM_SUPER free-space manager is there */ - if (!H5F_addr_defined(f->shared->fs_addr[type])) + if (!H5_addr_defined(f->shared->fs_addr[type])) TEST_ERROR; /* Start up H5FD_MEM_SUPER free-space manager */ @@ -6743,7 +6743,7 @@ test_mf_fs_persist_multi(void) TEST_ERROR; /* Verify that the free-space manager for H5FD_MEM_DRAW is there */ - if (!H5F_addr_defined(f->shared->fs_addr[stype])) + if (!H5_addr_defined(f->shared->fs_addr[stype])) TEST_ERROR; /* Start up H5FD_MEM_DRAW free-space manager */ @@ -6801,7 +6801,7 @@ test_mf_fs_persist_multi(void) FAIL_STACK_ERROR; /* Verify that the free-space manager for H5FD_MEM_SUPER is there */ - if (!H5F_addr_defined(f->shared->fs_addr[type])) + if (!H5_addr_defined(f->shared->fs_addr[type])) TEST_ERROR; /* Start up H5FD_MEM_SUPER free-space manager */ @@ -6823,11 +6823,11 @@ test_mf_fs_persist_multi(void) TEST_ERROR; /* Verify that the free-space manager for H5FD_MEM_DRAW is not there */ - if (H5F_addr_defined(f->shared->fs_addr[stype])) + if (H5_addr_defined(f->shared->fs_addr[stype])) TEST_ERROR; /* Verify that the free-space manager for H5FD_MEM_BTREE is there */ - if (!H5F_addr_defined(f->shared->fs_addr[btype])) + if (!H5_addr_defined(f->shared->fs_addr[btype])) TEST_ERROR; /* Start up H5FD_MEM_BTREE free-space manager */ @@ -6867,7 +6867,7 @@ test_mf_fs_persist_multi(void) FAIL_STACK_ERROR; /* If H5FD_MEM_SUPER is there, should not find block #1 & #3 */ - if (H5F_addr_defined(f->shared->fs_addr[type])) { + if (H5_addr_defined(f->shared->fs_addr[type])) { /* Start up H5FD_MEM_SUPER free-space manager */ if (H5MF__open_fstype(f, (H5F_mem_page_t)type) < 0) FAIL_STACK_ERROR; @@ -6886,7 +6886,7 @@ test_mf_fs_persist_multi(void) } /* Verify that the H5FD_MEM_GHEAP free-space manager is there */ - if (!H5F_addr_defined(f->shared->fs_addr[gtype])) + if (!H5_addr_defined(f->shared->fs_addr[gtype])) TEST_ERROR; /* Start up H5FD_MEM_GHEAP free-space manager */ @@ -7021,7 +7021,7 @@ test_mf_fs_persist(const char *env_h5_drvr, hid_t fapl, hbool_t new_format) H5MF__alloc_to_fs_type(f->shared, type, TBLOCK_SIZE6, (H5F_mem_page_t *)&tt); /* Verify that H5FD_MEM_SUPER free-space manager is there */ - if (!H5F_addr_defined(f->shared->fs_addr[tt])) + if (!H5_addr_defined(f->shared->fs_addr[tt])) TEST_ERROR; /* Start up H5FD_MEM_SUPER free-space manager */ @@ -7064,7 +7064,7 @@ test_mf_fs_persist(const char *env_h5_drvr, hid_t fapl, hbool_t new_format) FAIL_STACK_ERROR; /* Verify that H5FD_MEM_SUPER free-space manager is there */ - if (!H5F_addr_defined(f->shared->fs_addr[tt])) + if (!H5_addr_defined(f->shared->fs_addr[tt])) TEST_ERROR; /* Retrieve block #5 from H5FD_MEM_SUPER free-space manager */ @@ -7199,7 +7199,7 @@ test_mf_fs_gone(const char *env_h5_drvr, hid_t fapl, hbool_t new_format) H5MF__alloc_to_fs_type(f->shared, type, TBLOCK_SIZE4, (H5F_mem_page_t *)&fs_type); /* Verify that the H5FD_MEM_SUPER free-space manager is not there */ - if (H5F_addr_defined(f->shared->fs_addr[fs_type])) + if (H5_addr_defined(f->shared->fs_addr[fs_type])) TEST_ERROR; /* Put block #3 to H5FD_MEM_SUPER free-space manager */ @@ -7218,7 +7218,7 @@ test_mf_fs_gone(const char *env_h5_drvr, hid_t fapl, hbool_t new_format) FAIL_STACK_ERROR; /* Verify that H5FD_MEM_SUPER free-space manager is there */ - if (!H5F_addr_defined(f->shared->fs_addr[fs_type])) + if (!H5_addr_defined(f->shared->fs_addr[fs_type])) TEST_ERROR; /* Start up H5FD_MEM_SUPER free-space manager */ @@ -7230,7 +7230,7 @@ test_mf_fs_gone(const char *env_h5_drvr, hid_t fapl, hbool_t new_format) if (H5FS_stat_info(f, f->shared->fs_man[fs_type], &fs_stat) < 0) FAIL_STACK_ERROR; - if (!H5F_addr_defined(fs_stat.addr)) + if (!H5_addr_defined(fs_stat.addr)) TEST_ERROR; if (fs_stat.tot_space < TBLOCK_SIZE3) @@ -7258,7 +7258,7 @@ test_mf_fs_gone(const char *env_h5_drvr, hid_t fapl, hbool_t new_format) if (NULL == (f = (H5F_t *)H5VL_object(file))) FAIL_STACK_ERROR; /* Verify that the H5FD_MEM_SUPER free-space manager is not there */ - if (H5F_addr_defined(f->shared->fs_addr[fs_type])) + if (H5_addr_defined(f->shared->fs_addr[fs_type])) TEST_ERROR; /* Closing */ @@ -7427,7 +7427,7 @@ test_mf_strat_thres_persist(const char *env_h5_drvr, hid_t fapl, hbool_t new_for } } else { - if (H5F_addr_defined(f->shared->fs_addr[tt])) + if (H5_addr_defined(f->shared->fs_addr[tt])) TEST_ERROR; } @@ -7617,7 +7617,7 @@ test_mf_strat_thres_gone(const char *env_h5_drvr, hid_t fapl, hbool_t new_format /* Free-space manager should be empty */ if (!(fs_type == H5F_FSPACE_STRATEGY_PAGE && fs_persist)) - if (H5F_addr_defined(f->shared->fs_addr[tt])) + if (H5_addr_defined(f->shared->fs_addr[tt])) TEST_ERROR; /* Closing */ @@ -7933,13 +7933,13 @@ test_page_alloc_xfree(const char *env_h5_drvr, hid_t fapl) /* Verify that the large generic manager is there */ H5MF__alloc_to_fs_type(f->shared, H5FD_MEM_DRAW, TBLOCK_SIZE5000, (H5F_mem_page_t *)&fs_type); - if (!H5F_addr_defined(f->shared->fs_addr[fs_type])) + if (!H5_addr_defined(f->shared->fs_addr[fs_type])) TEST_ERROR; /* Verify that the small metadata manager is there */ H5MF__alloc_to_fs_type(f->shared, H5FD_MEM_OHDR, f->shared->fs_page_size - 1, (H5F_mem_page_t *)&fs_type); - if (!H5F_addr_defined(f->shared->fs_addr[fs_type])) + if (!H5_addr_defined(f->shared->fs_addr[fs_type])) TEST_ERROR; /* Set up to use the small metadata manager */ @@ -7957,7 +7957,7 @@ test_page_alloc_xfree(const char *env_h5_drvr, hid_t fapl) TEST_ERROR; /* Verify that the small raw data manager is there */ - if (!H5F_addr_defined(f->shared->fs_addr[H5F_MEM_PAGE_DRAW])) + if (!H5_addr_defined(f->shared->fs_addr[H5F_MEM_PAGE_DRAW])) TEST_ERROR; /* Set up to use the small raw data manager */ @@ -8555,7 +8555,7 @@ test_page_large(const char *env_h5_drvr, hid_t fapl) /* Allocate a large data block with gaddr3--should be on another page */ /* Allocate 2 pages + 3808 bytes; 288 bytes in free-space manager */ gaddr3 = H5MF_alloc(f, H5FD_MEM_DRAW, (hsize_t)TBLOCK_SIZE12000); - if (!H5F_addr_defined(gaddr3)) + if (!H5_addr_defined(gaddr3)) TEST_ERROR; /* Free the block with gaddr2 */ -- cgit v0.12