mirror/hdf5
2
0
Fork 0
mirror of https://github.com/HDFGroup/hdf5.git synced 2025-04-12 17:31:09 +08:00
Code Issues Packages Projects Releases Wiki Activity

Fixed more warnings about extra semicolons (#3249)

Browse Source 
* Require semi-colon after H5_CHECK_OVERFLOW calls



Co-authored-by: github-actions <41898282+github-actions[bot]@users.noreply.github.com>
This commit is contained in:
Sean McBride 2023-07-18 11:35:05 -04:00 committed by GitHub
parent aab497a631
commit 1903c4b1b0
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
108 changed files with 1422 additions and 1794 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

20
fortran/src/H5Af.c
View File

@ -220,14 +220,14 @@ h5adelete_by_idx_c(hid_t_f *loc_id, _fcd obj_name, size_t_f *obj_namelen, int_f
* Convert FORTRAN name to C name
*/
if (NULL == (c_obj_name = HD5f2cstring(obj_name, (size_t)*obj_namelen)))
HGOTO_DONE(FAIL)
HGOTO_DONE(FAIL);
/*
* Call H5Adelete_by_name function.
*/
if (H5Adelete_by_idx((hid_t)*loc_id, c_obj_name, (H5_index_t)*idx_type, (H5_iter_order_t)*order,
(hsize_t)*n, (hid_t)*lapl_id) < 0)
HGOTO_DONE(FAIL)
HGOTO_DONE(FAIL);
done:
if (c_obj_name)
@ -289,14 +289,14 @@ h5aget_name_by_idx_c(hid_t_f *loc_id, _fcd obj_name, size_t_f *obj_namelen, int_
* Convert FORTRAN name to C name
*/
if (NULL == (c_obj_name = HD5f2cstring(obj_name, (size_t)*obj_namelen)))
HGOTO_DONE(FAIL)
HGOTO_DONE(FAIL);
/*
* Allocate buffer to hold name of an attribute
*/
c_buf_size = (size_t)*size + 1;
if (NULL == (c_buf = (char *)malloc(c_buf_size)))
HGOTO_DONE(FAIL)
HGOTO_DONE(FAIL);
/*
* Call H5Aget_name_by_idx function.
@ -304,7 +304,7 @@ h5aget_name_by_idx_c(hid_t_f *loc_id, _fcd obj_name, size_t_f *obj_namelen, int_
c_size = H5Aget_name_by_idx((hid_t)*loc_id, c_obj_name, (H5_index_t)*idx_type, (H5_iter_order_t)*order,
(hsize_t)*n, c_buf, c_buf_size, (hid_t)*lapl_id);
if (c_size < 0)
HGOTO_DONE(FAIL)
HGOTO_DONE(FAIL);
/*
* Convert C name to FORTRAN and place it in the given buffer
@ -415,14 +415,14 @@ h5aget_info_by_idx_c(hid_t_f *loc_id, _fcd obj_name, size_t_f *obj_namelen, int_
* Convert FORTRAN name to C name
*/
if (NULL == (c_obj_name = HD5f2cstring(obj_name, (size_t)*obj_namelen)))
HGOTO_DONE(FAIL)
HGOTO_DONE(FAIL);
/*
* Call H5Ainfo_by_idx function.
*/
if (H5Aget_info_by_idx((hid_t)*loc_id, c_obj_name, (H5_index_t)*idx_type, (H5_iter_order_t)*order,
(hsize_t)*n, &ainfo, (hid_t)*lapl_id) < 0)
HGOTO_DONE(FAIL)
HGOTO_DONE(FAIL);
/* Unpack the structure */
*corder_valid = 0;
@ -477,15 +477,15 @@ h5aget_info_by_name_c(hid_t_f *loc_id, _fcd obj_name, size_t_f *obj_namelen, _fc
* Convert FORTRAN name to C name
*/
if (NULL == (c_obj_name = HD5f2cstring(obj_name, (size_t)*obj_namelen)))
HGOTO_DONE(FAIL)
HGOTO_DONE(FAIL);
if (NULL == (c_attr_name = HD5f2cstring(attr_name, (size_t)*attr_namelen)))
HGOTO_DONE(FAIL)
HGOTO_DONE(FAIL);
/*
* Call H5Ainfo_by_name function.
*/
if (H5Aget_info_by_name((hid_t)*loc_id, c_obj_name, c_attr_name, &ainfo, (hid_t)*lapl_id) < 0)
HGOTO_DONE(FAIL)
HGOTO_DONE(FAIL);
/* Unpack the structure */
*corder_valid = 0;

18
fortran/src/H5Ef.c
View File

@ -43,7 +43,7 @@ h5eclear_c(hid_t_f *estack_id)
* Call H5Eclear function.
*/
if (H5Eclear2((hid_t)*estack_id) < 0)
HGOTO_DONE(FAIL)
HGOTO_DONE(FAIL);
done:
return ret_value;
@ -72,15 +72,15 @@ h5eprint_c1(_fcd name, int_f *namelen)
int_f ret_value = 0;
if (NULL == (c_name = (char *)HD5f2cstring(name, (size_t)*namelen)))
HGOTO_DONE(FAIL)
HGOTO_DONE(FAIL);
if (NULL == (file = fopen(c_name, "a")))
HGOTO_DONE(FAIL)
HGOTO_DONE(FAIL);
/*
* Call H5Eprint2 function.
*/
if (H5Eprint2(H5E_DEFAULT, file) < 0)
HGOTO_DONE(FAIL)
HGOTO_DONE(FAIL);
done:
if (file)
@ -115,7 +115,7 @@ h5eprint_c2(void)
* Call H5Eprint2 function.
*/
if (H5Eprint2(H5E_DEFAULT, NULL) < 0)
HGOTO_DONE(FAIL)
HGOTO_DONE(FAIL);
done:
return ret_value;
@ -147,7 +147,7 @@ h5eget_major_c(int_f *error_no, _fcd name, size_t_f *namelen)
c_name = (char *)malloc(c_namelen + 1);
if (!c_name)
HGOTO_DONE(FAIL)
HGOTO_DONE(FAIL);
/*
* Call H5Eget_msg function.
@ -155,7 +155,7 @@ h5eget_major_c(int_f *error_no, _fcd name, size_t_f *namelen)
H5Eget_msg((hid_t)*error_no, NULL, c_name, c_namelen);
HD5packFstring((char *)c_name, _fcdtocp(name), c_namelen);
if (!strcmp(c_name, "Invalid major error number"))
HGOTO_DONE(FAIL)
HGOTO_DONE(FAIL);
done:
if (c_name)
@ -190,7 +190,7 @@ h5eget_minor_c(int_f *error_no, _fcd name, size_t_f *namelen)
c_name = (char *)malloc(c_namelen + 1);
if (!c_name)
HGOTO_DONE(FAIL)
HGOTO_DONE(FAIL);
/*
* Call H5Eget_msg function.
@ -198,7 +198,7 @@ h5eget_minor_c(int_f *error_no, _fcd name, size_t_f *namelen)
H5Eget_msg((hid_t)*error_no, NULL, c_name, c_namelen);
HD5packFstring((char *)c_name, _fcdtocp(name), c_namelen);
if (!strcmp(c_name, "Invalid minor error number"))
HGOTO_DONE(FAIL)
HGOTO_DONE(FAIL);
done:
if (c_name)

22
fortran/src/H5Lf.c
View File

@ -57,16 +57,16 @@ h5lcopy_c(hid_t_f *src_loc_id, _fcd src_name, size_t_f *src_namelen, hid_t_f *de
* Convert FORTRAN name to C name
*/
if (NULL == (c_src_name = HD5f2cstring(src_name, (size_t)*src_namelen)))
HGOTO_DONE(FAIL)
HGOTO_DONE(FAIL);
if (NULL == (c_dest_name = HD5f2cstring(dest_name, (size_t)*dest_namelen)))
HGOTO_DONE(FAIL)
HGOTO_DONE(FAIL);
/*
* Call H5Lcopy function.
*/
if (H5Lcopy((hid_t)*src_loc_id, c_src_name, (hid_t)*dest_loc_id, c_dest_name, (hid_t)*lcpl_id,
(hid_t)*lapl_id) < 0)
HGOTO_DONE(FAIL)
HGOTO_DONE(FAIL);
done:
if (c_src_name)
@ -350,16 +350,16 @@ h5lmove_c(hid_t_f *src_loc_id, _fcd src_name, size_t_f *src_namelen, hid_t_f *de
* Convert FORTRAN name to C name
*/
if (NULL == (c_src_name = HD5f2cstring(src_name, (size_t)*src_namelen)))
HGOTO_DONE(FAIL)
HGOTO_DONE(FAIL);
if (NULL == (c_dest_name = HD5f2cstring(dest_name, (size_t)*dest_namelen)))
HGOTO_DONE(FAIL)
HGOTO_DONE(FAIL);
/*
* Call H5Lmove function.
*/
if (H5Lmove((hid_t)*src_loc_id, c_src_name, (hid_t)*dest_loc_id, c_dest_name, (hid_t)*lcpl_id,
(hid_t)*lapl_id) < 0)
HGOTO_DONE(FAIL)
HGOTO_DONE(FAIL);
done:
if (c_src_name)
@ -407,7 +407,7 @@ h5lget_name_by_idx_c(hid_t_f *loc_id, _fcd group_name, size_t_f *group_namelen,
* Convert FORTRAN name to C name
*/
if (NULL == (c_group_name = HD5f2cstring(group_name, (size_t)*group_namelen)))
HGOTO_DONE(FAIL)
HGOTO_DONE(FAIL);
c_size = (size_t)*size + 1;
@ -415,12 +415,12 @@ h5lget_name_by_idx_c(hid_t_f *loc_id, _fcd group_name, size_t_f *group_namelen,
* Allocate buffer to hold name of an attribute
*/
if (NULL == (c_name = (char *)malloc(c_size)))
HGOTO_DONE(FAIL)
HGOTO_DONE(FAIL);
if ((c_size_link =
H5Lget_name_by_idx((hid_t)*loc_id, c_group_name, (H5_index_t)*index_field,
(H5_iter_order_t)*order, (hsize_t)*n, c_name, c_size, (hid_t)*lapl_id)) < 0)
HGOTO_DONE(FAIL)
HGOTO_DONE(FAIL);
*size = (size_t_f)c_size_link;
@ -625,13 +625,13 @@ h5lget_val_c(hid_t_f *link_loc_id, _fcd link_name, size_t_f *link_namelen, size_
* Convert FORTRAN name to C name
*/
if (NULL == (c_link_name = HD5f2cstring(link_name, (size_t)*link_namelen)))
HGOTO_DONE(FAIL)
HGOTO_DONE(FAIL);
/*
* Call H5Lget_val
*/
if (H5Lget_val((hid_t)*link_loc_id, c_link_name, &linkval_buff, (size_t)*size, (hid_t)*lapl_id) < 0)
HGOTO_DONE(FAIL)
HGOTO_DONE(FAIL);
done:
if (c_link_name)

16
fortran/src/H5Pf.c
View File

@ -61,7 +61,7 @@ h5pcreate_c(hid_t_f *cls, hid_t_f *prp_id)
c_prp_id = H5Pcreate((hid_t)*cls);
if (c_prp_id < 0)
HGOTO_DONE(FAIL)
HGOTO_DONE(FAIL);
*prp_id = (hid_t_f)c_prp_id;
@ -115,7 +115,7 @@ h5pcopy_c(hid_t_f *prp_id, hid_t_f *new_prp_id)
c_new_prp_id = H5Pcopy((hid_t)*prp_id);
if (c_new_prp_id < 0)
HGOTO_DONE(FAIL)
HGOTO_DONE(FAIL);
*new_prp_id = (hid_t_f)c_new_prp_id;
@ -146,7 +146,7 @@ h5pequal_c(hid_t_f *plist1_id, hid_t_f *plist2_id, int_f *c_flag)
c_c_flag = H5Pequal((hid_t)*plist1_id, (hid_t)*plist2_id);
if (c_c_flag < 0)
HGOTO_DONE(FAIL)
HGOTO_DONE(FAIL);
*c_flag = (int_f)c_c_flag;
@ -176,7 +176,7 @@ h5pget_class_c(hid_t_f *prp_id, hid_t_f *classtype)
int_f ret_value = 0;
if ((c_classtype = H5Pget_class((hid_t)*prp_id)) < 0)
HGOTO_DONE(FAIL)
HGOTO_DONE(FAIL);
*classtype = (hid_t_f)c_classtype;
@ -4117,7 +4117,7 @@ h5pget_data_transform_c(hid_t_f *plist_id, _fcd expression, int_f *expression_le
if (c_expression_len) {
c_expression = (char *)malloc(c_expression_len);
if (NULL == c_expression)
HGOTO_DONE(FAIL)
HGOTO_DONE(FAIL);
} /* end if */
/*
@ -4125,7 +4125,7 @@ h5pget_data_transform_c(hid_t_f *plist_id, _fcd expression, int_f *expression_le
*/
ret = H5Pget_data_transform((hid_t)*plist_id, c_expression, c_expression_len);
if (ret < 0)
HGOTO_DONE(FAIL)
HGOTO_DONE(FAIL);
/* or strlen ? */
HD5packFstring(c_expression, _fcdtocp(expression), (size_t)*expression_len);
@ -4170,13 +4170,13 @@ h5pset_data_transform_c(hid_t_f *plist_id, _fcd expression, int_f *expression_le
* Convert FORTRAN name to C name
*/
if (NULL == (c_expression = HD5f2cstring(expression, (size_t)*expression_len)))
HGOTO_DONE(FAIL)
HGOTO_DONE(FAIL);
/*
* Call H5Pset_data_transform function.
*/
if (H5Pset_data_transform((hid_t)*plist_id, c_expression) < 0)
HGOTO_DONE(FAIL)
HGOTO_DONE(FAIL);
done:
if (c_expression)

10
fortran/src/H5Rf.c
View File

@ -50,13 +50,13 @@ h5rcreate_region_c(int_f *ref, hid_t_f *loc_id, _fcd name, int_f *namelen, hid_t
* Convert FORTRAN name to C name
*/
if (NULL == (c_name = (char *)HD5f2cstring(name, (size_t)*namelen)))
HGOTO_DONE(FAIL)
HGOTO_DONE(FAIL);
/*
* Call H5Rcreate function.
*/
if (H5Rcreate(&ref_c, (hid_t)*loc_id, c_name, H5R_DATASET_REGION, (hid_t)*space_id) < 0)
HGOTO_DONE(FAIL)
HGOTO_DONE(FAIL);
/* Copy the reference created */
memcpy(ref, &ref_c, H5R_DSET_REG_REF_BUF_SIZE);
@ -170,7 +170,7 @@ h5rget_region_region_c(hid_t_f *dset_id, int_f *ref, hid_t_f *space_id)
* Call H5Rget_region function.
*/
if ((c_space_id = H5Rget_region((hid_t)*dset_id, H5R_DATASET_REGION, &ref_c)) < 0)
HGOTO_DONE(FAIL)
HGOTO_DONE(FAIL);
/* Copy the dataspace ID */
*space_id = (hid_t_f)c_space_id;
@ -204,7 +204,7 @@ h5rget_region_ptr_c(hid_t_f *dset_id, void *ref, hid_t_f *space_id)
* Call H5Rget_region function.
*/
if ((c_space_id = H5Rget_region((hid_t)*dset_id, H5R_DATASET_REGION, ref)) < 0)
HGOTO_DONE(FAIL)
HGOTO_DONE(FAIL);
/* Copy the dataspace ID */
*space_id = (hid_t_f)c_space_id;
@ -240,7 +240,7 @@ h5rget_object_type_obj_c(hid_t_f *dset_id, haddr_t_f *ref, int_f *obj_type)
* Call H5Rget_object_type function.
*/
if (H5Rget_obj_type2((hid_t)*dset_id, H5R_OBJECT, &ref_c, &c_obj_type) < 0)
HGOTO_DONE(FAIL)
HGOTO_DONE(FAIL);
/* Copy the object type */
*obj_type = (int_f)c_obj_type;

20
fortran/src/H5Sf.c
View File

@ -57,7 +57,7 @@ h5screate_simple_c(int_f *rank, hsize_t_f *dims, hsize_t_f *maxdims, hid_t_f *sp
c_space_id = H5Screate_simple(*rank, c_dims, c_maxdims);
if (c_space_id < 0)
HGOTO_DONE(FAIL)
HGOTO_DONE(FAIL);
*space_id = (hid_t_f)c_space_id;
@ -323,10 +323,10 @@ h5sget_select_bounds_c(hid_t_f *space_id, hsize_t_f *start, hsize_t_f *end)
c_space_id = (hid_t)*space_id;
rank = H5Sget_simple_extent_ndims(c_space_id);
if (rank < 0)
HGOTO_DONE(FAIL)
HGOTO_DONE(FAIL);
if (H5Sget_select_bounds(c_space_id, c_start, c_end) < 0)
HGOTO_DONE(FAIL)
HGOTO_DONE(FAIL);
for (i = 0; i < rank; i++) {
start[i] = (hsize_t_f)(c_start[rank - i - 1] + 1);
@ -644,7 +644,7 @@ h5soffset_simple_c(hid_t_f *space_id, hssize_t_f *offset)
c_space_id = (hid_t)*space_id;
rank = H5Sget_simple_extent_ndims(c_space_id);
if (rank < 0)
HGOTO_DONE(FAIL)
HGOTO_DONE(FAIL);
/*
* Reverse dimensions due to C-FORTRAN storage order.
@ -653,7 +653,7 @@ h5soffset_simple_c(hid_t_f *space_id, hssize_t_f *offset)
c_offset[i] = offset[rank - i - 1];
if (H5Soffset_simple(c_space_id, c_offset) < 0)
HGOTO_DONE(FAIL)
HGOTO_DONE(FAIL);
done:
return ret_value;
@ -693,7 +693,7 @@ h5sset_extent_simple_c(hid_t_f *space_id, int_f *rank, hsize_t_f *current_size,
} /* end for */
if (H5Sset_extent_simple((hid_t)*space_id, (int)*rank, c_current_size, c_maximum_size) < 0)
HGOTO_DONE(FAIL)
HGOTO_DONE(FAIL);
done:
return ret_value;
@ -729,10 +729,10 @@ h5sget_simple_extent_dims_c(hid_t_f *space_id, hsize_t_f *dims, hsize_t_f *maxdi
c_space_id = (hid_t)*space_id;
rank = H5Sget_simple_extent_ndims(c_space_id);
if (rank < 0)
HGOTO_DONE(FAIL)
HGOTO_DONE(FAIL);
if (H5Sget_simple_extent_dims(c_space_id, c_dims, c_maxdims) < 0)
HGOTO_DONE(FAIL)
HGOTO_DONE(FAIL);
/*
* Reverse dimensions due to C-FORTRAN storage order.
@ -870,7 +870,7 @@ h5sselect_hyperslab_c(hid_t_f *space_id, int_f *op, hsize_t_f *start, hsize_t_f
rank = H5Sget_simple_extent_ndims((hid_t)*space_id);
if (rank < 0)
HGOTO_DONE(FAIL)
HGOTO_DONE(FAIL);
/*
* Reverse dimensions due to C-FORTRAN storage order.
@ -885,7 +885,7 @@ h5sselect_hyperslab_c(hid_t_f *space_id, int_f *op, hsize_t_f *start, hsize_t_f
} /* end for */
if (H5Sselect_hyperslab((hid_t)*space_id, (H5S_seloper_t)*op, c_start, c_stride, c_count, c_block) < 0)
HGOTO_DONE(FAIL)
HGOTO_DONE(FAIL);
done:
return ret_value;

6
fortran/test/t.c
View File

@ -46,15 +46,15 @@ nh5_fixname_c(_fcd base_name, size_t_f *base_namelen, hid_t_f *fapl, _fcd full_n
* Convert FORTRAN name to C name
*/
if (NULL == (c_base_name = (char *)HD5f2cstring(base_name, (size_t)*base_namelen)))
HGOTO_DONE(FAIL)
HGOTO_DONE(FAIL);
if (NULL == (c_full_name = (char *)malloc((size_t)*full_namelen + 1)))
HGOTO_DONE(FAIL)
HGOTO_DONE(FAIL);
/*
* Call h5_fixname function.
*/
if (NULL == h5_fixname(c_base_name, (hid_t)*fapl, c_full_name, (size_t)*full_namelen + 1))
HGOTO_DONE(FAIL)
HGOTO_DONE(FAIL);
HD5packFstring(c_full_name, _fcdtocp(full_name), (size_t)*full_namelen);
done:

22
hl/fortran/src/H5DSfc.c
View File

@ -39,14 +39,14 @@ h5dsset_scale_c(hid_t_f *dsid, _fcd dimname, size_t_f *dimnamelen)
if (*dimnamelen != 0)
if (NULL == (c_dimname = (char *)HD5f2cstring(dimname, (size_t)*dimnamelen)))
HGOTO_DONE(FAIL)
HGOTO_DONE(FAIL);
/*
* call H5DSset_scale function.
*/
if (H5DSset_scale((hid_t)*dsid, c_dimname) < 0)
HGOTO_DONE(FAIL)
HGOTO_DONE(FAIL);
done:
if (c_dimname)
@ -77,7 +77,7 @@ h5dsattach_scale_c(hid_t_f *did, hid_t_f *dsid, int_f *idx)
*/
if (H5DSattach_scale((hid_t)*did, (hid_t)*dsid, (unsigned)*idx) < 0)
HGOTO_DONE(FAIL)
HGOTO_DONE(FAIL);
done:
return ret_value;
@ -105,7 +105,7 @@ h5dsdetach_scale_c(hid_t_f *did, hid_t_f *dsid, int_f *idx)
*/
if (H5DSdetach_scale((hid_t)*did, (hid_t)*dsid, (unsigned)*idx) < 0)
HGOTO_DONE(FAIL)
HGOTO_DONE(FAIL);
done:
return ret_value;
@ -134,7 +134,7 @@ h5dsis_attached_c(hid_t_f *did, hid_t_f *dsid, int_f *idx, int_f *is_attached)
*/
if ((c_is_attached = H5DSis_attached((hid_t)*did, (hid_t)*dsid, (unsigned)*idx)) < 0)
HGOTO_DONE(FAIL)
HGOTO_DONE(FAIL);
*is_attached = (int_f)c_is_attached;
@ -165,7 +165,7 @@ h5dsis_scale_c(hid_t_f *did, int_f *is_scale)
*/
if ((c_is_scale = H5DSis_scale((hid_t)*did)) < 0)
HGOTO_DONE(FAIL)
HGOTO_DONE(FAIL);
*is_scale = (int_f)c_is_scale;
@ -196,14 +196,14 @@ h5dsset_label_c(hid_t_f *did, int_f *idx, _fcd label, size_t_f *labellen)
*/
if (NULL == (c_label = (char *)HD5f2cstring(label, (size_t)*labellen)))
HGOTO_DONE(FAIL)
HGOTO_DONE(FAIL);
/*
* call H5DSset_label function.
*/
if (H5DSset_label((hid_t)*did, (unsigned)*idx, c_label) < 0)
HGOTO_DONE(FAIL)
HGOTO_DONE(FAIL);
done:
if (c_label)
@ -242,7 +242,7 @@ h5dsget_label_c(hid_t_f *did, int_f *idx, _fcd label, size_t_f *size)
*/
if ((size_c = H5DSget_label((hid_t)*did, (unsigned)*idx, c_label, (size_t)*size + 1)) < 0)
HGOTO_DONE(FAIL)
HGOTO_DONE(FAIL);
/*
* Convert C name to FORTRAN and place it in the given buffer
@ -288,7 +288,7 @@ h5dsget_scale_name_c(hid_t_f *did, _fcd name, size_t_f *size)
*/
if ((size_c = H5DSget_scale_name((hid_t)*did, c_scale_name, (size_t)*size + 1)) < 0)
HGOTO_DONE(FAIL)
HGOTO_DONE(FAIL);
/*
* Convert C name to FORTRAN and place it in the given buffer
@ -324,7 +324,7 @@ h5dsget_num_scales_c(hid_t_f *did, int_f *idx, int_f *num_scales)
*/
if ((*num_scales = (int_f)H5DSget_num_scales((hid_t)*did, (unsigned)*idx)) < 0)
HGOTO_DONE(FAIL)
HGOTO_DONE(FAIL);
done:
return ret_value;

4
hl/fortran/src/H5IMfc.c
View File

@ -297,7 +297,7 @@ h5immake_palette_c(hid_t_f *loc_id, size_t_f *namelen, _fcd name, hsize_t_f *dim
* convert FORTRAN name to C name
*/
if (NULL == (c_name = (char *)HD5f2cstring(name, (size_t)*namelen)))
HGOTO_DONE(FAIL)
HGOTO_DONE(FAIL);
for (i = 0; i < rank; i++)
c_dims[i] = (hsize_t)dims[i];
@ -306,7 +306,7 @@ h5immake_palette_c(hid_t_f *loc_id, size_t_f *namelen, _fcd name, hsize_t_f *dim
* call H5IMmake_palette function.
*/
if (H5IMmake_palettef((hid_t)*loc_id, c_name, c_dims, (int_f *)buf) < 0)
HGOTO_DONE(FAIL)
HGOTO_DONE(FAIL);
done:
if (c_name)

90
hl/fortran/src/H5TBfc.c
View File

@ -54,13 +54,13 @@ h5tbmake_table_c(size_t_f *namelen1, _fcd name1, hid_t_f *loc_id, size_t_f *name
* convert FORTRAN name to C name
*/
if (NULL == (c_name = (char *)HD5f2cstring(name, (size_t)*namelen)))
HGOTO_DONE(FAIL)
HGOTO_DONE(FAIL);
if (NULL == (c_name1 = (char *)HD5f2cstring(name1, (size_t)*namelen1)))
HGOTO_DONE(FAIL)
HGOTO_DONE(FAIL);
if (NULL == (c_field_offset = (size_t *)malloc(sizeof(size_t) * (size_t)c_nfields)))
HGOTO_DONE(FAIL)
HGOTO_DONE(FAIL);
if (NULL == (c_field_types = (hid_t *)malloc(sizeof(hid_t) * (size_t)c_nfields)))
HGOTO_DONE(FAIL)
HGOTO_DONE(FAIL);
for (i = 0; i < num_elem; i++) {
c_field_offset[i] = (size_t)field_offset[i];
@ -71,19 +71,19 @@ h5tbmake_table_c(size_t_f *namelen1, _fcd name1, hid_t_f *loc_id, size_t_f *name
* allocate array of character pointers
*/
if (NULL == (c_field_names = (char **)calloc((size_t)num_elem, sizeof(char *))))
HGOTO_DONE(FAIL)
HGOTO_DONE(FAIL);
/* copy data to long C string */
if (NULL ==
(tmp = (char *)HD5f2cstring(field_names, (size_t) * (max_char_size_field_names) * (size_t)num_elem)))
HGOTO_DONE(FAIL)
HGOTO_DONE(FAIL);
/*
* move data from temporary buffer
*/
tmp_p = tmp;
for (i = 0; i < num_elem; i++) {
if (NULL == (c_field_names[i] = (char *)malloc((size_t)char_len_field_names[i] + 1)))
HGOTO_DONE(FAIL)
HGOTO_DONE(FAIL);
memcpy(c_field_names[i], tmp_p, (size_t)char_len_field_names[i]);
c_field_names[i][char_len_field_names[i]] = '\0';
tmp_p = tmp_p + *max_char_size_field_names;
@ -95,7 +95,7 @@ h5tbmake_table_c(size_t_f *namelen1, _fcd name1, hid_t_f *loc_id, size_t_f *name
if (H5TBmake_table(c_name1, (hid_t)*loc_id, c_name, c_nfields, (hsize_t)*nrecords, (size_t)*type_size,
(const char **)c_field_names, c_field_offset, c_field_types, (hsize_t)*chunk_size,
NULL, *compress, NULL) < 0)
HGOTO_DONE(FAIL)
HGOTO_DONE(FAIL);
done:
if (c_name)
@ -155,13 +155,13 @@ h5tbmake_table_ptr_c(size_t_f *namelen1, _fcd name1, hid_t_f *loc_id, size_t_f *
* convert FORTRAN name to C name
*/
if (NULL == (c_name = (char *)HD5f2cstring(name, (size_t)*namelen)))
HGOTO_DONE(FAIL)
HGOTO_DONE(FAIL);
if (NULL == (c_name1 = (char *)HD5f2cstring(name1, (size_t)*namelen1)))
HGOTO_DONE(FAIL)
HGOTO_DONE(FAIL);
if (NULL == (c_field_offset = (size_t *)malloc(sizeof(size_t) * (size_t)c_nfields)))
HGOTO_DONE(FAIL)
HGOTO_DONE(FAIL);
if (NULL == (c_field_types = (hid_t *)malloc(sizeof(hid_t) * (size_t)c_nfields)))
HGOTO_DONE(FAIL)
HGOTO_DONE(FAIL);
for (i = 0; i < num_elem; i++) {
c_field_offset[i] = (size_t)field_offset[i];
@ -172,19 +172,19 @@ h5tbmake_table_ptr_c(size_t_f *namelen1, _fcd name1, hid_t_f *loc_id, size_t_f *
* allocate array of character pointers
*/
if (NULL == (c_field_names = (char **)calloc((size_t)num_elem, sizeof(char *))))
HGOTO_DONE(FAIL)
HGOTO_DONE(FAIL);
/* copy data to long C string */
if (NULL ==
(tmp = (char *)HD5f2cstring(field_names, (size_t) * (max_char_size_field_names) * (size_t)num_elem)))
HGOTO_DONE(FAIL)
HGOTO_DONE(FAIL);
/*
* move data from temporary buffer
*/
tmp_p = tmp;
for (i = 0; i < num_elem; i++) {
if (NULL == (c_field_names[i] = (char *)malloc((size_t)char_len_field_names[i] + 1)))
HGOTO_DONE(FAIL)
HGOTO_DONE(FAIL);
memcpy(c_field_names[i], tmp_p, (size_t)char_len_field_names[i]);
c_field_names[i][char_len_field_names[i]] = '\0';
tmp_p = tmp_p + *max_char_size_field_names;
@ -196,7 +196,7 @@ h5tbmake_table_ptr_c(size_t_f *namelen1, _fcd name1, hid_t_f *loc_id, size_t_f *
if (H5TBmake_table(c_name1, (hid_t)*loc_id, c_name, c_nfields, (hsize_t)*nrecords, (size_t)*type_size,
(const char **)c_field_names, c_field_offset, c_field_types, (hsize_t)*chunk_size,
fill_data, *compress, data) < 0)
HGOTO_DONE(FAIL)
HGOTO_DONE(FAIL);
done:
if (c_name)
@ -246,12 +246,12 @@ h5tbread_table_c(hid_t_f *loc_id, _fcd name, size_t_f *namelen, hsize_t_f *nfiel
* convert FORTRAN name to C name
*/
if (NULL == (c_name = (char *)HD5f2cstring(name, (size_t)*namelen)))
HGOTO_DONE(FAIL)
HGOTO_DONE(FAIL);
if (NULL == (c_dst_offset = (size_t *)malloc(sizeof(size_t) * (size_t)c_nfields)))
HGOTO_DONE(FAIL)
HGOTO_DONE(FAIL);
if (NULL == (c_dst_sizes = (size_t *)malloc(sizeof(size_t) * (size_t)c_nfields)))
HGOTO_DONE(FAIL)
HGOTO_DONE(FAIL);
for (i = 0; i < c_nfields; i++) {
c_dst_offset[i] = (size_t)dst_offset[i];
@ -262,7 +262,7 @@ h5tbread_table_c(hid_t_f *loc_id, _fcd name, size_t_f *namelen, hsize_t_f *nfiel
* call H5TBread_table function.
*/
if (H5TBread_table((hid_t)*loc_id, c_name, (size_t)*dst_size, c_dst_offset, c_dst_sizes, dst_buf) < 0)
HGOTO_DONE(FAIL)
HGOTO_DONE(FAIL);
done:
if (c_name)
@ -300,16 +300,16 @@ h5tbwrite_field_name_c(hid_t_f *loc_id, size_t_f *namelen, _fcd name, size_t_f *
* convert FORTRAN name to C name
*/
if (NULL == (c_name = (char *)HD5f2cstring(name, (size_t)*namelen)))
HGOTO_DONE(FAIL)
HGOTO_DONE(FAIL);
if (NULL == (c_name1 = (char *)HD5f2cstring(field_name, (size_t)*namelen1)))
HGOTO_DONE(FAIL)
HGOTO_DONE(FAIL);
/*
* call H5TBwrite_fields_name function.
*/
if (H5TBwrite_fields_name((hid_t)*loc_id, c_name, c_name1, (hsize_t)*start, (hsize_t)*nrecords,
c_type_size[0], 0, c_type_size, buf) < 0)
HGOTO_DONE(FAIL)
HGOTO_DONE(FAIL);
done:
if (c_name)
@ -344,16 +344,16 @@ h5tbread_field_name_c(hid_t_f *loc_id, size_t_f *namelen, _fcd name, size_t_f *n
* convert FORTRAN name to C name
*/
if (NULL == (c_name = (char *)HD5f2cstring(name, (size_t)*namelen)))
HGOTO_DONE(FAIL)
HGOTO_DONE(FAIL);
if (NULL == (c_name1 = (char *)HD5f2cstring(field_name, (size_t)*namelen1)))
HGOTO_DONE(FAIL)
HGOTO_DONE(FAIL);
/*
* call H5TBread_fields_name function.
*/
if (H5TBread_fields_name((hid_t)*loc_id, c_name, c_name1, (hsize_t)*start, (hsize_t)*nrecords,
c_type_size[0], 0, c_type_size, buf) < 0)
HGOTO_DONE(FAIL)
HGOTO_DONE(FAIL);
done:
if (c_name)
@ -388,14 +388,14 @@ h5tbwrite_field_index_c(hid_t_f *loc_id, size_t_f *namelen, _fcd name, int_f *fi
* convert FORTRAN name to C name
*/
if (NULL == (c_name = (char *)HD5f2cstring(name, (size_t)*namelen)))
HGOTO_DONE(FAIL)
HGOTO_DONE(FAIL);
/*
* call H5TBwrite_fields_name function.
*/
if (H5TBwrite_fields_index((hid_t)*loc_id, c_name, (hsize_t)1, &c_field_index, (hsize_t)*start,
(hsize_t)*nrecords, c_type_size, 0, &c_type_size, buf) < 0)
HGOTO_DONE(FAIL)
HGOTO_DONE(FAIL);
done:
if (c_name)
@ -428,14 +428,14 @@ h5tbread_field_index_c(hid_t_f *loc_id, size_t_f *namelen, _fcd name, int_f *fie
* convert FORTRAN name to C name
*/
if (NULL == (c_name = (char *)HD5f2cstring(name, (size_t)*namelen)))
HGOTO_DONE(FAIL)
HGOTO_DONE(FAIL);
/*
* call H5TBread_fields_index function.
*/
if (H5TBread_fields_index((hid_t)*loc_id, c_name, (hsize_t)1, &c_field_index, (hsize_t)*start,
(hsize_t)*nrecords, c_type_size, 0, &c_type_size, buf) < 0)
HGOTO_DONE(FAIL)
HGOTO_DONE(FAIL);
done:
if (c_name)
@ -467,16 +467,16 @@ h5tbinsert_field_c(hid_t_f *loc_id, size_t_f *namelen, _fcd name, size_t_f *name
* convert FORTRAN name to C name
*/
if (NULL == (c_name = (char *)HD5f2cstring(name, (size_t)*namelen)))
HGOTO_DONE(FAIL)
HGOTO_DONE(FAIL);
if (NULL == (c_name1 = (char *)HD5f2cstring(field_name, (size_t)*namelen1)))
HGOTO_DONE(FAIL)
HGOTO_DONE(FAIL);
/*
* call H5TBinsert_field function.
*/
if (H5TBinsert_field((hid_t)*loc_id, c_name, c_name1, (hid_t)*field_type, (hsize_t)*position, NULL, buf) <
0)
HGOTO_DONE(FAIL)
HGOTO_DONE(FAIL);
done:
if (c_name)
@ -509,15 +509,15 @@ h5tbdelete_field_c(hid_t_f *loc_id, size_t_f *namelen, _fcd name, size_t_f *name
* convert FORTRAN name to C name
*/
if (NULL == (c_name = (char *)HD5f2cstring(name, (size_t)*namelen)))
HGOTO_DONE(FAIL)
HGOTO_DONE(FAIL);
if (NULL == (c_name1 = (char *)HD5f2cstring(field_name, (size_t)*namelen1)))
HGOTO_DONE(FAIL)
HGOTO_DONE(FAIL);
/*
* call H5TBinsert_field function.
*/
if (H5TBdelete_field((hid_t)*loc_id, c_name, c_name1) < 0)
HGOTO_DONE(FAIL)
HGOTO_DONE(FAIL);
done:
if (c_name)
@ -551,14 +551,14 @@ h5tbget_table_info_c(hid_t_f *loc_id, size_t_f *namelen, _fcd name, hsize_t_f *n
* convert FORTRAN name to C name
*/
if (NULL == (c_name = (char *)HD5f2cstring(name, (size_t)*namelen)))
HGOTO_DONE(FAIL)
HGOTO_DONE(FAIL);
/*
* call H5TBread_fields_index function.
*/
if (H5TBget_table_info((hid_t)*loc_id, c_name, &c_nfields, &c_nrecords) < 0)
HGOTO_DONE(FAIL)
HGOTO_DONE(FAIL);
*nfields = (hsize_t_f)c_nfields;
*nrecords = (hsize_t_f)c_nrecords;
@ -610,30 +610,30 @@ h5tbget_field_info_c(hid_t_f *loc_id, size_t_f *namelen, _fcd name, hsize_t_f *n
* convert FORTRAN name to C name
*/
if (NULL == (c_name = (char *)HD5f2cstring(name, (size_t)*namelen)))
HGOTO_DONE(FAIL)
HGOTO_DONE(FAIL);
if (NULL == (c_field_offsets = (size_t *)malloc(sizeof(size_t) * (size_t)c_nfields)))
HGOTO_DONE(FAIL)
HGOTO_DONE(FAIL);
if (NULL == (c_field_sizes = (size_t *)malloc(sizeof(size_t) * (size_t)c_nfields)))
HGOTO_DONE(FAIL)
HGOTO_DONE(FAIL);
if (NULL == (c_field_names = (char **)calloc((size_t)c_nfields, sizeof(char *))))
HGOTO_DONE(FAIL)
HGOTO_DONE(FAIL);
for (i = 0; i < c_nfields; i++)
if (NULL == (c_field_names[i] = (char *)malloc(sizeof(char) * HLTB_MAX_FIELD_LEN)))
HGOTO_DONE(FAIL)
HGOTO_DONE(FAIL);
/*
* call H5TBget_field_info function.
*/
if (H5TBget_field_info((hid_t)*loc_id, c_name, c_field_names, c_field_sizes, c_field_offsets,
&c_type_size) < 0)
HGOTO_DONE(FAIL)
HGOTO_DONE(FAIL);
/* return values */
/* names array */
if (NULL == (tmp = (char *)malloc((c_lenmax * (size_t)c_nfields) + 1)))
HGOTO_DONE(FAIL)
HGOTO_DONE(FAIL);
tmp_p = tmp;
memset(tmp, ' ', c_lenmax * (size_t)c_nfields);
tmp[c_lenmax * c_nfields] = '\0';

4
src/H5.c
View File

@ -145,7 +145,7 @@ H5_init_library(void)
/* Run the library initialization routine, if it hasn't already run */
if (H5_INIT_GLOBAL || H5_TERM_GLOBAL)
HGOTO_DONE(SUCCEED)
HGOTO_DONE(SUCCEED);
/* Set the 'library initialized' flag as early as possible, to avoid
* possible re-entrancy.
@ -881,7 +881,7 @@ H5check_version(unsigned majnum, unsigned minnum, unsigned relnum)
/* Don't check again, if we already have */
if (checked)
HGOTO_DONE(SUCCEED)
HGOTO_DONE(SUCCEED);
{
const char *s; /* Environment string for disabling version check */

2
src/H5AC.c
View File

@ -2314,7 +2314,7 @@ H5AC_cork(H5F_t *f, haddr_t obj_addr, unsigned action, hbool_t *corked)
assert(corked);
if (H5C_get_num_objs_corked(f->shared->cache) == 0) {
*corked = FALSE;
HGOTO_DONE(SUCCEED)
HGOTO_DONE(SUCCEED);
}
}

2
src/H5B.c
View File

@ -570,7 +570,7 @@ H5B_insert(H5F_t *f, const H5B_class_t *type, haddr_t addr, void *udata)
if (H5B_INS_NOOP == my_ins) {
/* The root node did not split - just return */
assert(!split_bt_ud.bt);
HGOTO_DONE(SUCCEED)
HGOTO_DONE(SUCCEED);
} /* end if */
assert(H5B_INS_RIGHT == my_ins);
assert(split_bt_ud.bt);

16
src/H5B2.c
View File

@ -455,7 +455,7 @@ H5B2_find(H5B2_t *bt2, void *udata, hbool_t *found, H5B2_found_t op, void *op_da
/* Check for empty tree */
if (curr_node_ptr.node_nrec == 0) {
*found = FALSE;
HGOTO_DONE(SUCCEED)
HGOTO_DONE(SUCCEED);
}
/* Check record against min & max records in tree, to attempt to quickly
@ -466,14 +466,14 @@ H5B2_find(H5B2_t *bt2, void *udata, hbool_t *found, H5B2_found_t op, void *op_da
HGOTO_ERROR(H5E_BTREE, H5E_CANTCOMPARE, FAIL, "can't compare btree2 records")
if (cmp < 0) {
*found = FALSE; /* Less than the least record--not found */
HGOTO_DONE(SUCCEED)
HGOTO_DONE(SUCCEED);
}
else if (cmp == 0) { /* Record is found */
if (op && (op)(hdr->min_native_rec, op_data) < 0)
HGOTO_ERROR(H5E_BTREE, H5E_NOTFOUND, FAIL,
"'found' callback failed for B-tree find operation")
*found = TRUE;
HGOTO_DONE(SUCCEED)
HGOTO_DONE(SUCCEED);
} /* end if */
} /* end if */
if (hdr->max_native_rec != NULL) {
@ -481,14 +481,14 @@ H5B2_find(H5B2_t *bt2, void *udata, hbool_t *found, H5B2_found_t op, void *op_da
HGOTO_ERROR(H5E_BTREE, H5E_CANTCOMPARE, FAIL, "can't compare btree2 records")
if (cmp > 0) {
*found = FALSE; /* Greater than the largest record--not found */
HGOTO_DONE(SUCCEED)
HGOTO_DONE(SUCCEED);
}
else if (cmp == 0) { /* Record is found */
if (op && (op)(hdr->max_native_rec, op_data) < 0)
HGOTO_ERROR(H5E_BTREE, H5E_NOTFOUND, FAIL,
"'found' callback failed for B-tree find operation")
*found = TRUE;
HGOTO_DONE(SUCCEED)
HGOTO_DONE(SUCCEED);
} /* end if */
} /* end if */
@ -580,7 +580,7 @@ H5B2_find(H5B2_t *bt2, void *udata, hbool_t *found, H5B2_found_t op, void *op_da
/* Indicate record found */
*found = TRUE;
HGOTO_DONE(SUCCEED)
HGOTO_DONE(SUCCEED);
} /* end else */
/* Decrement depth we're at in B-tree */
@ -616,7 +616,7 @@ H5B2_find(H5B2_t *bt2, void *udata, hbool_t *found, H5B2_found_t op, void *op_da
/* Record not found */
*found = FALSE;
HGOTO_DONE(SUCCEED)
HGOTO_DONE(SUCCEED);
} /* end if */
else {
/* Make callback for current record */
@ -1280,7 +1280,7 @@ H5B2_modify(H5B2_t *bt2, void *udata, H5B2_modify_t op, void *op_data)
* since many times the B-tree is searched in order to determine
* if an object exists in the B-tree or not.
*/
HGOTO_DONE(FAIL)
HGOTO_DONE(FAIL);
}
else {
/* Make callback for current record */

2
src/H5B2leaf.c
View File

@ -470,7 +470,7 @@ H5B2__update_leaf(H5B2_hdr_t *hdr, H5B2_node_ptr_t *curr_node_ptr, H5B2_update_s
*status = H5B2_UPDATE_INSERT_CHILD_FULL;
/* Let calling routine handle insertion */
HGOTO_DONE(SUCCEED)
HGOTO_DONE(SUCCEED);
} /* end if */
/* Adjust index to leave room for record to insert */

2
src/H5B2test.c
View File

@ -526,7 +526,7 @@ H5B2__get_node_info_test(H5B2_t *bt2, void *udata, H5B2_node_info_test_t *ninfo)
ninfo->nrec = curr_node_ptr.node_nrec;
/* Indicate success */
HGOTO_DONE(SUCCEED)
HGOTO_DONE(SUCCEED);
} /* end else */
/* Decrement depth we're at in B-tree */

4
src/H5C.c
View File

@ -404,7 +404,7 @@ H5C_prep_for_file_close(H5F_t *f)
/* It is possible to receive the close warning more than once */
if (cache_ptr->close_warning_received)
HGOTO_DONE(SUCCEED)
HGOTO_DONE(SUCCEED);
cache_ptr->close_warning_received = TRUE;
/* Make certain there aren't any protected entries */
@ -1124,7 +1124,7 @@ H5C_set_slist_enabled(H5C_t *cache_ptr, hbool_t slist_enabled, hbool_t clear_sli
node_ptr = H5SL_first(cache_ptr->slist_ptr);
while (node_ptr != NULL) {
entry_ptr = (H5C_cache_entry_t *)H5SL_item(node_ptr);
H5C__REMOVE_ENTRY_FROM_SLIST(cache_ptr, entry_ptr, FALSE, FAIL)
H5C__REMOVE_ENTRY_FROM_SLIST(cache_ptr, entry_ptr, FALSE, FAIL);
node_ptr = H5SL_first(cache_ptr->slist_ptr);
}
}

2
src/H5Cdbg.c
View File

@ -1067,7 +1067,7 @@ H5C_cache_is_clean(const H5C_t *cache_ptr, H5C_ring_t inner_ring)
while (ring <= inner_ring) {
if (cache_ptr->dirty_index_ring_size[ring] > 0)
HGOTO_DONE(FALSE)
HGOTO_DONE(FALSE);
ring++;
} /* end while */

102
src/H5Centry.c
View File

@ -131,7 +131,7 @@ H5C__pin_entry_from_client(H5C_t
else {
entry_ptr->is_pinned = TRUE;
H5C__UPDATE_STATS_FOR_PIN(cache_ptr, entry_ptr)
H5C__UPDATE_STATS_FOR_PIN(cache_ptr, entry_ptr);
} /* end else */
/* Mark that the entry was pinned through an explicit pin from a client */
@ -168,13 +168,13 @@ H5C__unpin_entry_real(H5C_t *cache_ptr, H5C_cache_entry_t *entry_ptr, hbool_t up
/* If requested, update the replacement policy if the entry is not protected */
if (update_rp && !entry_ptr->is_protected)
H5C__UPDATE_RP_FOR_UNPIN(cache_ptr, entry_ptr, FAIL)
H5C__UPDATE_RP_FOR_UNPIN(cache_ptr, entry_ptr, FAIL);
/* Unpin the entry now */
entry_ptr->is_pinned = FALSE;
/* Update the stats for an unpin operation */
H5C__UPDATE_STATS_FOR_UNPIN(cache_ptr, entry_ptr)
H5C__UPDATE_STATS_FOR_UNPIN(cache_ptr, entry_ptr);
#ifdef H5C_DO_SANITY_CHECKS
done:
@ -349,13 +349,13 @@ H5C__generate_image(H5F_t *f, H5C_t *cache_ptr, H5C_cache_entry_t *entry_ptr)
*/
if (serialize_flags & H5C__SERIALIZE_MOVED_FLAG) {
/* Update stats and entries relocated counter */
H5C__UPDATE_STATS_FOR_MOVE(cache_ptr, entry_ptr)
H5C__UPDATE_STATS_FOR_MOVE(cache_ptr, entry_ptr);
/* We must update cache data structures for the change in address */
if (entry_ptr->addr == old_addr) {
/* Delete the entry from the hash table and the slist */
H5C__DELETE_FROM_INDEX(cache_ptr, entry_ptr, FAIL);
H5C__REMOVE_ENTRY_FROM_SLIST(cache_ptr, entry_ptr, FALSE, FAIL)
H5C__REMOVE_ENTRY_FROM_SLIST(cache_ptr, entry_ptr, FALSE, FAIL);
/* Update the entry for its new address */
entry_ptr->addr = new_addr;
@ -631,13 +631,13 @@ H5C__flush_single_entry(H5F_t *f, H5C_cache_entry_t *entry_ptr, unsigned flags)
if (clear_only) {
/* only log a clear if the entry was dirty */
if (was_dirty)
H5C__UPDATE_STATS_FOR_CLEAR(cache_ptr, entry_ptr)
H5C__UPDATE_STATS_FOR_CLEAR(cache_ptr, entry_ptr);
}
else if (write_entry) {
assert(was_dirty);
/* only log a flush if we actually wrote to disk */
H5C__UPDATE_STATS_FOR_FLUSH(cache_ptr, entry_ptr)
H5C__UPDATE_STATS_FOR_FLUSH(cache_ptr, entry_ptr);
} /* end else if */
/* Note that the algorithm below is (very) similar to the set of operations
@ -656,7 +656,7 @@ H5C__flush_single_entry(H5F_t *f, H5C_cache_entry_t *entry_ptr, unsigned flags)
assert(!entry_ptr->is_pinned);
/* Update stats, while entry is still in the cache */
H5C__UPDATE_STATS_FOR_EVICTION(cache_ptr, entry_ptr, take_ownership)
H5C__UPDATE_STATS_FOR_EVICTION(cache_ptr, entry_ptr, take_ownership);
/* If the entry's type has a 'notify' callback and the entry is about
* to be removed from the cache, send a 'before eviction' notice while
@ -685,17 +685,17 @@ H5C__flush_single_entry(H5F_t *f, H5C_cache_entry_t *entry_ptr, unsigned flags)
H5C__DELETE_FROM_INDEX(cache_ptr, entry_ptr, FAIL);
if (entry_ptr->in_slist && del_from_slist_on_destroy)
H5C__REMOVE_ENTRY_FROM_SLIST(cache_ptr, entry_ptr, during_flush, FAIL)
H5C__REMOVE_ENTRY_FROM_SLIST(cache_ptr, entry_ptr, during_flush, FAIL);
#ifdef H5_HAVE_PARALLEL
/* Check for collective read access flag */
if (entry_ptr->coll_access) {
entry_ptr->coll_access = FALSE;
H5C__REMOVE_FROM_COLL_LIST(cache_ptr, entry_ptr, FAIL)
H5C__REMOVE_FROM_COLL_LIST(cache_ptr, entry_ptr, FAIL);
} /* end if */
#endif /* H5_HAVE_PARALLEL */
H5C__UPDATE_RP_FOR_EVICTION(cache_ptr, entry_ptr, FAIL)
H5C__UPDATE_RP_FOR_EVICTION(cache_ptr, entry_ptr, FAIL);
/* Remove entry from tag list */
if (H5C__untag_entry(cache_ptr, entry_ptr) < 0)
@ -716,8 +716,8 @@ H5C__flush_single_entry(H5F_t *f, H5C_cache_entry_t *entry_ptr, unsigned flags)
* view of the replacement policy and the slist.
* Hence no differentiation between them.
*/
H5C__UPDATE_RP_FOR_FLUSH(cache_ptr, entry_ptr, FAIL)
H5C__REMOVE_ENTRY_FROM_SLIST(cache_ptr, entry_ptr, during_flush, FAIL)
H5C__UPDATE_RP_FOR_FLUSH(cache_ptr, entry_ptr, FAIL);
H5C__REMOVE_ENTRY_FROM_SLIST(cache_ptr, entry_ptr, during_flush, FAIL);
/* mark the entry as clean and update the index for
* entry clean. Also, call the clear callback
@ -2001,7 +2001,7 @@ H5C__deserialize_prefetched_entry(H5F_t *f, H5C_t *cache_ptr, H5C_cache_entry_t
if (ds_entry_ptr->is_dirty)
H5C__INSERT_ENTRY_IN_SLIST(cache_ptr, ds_entry_ptr, FAIL);
H5C__UPDATE_RP_FOR_INSERTION(cache_ptr, ds_entry_ptr, FAIL)
H5C__UPDATE_RP_FOR_INSERTION(cache_ptr, ds_entry_ptr, FAIL);
/* Deserializing a prefetched entry is the conceptual equivalent of
* loading it from file. If the deserialized entry has a notify callback,
@ -2019,7 +2019,7 @@ H5C__deserialize_prefetched_entry(H5F_t *f, H5C_t *cache_ptr, H5C_cache_entry_t
*/
i = 0;
if (fd_children != NULL) {
H5C__UPDATE_RP_FOR_PROTECT(cache_ptr, ds_entry_ptr, FAIL)
H5C__UPDATE_RP_FOR_PROTECT(cache_ptr, ds_entry_ptr, FAIL);
ds_entry_ptr->is_protected = TRUE;
while (fd_children[i] != NULL) {
/* Sanity checks */
@ -2056,7 +2056,7 @@ H5C__deserialize_prefetched_entry(H5F_t *f, H5C_t *cache_ptr, H5C_cache_entry_t
assert((unsigned)i == ds_entry_ptr->fd_child_count);
ds_entry_ptr->fd_child_count = 0;
H5C__UPDATE_STATS_FOR_PREFETCH_HIT(cache_ptr)
H5C__UPDATE_STATS_FOR_PREFETCH_HIT(cache_ptr);
/* finally, pass ds_entry_ptr back to the caller */
*entry_ptr_ptr = ds_entry_ptr;
@ -2137,7 +2137,7 @@ H5C_insert_entry(H5F_t *f, const H5C_class_t *type, haddr_t addr, void *thing, u
* and die if it is.
*/
H5C__SEARCH_INDEX(cache_ptr, addr, test_entry_ptr, FAIL)
H5C__SEARCH_INDEX(cache_ptr, addr, test_entry_ptr, FAIL);
if (test_entry_ptr != NULL) {
if (test_entry_ptr == entry_ptr)
@ -2238,7 +2238,7 @@ H5C_insert_entry(H5F_t *f, const H5C_class_t *type, haddr_t addr, void *thing, u
HGOTO_ERROR(H5E_CACHE, H5E_CANTTAG, FAIL, "Cannot tag metadata entry")
entry_tagged = TRUE;
H5C__RESET_CACHE_ENTRY_STATS(entry_ptr)
H5C__RESET_CACHE_ENTRY_STATS(entry_ptr);
if (cache_ptr->flash_size_increase_possible &&
(entry_ptr->size > cache_ptr->flash_size_increase_threshold))
@ -2302,7 +2302,7 @@ H5C_insert_entry(H5F_t *f, const H5C_class_t *type, haddr_t addr, void *thing, u
assert(entry_ptr->is_dirty);
entry_ptr->flush_marker = set_flush_marker;
H5C__INSERT_ENTRY_IN_SLIST(cache_ptr, entry_ptr, FAIL);
H5C__UPDATE_RP_FOR_INSERTION(cache_ptr, entry_ptr, FAIL)
H5C__UPDATE_RP_FOR_INSERTION(cache_ptr, entry_ptr, FAIL);
#ifdef H5C_DO_EXTREME_SANITY_CHECKS
if (H5C__validate_protected_entry_list(cache_ptr) < 0 || H5C__validate_pinned_entry_list(cache_ptr) < 0 ||
@ -2316,7 +2316,7 @@ H5C_insert_entry(H5F_t *f, const H5C_class_t *type, haddr_t addr, void *thing, u
if (entry_ptr->type->notify && (entry_ptr->type->notify)(H5C_NOTIFY_ACTION_AFTER_INSERT, entry_ptr) < 0)
HGOTO_ERROR(H5E_CACHE, H5E_CANTNOTIFY, FAIL, "can't notify client about entry inserted into cache")
H5C__UPDATE_STATS_FOR_INSERTION(cache_ptr, entry_ptr)
H5C__UPDATE_STATS_FOR_INSERTION(cache_ptr, entry_ptr);
#ifdef H5_HAVE_PARALLEL
if (H5F_HAS_FEATURE(f, H5FD_FEAT_HAS_MPI))
@ -2324,7 +2324,7 @@ H5C_insert_entry(H5F_t *f, const H5C_class_t *type, haddr_t addr, void *thing, u
entry_ptr->coll_access = coll_access;
if (coll_access) {
H5C__INSERT_IN_COLL_LIST(cache_ptr, entry_ptr, FAIL)
H5C__INSERT_IN_COLL_LIST(cache_ptr, entry_ptr, FAIL);
/* Make sure the size of the collective entries in the cache remain in check */
if (H5P_USER_TRUE == H5F_COLL_MD_READ(f)) {
@ -2421,12 +2421,12 @@ H5C_mark_entry_dirty(void *thing)
/* Modify cache data structures */
if (was_clean)
H5C__UPDATE_INDEX_FOR_ENTRY_DIRTY(cache_ptr, entry_ptr, FAIL)
H5C__UPDATE_INDEX_FOR_ENTRY_DIRTY(cache_ptr, entry_ptr, FAIL);
if (!entry_ptr->in_slist)
H5C__INSERT_ENTRY_IN_SLIST(cache_ptr, entry_ptr, FAIL);
/* Update stats for entry being marked dirty */
H5C__UPDATE_STATS_FOR_DIRTY_PIN(cache_ptr, entry_ptr)
H5C__UPDATE_STATS_FOR_DIRTY_PIN(cache_ptr, entry_ptr);
/* Check for entry changing status and do notifications, etc. */
if (was_clean) {
@ -2500,12 +2500,12 @@ H5C_mark_entry_clean(void *_thing)
/* Modify cache data structures */
if (was_dirty)
H5C__UPDATE_INDEX_FOR_ENTRY_CLEAN(cache_ptr, entry_ptr, FAIL)
H5C__UPDATE_INDEX_FOR_ENTRY_CLEAN(cache_ptr, entry_ptr, FAIL);
if (entry_ptr->in_slist)
H5C__REMOVE_ENTRY_FROM_SLIST(cache_ptr, entry_ptr, FALSE, FAIL)
H5C__REMOVE_ENTRY_FROM_SLIST(cache_ptr, entry_ptr, FALSE, FAIL);
/* Update stats for entry being marked clean */
H5C__UPDATE_STATS_FOR_CLEAR(cache_ptr, entry_ptr)
H5C__UPDATE_STATS_FOR_CLEAR(cache_ptr, entry_ptr);
/* Check for entry changing status and do notifications, etc. */
if (was_dirty) {
@ -2649,11 +2649,11 @@ H5C_move_entry(H5C_t *cache_ptr, const H5C_class_t *type, haddr_t old_addr, hadd
HGOTO_ERROR(H5E_CACHE, H5E_SYSTEM, FAIL, "an extreme sanity check failed on entry")
#endif /* H5C_DO_EXTREME_SANITY_CHECKS */
H5C__SEARCH_INDEX(cache_ptr, old_addr, entry_ptr, FAIL)
H5C__SEARCH_INDEX(cache_ptr, old_addr, entry_ptr, FAIL);
if (entry_ptr == NULL || entry_ptr->type != type)
/* the old item doesn't exist in the cache, so we are done. */
HGOTO_DONE(SUCCEED)
HGOTO_DONE(SUCCEED);
assert(entry_ptr->addr == old_addr);
assert(entry_ptr->type == type);
@ -2665,7 +2665,7 @@ H5C_move_entry(H5C_t *cache_ptr, const H5C_class_t *type, haddr_t old_addr, hadd
if (entry_ptr->is_read_only)
HGOTO_ERROR(H5E_CACHE, H5E_CANTMOVE, FAIL, "can't move R/O entry")
H5C__SEARCH_INDEX(cache_ptr, new_addr, test_entry_ptr, FAIL)
H5C__SEARCH_INDEX(cache_ptr, new_addr, test_entry_ptr, FAIL);
if (test_entry_ptr != NULL) { /* we are hosed */
if (test_entry_ptr->type == type)
@ -2694,7 +2694,7 @@ H5C_move_entry(H5C_t *cache_ptr, const H5C_class_t *type, haddr_t old_addr, hadd
if (entry_ptr->in_slist) {
assert(cache_ptr->slist_ptr);
H5C__REMOVE_ENTRY_FROM_SLIST(cache_ptr, entry_ptr, FALSE, FAIL)
H5C__REMOVE_ENTRY_FROM_SLIST(cache_ptr, entry_ptr, FALSE, FAIL);
} /* end if */
} /* end if */
@ -2746,7 +2746,7 @@ H5C_move_entry(H5C_t *cache_ptr, const H5C_class_t *type, haddr_t old_addr, hadd
} /* end if */
} /* end if */
H5C__UPDATE_STATS_FOR_MOVE(cache_ptr, entry_ptr)
H5C__UPDATE_STATS_FOR_MOVE(cache_ptr, entry_ptr);
done:
#ifdef H5C_DO_EXTREME_SANITY_CHECKS
@ -2863,7 +2863,7 @@ H5C_resize_entry(void *thing, size_t new_size)
H5C__INSERT_ENTRY_IN_SLIST(cache_ptr, entry_ptr, FAIL);
if (entry_ptr->is_pinned)
H5C__UPDATE_STATS_FOR_DIRTY_PIN(cache_ptr, entry_ptr)
H5C__UPDATE_STATS_FOR_DIRTY_PIN(cache_ptr, entry_ptr);
/* Check for entry changing status and do notifications, etc. */
if (was_clean) {
@ -3014,7 +3014,7 @@ H5C_protect(H5F_t *f, const H5C_class_t *type, haddr_t addr, void *udata, unsign
#endif /* H5_HAVE_PARALLEL */
/* first check to see if the target is in cache */
H5C__SEARCH_INDEX(cache_ptr, addr, entry_ptr, NULL)
H5C__SEARCH_INDEX(cache_ptr, addr, entry_ptr, NULL);
if (entry_ptr != NULL) {
if (entry_ptr->ring != ring)
@ -3080,10 +3080,10 @@ H5C_protect(H5F_t *f, const H5C_class_t *type, haddr_t addr, void *udata, unsign
/* Mark the entry as collective and insert into the collective list */
entry_ptr->coll_access = TRUE;
H5C__INSERT_IN_COLL_LIST(cache_ptr, entry_ptr, NULL)
H5C__INSERT_IN_COLL_LIST(cache_ptr, entry_ptr, NULL);
} /* end if */
else if (entry_ptr->coll_access)
H5C__MOVE_TO_TOP_IN_COLL_LIST(cache_ptr, entry_ptr, NULL)
H5C__MOVE_TO_TOP_IN_COLL_LIST(cache_ptr, entry_ptr, NULL);
} /* end if */
#endif /* H5_HAVE_PARALLEL */
@ -3127,7 +3127,7 @@ H5C_protect(H5F_t *f, const H5C_class_t *type, haddr_t addr, void *udata, unsign
entry_ptr->ring = ring;
#ifdef H5_HAVE_PARALLEL
if (H5F_HAS_FEATURE(f, H5FD_FEAT_HAS_MPI) && entry_ptr->coll_access)
H5C__INSERT_IN_COLL_LIST(cache_ptr, entry_ptr, NULL)
H5C__INSERT_IN_COLL_LIST(cache_ptr, entry_ptr, NULL);
#endif /* H5_HAVE_PARALLEL */
/* Apply tag to newly protected entry */
@ -3229,7 +3229,7 @@ H5C_protect(H5F_t *f, const H5C_class_t *type, haddr_t addr, void *udata, unsign
* the replacement policy for a protect, but this simplifies the
* code. If we do this often enough, we may want to optimize this.
*/
H5C__UPDATE_RP_FOR_INSERTION(cache_ptr, entry_ptr, NULL)
H5C__UPDATE_RP_FOR_INSERTION(cache_ptr, entry_ptr, NULL);
/* Record that the entry was loaded, to trigger a notify callback later */
/* (After the entry is fully added to the cache) */
@ -3248,7 +3248,7 @@ H5C_protect(H5F_t *f, const H5C_class_t *type, haddr_t addr, void *udata, unsign
HGOTO_ERROR(H5E_CACHE, H5E_CANTPROTECT, NULL, "Target already protected & not read only?!?")
} /* end if */
else {
H5C__UPDATE_RP_FOR_PROTECT(cache_ptr, entry_ptr, NULL)
H5C__UPDATE_RP_FOR_PROTECT(cache_ptr, entry_ptr, NULL);
entry_ptr->is_protected = TRUE;
if (read_only) {
@ -3258,8 +3258,8 @@ H5C_protect(H5F_t *f, const H5C_class_t *type, haddr_t addr, void *udata, unsign
entry_ptr->dirtied = FALSE;
} /* end else */
H5C__UPDATE_CACHE_HIT_RATE_STATS(cache_ptr, hit)
H5C__UPDATE_STATS_FOR_PROTECT(cache_ptr, entry_ptr, hit)
H5C__UPDATE_CACHE_HIT_RATE_STATS(cache_ptr, hit);
H5C__UPDATE_STATS_FOR_PROTECT(cache_ptr, entry_ptr, hit);
ret_value = thing;
@ -3561,7 +3561,7 @@ H5C_unprotect(H5F_t *f, haddr_t addr, void *thing, unsigned flags)
/* Check for newly dirtied entry */
if (was_clean && entry_ptr->is_dirty) {
/* Update index for newly dirtied entry */
H5C__UPDATE_INDEX_FOR_ENTRY_DIRTY(cache_ptr, entry_ptr, FAIL)
H5C__UPDATE_INDEX_FOR_ENTRY_DIRTY(cache_ptr, entry_ptr, FAIL);
/* If the entry's type has a 'notify' callback send a
* 'entry dirtied' notice now that the entry is fully
@ -3636,7 +3636,7 @@ H5C_unprotect(H5F_t *f, haddr_t addr, void *thing, unsigned flags)
unsigned flush_flags = (H5C__FLUSH_CLEAR_ONLY_FLAG | H5C__FLUSH_INVALIDATE_FLAG);
/* verify that the target entry is in the cache. */
H5C__SEARCH_INDEX(cache_ptr, addr, test_entry_ptr, FAIL)
H5C__SEARCH_INDEX(cache_ptr, addr, test_entry_ptr, FAIL);
if (test_entry_ptr == NULL)
HGOTO_ERROR(H5E_CACHE, H5E_CANTUNPROTECT, FAIL, "entry not in hash table?!?")
@ -3663,7 +3663,7 @@ H5C_unprotect(H5F_t *f, haddr_t addr, void *thing, unsigned flags)
#ifdef H5_HAVE_PARALLEL
else if (clear_entry) {
/* Verify that the target entry is in the cache. */
H5C__SEARCH_INDEX(cache_ptr, addr, test_entry_ptr, FAIL)
H5C__SEARCH_INDEX(cache_ptr, addr, test_entry_ptr, FAIL);
if (test_entry_ptr == NULL)
HGOTO_ERROR(H5E_CACHE, H5E_CANTUNPROTECT, FAIL, "entry not in hash table?!?")
@ -3678,7 +3678,7 @@ H5C_unprotect(H5F_t *f, haddr_t addr, void *thing, unsigned flags)
#endif /* H5_HAVE_PARALLEL */
}
H5C__UPDATE_STATS_FOR_UNPROTECT(cache_ptr)
H5C__UPDATE_STATS_FOR_UNPROTECT(cache_ptr);
done:
#ifdef H5C_DO_EXTREME_SANITY_CHECKS
@ -3820,7 +3820,7 @@ H5C_create_flush_dependency(void *parent_thing, void *child_thing)
/* Pin the parent entry */
parent_entry->is_pinned = TRUE;
H5C__UPDATE_STATS_FOR_PIN(cache_ptr, parent_entry)
H5C__UPDATE_STATS_FOR_PIN(cache_ptr, parent_entry);
} /* end else */
/* Mark the entry as pinned from the cache's action (possibly redundantly) */
@ -4053,10 +4053,10 @@ H5C_expunge_entry(H5F_t *f, const H5C_class_t *type, haddr_t addr, unsigned flag
#endif /* H5C_DO_EXTREME_SANITY_CHECKS */
/* Look for entry in cache */
H5C__SEARCH_INDEX(cache_ptr, addr, entry_ptr, FAIL)
H5C__SEARCH_INDEX(cache_ptr, addr, entry_ptr, FAIL);
if ((entry_ptr == NULL) || (entry_ptr->type != type))
/* the target doesn't exist in the cache, so we are done. */
HGOTO_DONE(SUCCEED)
HGOTO_DONE(SUCCEED);
assert(entry_ptr->addr == addr);
assert(entry_ptr->type == type);
@ -4146,7 +4146,7 @@ H5C_remove_entry(void *_entry)
*/
/* Update stats, as if we are "destroying" and taking ownership of the entry */
H5C__UPDATE_STATS_FOR_EVICTION(cache, entry, TRUE)
H5C__UPDATE_STATS_FOR_EVICTION(cache, entry, TRUE);
/* If the entry's type has a 'notify' callback, send a 'before eviction'
* notice while the entry is still fully integrated in the cache.
@ -4168,15 +4168,15 @@ H5C_remove_entry(void *_entry)
/* Check for collective read access flag */
if (entry->coll_access) {
entry->coll_access = FALSE;
H5C__REMOVE_FROM_COLL_LIST(cache, entry, FAIL)
H5C__REMOVE_FROM_COLL_LIST(cache, entry, FAIL);
} /* end if */
#endif /* H5_HAVE_PARALLEL */
H5C__UPDATE_RP_FOR_EVICTION(cache, entry, FAIL)
H5C__UPDATE_RP_FOR_EVICTION(cache, entry, FAIL);
/* Remove entry from tag list */
if (H5C__untag_entry(cache, entry) < 0)
HGOTO_ERROR(H5E_CACHE, H5E_CANTREMOVE, FAIL, "can't remove entry from tag list")
HGOTO_ERROR(H5E_CACHE, H5E_CANTREMOVE, FAIL, "can't remove entry from tag list");
/* Increment entries_removed_counter and set last_entry_removed_ptr.
* As we me be about to free the entry, recall that last_entry_removed_ptr

18
src/H5Cimage.c
View File

@ -85,20 +85,22 @@
#if H5C_COLLECT_CACHE_STATS
/* clang-format off */
#define H5C__UPDATE_STATS_FOR_CACHE_IMAGE_CREATE(cache_ptr) \
(cache_ptr)->images_created++;
do { \
(cache_ptr)->images_created++; \
} while (0)
#define H5C__UPDATE_STATS_FOR_CACHE_IMAGE_READ(cache_ptr) \
{ \
do { \
/* make sure image len is still good */ \
assert((cache_ptr)->image_len > 0); \
(cache_ptr)->images_read++; \
}
} while (0)
#define H5C__UPDATE_STATS_FOR_CACHE_IMAGE_LOAD(cache_ptr) \
{ \
do { \
/* make sure image len is still good */ \
assert((cache_ptr)->image_len > 0); \
(cache_ptr)->images_loaded++; \
(cache_ptr)->last_image_size = (cache_ptr)->image_len; \
}
} while (0)
/* clang-format on */
#else /* H5C_COLLECT_CACHE_STATS */
#define H5C__UPDATE_STATS_FOR_CACHE_IMAGE_CREATE(cache_ptr)
@ -551,7 +553,7 @@ H5C__read_cache_image(H5F_t *f, H5C_t *cache_ptr)
cache_ptr->image_buffer) < 0)
HGOTO_ERROR(H5E_CACHE, H5E_READERROR, FAIL, "Can't read metadata cache image block")
H5C__UPDATE_STATS_FOR_CACHE_IMAGE_READ(cache_ptr)
H5C__UPDATE_STATS_FOR_CACHE_IMAGE_READ(cache_ptr);
#ifdef H5_HAVE_PARALLEL
if (aux_ptr) {
@ -634,7 +636,7 @@ H5C__load_cache_image(H5F_t *f)
/* Update stats -- must do this now, as we are about
* to discard the size of the cache image.
*/
H5C__UPDATE_STATS_FOR_CACHE_IMAGE_LOAD(cache_ptr)
H5C__UPDATE_STATS_FOR_CACHE_IMAGE_LOAD(cache_ptr);
cache_ptr->image_loaded = TRUE;
} /* end if */
@ -2441,7 +2443,7 @@ H5C__reconstruct_cache_contents(H5F_t *f, H5C_t *cache_ptr)
/* Must protect parent entry to set up a flush dependency.
* Do this now, and then uprotect when done.
*/
H5C__UPDATE_RP_FOR_PROTECT(cache_ptr, parent_ptr, FAIL)
H5C__UPDATE_RP_FOR_PROTECT(cache_ptr, parent_ptr, FAIL);
parent_ptr->is_protected = TRUE;
/* Setup the flush dependency */

14
src/H5Cint.c
View File

@ -111,7 +111,7 @@ H5C__auto_adjust_cache_size(H5F_t *f, hbool_t write_permitted)
*/
if (cache_ptr->resize_in_progress) {
reentrant_call = TRUE;
HGOTO_DONE(SUCCEED)
HGOTO_DONE(SUCCEED);
} /* end if */
cache_ptr->resize_in_progress = TRUE;
@ -593,7 +593,7 @@ H5C__autoadjust__ageout__evict_aged_out_entries(H5F_t *f, hbool_t write_permitte
restart_scan = FALSE;
entry_ptr = cache_ptr->LRU_tail_ptr;
H5C__UPDATE_STATS_FOR_LRU_SCAN_RESTART(cache_ptr)
H5C__UPDATE_STATS_FOR_LRU_SCAN_RESTART(cache_ptr);
} /* end else-if */
else
entry_ptr = prev_ptr;
@ -1357,7 +1357,7 @@ H5C__flush_invalidate_ring(H5F_t *f, H5C_ring_t ring, unsigned flags)
*/
restart_slist_scan = TRUE;
cache_ptr->slist_changed = FALSE;
H5C__UPDATE_STATS_FOR_SLIST_SCAN_RESTART(cache_ptr)
H5C__UPDATE_STATS_FOR_SLIST_SCAN_RESTART(cache_ptr);
} /* end if */
} /* end else */
} /* end if */
@ -1474,7 +1474,7 @@ H5C__flush_invalidate_ring(H5F_t *f, H5C_ring_t ring, unsigned flags)
cache_ptr->entries_inserted_counter = 0;
cache_ptr->entries_relocated_counter = 0;
H5C__UPDATE_STATS_FOR_INDEX_SCAN_RESTART(cache_ptr)
H5C__UPDATE_STATS_FOR_INDEX_SCAN_RESTART(cache_ptr);
} /* end if */
else
cache_ptr->entry_watched_for_removal = NULL;
@ -1509,7 +1509,7 @@ H5C__flush_invalidate_ring(H5F_t *f, H5C_ring_t ring, unsigned flags)
if ((cur_ring_pel_len > 0) && (cur_ring_pel_len >= old_ring_pel_len)) {
/* Don't error if allowed to have pinned entries remaining */
if (evict_flags)
HGOTO_DONE(TRUE)
HGOTO_DONE(TRUE);
HGOTO_ERROR(
H5E_CACHE, H5E_CANTFLUSH, FAIL,
@ -1767,7 +1767,7 @@ H5C__flush_ring(H5F_t *f, H5C_ring_t ring, unsigned flags)
*/
restart_slist_scan = TRUE;
cache_ptr->slist_changed = FALSE;
H5C__UPDATE_STATS_FOR_SLIST_SCAN_RESTART(cache_ptr)
H5C__UPDATE_STATS_FOR_SLIST_SCAN_RESTART(cache_ptr);
} /* end if */
flushed_entries_last_pass = TRUE;
@ -1982,7 +1982,7 @@ H5C__make_space_in_cache(H5F_t *f, size_t space_needed, hbool_t write_permitted)
*/
restart_scan = FALSE;
entry_ptr = cache_ptr->LRU_tail_ptr;
H5C__UPDATE_STATS_FOR_LRU_SCAN_RESTART(cache_ptr)
H5C__UPDATE_STATS_FOR_LRU_SCAN_RESTART(cache_ptr);
}
else
entry_ptr = prev_ptr;

8
src/H5Cmpio.c
View File

@ -333,7 +333,7 @@ H5C_apply_candidate_list(H5F_t *f, H5C_t *cache_ptr, unsigned num_candidates, ha
*/
if (entry_ptr->coll_access) {
entry_ptr->coll_access = FALSE;
H5C__REMOVE_FROM_COLL_LIST(cache_ptr, entry_ptr, FAIL)
H5C__REMOVE_FROM_COLL_LIST(cache_ptr, entry_ptr, FAIL);
} /* end if */
} /* end for */
@ -690,7 +690,7 @@ H5C_mark_entries_as_clean(H5F_t *f, unsigned ce_array_len, haddr_t *ce_array_ptr
it so it can be cleared */
if (TRUE == entry_ptr->coll_access) {
entry_ptr->coll_access = FALSE;
H5C__REMOVE_FROM_COLL_LIST(cache_ptr, entry_ptr, FAIL)
H5C__REMOVE_FROM_COLL_LIST(cache_ptr, entry_ptr, FAIL);
} /* end if */
entry_ptr->clear_on_unprotect = TRUE;
@ -837,7 +837,7 @@ H5C_clear_coll_entries(H5C_t *cache_ptr, hbool_t partial)
/* Mark entry as independent */
entry_ptr->coll_access = FALSE;
H5C__REMOVE_FROM_COLL_LIST(cache_ptr, entry_ptr, FAIL)
H5C__REMOVE_FROM_COLL_LIST(cache_ptr, entry_ptr, FAIL);
/* Decrement entry count */
clear_cnt--;
@ -1283,7 +1283,7 @@ H5C__flush_candidates_in_ring(H5F_t *f, H5C_ring_t ring, unsigned entries_to_flu
restart_scan = FALSE;
entry_ptr = cache_ptr->LRU_tail_ptr;
H5C__UPDATE_STATS_FOR_LRU_SCAN_RESTART(cache_ptr)
H5C__UPDATE_STATS_FOR_LRU_SCAN_RESTART(cache_ptr);
} /* end if */
} /* end while */

425
src/H5Cpkg.h
View File

@ -71,7 +71,7 @@
#ifdef H5C_DO_SANITY_CHECKS
#define H5C__GEN_DLL_PRE_REMOVE_SC(entry_ptr, list_next, list_prev, head_ptr, tail_ptr, len, list_size, fail_val) \
if ((head_ptr) == NULL || (tail_ptr) == NULL || \
do { if ((head_ptr) == NULL || (tail_ptr) == NULL || \
(entry_ptr) == NULL || (len) <= 0 || \
(list_size) < (entry_ptr)->size || \
((entry_ptr)->list_prev == NULL && (head_ptr) != (entry_ptr)) || \
@ -84,7 +84,7 @@ if ((head_ptr) == NULL || (tail_ptr) == NULL || \
) \
) { \
HGOTO_ERROR(H5E_CACHE, H5E_SYSTEM, (fail_val), "DLL pre remove SC failed") \
}
} } while (0)
#define H5C__GEN_DLL_PRE_INSERT_SC(entry_ptr, list_next, list_prev, head_ptr, tail_ptr, len, list_size, fail_val) \
if ((entry_ptr) == NULL || (entry_ptr)->list_next != NULL || (entry_ptr)->list_prev != NULL || \
@ -157,7 +157,7 @@ if ((new_size) > (dll_size) || ((dll_len) == 1 && (new_size) != (dll_size))) { \
#define H5C__GEN_DLL_REMOVE(entry_ptr, list_next, list_prev, head_ptr, tail_ptr, len, list_size, fail_val) \
{ \
H5C__GEN_DLL_PRE_REMOVE_SC(entry_ptr, list_next, list_prev, head_ptr, tail_ptr, len, list_size, fail_val) \
H5C__GEN_DLL_PRE_REMOVE_SC(entry_ptr, list_next, list_prev, head_ptr, tail_ptr, len, list_size, fail_val); \
if ((head_ptr) == (entry_ptr)) { \
(head_ptr) = (entry_ptr)->list_next; \
if ((head_ptr) != NULL) \
@ -226,24 +226,31 @@ if ((new_size) > (dll_size) || ((dll_len) == 1 && (new_size) != (dll_size))) { \
***********************************************************************/
#define H5C__UPDATE_CACHE_HIT_RATE_STATS(cache_ptr, hit) \
do { \
(cache_ptr)->cache_accesses++; \
if (hit) \
(cache_ptr)->cache_hits++;
(cache_ptr)->cache_hits++; \
} while (0)
#if H5C_COLLECT_CACHE_STATS
#define H5C__UPDATE_MAX_INDEX_SIZE_STATS(cache_ptr) \
do { \
if ((cache_ptr)->index_size > (cache_ptr)->max_index_size) \
(cache_ptr)->max_index_size = (cache_ptr)->index_size; \
if ((cache_ptr)->clean_index_size > (cache_ptr)->max_clean_index_size) \
(cache_ptr)->max_clean_index_size = (cache_ptr)->clean_index_size; \
if ((cache_ptr)->dirty_index_size > (cache_ptr)->max_dirty_index_size) \
(cache_ptr)->max_dirty_index_size = (cache_ptr)->dirty_index_size;
(cache_ptr)->max_dirty_index_size = (cache_ptr)->dirty_index_size; \
} while (0)
#define H5C__UPDATE_STATS_FOR_DIRTY_PIN(cache_ptr, entry_ptr) \
(cache_ptr)->dirty_pins[(entry_ptr)->type->id]++;
#define H5C__UPDATE_STATS_FOR_DIRTY_PIN(cache_ptr, entry_ptr) \
do { \
(cache_ptr)->dirty_pins[(entry_ptr)->type->id]++; \
} while (0)
#define H5C__UPDATE_STATS_FOR_UNPROTECT(cache_ptr) \
do { \
if ((cache_ptr)->slist_len > (cache_ptr)->max_slist_len) \
(cache_ptr)->max_slist_len = (cache_ptr)->slist_len; \
if ((cache_ptr)->slist_size > (cache_ptr)->max_slist_size) \
@ -251,96 +258,118 @@ if ((new_size) > (dll_size) || ((dll_len) == 1 && (new_size) != (dll_size))) { \
if ((cache_ptr)->pel_len > (cache_ptr)->max_pel_len) \
(cache_ptr)->max_pel_len = (cache_ptr)->pel_len; \
if ((cache_ptr)->pel_size > (cache_ptr)->max_pel_size) \
(cache_ptr)->max_pel_size = (cache_ptr)->pel_size;
(cache_ptr)->max_pel_size = (cache_ptr)->pel_size; \
} while (0)
#define H5C__UPDATE_STATS_FOR_MOVE(cache_ptr, entry_ptr) \
do { \
if ((cache_ptr)->flush_in_progress) \
(cache_ptr)->cache_flush_moves[(entry_ptr)->type->id]++; \
if ((entry_ptr)->flush_in_progress) \
(cache_ptr)->entry_flush_moves[(entry_ptr)->type->id]++; \
(cache_ptr)->moves[(entry_ptr)->type->id]++; \
(cache_ptr)->entries_relocated_counter++;
(cache_ptr)->entries_relocated_counter++; \
} while (0)
#define H5C__UPDATE_STATS_FOR_ENTRY_SIZE_CHANGE(cache_ptr, entry_ptr, new_size) \
do { \
if ((cache_ptr)->flush_in_progress) \
(cache_ptr)->cache_flush_size_changes[(entry_ptr)->type->id]++; \
if ((entry_ptr)->flush_in_progress) \
(cache_ptr)->entry_flush_size_changes[(entry_ptr)->type->id]++; \
if ((entry_ptr)->size < (new_size)) { \
(cache_ptr)->size_increases[(entry_ptr)->type->id]++; \
H5C__UPDATE_MAX_INDEX_SIZE_STATS(cache_ptr) \
H5C__UPDATE_MAX_INDEX_SIZE_STATS(cache_ptr); \
if ((cache_ptr)->slist_size > (cache_ptr)->max_slist_size) \
(cache_ptr)->max_slist_size = (cache_ptr)->slist_size; \
if ((cache_ptr)->pl_size > (cache_ptr)->max_pl_size) \
(cache_ptr)->max_pl_size = (cache_ptr)->pl_size; \
} else if ((entry_ptr)->size > (new_size)) \
(cache_ptr)->size_decreases[(entry_ptr)->type->id]++;
} else if ((entry_ptr)->size > (new_size)) { \
(cache_ptr)->size_decreases[(entry_ptr)->type->id]++; \
} \
} while (0)
#define H5C__UPDATE_STATS_FOR_HT_INSERTION(cache_ptr) \
(cache_ptr)->total_ht_insertions++;
do { \
(cache_ptr)->total_ht_insertions++; \
} while (0)
#define H5C__UPDATE_STATS_FOR_HT_DELETION(cache_ptr) \
(cache_ptr)->total_ht_deletions++;
do { \
(cache_ptr)->total_ht_deletions++; \
} while (0)
#define H5C__UPDATE_STATS_FOR_HT_SEARCH(cache_ptr, success, depth) \
do { \
if (success) { \
(cache_ptr)->successful_ht_searches++; \
(cache_ptr)->total_successful_ht_search_depth += depth; \
} else { \
(cache_ptr)->failed_ht_searches++; \
(cache_ptr)->total_failed_ht_search_depth += depth; \
}
} \
} while (0)
#define H5C__UPDATE_STATS_FOR_UNPIN(cache_ptr, entry_ptr) \
(cache_ptr)->unpins[(entry_ptr)->type->id]++;
do { \
(cache_ptr)->unpins[(entry_ptr)->type->id]++; \
} while (0)
#define H5C__UPDATE_STATS_FOR_PREFETCH(cache_ptr, dirty) \
{ \
do { \
(cache_ptr)->prefetches++; \
if (dirty) \
(cache_ptr)->dirty_prefetches++; \
}
} while (0)
#define H5C__UPDATE_STATS_FOR_PREFETCH_HIT(cache_ptr) \
(cache_ptr)->prefetch_hits++;
do { \
(cache_ptr)->prefetch_hits++; \
} while (0)
#define H5C__UPDATE_STATS_FOR_SLIST_SCAN_RESTART(cache_ptr) \
(cache_ptr)->slist_scan_restarts++;
do { \
(cache_ptr)->slist_scan_restarts++; \
} while (0)
#define H5C__UPDATE_STATS_FOR_LRU_SCAN_RESTART(cache_ptr) \
(cache_ptr)->LRU_scan_restarts++;
do { \
(cache_ptr)->LRU_scan_restarts++; \
} while (0)
#define H5C__UPDATE_STATS_FOR_INDEX_SCAN_RESTART(cache_ptr) \
(cache_ptr)->index_scan_restarts++;
do { \
(cache_ptr)->index_scan_restarts++; \
} while (0)
#if H5C_COLLECT_CACHE_ENTRY_STATS
#define H5C__RESET_CACHE_ENTRY_STATS(entry_ptr) \
{ \
do { \
(entry_ptr)->accesses = 0; \
(entry_ptr)->clears = 0; \
(entry_ptr)->flushes = 0; \
(entry_ptr)->pins = 0; \
}
} while (0)
#define H5C__UPDATE_STATS_FOR_CLEAR(cache_ptr, entry_ptr) \
{ \
do { \
(cache_ptr)->clears[(entry_ptr)->type->id]++; \
if((entry_ptr)->is_pinned) \
(cache_ptr)->pinned_clears[(entry_ptr)->type->id]++; \
(entry_ptr)->clears++; \
}
} while (0)
#define H5C__UPDATE_STATS_FOR_FLUSH(cache_ptr, entry_ptr) \
{ \
do { \
(cache_ptr)->flushes[(entry_ptr)->type->id]++; \
if((entry_ptr)->is_pinned) \
(cache_ptr)->pinned_flushes[(entry_ptr)->type->id]++; \
(entry_ptr)->flushes++; \
}
} while (0)
#define H5C__UPDATE_STATS_FOR_EVICTION(cache_ptr, entry_ptr, take_ownership) \
{ \
do { \
if (take_ownership) \
(cache_ptr)->take_ownerships[(entry_ptr)->type->id]++; \
else \
@ -357,10 +386,10 @@ if ((new_size) > (dll_size) || ((dll_len) == 1 && (new_size) != (dll_size))) { \
(cache_ptr)->max_size[(entry_ptr)->type->id] = (entry_ptr)->size; \
if ((entry_ptr)->pins > (cache_ptr)->max_pins[(entry_ptr)->type->id]) \
(cache_ptr)->max_pins[(entry_ptr)->type->id] = (entry_ptr)->pins; \
}
} while (0)
#define H5C__UPDATE_STATS_FOR_INSERTION(cache_ptr, entry_ptr) \
{ \
do { \
(cache_ptr)->insertions[(entry_ptr)->type->id]++; \
if ((entry_ptr)->is_pinned) { \
(cache_ptr)->pinned_insertions[(entry_ptr)->type->id]++; \
@ -373,7 +402,7 @@ if ((new_size) > (dll_size) || ((dll_len) == 1 && (new_size) != (dll_size))) { \
} \
if ((cache_ptr)->index_len > (cache_ptr)->max_index_len) \
(cache_ptr)->max_index_len = (cache_ptr)->index_len; \
H5C__UPDATE_MAX_INDEX_SIZE_STATS(cache_ptr) \
H5C__UPDATE_MAX_INDEX_SIZE_STATS(cache_ptr); \
if ((cache_ptr)->slist_len > (cache_ptr)->max_slist_len) \
(cache_ptr)->max_slist_len = (cache_ptr)->slist_len; \
if ((cache_ptr)->slist_size > (cache_ptr)->max_slist_size) \
@ -381,10 +410,10 @@ if ((new_size) > (dll_size) || ((dll_len) == 1 && (new_size) != (dll_size))) { \
if ((entry_ptr)->size > (cache_ptr)->max_size[(entry_ptr)->type->id]) \
(cache_ptr)->max_size[(entry_ptr)->type->id] = (entry_ptr)->size; \
(cache_ptr)->entries_inserted_counter++; \
}
} while (0)
#define H5C__UPDATE_STATS_FOR_PROTECT(cache_ptr, entry_ptr, hit) \
{ \
do { \
if (hit) \
(cache_ptr)->hits[(entry_ptr)->type->id]++; \
else \
@ -398,7 +427,7 @@ if ((new_size) > (dll_size) || ((dll_len) == 1 && (new_size) != (dll_size))) { \
} \
if ((cache_ptr)->index_len > (cache_ptr)->max_index_len) \
(cache_ptr)->max_index_len = (cache_ptr)->index_len; \
H5C__UPDATE_MAX_INDEX_SIZE_STATS(cache_ptr) \
H5C__UPDATE_MAX_INDEX_SIZE_STATS(cache_ptr); \
if ((cache_ptr)->pl_len > (cache_ptr)->max_pl_len) \
(cache_ptr)->max_pl_len = (cache_ptr)->pl_len; \
if ((cache_ptr)->pl_size > (cache_ptr)->max_pl_size) \
@ -406,46 +435,46 @@ if ((new_size) > (dll_size) || ((dll_len) == 1 && (new_size) != (dll_size))) { \
if ((entry_ptr)->size > (cache_ptr)->max_size[(entry_ptr)->type->id]) \
(cache_ptr)->max_size[(entry_ptr)->type->id] = (entry_ptr)->size; \
(entry_ptr)->accesses++; \
}
} while (0)
#define H5C__UPDATE_STATS_FOR_PIN(cache_ptr, entry_ptr) \
{ \
do { \
(cache_ptr)->pins[(entry_ptr)->type->id]++; \
(entry_ptr)->pins++; \
if ((cache_ptr)->pel_len > (cache_ptr)->max_pel_len) \
(cache_ptr)->max_pel_len = (cache_ptr)->pel_len; \
if ((cache_ptr)->pel_size > (cache_ptr)->max_pel_size) \
(cache_ptr)->max_pel_size = (cache_ptr)->pel_size; \
}
} while (0)
#else /* H5C_COLLECT_CACHE_ENTRY_STATS */
#define H5C__RESET_CACHE_ENTRY_STATS(entry_ptr)
#define H5C__UPDATE_STATS_FOR_CLEAR(cache_ptr, entry_ptr) \
{ \
do { \
(cache_ptr)->clears[(entry_ptr)->type->id]++; \
if((entry_ptr)->is_pinned) \
(cache_ptr)->pinned_clears[(entry_ptr)->type->id]++; \
}
} while (0)
#define H5C__UPDATE_STATS_FOR_FLUSH(cache_ptr, entry_ptr) \
{ \
do { \
(cache_ptr)->flushes[(entry_ptr)->type->id]++; \
if ((entry_ptr)->is_pinned) \
(cache_ptr)->pinned_flushes[(entry_ptr)->type->id]++; \
}
} while (0)
#define H5C__UPDATE_STATS_FOR_EVICTION(cache_ptr, entry_ptr, take_ownership) \
{ \
do { \
if (take_ownership) \
(cache_ptr)->take_ownerships[(entry_ptr)->type->id]++; \
else \
(cache_ptr)->evictions[(entry_ptr)->type->id]++; \
}
} while (0)
#define H5C__UPDATE_STATS_FOR_INSERTION(cache_ptr, entry_ptr) \
{ \
do { \
(cache_ptr)->insertions[(entry_ptr)->type->id]++; \
if ((entry_ptr)->is_pinned) { \
(cache_ptr)->pinned_insertions[(entry_ptr)->type->id]++; \
@ -463,10 +492,10 @@ if ((new_size) > (dll_size) || ((dll_len) == 1 && (new_size) != (dll_size))) { \
if ((cache_ptr)->slist_size > (cache_ptr)->max_slist_size) \
(cache_ptr)->max_slist_size = (cache_ptr)->slist_size; \
(cache_ptr)->entries_inserted_counter++; \
}
} while (0)
#define H5C__UPDATE_STATS_FOR_PROTECT(cache_ptr, entry_ptr, hit) \
{ \
do { \
if (hit) \
(cache_ptr)->hits[(entry_ptr)->type->id]++; \
else \
@ -487,16 +516,16 @@ if ((new_size) > (dll_size) || ((dll_len) == 1 && (new_size) != (dll_size))) { \
(cache_ptr)->max_pl_len = (cache_ptr)->pl_len; \
if ((cache_ptr)->pl_size > (cache_ptr)->max_pl_size) \
(cache_ptr)->max_pl_size = (cache_ptr)->pl_size; \
}
} while (0)
#define H5C__UPDATE_STATS_FOR_PIN(cache_ptr, entry_ptr) \
{ \
do { \
(cache_ptr)->pins[(entry_ptr)->type->id]++; \
if ((cache_ptr)->pel_len > (cache_ptr)->max_pel_len) \
(cache_ptr)->max_pel_len = (cache_ptr)->pel_len; \
if ((cache_ptr)->pel_size > (cache_ptr)->max_pel_size) \
(cache_ptr)->max_pel_size = (cache_ptr)->pel_size; \
}
} while (0)
#endif /* H5C_COLLECT_CACHE_ENTRY_STATS */
@ -839,9 +868,9 @@ do { \
} \
H5C__IL_DLL_APPEND((entry_ptr), (cache_ptr)->il_head, \
(cache_ptr)->il_tail, (cache_ptr)->il_len, \
(cache_ptr)->il_size, fail_val) \
H5C__UPDATE_STATS_FOR_HT_INSERTION(cache_ptr) \
H5C__POST_HT_INSERT_SC(cache_ptr, entry_ptr, fail_val) \
(cache_ptr)->il_size, fail_val); \
H5C__UPDATE_STATS_FOR_HT_INSERTION(cache_ptr); \
H5C__POST_HT_INSERT_SC(cache_ptr, entry_ptr, fail_val); \
} while (0)
#define H5C__DELETE_FROM_INDEX(cache_ptr, entry_ptr, fail_val) \
@ -874,21 +903,21 @@ do { \
} \
H5C__IL_DLL_REMOVE((entry_ptr), (cache_ptr)->il_head, \
(cache_ptr)->il_tail, (cache_ptr)->il_len, \
(cache_ptr)->il_size, fail_val) \
H5C__UPDATE_STATS_FOR_HT_DELETION(cache_ptr) \
H5C__POST_HT_REMOVE_SC(cache_ptr, entry_ptr, fail_val) \
(cache_ptr)->il_size, fail_val); \
H5C__UPDATE_STATS_FOR_HT_DELETION(cache_ptr); \
H5C__POST_HT_REMOVE_SC(cache_ptr, entry_ptr, fail_val); \
} while (0)
#define H5C__SEARCH_INDEX(cache_ptr, entry_addr, entry_ptr, fail_val) \
{ \
do { \
int k; \
int depth = 0; \
H5C__PRE_HT_SEARCH_SC(cache_ptr, entry_addr, fail_val) \
H5C__PRE_HT_SEARCH_SC(cache_ptr, entry_addr, fail_val); \
k = H5C__HASH_FCN(entry_addr); \
(entry_ptr) = (cache_ptr)->index[k]; \
while(entry_ptr) { \
if(H5_addr_eq(entry_addr, (entry_ptr)->addr)) { \
H5C__POST_SUC_HT_SEARCH_SC(cache_ptr, entry_ptr, k, fail_val) \
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) \
(entry_ptr)->ht_next->ht_prev = (entry_ptr)->ht_prev; \
@ -898,41 +927,41 @@ do { \
(entry_ptr)->ht_next = (cache_ptr)->index[k]; \
(entry_ptr)->ht_prev = NULL; \
(cache_ptr)->index[k] = (entry_ptr); \
H5C__POST_HT_SHIFT_TO_FRONT_SC(cache_ptr, entry_ptr, k, fail_val) \
H5C__POST_HT_SHIFT_TO_FRONT_SC(cache_ptr, entry_ptr, k, fail_val); \
} \
break; \
} \
(entry_ptr) = (entry_ptr)->ht_next; \
(depth)++; \
} \
H5C__UPDATE_STATS_FOR_HT_SEARCH(cache_ptr, ((entry_ptr) != NULL), depth) \
}
H5C__UPDATE_STATS_FOR_HT_SEARCH(cache_ptr, ((entry_ptr) != NULL), depth); \
} while (0)
#define H5C__UPDATE_INDEX_FOR_ENTRY_CLEAN(cache_ptr, entry_ptr, fail_val) \
{ \
H5C__PRE_HT_UPDATE_FOR_ENTRY_CLEAN_SC(cache_ptr, entry_ptr, fail_val) \
do { \
H5C__PRE_HT_UPDATE_FOR_ENTRY_CLEAN_SC(cache_ptr, entry_ptr, fail_val); \
(cache_ptr)->dirty_index_size -= (entry_ptr)->size; \
(cache_ptr)->dirty_index_ring_size[(entry_ptr)->ring] -= (entry_ptr)->size; \
(cache_ptr)->clean_index_size += (entry_ptr)->size; \
(cache_ptr)->clean_index_ring_size[(entry_ptr)->ring] += (entry_ptr)->size; \
H5C__POST_HT_UPDATE_FOR_ENTRY_CLEAN_SC(cache_ptr, entry_ptr, fail_val) \
}
H5C__POST_HT_UPDATE_FOR_ENTRY_CLEAN_SC(cache_ptr, entry_ptr, fail_val); \
} while (0)
#define H5C__UPDATE_INDEX_FOR_ENTRY_DIRTY(cache_ptr, entry_ptr, fail_val) \
{ \
H5C__PRE_HT_UPDATE_FOR_ENTRY_DIRTY_SC(cache_ptr, entry_ptr, fail_val) \
do { \
H5C__PRE_HT_UPDATE_FOR_ENTRY_DIRTY_SC(cache_ptr, entry_ptr, fail_val); \
(cache_ptr)->clean_index_size -= (entry_ptr)->size; \
(cache_ptr)->clean_index_ring_size[(entry_ptr)->ring] -= (entry_ptr)->size; \
(cache_ptr)->dirty_index_size += (entry_ptr)->size; \
(cache_ptr)->dirty_index_ring_size[(entry_ptr)->ring] += (entry_ptr)->size; \
H5C__POST_HT_UPDATE_FOR_ENTRY_DIRTY_SC(cache_ptr, entry_ptr, fail_val) \
}
H5C__POST_HT_UPDATE_FOR_ENTRY_DIRTY_SC(cache_ptr, entry_ptr, fail_val); \
} while (0)
#define H5C__UPDATE_INDEX_FOR_SIZE_CHANGE(cache_ptr, old_size, new_size, \
entry_ptr, was_clean, fail_val) \
{ \
do { \
H5C__PRE_HT_ENTRY_SIZE_CHANGE_SC(cache_ptr, old_size, new_size, \
entry_ptr, was_clean, fail_val) \
entry_ptr, was_clean, fail_val); \
(cache_ptr)->index_size -= (old_size); \
(cache_ptr)->index_size += (new_size); \
(cache_ptr)->index_ring_size[(entry_ptr)->ring] -= (old_size); \
@ -953,9 +982,9 @@ do { \
} \
H5C__DLL_UPDATE_FOR_SIZE_CHANGE((cache_ptr)->il_len, \
(cache_ptr)->il_size, \
(old_size), (new_size), (fail_val)) \
(old_size), (new_size), (fail_val)); \
H5C__POST_HT_ENTRY_SIZE_CHANGE_SC(cache_ptr, old_size, new_size, \
entry_ptr, fail_val) \
entry_ptr, fail_val); \
} while (0)
@ -980,20 +1009,20 @@ do { \
#ifdef H5C_DO_SANITY_CHECKS
#define H5C__SLIST_INSERT_ENTRY_SC(cache_ptr, entry_ptr) \
{ \
do { \
(cache_ptr)->slist_len_increase++; \
(cache_ptr)->slist_size_increase += (int64_t)((entry_ptr)->size); \
} /* H5C__SLIST_INSERT_ENTRY_SC() */
} while (0) /* H5C__SLIST_INSERT_ENTRY_SC() */
#define H5C__SLIST_REMOVE_ENTRY_SC(cache_ptr, entry_ptr) \
{ \
do { \
(cache_ptr)->slist_len_increase--; \
(cache_ptr)->slist_size_increase -= (int64_t)((entry_ptr)->size); \
} /* H5C__SLIST_REMOVE_ENTRY_SC() */
} while (0) /* H5C__SLIST_REMOVE_ENTRY_SC() */
#define H5C__SLIST_UPDATE_FOR_ENTRY_SIZE_CHANGE_SC(cache_ptr, old_size, new_size) \
{ \
do { \
(cache_ptr)->slist_size_increase -= (int64_t)(old_size); \
(cache_ptr)->slist_size_increase += (int64_t)(new_size); \
} /* H5C__SLIST_UPDATE_FOR_ENTRY_SIZE_CHANGE_SC() */
} while (0) /* H5C__SLIST_UPDATE_FOR_ENTRY_SIZE_CHANGE_SC() */
#else /* H5C_DO_SANITY_CHECKS */
@ -1044,7 +1073,7 @@ do { \
(cache_ptr)->slist_size += (entry_ptr)->size; \
((cache_ptr)->slist_ring_len[(entry_ptr)->ring])++; \
((cache_ptr)->slist_ring_size[(entry_ptr)->ring]) += (entry_ptr)->size;\
H5C__SLIST_INSERT_ENTRY_SC(cache_ptr, entry_ptr) \
H5C__SLIST_INSERT_ENTRY_SC(cache_ptr, entry_ptr); \
\
assert((cache_ptr)->slist_len > 0); \
assert((cache_ptr)->slist_size > 0); \
@ -1066,7 +1095,7 @@ do { \
*/
#define H5C__REMOVE_ENTRY_FROM_SLIST(cache_ptr, entry_ptr, during_flush, fail_val) \
{ \
do { \
assert(cache_ptr); \
\
if((cache_ptr)->slist_enabled) { \
@ -1096,13 +1125,13 @@ do { \
(cache_ptr)->slist_ring_len[(entry_ptr)->ring]--; \
assert((cache_ptr)->slist_ring_size[(entry_ptr)->ring] >= (entry_ptr)->size); \
((cache_ptr)->slist_ring_size[(entry_ptr)->ring]) -= (entry_ptr)->size;\
H5C__SLIST_REMOVE_ENTRY_SC(cache_ptr, entry_ptr) \
H5C__SLIST_REMOVE_ENTRY_SC(cache_ptr, entry_ptr); \
(entry_ptr)->in_slist = FALSE; \
} else { /* slist disabled */ \
assert((cache_ptr)->slist_len == 0); \
assert((cache_ptr)->slist_size == 0); \
} \
} /* H5C__REMOVE_ENTRY_FROM_SLIST */
} while (0) /* H5C__REMOVE_ENTRY_FROM_SLIST */
/*-------------------------------------------------------------------------
@ -1141,7 +1170,7 @@ do { \
(cache_ptr)->slist_ring_size[(entry_ptr)->ring] -= (old_size); \
(cache_ptr)->slist_ring_size[(entry_ptr)->ring] += (new_size); \
\
H5C__SLIST_UPDATE_FOR_ENTRY_SIZE_CHANGE_SC(cache_ptr, old_size, new_size) \
H5C__SLIST_UPDATE_FOR_ENTRY_SIZE_CHANGE_SC(cache_ptr, old_size, new_size); \
\
assert((new_size) <= (cache_ptr)->slist_size); \
assert((cache_ptr)->slist_len > 1 || \
@ -1162,7 +1191,7 @@ do { \
#if H5C_MAINTAIN_CLEAN_AND_DIRTY_LRU_LISTS
#define H5C__UPDATE_RP_FOR_EVICTION_CD_LRU(cache_ptr, entry_ptr, fail_val) \
{ \
do { \
/* If the entry is clean when it is evicted, it should be on the \
* clean LRU list, if it was dirty, it should be on the dirty LRU list. \
* Remove it from the appropriate list according to the value of the \
@ -1179,9 +1208,10 @@ do { \
(cache_ptr)->cLRU_list_len, \
(cache_ptr)->cLRU_list_size, (fail_val)) \
} \
} /* H5C__UPDATE_RP_FOR_EVICTION_CD_LRU() */
} while (0) /* H5C__UPDATE_RP_FOR_EVICTION_CD_LRU() */
#define H5C__UPDATE_RP_FOR_FLUSH_CD_LRU(cache_ptr, entry_ptr, fail_val) \
{ \
do { \
/* An entry being flushed or cleared, may not be dirty. Use the \
* dirty flag to infer whether the entry is on the clean or dirty \
* LRU list, and remove it. Then insert it at the head of the \
@ -1207,9 +1237,10 @@ do { \
(cache_ptr)->cLRU_tail_ptr, \
(cache_ptr)->cLRU_list_len, \
(cache_ptr)->cLRU_list_size, (fail_val)) \
} /* H5C__UPDATE_RP_FOR_FLUSH_CD_LRU() */
} while (0) /* H5C__UPDATE_RP_FOR_FLUSH_CD_LRU() */
#define H5C__UPDATE_RP_FOR_INSERT_APPEND_CD_LRU(cache_ptr, entry_ptr, fail_val) \
{ \
do { \
/* Insert the entry at the _tail_ of the clean or dirty LRU list as \
* appropriate. \
*/ \
@ -1217,16 +1248,17 @@ do { \
H5C__AUX_DLL_APPEND((entry_ptr), (cache_ptr)->dLRU_head_ptr, \
(cache_ptr)->dLRU_tail_ptr, \
(cache_ptr)->dLRU_list_len, \
(cache_ptr)->dLRU_list_size, (fail_val)) \
(cache_ptr)->dLRU_list_size, (fail_val)); \
} else { \
H5C__AUX_DLL_APPEND((entry_ptr), (cache_ptr)->cLRU_head_ptr, \
(cache_ptr)->cLRU_tail_ptr, \
(cache_ptr)->cLRU_list_len, \
(cache_ptr)->cLRU_list_size, (fail_val)) \
(cache_ptr)->cLRU_list_size, (fail_val)); \
} \
} /* H5C__UPDATE_RP_FOR_INSERT_APPEND_CD_LRU() */
} while (0) /* H5C__UPDATE_RP_FOR_INSERT_APPEND_CD_LRU() */
#define H5C__UPDATE_RP_FOR_INSERTION_CD_LRU(cache_ptr, entry_ptr, fail_val) \
{ \
do { \
/* Insert the entry at the head of the clean or dirty LRU list as \
* appropriate. \
*/ \
@ -1241,7 +1273,8 @@ do { \
(cache_ptr)->cLRU_list_len, \
(cache_ptr)->cLRU_list_size, (fail_val)) \
} \
} /* H5C__UPDATE_RP_FOR_INSERTION_CD_LRU() */
} while(0) /* H5C__UPDATE_RP_FOR_INSERTION_CD_LRU() */
#define H5C__UPDATE_RP_FOR_PROTECT_CD_LRU(cache_ptr, entry_ptr, fail_val) \
{ \
/* Remove the entry from the clean or dirty LRU list as appropriate */ \
@ -1256,9 +1289,10 @@ do { \
(cache_ptr)->cLRU_list_len, \
(cache_ptr)->cLRU_list_size, (fail_val)) \
} \
} /* H5C__UPDATE_RP_FOR_PROTECT_CD_LRU() */
} while (0) /* H5C__UPDATE_RP_FOR_PROTECT_CD_LRU() */
#define H5C__UPDATE_RP_FOR_MOVE_CD_LRU(cache_ptr, entry_ptr, was_dirty, fail_val) \
{ \
do { \
/* Remove the entry from either the clean or dirty LRU list as \
* indicated by the was_dirty parameter \
*/ \
@ -1267,14 +1301,14 @@ do { \
(cache_ptr)->dLRU_head_ptr, \
(cache_ptr)->dLRU_tail_ptr, \
(cache_ptr)->dLRU_list_len, \
(cache_ptr)->dLRU_list_size, (fail_val)) \
(cache_ptr)->dLRU_list_size, (fail_val)); \
\
} else { \
H5C__AUX_DLL_REMOVE((entry_ptr), \
(cache_ptr)->cLRU_head_ptr, \
(cache_ptr)->cLRU_tail_ptr, \
(cache_ptr)->cLRU_list_len, \
(cache_ptr)->cLRU_list_size, (fail_val)) \
(cache_ptr)->cLRU_list_size, (fail_val)); \
} \
\
/* Insert the entry at the head of either the clean or dirty \
@ -1285,17 +1319,18 @@ do { \
(cache_ptr)->dLRU_head_ptr, \
(cache_ptr)->dLRU_tail_ptr, \
(cache_ptr)->dLRU_list_len, \
(cache_ptr)->dLRU_list_size, (fail_val)) \
(cache_ptr)->dLRU_list_size, (fail_val)); \
} else { \
H5C__AUX_DLL_PREPEND((entry_ptr), \
(cache_ptr)->cLRU_head_ptr, \
(cache_ptr)->cLRU_tail_ptr, \
(cache_ptr)->cLRU_list_len, \
(cache_ptr)->cLRU_list_size, (fail_val)) \
(cache_ptr)->cLRU_list_size, (fail_val)); \
} \
} /* H5C__UPDATE_RP_FOR_MOVE_CD_LRU() */
} while (0) /* H5C__UPDATE_RP_FOR_MOVE_CD_LRU() */
#define H5C__UPDATE_RP_FOR_SIZE_CHANGE_CD_LRU(cache_ptr, entry_ptr, new_size, fail_val) \
{ \
do { \
/* Update the size of the clean or dirty LRU list as \
* appropriate. \
*/ \
@ -1311,9 +1346,10 @@ do { \
(entry_ptr)->size, \
(new_size), (fail_val)) \
} \
} /* H5C__UPDATE_RP_FOR_SIZE_CHANGE_CD_LRU() */
} while (0) /* H5C__UPDATE_RP_FOR_SIZE_CHANGE_CD_LRU() */
#define H5C__UPDATE_RP_FOR_UNPIN_CD_LRU(cache_ptr, entry_ptr, fail_val) \
{ \
do { \
/* Insert the entry at the head of either the clean \
* or dirty LRU list as appropriate. \
*/ \
@ -1330,9 +1366,10 @@ do { \
(cache_ptr)->cLRU_list_len, \
(cache_ptr)->cLRU_list_size, (fail_val)) \
} \
} /* H5C__UPDATE_RP_FOR_UNPIN_CD_LRU() */
} while (0) /* H5C__UPDATE_RP_FOR_UNPIN_CD_LRU() */
#define H5C__UPDATE_RP_FOR_UNPROTECT_CD_LRU(cache_ptr, entry_ptr, fail_val) \
{ \
do { \
/* Insert the entry at the head of either the clean or \
* dirty LRU list as appropriate. \
*/ \
@ -1347,7 +1384,7 @@ do { \
(cache_ptr)->cLRU_list_len, \
(cache_ptr)->cLRU_list_size, (fail_val)) \
} \
} /* H5C__UPDATE_RP_FOR_UNPROTECT_CD_LRU() */
} while (0) /* H5C__UPDATE_RP_FOR_UNPROTECT_CD_LRU() */
#else /* H5C_MAINTAIN_CLEAN_AND_DIRTY_LRU_LISTS */
@ -1374,7 +1411,7 @@ do { \
*/
#define H5C__UPDATE_RP_FOR_EVICTION(cache_ptr, entry_ptr, fail_val) \
{ \
do { \
assert(cache_ptr); \
assert(entry_ptr); \
assert(!(entry_ptr)->is_protected); \
@ -1389,8 +1426,8 @@ do { \
(cache_ptr)->LRU_list_size, (fail_val)) \
\
/* Remove the entry from the clean & dirty LRU lists, if enabled */ \
H5C__UPDATE_RP_FOR_EVICTION_CD_LRU(cache_ptr, entry_ptr, fail_val) \
} /* H5C__UPDATE_RP_FOR_EVICTION */
H5C__UPDATE_RP_FOR_EVICTION_CD_LRU(cache_ptr, entry_ptr, fail_val); \
} while (0) /* H5C__UPDATE_RP_FOR_EVICTION */
/*-------------------------------------------------------------------------
@ -1404,7 +1441,7 @@ do { \
*/
#define H5C__UPDATE_RP_FOR_FLUSH(cache_ptr, entry_ptr, fail_val) \
{ \
do { \
assert(cache_ptr); \
assert(entry_ptr); \
assert(!(entry_ptr)->is_protected); \
@ -1427,9 +1464,9 @@ do { \
(cache_ptr)->LRU_list_size, (fail_val)) \
\
/* Maintain the clean & dirty LRU lists, if enabled */ \
H5C__UPDATE_RP_FOR_FLUSH_CD_LRU(cache_ptr, entry_ptr, fail_val) \
H5C__UPDATE_RP_FOR_FLUSH_CD_LRU(cache_ptr, entry_ptr, fail_val); \
} \
} /* H5C__UPDATE_RP_FOR_FLUSH */
} while (0) /* H5C__UPDATE_RP_FOR_FLUSH */
/*-------------------------------------------------------------------------
@ -1468,7 +1505,7 @@ do { \
(cache_ptr)->LRU_list_size, (fail_val)) \
\
/* Maintain the clean & dirty LRU lists, if enabled */ \
H5C__UPDATE_RP_FOR_INSERT_APPEND_CD_LRU(cache_ptr, entry_ptr, fail_val) \
H5C__UPDATE_RP_FOR_INSERT_APPEND_CD_LRU(cache_ptr, entry_ptr, fail_val); \
} \
} while (0)
@ -1483,32 +1520,32 @@ do { \
*-------------------------------------------------------------------------
*/
#define H5C__UPDATE_RP_FOR_INSERTION(cache_ptr, entry_ptr, fail_val) \
{ \
assert(cache_ptr); \
assert(entry_ptr); \
assert(!(entry_ptr)->is_protected); \
assert(!(entry_ptr)->is_read_only); \
assert((entry_ptr)->ro_ref_count == 0); \
assert((entry_ptr)->size > 0); \
\
if((entry_ptr)->is_pinned) { \
H5C__DLL_PREPEND((entry_ptr), (cache_ptr)->pel_head_ptr, \
(cache_ptr)->pel_tail_ptr, \
(cache_ptr)->pel_len, \
(cache_ptr)->pel_size, (fail_val)) \
\
} else { \
/* Insert the entry at the head of the LRU list. */ \
H5C__DLL_PREPEND((entry_ptr), (cache_ptr)->LRU_head_ptr, \
(cache_ptr)->LRU_tail_ptr, \
(cache_ptr)->LRU_list_len, \
(cache_ptr)->LRU_list_size, (fail_val)) \
\
/* Maintain the clean & dirty LRU lists, if enabled */ \
H5C__UPDATE_RP_FOR_INSERTION_CD_LRU(cache_ptr, entry_ptr, fail_val) \
} \
}
#define H5C__UPDATE_RP_FOR_INSERTION(cache_ptr, entry_ptr, fail_val) \
do { \
assert(cache_ptr); \
assert(entry_ptr); \
assert(!(entry_ptr)->is_protected); \
assert(!(entry_ptr)->is_read_only); \
assert((entry_ptr)->ro_ref_count == 0); \
assert((entry_ptr)->size > 0); \
\
if((entry_ptr)->is_pinned) { \
H5C__DLL_PREPEND((entry_ptr), (cache_ptr)->pel_head_ptr, \
(cache_ptr)->pel_tail_ptr, \
(cache_ptr)->pel_len, \
(cache_ptr)->pel_size, (fail_val)) \
\
} else { \
/* Insert the entry at the head of the LRU list. */ \
H5C__DLL_PREPEND((entry_ptr), (cache_ptr)->LRU_head_ptr, \
(cache_ptr)->LRU_tail_ptr, \
(cache_ptr)->LRU_list_len, \
(cache_ptr)->LRU_list_size, (fail_val)) \
\
/* Maintain the clean & dirty LRU lists, if enabled */ \
H5C__UPDATE_RP_FOR_INSERTION_CD_LRU(cache_ptr, entry_ptr, fail_val); \
} \
} while (0)
/*-------------------------------------------------------------------------
@ -1526,39 +1563,39 @@ do { \
*-------------------------------------------------------------------------
*/
#define H5C__UPDATE_RP_FOR_PROTECT(cache_ptr, entry_ptr, fail_val) \
{ \
assert(cache_ptr); \
assert(entry_ptr); \
assert(!(entry_ptr)->is_protected); \
assert(!(entry_ptr)->is_read_only); \
assert((entry_ptr)->ro_ref_count == 0); \
assert((entry_ptr)->size > 0); \
\
if((entry_ptr)->is_pinned) { \
H5C__DLL_REMOVE((entry_ptr), (cache_ptr)->pel_head_ptr, \
(cache_ptr)->pel_tail_ptr, \
(cache_ptr)->pel_len, \
(cache_ptr)->pel_size, (fail_val)) \
} else { \
/* Remove the entry from the LRU list. */ \
H5C__DLL_REMOVE((entry_ptr), (cache_ptr)->LRU_head_ptr, \
(cache_ptr)->LRU_tail_ptr, \
(cache_ptr)->LRU_list_len, \
(cache_ptr)->LRU_list_size, (fail_val)) \
\
/* Maintain the clean & dirty LRU lists, if enabled */ \
H5C__UPDATE_RP_FOR_PROTECT_CD_LRU(cache_ptr, entry_ptr, fail_val) \
} \
\
/* Regardless of whether the entry is pinned, add it to the protected \
* list. \
*/ \
H5C__DLL_APPEND((entry_ptr), (cache_ptr)->pl_head_ptr, \
(cache_ptr)->pl_tail_ptr, \
(cache_ptr)->pl_len, \
(cache_ptr)->pl_size, (fail_val)) \
} /* H5C__UPDATE_RP_FOR_PROTECT */
#define H5C__UPDATE_RP_FOR_PROTECT(cache_ptr, entry_ptr, fail_val) \
do { \
assert(cache_ptr); \
assert(entry_ptr); \
assert(!(entry_ptr)->is_protected); \
assert(!(entry_ptr)->is_read_only); \
assert((entry_ptr)->ro_ref_count == 0); \
assert((entry_ptr)->size > 0); \
\
if((entry_ptr)->is_pinned) { \
H5C__DLL_REMOVE((entry_ptr), (cache_ptr)->pel_head_ptr, \
(cache_ptr)->pel_tail_ptr, \
(cache_ptr)->pel_len, \
(cache_ptr)->pel_size, (fail_val)) \
} else { \
/* Remove the entry from the LRU list. */ \
H5C__DLL_REMOVE((entry_ptr), (cache_ptr)->LRU_head_ptr, \
(cache_ptr)->LRU_tail_ptr, \
(cache_ptr)->LRU_list_len, \
(cache_ptr)->LRU_list_size, (fail_val)) \
\
/* Maintain the clean & dirty LRU lists, if enabled */ \
H5C__UPDATE_RP_FOR_PROTECT_CD_LRU(cache_ptr, entry_ptr, fail_val); \
} \
\
/* Regardless of whether the entry is pinned, add it to the protected \
* list. \
*/ \
H5C__DLL_APPEND((entry_ptr), (cache_ptr)->pl_head_ptr, \
(cache_ptr)->pl_tail_ptr, \
(cache_ptr)->pl_len, \
(cache_ptr)->pl_size, (fail_val)) \
} while (0) /* H5C__UPDATE_RP_FOR_PROTECT */
/*-------------------------------------------------------------------------
@ -1593,7 +1630,7 @@ do { \
(cache_ptr)->LRU_list_size, (fail_val)) \
\
/* Maintain the clean & dirty LRU lists, if enabled */ \
H5C__UPDATE_RP_FOR_MOVE_CD_LRU(cache_ptr, entry_ptr, was_dirty, fail_val) \
H5C__UPDATE_RP_FOR_MOVE_CD_LRU(cache_ptr, entry_ptr, was_dirty, fail_val); \
} \
} while (0) /* H5C__UPDATE_RP_FOR_MOVE */
@ -1621,7 +1658,7 @@ do { \
#ifdef H5_HAVE_PARALLEL
#define H5C__UPDATE_RP_FOR_SIZE_CHANGE_COLL(cache_ptr, entry_ptr, new_size, fail_val) \
{ \
do { \
if((entry_ptr)->coll_access) { \
H5C__DLL_UPDATE_FOR_SIZE_CHANGE((cache_ptr)->coll_list_len, \
(cache_ptr)->coll_list_size, \
@ -1629,7 +1666,7 @@ do { \
(new_size), (fail_val)); \
\
} \
} /* H5C__UPDATE_RP_FOR_SIZE_CHANGE_COLL() */
} while (0) /* H5C__UPDATE_RP_FOR_SIZE_CHANGE_COLL() */
#else /* H5_HAVE_PARALLEL */
@ -1638,7 +1675,7 @@ do { \
#endif /* H5_HAVE_PARALLEL */
#define H5C__UPDATE_RP_FOR_SIZE_CHANGE(cache_ptr, entry_ptr, new_size, fail_val) \
{ \
do { \
assert(cache_ptr); \
assert(entry_ptr); \
assert(!(entry_ptr)->is_protected); \
@ -1648,7 +1685,7 @@ do { \
assert(new_size > 0 ); \
\
/* Maintain the collective access list, if enabled */ \
H5C__UPDATE_RP_FOR_SIZE_CHANGE_COLL(cache_ptr, entry_ptr, new_size, fail_val) \
H5C__UPDATE_RP_FOR_SIZE_CHANGE_COLL(cache_ptr, entry_ptr, new_size, fail_val); \
\
if((entry_ptr)->is_pinned) { \
H5C__DLL_UPDATE_FOR_SIZE_CHANGE((cache_ptr)->pel_len, \
@ -1663,9 +1700,9 @@ do { \
(new_size), (fail_val)) \
\
/* Maintain the clean & dirty LRU lists, if enabled */ \
H5C__UPDATE_RP_FOR_SIZE_CHANGE_CD_LRU(cache_ptr, entry_ptr, new_size, fail_val) \
H5C__UPDATE_RP_FOR_SIZE_CHANGE_CD_LRU(cache_ptr, entry_ptr, new_size, fail_val); \
} \
} /* H5C__UPDATE_RP_FOR_SIZE_CHANGE */
} while (0) /* H5C__UPDATE_RP_FOR_SIZE_CHANGE */
/*-------------------------------------------------------------------------
@ -1683,7 +1720,7 @@ do { \
*/
#define H5C__UPDATE_RP_FOR_UNPIN(cache_ptr, entry_ptr, fail_val) \
{ \
do { \
assert(cache_ptr); \
assert(entry_ptr); \
assert(!(entry_ptr)->is_protected); \
@ -1697,17 +1734,17 @@ do { \
*/ \
H5C__DLL_REMOVE((entry_ptr), (cache_ptr)->pel_head_ptr, \
(cache_ptr)->pel_tail_ptr, (cache_ptr)->pel_len, \
(cache_ptr)->pel_size, (fail_val)) \
(cache_ptr)->pel_size, (fail_val)); \
\
/* Insert the entry at the head of the LRU list. */ \
H5C__DLL_PREPEND((entry_ptr), (cache_ptr)->LRU_head_ptr, \
(cache_ptr)->LRU_tail_ptr, \
(cache_ptr)->LRU_list_len, \
(cache_ptr)->LRU_list_size, (fail_val)) \
(cache_ptr)->LRU_list_size, (fail_val)); \
\
/* Maintain the clean & dirty LRU lists, if enabled */ \
H5C__UPDATE_RP_FOR_UNPIN_CD_LRU(cache_ptr, entry_ptr, fail_val) \
} /* H5C__UPDATE_RP_FOR_UNPIN */
H5C__UPDATE_RP_FOR_UNPIN_CD_LRU(cache_ptr, entry_ptr, fail_val); \
} while(0) /* H5C__UPDATE_RP_FOR_UNPIN */
/*-------------------------------------------------------------------------
@ -1751,7 +1788,7 @@ do { \
(cache_ptr)->LRU_list_size, (fail_val)) \
\
/* Maintain the clean & dirty LRU lists, if enabled */ \
H5C__UPDATE_RP_FOR_UNPROTECT_CD_LRU(cache_ptr, entry_ptr, fail_val) \
H5C__UPDATE_RP_FOR_UNPROTECT_CD_LRU(cache_ptr, entry_ptr, fail_val); \
} \
} while (0) /* H5C__UPDATE_RP_FOR_UNPROTECT */
@ -1775,7 +1812,7 @@ do { \
*/
#define H5C__INSERT_IN_COLL_LIST(cache_ptr, entry_ptr, fail_val) \
{ \
do { \
assert(cache_ptr); \
assert(entry_ptr); \
\
@ -1784,7 +1821,7 @@ do { \
(cache_ptr)->coll_tail_ptr, \
(cache_ptr)->coll_list_len, \
(cache_ptr)->coll_list_size, (fail_val)) \
} /* H5C__INSERT_IN_COLL_LIST */
} while (0) /* H5C__INSERT_IN_COLL_LIST */
/*-------------------------------------------------------------------------
@ -1797,7 +1834,7 @@ do { \
*/
#define H5C__REMOVE_FROM_COLL_LIST(cache_ptr, entry_ptr, fail_val) \
{ \
do { \
assert(cache_ptr); \
assert(entry_ptr); \
\
@ -1806,7 +1843,7 @@ do { \
(cache_ptr)->coll_tail_ptr, \
(cache_ptr)->coll_list_len, \
(cache_ptr)->coll_list_size, (fail_val)) \
} /* H5C__REMOVE_FROM_COLL_LIST */
} while (0) /* H5C__REMOVE_FROM_COLL_LIST */
/*-------------------------------------------------------------------------
@ -1819,7 +1856,7 @@ do { \
*/
#define H5C__MOVE_TO_TOP_IN_COLL_LIST(cache_ptr, entry_ptr, fail_val) \
{ \
do { \
assert(cache_ptr); \
assert(entry_ptr); \
\
@ -1834,7 +1871,7 @@ do { \
(cache_ptr)->coll_list_len, \
(cache_ptr)->coll_list_size, (fail_val)) \
\
} /* H5C__MOVE_TO_TOP_IN_COLL_LIST */
} while (0) /* H5C__MOVE_TO_TOP_IN_COLL_LIST */
#endif /* H5_HAVE_PARALLEL */

10
src/H5D.c
View File

@ -1127,7 +1127,7 @@ H5Dread_multi(size_t count, hid_t dset_id[], hid_t mem_type_id[], hid_t mem_spac
H5TRACE7("e", "z*i*i*i*iix", count, dset_id, mem_type_id, mem_space_id, file_space_id, dxpl_id, buf);
if (count == 0)
HGOTO_DONE(SUCCEED)
HGOTO_DONE(SUCCEED);
/* Read the data */
if (H5D__read_api_common(count, dset_id, mem_type_id, mem_space_id, file_space_id, dxpl_id, buf, NULL,
@ -1438,7 +1438,7 @@ H5Dwrite_multi(size_t count, hid_t dset_id[], hid_t mem_type_id[], hid_t mem_spa
H5TRACE7("e", "z*i*i*i*ii**x", count, dset_id, mem_type_id, mem_space_id, file_space_id, dxpl_id, buf);
if (count == 0)
HGOTO_DONE(SUCCEED)
HGOTO_DONE(SUCCEED);
/* Write the data */
if (H5D__write_api_common(count, dset_id, mem_type_id, mem_space_id, file_space_id, dxpl_id, buf, NULL,
@ -2264,7 +2264,7 @@ H5Dget_chunk_storage_size(hid_t dset_id, const hsize_t *offset, hsize_t *chunk_n
HGOTO_ERROR(H5E_DATASET, H5E_CANTGET, FAIL, "can't get storage size of chunk")
done:
FUNC_LEAVE_API(ret_value);
FUNC_LEAVE_API(ret_value)
} /* H5Dget_chunk_storage_size() */
/*-------------------------------------------------------------------------
@ -2313,7 +2313,7 @@ H5Dget_num_chunks(hid_t dset_id, hid_t fspace_id, hsize_t *nchunks /*out*/)
HGOTO_ERROR(H5E_DATASET, H5E_CANTGET, FAIL, "can't get number of chunks")
done:
FUNC_LEAVE_API(ret_value);
FUNC_LEAVE_API(ret_value)
} /* H5Dget_num_chunks() */
/*-------------------------------------------------------------------------
@ -2384,7 +2384,7 @@ H5Dget_chunk_info(hid_t dset_id, hid_t fspace_id, hsize_t chk_index, hsize_t *of
HGOTO_ERROR(H5E_DATASET, H5E_CANTGET, FAIL, "can't get chunk info by index")
done:
FUNC_LEAVE_API(ret_value);
FUNC_LEAVE_API(ret_value)
} /* H5Dget_chunk_info() */
/*-------------------------------------------------------------------------

4
src/H5Dbtree.c
View File

@ -417,7 +417,7 @@ H5D__btree_found(H5F_t H5_ATTR_UNUSED *f, haddr_t addr, const void *_lt_key, hbo
for (u = 0; u < udata->common.layout->ndims; u++)
if (udata->common.scaled[u] >= (lt_key->scaled[u] + 1)) {
*found = FALSE;
HGOTO_DONE(SUCCEED)
HGOTO_DONE(SUCCEED);
}
/* Initialize return values */
@ -459,7 +459,7 @@ H5D__chunk_disjoint(unsigned n, const hsize_t *scaled1, const hsize_t *scaled2)
/* Loop over two chunks, detecting disjointness and getting out quickly */
for (u = 0; u < n; u++)
if ((scaled1[u] + 1) <= scaled2[u] || (scaled2[u] + 1) <= scaled1[u])
HGOTO_DONE(TRUE)
HGOTO_DONE(TRUE);
done:
FUNC_LEAVE_NOAPI(ret_value)

22
src/H5Dchunk.c
View File

@ -591,7 +591,7 @@ H5D__get_chunk_storage_size(H5D_t *dset, const hsize_t *offset, hsize_t *storage
/* Allocate dataspace and initialize it if it hasn't been. */
if (!(*layout->ops->is_space_alloc)(&layout->storage))
HGOTO_DONE(SUCCEED)
HGOTO_DONE(SUCCEED);
/* Calculate the index of this chunk */
H5VM_chunk_scaled(dset->shared->ndims, offset, layout->u.chunk.dim, scaled);
@ -1894,7 +1894,7 @@ H5D__create_piece_file_map_hyper(H5D_dset_io_info_t *dinfo, H5D_io_info_t *io_in
/* Leave if we are done */
if (sel_points == 0)
HGOTO_DONE(SUCCEED)
HGOTO_DONE(SUCCEED);
} /* end if */
/* Increment chunk index */
@ -2740,7 +2740,7 @@ H5D__chunk_read(H5D_io_info_t *io_info, H5D_dset_io_info_t *dset_info)
/* Issue selection I/O call (we can skip the page buffer because we've
* already verified it won't be used, and the metadata accumulator
* because this is raw data) */
H5_CHECK_OVERFLOW(num_chunks, size_t, uint32_t)
H5_CHECK_OVERFLOW(num_chunks, size_t, uint32_t);
if (H5F_shared_select_read(H5F_SHARED(dset_info->dset->oloc.file), H5FD_MEM_DRAW,
(uint32_t)num_chunks, chunk_mem_spaces, chunk_file_spaces, chunk_addrs,
element_sizes, bufs) < 0)
@ -3126,7 +3126,7 @@ H5D__chunk_write(H5D_io_info_t *io_info, H5D_dset_io_info_t *dset_info)
/* Issue selection I/O call (we can skip the page buffer because we've
* already verified it won't be used, and the metadata accumulator
* because this is raw data) */
H5_CHECK_OVERFLOW(num_chunks, size_t, uint32_t)
H5_CHECK_OVERFLOW(num_chunks, size_t, uint32_t);
if (H5F_shared_select_write(H5F_SHARED(dset_info->dset->oloc.file), H5FD_MEM_DRAW,
(uint32_t)num_chunks, chunk_mem_spaces, chunk_file_spaces,
chunk_addrs, element_sizes, bufs) < 0)
@ -3552,7 +3552,7 @@ H5D__chunk_cinfo_cache_found(const H5D_chunk_cached_t *last, H5D_chunk_ud_t *uda
/* Check that the scaled offset is the same */
for (u = 0; u < udata->common.layout->ndims; u++)
if (last->scaled[u] != udata->common.scaled[u])
HGOTO_DONE(FALSE)
HGOTO_DONE(FALSE);
/* Retrieve the information from the cache */
udata->chunk_block.offset = last->addr;
@ -3561,7 +3561,7 @@ H5D__chunk_cinfo_cache_found(const H5D_chunk_cached_t *last, H5D_chunk_ud_t *uda
udata->filter_mask = last->filter_mask;
/* Indicate that the data was found */
HGOTO_DONE(TRUE)
HGOTO_DONE(TRUE);
} /* end if */
done:
@ -4845,7 +4845,7 @@ H5D__chunk_allocate(const H5D_t *dset, hbool_t full_overwrite, const hsize_t old
if (space_dim[op_dim] == 0) {
/* Reset any cached chunk info for this dataset */
H5D__chunk_cinfo_cache_reset(&dset->shared->cache.chunk.last);
HGOTO_DONE(SUCCEED)
HGOTO_DONE(SUCCEED);
} /* end if */
#ifdef H5_HAVE_PARALLEL
@ -5300,7 +5300,7 @@ H5D__chunk_update_old_edge_chunks(H5D_t *dset, hsize_t old_dim[])
if ((space_dim[op_dim] < chunk_dim[op_dim]) || old_dim[op_dim] == 0) {
/* Reset any cached chunk info for this dataset */
H5D__chunk_cinfo_cache_reset(&dset->shared->cache.chunk.last);
HGOTO_DONE(SUCCEED)
HGOTO_DONE(SUCCEED);
} /* end if */
/* Set up chunked I/O info object, for operations on chunks (in callback).
@ -5736,7 +5736,7 @@ H5D__chunk_prune_fill(H5D_chunk_it_ud1_t *udata, hbool_t new_unfilt_chunk)
/* If this chunk does not exist in cache or on disk, no need to do anything */
if (!H5_addr_defined(chk_udata.chunk_block.offset) && UINT_MAX == chk_udata.idx_hint)
HGOTO_DONE(SUCCEED)
HGOTO_DONE(SUCCEED);
/* Initialize the fill value buffer, if necessary */
if (!udata->fb_info_init) {
@ -5964,7 +5964,7 @@ H5D__chunk_prune_by_extent(H5D_t *dset, const hsize_t *old_dim)
if (old_dim[op_dim] == 0) {
/* Reset any cached chunk info for this dataset */
H5D__chunk_cinfo_cache_reset(&dset->shared->cache.chunk.last);
HGOTO_DONE(SUCCEED)
HGOTO_DONE(SUCCEED);
} /* end if */
/* Round up to the next integer # of chunks, to accommodate partial chunks */
@ -7224,7 +7224,7 @@ H5D__chunk_stats(const H5D_t *dset, hbool_t headers)
FUNC_ENTER_PACKAGE_NOERR
if (!H5DEBUG(AC))
HGOTO_DONE(SUCCEED)
HGOTO_DONE(SUCCEED);
if (headers) {
fprintf(H5DEBUG(AC), "H5D: raw data cache statistics\n");

6
src/H5Dio.c
View File

@ -288,7 +288,7 @@ H5D__read(size_t count, H5D_dset_io_info_t *dset_info)
/* If no datasets have I/O, we're done */
if (io_op_init == 0)
HGOTO_DONE(SUCCEED)
HGOTO_DONE(SUCCEED);
/* Perform second phase of type info initialization */
if (H5D__typeinfo_init_phase2(&io_info) < 0)
@ -395,7 +395,7 @@ H5D__read(size_t count, H5D_dset_io_info_t *dset_info)
}
else {
/* Call selection I/O directly */
H5_CHECK_OVERFLOW(io_info.pieces_added, size_t, uint32_t)
H5_CHECK_OVERFLOW(io_info.pieces_added, size_t, uint32_t);
if (H5F_shared_select_read(io_info.f_sh, H5FD_MEM_DRAW, (uint32_t)io_info.pieces_added,
io_info.mem_spaces, io_info.file_spaces, io_info.addrs,
io_info.element_sizes, io_info.rbufs) < 0)
@ -797,7 +797,7 @@ H5D__write(size_t count, H5D_dset_io_info_t *dset_info)
}
else {
/* Call selection I/O directly */
H5_CHECK_OVERFLOW(io_info.pieces_added, size_t, uint32_t)
H5_CHECK_OVERFLOW(io_info.pieces_added, size_t, uint32_t);
if (H5F_shared_select_write(io_info.f_sh, H5FD_MEM_DRAW, (uint32_t)io_info.pieces_added,
io_info.mem_spaces, io_info.file_spaces, io_info.addrs,
io_info.element_sizes, io_info.wbufs) < 0)

14
src/H5Dmpio.c
View File

@ -2855,7 +2855,7 @@ H5D__obtain_mpio_mode(H5D_io_info_t *io_info, H5D_dset_io_info_t *di, uint8_t as
for (ic = 0; ic < total_chunks; ic++)
assign_io_mode[ic] = H5D_CHUNK_IO_MODE_COL;
HGOTO_DONE(SUCCEED)
HGOTO_DONE(SUCCEED);
} /* end if */
threshold_nproc_per_chunk = (unsigned)mpi_size * percent_nproc_per_chunk / 100;
@ -2880,7 +2880,7 @@ H5D__obtain_mpio_mode(H5D_io_info_t *io_info, H5D_dset_io_info_t *di, uint8_t as
} /* end while */
/* Gather all the information */
H5_CHECK_OVERFLOW(total_chunks, size_t, int)
H5_CHECK_OVERFLOW(total_chunks, size_t, int);
if (MPI_SUCCESS != (mpi_code = MPI_Gather(io_mode_info, (int)total_chunks, MPI_BYTE, recv_io_mode_info,
(int)total_chunks, MPI_BYTE, root, comm)))
HMPI_GOTO_ERROR(FAIL, "MPI_Gather failed", mpi_code)
@ -3842,7 +3842,7 @@ H5D__mpio_share_chunk_modification_data(H5D_filtered_collective_io_info_t *chunk
* future, this may become a problem and derived datatypes
* will need to be used.
*/
H5_CHECK_OVERFLOW(mod_data_size, size_t, int)
H5_CHECK_OVERFLOW(mod_data_size, size_t, int);
/* Send modification data to new owner */
if (MPI_SUCCESS !=
@ -3882,8 +3882,8 @@ H5D__mpio_share_chunk_modification_data(H5D_filtered_collective_io_info_t *chunk
HGOTO_ERROR(H5E_DATASET, H5E_WRITEERROR, FAIL,
"too many shared chunks in parallel filtered write operation")
H5_CHECK_OVERFLOW(num_send_requests, size_t, int)
H5_CHECK_OVERFLOW(num_msgs_incoming, size_t, int)
H5_CHECK_OVERFLOW(num_send_requests, size_t, int);
H5_CHECK_OVERFLOW(num_msgs_incoming, size_t, int);
/*
* Allocate receive buffer and MPI_Request arrays for non-blocking
@ -3919,7 +3919,7 @@ H5D__mpio_share_chunk_modification_data(H5D_filtered_collective_io_info_t *chunk
if (MPI_SUCCESS != (mpi_code = MPI_Get_elements_x(&status, MPI_BYTE, &msg_size)))
HMPI_GOTO_ERROR(FAIL, "MPI_Get_elements_x failed", mpi_code)
H5_CHECK_OVERFLOW(msg_size, MPI_Count, int)
H5_CHECK_OVERFLOW(msg_size, MPI_Count, int);
#else
int msg_size = 0;
@ -4162,7 +4162,7 @@ H5D__mpio_collective_filtered_chunk_common_io(H5D_filtered_collective_io_info_t
*/
if (num_chunks == 0) {
if (mpi_size == 1)
HGOTO_DONE(SUCCEED)
HGOTO_DONE(SUCCEED);
else {
if (io_info->op_type == H5D_IO_OP_WRITE)
coll_io_info.base_maddr.cvp = &fake_buf;

4
src/H5Doh.c
View File

@ -171,13 +171,13 @@ H5O__dset_isa(const H5O_t *oh)
if ((exists = H5O_msg_exists_oh(oh, H5O_DTYPE_ID)) < 0)
HGOTO_ERROR(H5E_DATASET, H5E_CANTINIT, FAIL, "unable to read object header")
else if (!exists)
HGOTO_DONE(FALSE)
HGOTO_DONE(FALSE);
/* Layout */
if ((exists = H5O_msg_exists_oh(oh, H5O_SDSPACE_ID)) < 0)
HGOTO_ERROR(H5E_DATASET, H5E_CANTINIT, FAIL, "unable to read object header")
else if (!exists)
HGOTO_DONE(FALSE)
HGOTO_DONE(FALSE);
done:
FUNC_LEAVE_NOAPI(ret_value)

10
src/H5Dscatgath.c
View File

@ -464,7 +464,7 @@ H5D__scatgath_read(const H5D_io_info_t *io_info, const H5D_dset_io_info_t *dset_
/* Check for NOOP read */
if (dset_info->nelmts == 0)
HGOTO_DONE(SUCCEED)
HGOTO_DONE(SUCCEED);
/* Allocate the iterators */
if (NULL == (mem_iter = H5FL_MALLOC(H5S_sel_iter_t)))
@ -606,7 +606,7 @@ H5D__scatgath_write(const H5D_io_info_t *io_info, const H5D_dset_io_info_t *dset
/* Check for NOOP write */
if (dset_info->nelmts == 0)
HGOTO_DONE(SUCCEED)
HGOTO_DONE(SUCCEED);
/* Allocate the iterators */
if (NULL == (mem_iter = H5FL_MALLOC(H5S_sel_iter_t)))
@ -834,7 +834,7 @@ H5D__scatgath_read_select(H5D_io_info_t *io_info)
}
/* Read data from all pieces */
H5_CHECK_OVERFLOW(io_info->pieces_added, size_t, uint32_t)
H5_CHECK_OVERFLOW(io_info->pieces_added, size_t, uint32_t);
if (H5F_shared_select_read(io_info->f_sh, H5FD_MEM_DRAW, (uint32_t)io_info->pieces_added, tmp_mem_spaces,
io_info->file_spaces, io_info->addrs, io_info->element_sizes, tmp_bufs) < 0)
HGOTO_ERROR(H5E_DATASET, H5E_READERROR, FAIL, "selection read failed")
@ -1171,7 +1171,7 @@ H5D__scatgath_write_select(H5D_io_info_t *io_info)
size_t j = 0; /* Index into array of background buffers */
/* Read data */
H5_CHECK_OVERFLOW(bkg_pieces, size_t, uint32_t)
H5_CHECK_OVERFLOW(bkg_pieces, size_t, uint32_t);
if (H5F_shared_select_read(io_info->f_sh, H5FD_MEM_DRAW, (uint32_t)bkg_pieces, bkg_mem_spaces,
bkg_file_spaces, bkg_addrs, bkg_element_sizes, bkg_bufs) < 0)
HGOTO_ERROR(H5E_DATASET, H5E_READERROR, FAIL, "selection read to background buffer failed")
@ -1222,7 +1222,7 @@ H5D__scatgath_write_select(H5D_io_info_t *io_info)
}
/* Write data to disk */
H5_CHECK_OVERFLOW(io_info->pieces_added, size_t, uint32_t)
H5_CHECK_OVERFLOW(io_info->pieces_added, size_t, uint32_t);
if (H5F_shared_select_write(io_info->f_sh, H5FD_MEM_DRAW, (uint32_t)io_info->pieces_added,
write_mem_spaces, io_info->file_spaces, io_info->addrs,
io_info->element_sizes, write_bufs) < 0)

2
src/H5Dvirtual.c
View File

@ -318,7 +318,7 @@ H5D_virtual_update_min_dims(H5O_layout_t *layout, size_t idx)
/* Do not update min_dims for "all" or "none" selections */
if ((sel_type == H5S_SEL_ALL) || (sel_type == H5S_SEL_NONE))
HGOTO_DONE(SUCCEED)
HGOTO_DONE(SUCCEED);
/* Get rank of vspace */
if ((rank = H5S_GET_EXTENT_NDIMS(ent->source_dset.virtual_select)) < 0)

10
src/H5EA.c
View File

@ -350,7 +350,7 @@ H5EA__lookup_elmt(const H5EA_t *ea, hsize_t idx, hbool_t will_extend, unsigned t
hdr_dirty = TRUE;
} /* end if */
else
HGOTO_DONE(SUCCEED)
HGOTO_DONE(SUCCEED);
} /* end if */
/* Protect index block */
@ -406,7 +406,7 @@ H5EA__lookup_elmt(const H5EA_t *ea, hsize_t idx, hbool_t will_extend, unsigned t
iblock_cache_flags |= H5AC__DIRTIED_FLAG;
} /* end if */
else
HGOTO_DONE(SUCCEED)
HGOTO_DONE(SUCCEED);
} /* end if */
/* Protect data block */
@ -458,7 +458,7 @@ H5EA__lookup_elmt(const H5EA_t *ea, hsize_t idx, hbool_t will_extend, unsigned t
iblock_cache_flags |= H5AC__DIRTIED_FLAG;
} /* end if */
else
HGOTO_DONE(SUCCEED)
HGOTO_DONE(SUCCEED);
} /* end if */
/* Protect super block */
@ -505,7 +505,7 @@ H5EA__lookup_elmt(const H5EA_t *ea, hsize_t idx, hbool_t will_extend, unsigned t
} /* end if */
} /* end if */
else
HGOTO_DONE(SUCCEED)
HGOTO_DONE(SUCCEED);
} /* end if */
/* Adjust index to offset in data block */
@ -543,7 +543,7 @@ H5EA__lookup_elmt(const H5EA_t *ea, hsize_t idx, hbool_t will_extend, unsigned t
sblock_cache_flags |= H5AC__DIRTIED_FLAG;
} /* end if */
else
HGOTO_DONE(SUCCEED)
HGOTO_DONE(SUCCEED);
} /* end if */
/* Protect data block page */

24
src/H5EAtest.c
View File

@ -416,34 +416,34 @@ H5EA__cmp_cparam_test(const H5EA_create_t *cparam1, const H5EA_create_t *cparam2
/* Compare creation parameters for array */
if (cparam1->raw_elmt_size < cparam2->raw_elmt_size)
HGOTO_DONE(-1)
HGOTO_DONE(-1);
else if (cparam1->raw_elmt_size > cparam2->raw_elmt_size)
HGOTO_DONE(1)
HGOTO_DONE(1);
if (cparam1->max_nelmts_bits < cparam2->max_nelmts_bits)
HGOTO_DONE(-1)
HGOTO_DONE(-1);
else if (cparam1->max_nelmts_bits > cparam2->max_nelmts_bits)
HGOTO_DONE(1)
HGOTO_DONE(1);
if (cparam1->idx_blk_elmts < cparam2->idx_blk_elmts)
HGOTO_DONE(-1)
HGOTO_DONE(-1);
else if (cparam1->idx_blk_elmts > cparam2->idx_blk_elmts)
HGOTO_DONE(1)
HGOTO_DONE(1);
if (cparam1->sup_blk_min_data_ptrs < cparam2->sup_blk_min_data_ptrs)
HGOTO_DONE(-1)
HGOTO_DONE(-1);
else if (cparam1->sup_blk_min_data_ptrs > cparam2->sup_blk_min_data_ptrs)
HGOTO_DONE(1)
HGOTO_DONE(1);
if (cparam1->data_blk_min_elmts < cparam2->data_blk_min_elmts)
HGOTO_DONE(-1)
HGOTO_DONE(-1);
else if (cparam1->data_blk_min_elmts > cparam2->data_blk_min_elmts)
HGOTO_DONE(1)
HGOTO_DONE(1);
if (cparam1->max_dblk_page_nelmts_bits < cparam2->max_dblk_page_nelmts_bits)
HGOTO_DONE(-1)
HGOTO_DONE(-1);
else if (cparam1->max_dblk_page_nelmts_bits > cparam2->max_dblk_page_nelmts_bits)
HGOTO_DONE(1)
HGOTO_DONE(1);
done:
FUNC_LEAVE_NOAPI(ret_value)

20
src/H5Eint.c
View File

@ -198,7 +198,7 @@ H5E__walk1_cb(int n, H5E_error1_t *err_desc, void *client_data)
/* Check for bad pointer(s), but can't issue error, just leave */
if (!maj_ptr || !min_ptr)
HGOTO_DONE(FAIL)
HGOTO_DONE(FAIL);
if (maj_ptr->msg)
maj_str = maj_ptr->msg;
@ -317,7 +317,7 @@ H5E__walk2_cb(unsigned n, const H5E_error2_t *err_desc, void *client_data)
/* Check for bad pointer(s), but can't issue error, just leave */
if (!maj_ptr || !min_ptr)
HGOTO_DONE(FAIL)
HGOTO_DONE(FAIL);
if (maj_ptr->msg)
maj_str = maj_ptr->msg;
@ -330,7 +330,7 @@ H5E__walk2_cb(unsigned n, const H5E_error2_t *err_desc, void *client_data)
/* Check for bad pointer(s), but can't issue error, just leave */
if (!cls_ptr)
HGOTO_DONE(FAIL)
HGOTO_DONE(FAIL);
/* Print error class header if new class */
if (eprint->cls.lib_name == NULL || HDstrcmp(cls_ptr->lib_name, eprint->cls.lib_name) != 0) {
@ -652,11 +652,11 @@ H5E_printf_stack(H5E_t *estack, const char *file, const char *func, unsigned lin
/* Use the vasprintf() routine, since it does what we're trying to do below */
if (HDvasprintf(&tmp, fmt, ap) < 0)
HGOTO_DONE(FAIL)
HGOTO_DONE(FAIL);
/* Push the error on the stack */
if (H5E__push_stack(estack, file, func, line, cls_id, maj_id, min_id, tmp) < 0)
HGOTO_DONE(FAIL)
HGOTO_DONE(FAIL);
done:
if (va_started)
@ -711,7 +711,7 @@ H5E__push_stack(H5E_t *estack, const char *file, const char *func, unsigned line
if (estack == NULL)
if (NULL == (estack = H5E__get_my_stack())) /*lint !e506 !e774 Make lint 'constant value Boolean' in
non-threaded case */
HGOTO_DONE(FAIL)
HGOTO_DONE(FAIL);
/*
* Don't fail if arguments are bad. Instead, substitute some default
@ -732,13 +732,13 @@ H5E__push_stack(H5E_t *estack, const char *file, const char *func, unsigned line
if (estack->nused < H5E_NSLOTS) {
/* Increment the IDs to indicate that they are used in this stack */
if (H5I_inc_ref(cls_id, FALSE) < 0)
HGOTO_DONE(FAIL)
HGOTO_DONE(FAIL);
estack->slot[estack->nused].cls_id = cls_id;
if (H5I_inc_ref(maj_id, FALSE) < 0)
HGOTO_DONE(FAIL)
HGOTO_DONE(FAIL);
estack->slot[estack->nused].maj_num = maj_id;
if (H5I_inc_ref(min_id, FALSE) < 0)
HGOTO_DONE(FAIL)
HGOTO_DONE(FAIL);
estack->slot[estack->nused].min_num = min_id;
/* The 'func' & 'file' strings are statically allocated (by the compiler)
* there's no need to duplicate them.
@ -747,7 +747,7 @@ H5E__push_stack(H5E_t *estack, const char *file, const char *func, unsigned line
estack->slot[estack->nused].file_name = file;
estack->slot[estack->nused].line = line;
if (NULL == (estack->slot[estack->nused].desc = H5MM_xstrdup(desc)))
HGOTO_DONE(FAIL)
HGOTO_DONE(FAIL);
estack->nused++;
} /* end if */

10
src/H5Eprivate.h
View File

@ -66,7 +66,7 @@ typedef struct H5E_t H5E_t;
#define HGOTO_ERROR(maj, min, ret_val, ...) \
{ \
HCOMMON_ERROR(maj, min, __VA_ARGS__); \
HGOTO_DONE(ret_val) \
HGOTO_DONE(ret_val); \
}
/*
@ -77,7 +77,7 @@ typedef struct H5E_t H5E_t;
{ \
H5AC_tag(prv_tag, NULL); \
HCOMMON_ERROR(maj, min, __VA_ARGS__); \
HGOTO_DONE(ret_val) \
HGOTO_DONE(ret_val); \
}
/*
@ -87,10 +87,10 @@ typedef struct H5E_t H5E_t;
* the `done' label.
*/
#define HGOTO_DONE(ret_val) \
{ \
do { \
ret_value = ret_val; \
goto done; \
}
} while (0)
/*
* HGOTO_DONE_TAG macro, used like HGOTO_DONE between H5_BEGIN_TAG and
@ -99,7 +99,7 @@ typedef struct H5E_t H5E_t;
#define HGOTO_DONE_TAG(ret_val) \
{ \
H5AC_tag(prv_tag, NULL); \
HGOTO_DONE(ret_val) \
HGOTO_DONE(ret_val); \
}
/*

2
src/H5FA.c
View File

@ -450,7 +450,7 @@ H5FA_get(const H5FA_t *fa, hsize_t idx, void *elmt)
HGOTO_ERROR(H5E_FARRAY, H5E_CANTSET, FAIL, "can't set element to class's fill value")
/* We've retrieved the value, leave now */
HGOTO_DONE(SUCCEED)
HGOTO_DONE(SUCCEED);
} /* end if */
else { /* get the page */
size_t dblk_page_nelmts; /* # of elements in a data block page */

16
src/H5FD.c
View File

@ -932,23 +932,23 @@ H5FD_cmp(const H5FD_t *f1, const H5FD_t *f2)
FUNC_ENTER_NOAPI_NOERR /* return value is arbitrary */
if ((!f1 || !f1->cls) && (!f2 || !f2->cls))
HGOTO_DONE(0)
HGOTO_DONE(0);
if (!f1 || !f1->cls)
HGOTO_DONE(-1)
HGOTO_DONE(-1);
if (!f2 || !f2->cls)
HGOTO_DONE(1)
HGOTO_DONE(1);
if (f1->cls < f2->cls)
HGOTO_DONE(-1)
HGOTO_DONE(-1);
if (f1->cls > f2->cls)
HGOTO_DONE(1)
HGOTO_DONE(1);
/* Files are same driver; no cmp callback */
if (!f1->cls->cmp) {
if (f1 < f2)
HGOTO_DONE(-1)
HGOTO_DONE(-1);
if (f1 > f2)
HGOTO_DONE(1)
HGOTO_DONE(0)
HGOTO_DONE(1);
HGOTO_DONE(0);
}
/* Dispatch to driver */

34
src/H5FDcore.c
View File

@ -1034,57 +1034,57 @@ H5FD__core_cmp(const H5FD_t *_f1, const H5FD_t *_f2)
/* Compare low level file information for backing store */
#ifdef H5_HAVE_WIN32_API
if (f1->dwVolumeSerialNumber < f2->dwVolumeSerialNumber)
HGOTO_DONE(-1)
HGOTO_DONE(-1);
if (f1->dwVolumeSerialNumber > f2->dwVolumeSerialNumber)
HGOTO_DONE(1)
HGOTO_DONE(1);
if (f1->nFileIndexHigh < f2->nFileIndexHigh)
HGOTO_DONE(-1)
HGOTO_DONE(-1);
if (f1->nFileIndexHigh > f2->nFileIndexHigh)
HGOTO_DONE(1)
HGOTO_DONE(1);
if (f1->nFileIndexLow < f2->nFileIndexLow)
HGOTO_DONE(-1)
HGOTO_DONE(-1);
if (f1->nFileIndexLow > f2->nFileIndexLow)
HGOTO_DONE(1)
HGOTO_DONE(1);
#else
#ifdef H5_DEV_T_IS_SCALAR
if (f1->device < f2->device)
HGOTO_DONE(-1)
HGOTO_DONE(-1);
if (f1->device > f2->device)
HGOTO_DONE(1)
HGOTO_DONE(1);
#else /* H5_DEV_T_IS_SCALAR */
/* If dev_t isn't a scalar value on this system, just use memcmp to
* determine if the values are the same or not. The actual return value
* shouldn't really matter...
*/
if (memcmp(&(f1->device), &(f2->device), sizeof(dev_t)) < 0)
HGOTO_DONE(-1)
HGOTO_DONE(-1);
if (memcmp(&(f1->device), &(f2->device), sizeof(dev_t)) > 0)
HGOTO_DONE(1)
HGOTO_DONE(1);
#endif /* H5_DEV_T_IS_SCALAR */
if (f1->inode < f2->inode)
HGOTO_DONE(-1)
HGOTO_DONE(-1);
if (f1->inode > f2->inode)
HGOTO_DONE(1)
HGOTO_DONE(1);
#endif /*H5_HAVE_WIN32_API*/
} /* end if */
else {
if (NULL == f1->name && NULL == f2->name) {
if (f1 < f2)
HGOTO_DONE(-1)
HGOTO_DONE(-1);
if (f1 > f2)
HGOTO_DONE(1)
HGOTO_DONE(0)
HGOTO_DONE(1);
HGOTO_DONE(0);
} /* end if */
if (NULL == f1->name)
HGOTO_DONE(-1)
HGOTO_DONE(-1);
if (NULL == f2->name)
HGOTO_DONE(1)
HGOTO_DONE(1);
ret_value = HDstrcmp(f1->name, f2->name);
} /* end else */

20
src/H5FDdirect.c
View File

@ -635,36 +635,36 @@ H5FD__direct_cmp(const H5FD_t *_f1, const H5FD_t *_f2)
#ifdef H5_HAVE_WIN32_API
if (f1->fileindexhi < f2->fileindexhi)
HGOTO_DONE(-1)
HGOTO_DONE(-1);
if (f1->fileindexhi > f2->fileindexhi)
HGOTO_DONE(1)
HGOTO_DONE(1);
if (f1->fileindexlo < f2->fileindexlo)
HGOTO_DONE(-1)
HGOTO_DONE(-1);
if (f1->fileindexlo > f2->fileindexlo)
HGOTO_DONE(1)
HGOTO_DONE(1);
#else
#ifdef H5_DEV_T_IS_SCALAR
if (f1->device < f2->device)
HGOTO_DONE(-1)
HGOTO_DONE(-1);
if (f1->device > f2->device)
HGOTO_DONE(1)
HGOTO_DONE(1);
#else /* H5_DEV_T_IS_SCALAR */
/* If dev_t isn't a scalar value on this system, just use memcmp to
* determine if the values are the same or not. The actual return value
* shouldn't really matter...
*/
if (memcmp(&(f1->device), &(f2->device), sizeof(dev_t)) < 0)
HGOTO_DONE(-1)
HGOTO_DONE(-1);
if (memcmp(&(f1->device), &(f2->device), sizeof(dev_t)) > 0)
HGOTO_DONE(1)
HGOTO_DONE(1);
#endif /* H5_DEV_T_IS_SCALAR */
if (f1->inode < f2->inode)
HGOTO_DONE(-1)
HGOTO_DONE(-1);
if (f1->inode > f2->inode)
HGOTO_DONE(1)
HGOTO_DONE(1);
#endif

20
src/H5FDint.c
View File

@ -230,7 +230,7 @@ H5FD_read(H5FD_t *file, H5FD_mem_t type, haddr_t addr, size_t size, void *buf /*
* collective transfer.
*/
if (0 == size)
HGOTO_DONE(SUCCEED)
HGOTO_DONE(SUCCEED);
#endif /* H5_HAVE_PARALLEL */
/* If the file is open for SWMR read access, allow access to data past
@ -292,7 +292,7 @@ H5FD_write(H5FD_t *file, H5FD_mem_t type, haddr_t addr, size_t size, const void
* collective transfer.
*/
if (0 == size)
HGOTO_DONE(SUCCEED)
HGOTO_DONE(SUCCEED);
#endif /* H5_HAVE_PARALLEL */
if (HADDR_UNDEF == (eoa = (file->cls->get_eoa)(file, type)))
@ -386,7 +386,7 @@ H5FD_read_vector(H5FD_t *file, uint32_t count, H5FD_mem_t types[], haddr_t addrs
* collective transfer.
*/
if (0 == count) {
HGOTO_DONE(SUCCEED)
HGOTO_DONE(SUCCEED);
}
#endif /* H5_HAVE_PARALLEL */
@ -601,7 +601,7 @@ H5FD_write_vector(H5FD_t *file, uint32_t count, H5FD_mem_t types[], haddr_t addr
* collective transfer.
*/
if (0 == count)
HGOTO_DONE(SUCCEED)
HGOTO_DONE(SUCCEED);
#endif /* H5_HAVE_PARALLEL */
if (file->base_addr > 0) {
@ -993,7 +993,7 @@ H5FD__read_selection_translate(H5FD_t *file, H5FD_mem_t type, hid_t dxpl_id, uin
/* Issue vector read call if appropriate */
if (use_vector) {
H5_CHECK_OVERFLOW(vec_arr_nused, size_t, uint32_t)
H5_CHECK_OVERFLOW(vec_arr_nused, size_t, uint32_t);
if ((file->cls->read_vector)(file, dxpl_id, (uint32_t)vec_arr_nused, types, addrs, sizes, vec_bufs) <
0)
HGOTO_ERROR(H5E_VFL, H5E_READERROR, FAIL, "driver read vector request failed")
@ -1115,7 +1115,7 @@ H5FD_read_selection(H5FD_t *file, H5FD_mem_t type, uint32_t count, H5S_t **mem_s
* collective transfer.
*/
if (0 == count) {
HGOTO_DONE(SUCCEED)
HGOTO_DONE(SUCCEED);
}
#endif /* H5_HAVE_PARALLEL */
@ -1277,7 +1277,7 @@ H5FD_read_selection_id(H5FD_t *file, H5FD_mem_t type, uint32_t count, hid_t mem_
* collective transfer.
*/
if (0 == count) {
HGOTO_DONE(SUCCEED)
HGOTO_DONE(SUCCEED);
}
#endif /* H5_HAVE_PARALLEL */
@ -1634,7 +1634,7 @@ H5FD__write_selection_translate(H5FD_t *file, H5FD_mem_t type, hid_t dxpl_id, ui
/* Issue vector write call if appropriate */
if (use_vector) {
H5_CHECK_OVERFLOW(vec_arr_nused, size_t, uint32_t)
H5_CHECK_OVERFLOW(vec_arr_nused, size_t, uint32_t);
if ((file->cls->write_vector)(file, dxpl_id, (uint32_t)vec_arr_nused, types, addrs, sizes, vec_bufs) <
0)
HGOTO_ERROR(H5E_VFL, H5E_WRITEERROR, FAIL, "driver write vector request failed")
@ -1754,7 +1754,7 @@ H5FD_write_selection(H5FD_t *file, H5FD_mem_t type, uint32_t count, H5S_t **mem_
* collective transfer.
*/
if (0 == count) {
HGOTO_DONE(SUCCEED)
HGOTO_DONE(SUCCEED);
}
#endif /* H5_HAVE_PARALLEL */
@ -1907,7 +1907,7 @@ H5FD_write_selection_id(H5FD_t *file, H5FD_mem_t type, uint32_t count, hid_t mem
* collective transfer.
*/
if (0 == count) {
HGOTO_DONE(SUCCEED)
HGOTO_DONE(SUCCEED);
}
#endif /* H5_HAVE_PARALLEL */

24
src/H5FDlog.c
View File

@ -806,40 +806,40 @@ H5FD__log_cmp(const H5FD_t *_f1, const H5FD_t *_f2)
#ifdef H5_HAVE_WIN32_API
if (f1->dwVolumeSerialNumber < f2->dwVolumeSerialNumber)
HGOTO_DONE(-1)
HGOTO_DONE(-1);
if (f1->dwVolumeSerialNumber > f2->dwVolumeSerialNumber)
HGOTO_DONE(1)
HGOTO_DONE(1);
if (f1->nFileIndexHigh < f2->nFileIndexHigh)
HGOTO_DONE(-1)
HGOTO_DONE(-1);
if (f1->nFileIndexHigh > f2->nFileIndexHigh)
HGOTO_DONE(1)
HGOTO_DONE(1);
if (f1->nFileIndexLow < f2->nFileIndexLow)
HGOTO_DONE(-1)
HGOTO_DONE(-1);
if (f1->nFileIndexLow > f2->nFileIndexLow)
HGOTO_DONE(1)
HGOTO_DONE(1);
#else
#ifdef H5_DEV_T_IS_SCALAR
if (f1->device < f2->device)
HGOTO_DONE(-1)
HGOTO_DONE(-1);
if (f1->device > f2->device)
HGOTO_DONE(1)
HGOTO_DONE(1);
#else /* H5_DEV_T_IS_SCALAR */
/* If dev_t isn't a scalar value on this system, just use memcmp to
* determine if the values are the same or not. The actual return value
* shouldn't really matter...
*/
if (memcmp(&(f1->device), &(f2->device), sizeof(dev_t)) < 0)
HGOTO_DONE(-1)
HGOTO_DONE(-1);
if (memcmp(&(f1->device), &(f2->device), sizeof(dev_t)) > 0)
HGOTO_DONE(1)
HGOTO_DONE(1);
#endif /* H5_DEV_T_IS_SCALAR */
if (f1->inode < f2->inode)
HGOTO_DONE(-1)
HGOTO_DONE(-1);
if (f1->inode > f2->inode)
HGOTO_DONE(1)
HGOTO_DONE(1);
#endif

2
src/H5FDmirror.c
View File

@ -1285,7 +1285,7 @@ H5Pget_fapl_mirror(hid_t fapl_id, H5FD_mirror_fapl_t *fa_dst /*out*/)
H5MM_memcpy(fa_dst, fa_src, sizeof(H5FD_mirror_fapl_t));
done:
FUNC_LEAVE_API(ret_value);
FUNC_LEAVE_API(ret_value)
} /* end H5Pget_fapl_mirror() */
/*-------------------------------------------------------------------------

8
src/H5FDonion_index.c
View File

@ -189,15 +189,15 @@ H5FD__onion_archival_index_is_valid(const H5FD_onion_archival_index_t *aix)
assert(aix);
if (H5FD_ONION_ARCHIVAL_INDEX_VERSION_CURR != aix->version)
HGOTO_DONE(FALSE)
HGOTO_DONE(FALSE);
if (NULL == aix->list)
HGOTO_DONE(FALSE)
HGOTO_DONE(FALSE);
/* Ensure list is sorted on logical_page field */
if (aix->n_entries > 1)
for (uint64_t i = 1; i < aix->n_entries - 1; i++)
if (aix->list[i + 1].logical_page <= aix->list[i].logical_page)
HGOTO_DONE(FALSE)
HGOTO_DONE(FALSE);
done:
FUNC_LEAVE_NOAPI(ret_value)
@ -242,7 +242,7 @@ H5FD__onion_archival_index_find(const H5FD_onion_archival_index_t *aix, uint64_t
/* Trivial cases */
if (aix->n_entries == 0 || logical_page > aix->list[high].logical_page ||
logical_page < aix->list[0].logical_page)
HGOTO_DONE(0)
HGOTO_DONE(0);
/*
* Binary search on sorted list

40
src/H5FDros3.c
View File

@ -1399,71 +1399,71 @@ H5FD__ros3_cmp(const H5FD_t *_f1, const H5FD_t *_f2)
/* URL: SCHEME */
if (HDstrcmp(purl1->scheme, purl2->scheme))
HGOTO_DONE(-1)
HGOTO_DONE(-1);
/* URL: HOST */
if (HDstrcmp(purl1->host, purl2->host))
HGOTO_DONE(-1)
HGOTO_DONE(-1);
/* URL: PORT */
if (purl1->port && purl2->port) {
if (HDstrcmp(purl1->port, purl2->port))
HGOTO_DONE(-1)
HGOTO_DONE(-1);
}
else if (purl1->port)
HGOTO_DONE(-1)
HGOTO_DONE(-1);
else if (purl2->port)
HGOTO_DONE(-1)
HGOTO_DONE(-1);
/* URL: PATH */
if (purl1->path && purl2->path) {
if (HDstrcmp(purl1->path, purl2->path))
HGOTO_DONE(-1)
HGOTO_DONE(-1);
}
else if (purl1->path && !purl2->path)
HGOTO_DONE(-1)
HGOTO_DONE(-1);
else if (purl2->path && !purl1->path)
HGOTO_DONE(-1)
HGOTO_DONE(-1);
/* URL: QUERY */
if (purl1->query && purl2->query) {
if (HDstrcmp(purl1->query, purl2->query))
HGOTO_DONE(-1)
HGOTO_DONE(-1);
}
else if (purl1->query && !purl2->query)
HGOTO_DONE(-1)
HGOTO_DONE(-1);
else if (purl2->query && !purl1->query)
HGOTO_DONE(-1)
HGOTO_DONE(-1);
/* FAPL: AWS_REGION */
if (f1->fa.aws_region[0] != '\0' && f2->fa.aws_region[0] != '\0') {
if (HDstrcmp(f1->fa.aws_region, f2->fa.aws_region))
HGOTO_DONE(-1)
HGOTO_DONE(-1);
}
else if (f1->fa.aws_region[0] != '\0')
HGOTO_DONE(-1)
HGOTO_DONE(-1);
else if (f2->fa.aws_region[0] != '\0')
HGOTO_DONE(-1)
HGOTO_DONE(-1);
/* FAPL: SECRET_ID */
if (f1->fa.secret_id[0] != '\0' && f2->fa.secret_id[0] != '\0') {
if (HDstrcmp(f1->fa.secret_id, f2->fa.secret_id))
HGOTO_DONE(-1)
HGOTO_DONE(-1);
}
else if (f1->fa.secret_id[0] != '\0')
HGOTO_DONE(-1)
HGOTO_DONE(-1);
else if (f2->fa.secret_id[0] != '\0')
HGOTO_DONE(-1)
HGOTO_DONE(-1);
/* FAPL: SECRET_KEY */
if (f1->fa.secret_key[0] != '\0' && f2->fa.secret_key[0] != '\0') {
if (HDstrcmp(f1->fa.secret_key, f2->fa.secret_key))
HGOTO_DONE(-1)
HGOTO_DONE(-1);
}
else if (f1->fa.secret_key[0] != '\0')
HGOTO_DONE(-1)
HGOTO_DONE(-1);
else if (f2->fa.secret_key[0] != '\0')
HGOTO_DONE(-1)
HGOTO_DONE(-1);
done:
FUNC_LEAVE_NOAPI(ret_value)

24
src/H5FDsec2.c
View File

@ -453,39 +453,39 @@ H5FD__sec2_cmp(const H5FD_t *_f1, const H5FD_t *_f2)
#ifdef H5_HAVE_WIN32_API
if (f1->dwVolumeSerialNumber < f2->dwVolumeSerialNumber)
HGOTO_DONE(-1)
HGOTO_DONE(-1);
if (f1->dwVolumeSerialNumber > f2->dwVolumeSerialNumber)
HGOTO_DONE(1)
HGOTO_DONE(1);
if (f1->nFileIndexHigh < f2->nFileIndexHigh)
HGOTO_DONE(-1)
HGOTO_DONE(-1);
if (f1->nFileIndexHigh > f2->nFileIndexHigh)
HGOTO_DONE(1)
HGOTO_DONE(1);
if (f1->nFileIndexLow < f2->nFileIndexLow)
HGOTO_DONE(-1)
HGOTO_DONE(-1);
if (f1->nFileIndexLow > f2->nFileIndexLow)
HGOTO_DONE(1)
HGOTO_DONE(1);
#else /* H5_HAVE_WIN32_API */
#ifdef H5_DEV_T_IS_SCALAR
if (f1->device < f2->device)
HGOTO_DONE(-1)
HGOTO_DONE(-1);
if (f1->device > f2->device)
HGOTO_DONE(1)
HGOTO_DONE(1);
#else /* H5_DEV_T_IS_SCALAR */
/* If dev_t isn't a scalar value on this system, just use memcmp to
* determine if the values are the same or not. The actual return value
* shouldn't really matter...
*/
if (memcmp(&(f1->device), &(f2->device), sizeof(dev_t)) < 0)
HGOTO_DONE(-1)
HGOTO_DONE(-1);
if (memcmp(&(f1->device), &(f2->device), sizeof(dev_t)) > 0)
HGOTO_DONE(1)
HGOTO_DONE(1);
#endif /* H5_DEV_T_IS_SCALAR */
if (f1->inode < f2->inode)
HGOTO_DONE(-1)
HGOTO_DONE(-1);
if (f1->inode > f2->inode)
HGOTO_DONE(1)
HGOTO_DONE(1);
#endif /* H5_HAVE_WIN32_API */
done:

2
src/H5FDspace.c
View File

@ -413,7 +413,7 @@ H5FD_try_extend(H5FD_t *file, H5FD_mem_t type, H5F_t *f, haddr_t blk_end, hsize_
HGOTO_ERROR(H5E_VFL, H5E_CANTMARKDIRTY, FAIL, "unable to mark EOA info as dirty")
/* Indicate success */
HGOTO_DONE(TRUE)
HGOTO_DONE(TRUE);
} /* end if */
done:

2
src/H5FL.c
View File

@ -1367,7 +1367,7 @@ H5FL_arr_free(H5FL_arr_head_t *head, void *obj)
/* The H5MM_xfree code allows obj to null */
if (!obj)
HGOTO_DONE(NULL)
HGOTO_DONE(NULL);
/* Double check parameters */
assert(head);

8
src/H5FSsection.c
View File

@ -1536,7 +1536,7 @@ H5FS_sect_try_merge(H5F_t *f, H5FS_t *fspace, H5FS_section_info_t *sect, unsigne
/* Check if section is shrunk and/or merged away completely */
if (!sect) {
sinfo_modified = TRUE;
HGOTO_DONE(TRUE)
HGOTO_DONE(TRUE);
} /* end if */
else {
/* Check if section is merged */
@ -1545,7 +1545,7 @@ H5FS_sect_try_merge(H5F_t *f, H5FS_t *fspace, H5FS_section_info_t *sect, unsigne
HGOTO_ERROR(H5E_FSPACE, H5E_CANTINSERT, FAIL,
"can't insert free space section into skip list")
sinfo_modified = TRUE;
HGOTO_DONE(TRUE)
HGOTO_DONE(TRUE);
} /* end if */
} /* end else */
@ -1621,7 +1621,7 @@ H5FS__sect_find_node(H5FS_t *fspace, hsize_t request, H5FS_section_info_t **node
HGOTO_ERROR(H5E_FSPACE, H5E_CANTFREE, FAIL,
"can't remove section from non-size tracking data structures")
/* Indicate that we found a node for the request */
HGOTO_DONE(TRUE)
HGOTO_DONE(TRUE);
} /* end if */
} /* end if */
else { /* alignment is set */
@ -1687,7 +1687,7 @@ H5FS__sect_find_node(H5FS_t *fspace, hsize_t request, H5FS_section_info_t **node
assert(request <= (*node)->size);
} /* end if */
/* Indicate that we found a node for the request */
HGOTO_DONE(TRUE)
HGOTO_DONE(TRUE);
} /* end if */
/* Get the next section node in the list */

20
src/H5FStest.c
View File

@ -107,29 +107,29 @@ H5FS__cmp_cparam_test(const H5FS_create_t *cparam1, const H5FS_create_t *cparam2
assert(cparam2);
if (cparam1->client < cparam2->client)
HGOTO_DONE(-1)
HGOTO_DONE(-1);
else if (cparam1->client > cparam2->client)
HGOTO_DONE(1)
HGOTO_DONE(1);
if (cparam1->shrink_percent < cparam2->shrink_percent)
HGOTO_DONE(-1)
HGOTO_DONE(-1);
else if (cparam1->shrink_percent > cparam2->shrink_percent)
HGOTO_DONE(1)
HGOTO_DONE(1);
if (cparam1->expand_percent < cparam2->expand_percent)
HGOTO_DONE(-1)
HGOTO_DONE(-1);
else if (cparam1->expand_percent > cparam2->expand_percent)
HGOTO_DONE(1)
HGOTO_DONE(1);
if (cparam1->max_sect_size < cparam2->max_sect_size)
HGOTO_DONE(-1)
HGOTO_DONE(-1);
else if (cparam1->max_sect_size > cparam2->max_sect_size)
HGOTO_DONE(1)
HGOTO_DONE(1);
if (cparam1->max_sect_addr < cparam2->max_sect_addr)
HGOTO_DONE(-1)
HGOTO_DONE(-1);
else if (cparam1->max_sect_addr > cparam2->max_sect_addr)
HGOTO_DONE(1)
HGOTO_DONE(1);
done:
FUNC_LEAVE_NOAPI(ret_value)

12
src/H5Fefc.c
View File

@ -171,7 +171,7 @@ H5F__efc_open(H5F_efc_t *efc, const char *name, unsigned flags, hid_t fcpl_id, h
* H5F_decr_nopen_objs() in H5L_extern_traverse(). */
ret_value->nopen_objs++;
HGOTO_DONE(ret_value)
HGOTO_DONE(ret_value);
} /* end if */
/* Search the skip list for name if the skip list exists, create the skip
@ -247,7 +247,7 @@ H5F__efc_open(H5F_efc_t *efc, const char *name, unsigned flags, hid_t fcpl_id, h
* file id */
ret_value->nopen_objs++;
HGOTO_DONE(ret_value)
HGOTO_DONE(ret_value);
} /* end else */
} /* end if */
else
@ -358,7 +358,7 @@ H5F_efc_close(H5F_t *parent, H5F_t *file)
if (H5F_try_close(file, NULL) < 0)
HGOTO_ERROR(H5E_FILE, H5E_CANTCLOSEFILE, FAIL, "can't close external file")
HGOTO_DONE(SUCCEED)
HGOTO_DONE(SUCCEED);
} /* end if */
/* Scan the parent's LRU list from the head to file file. We do this
@ -819,7 +819,7 @@ H5F__efc_try_close(H5F_t *f)
* EFC (i.e. none were open). */
assert(f->shared->efc->nfiles == 0);
HGOTO_DONE(SUCCEED)
HGOTO_DONE(SUCCEED);
} /* end if */
/* Conditions where we should not do anything and just return immediately */
@ -838,7 +838,7 @@ H5F__efc_try_close(H5F_t *f)
(f->shared->efc->nfiles == 0))
/* We must have reentered this function, and we should not close this
* file. Just return. */
HGOTO_DONE(SUCCEED)
HGOTO_DONE(SUCCEED);
/* If the file EFC were locked, that should always mean that there exists
* a reference to this file that is not in an EFC (it may have just been
@ -871,7 +871,7 @@ H5F__efc_try_close(H5F_t *f)
sf->efc->tmp_next = NULL;
sf = next;
} /* end while */
HGOTO_DONE(SUCCEED)
HGOTO_DONE(SUCCEED);
} /* end if */
/* Run through the linked list , separating into two lists, one with tag ==

12
src/H5Fint.c
View File

@ -717,8 +717,8 @@ H5F__get_objects_cb(void *obj_ptr, hid_t obj_id, void *key)
* H5_ITER_CONT to continue the iteration.
*/
if (olist->max_nobjs > 0 && olist->list_index >= olist->max_nobjs)
HGOTO_DONE(H5_ITER_STOP) /* Indicate that the iterator should stop */
} /* end if */
HGOTO_DONE(H5_ITER_STOP); /* Indicate that the iterator should stop */
} /* end if */
done:
FUNC_LEAVE_NOAPI(ret_value)
@ -2425,7 +2425,7 @@ H5F_try_close(H5F_t *f, hbool_t *was_closed /*out*/)
if (f->closing) {
if (was_closed)
*was_closed = TRUE;
HGOTO_DONE(SUCCEED)
HGOTO_DONE(SUCCEED);
}
/* Get the number of open objects and open files on this file/mount hierarchy */
@ -2451,13 +2451,13 @@ H5F_try_close(H5F_t *f, hbool_t *was_closed /*out*/)
* close all objects isn't a major problem.
*/
if ((nopen_files + nopen_objs) > 0)
HGOTO_DONE(SUCCEED)
HGOTO_DONE(SUCCEED);
break;
case H5F_CLOSE_SEMI:
/* Can leave safely if file IDs are still open on this file */
if (nopen_files > 0)
HGOTO_DONE(SUCCEED)
HGOTO_DONE(SUCCEED);
/* Sanity check: If close degree if "semi" and we have gotten this
* far and there are objects left open, bail out now.
@ -2471,7 +2471,7 @@ H5F_try_close(H5F_t *f, hbool_t *was_closed /*out*/)
case H5F_CLOSE_STRONG:
/* If there are other open files in the hierarchy, we can leave now */
if (nopen_files > 0)
HGOTO_DONE(SUCCEED)
HGOTO_DONE(SUCCEED);
/* If we've gotten this far (ie. there are no open file IDs in the file/mount hierarchy), fall
* through to flush & close */

4
src/H5Fmpi.c
View File

@ -245,7 +245,7 @@ H5Fset_mpi_atomicity(hid_t file_id, hbool_t flag)
HGOTO_ERROR(H5E_FILE, H5E_CANTSET, FAIL, "unable to set MPI atomicity");
done:
FUNC_LEAVE_API(ret_value);
FUNC_LEAVE_API(ret_value)
} /* end H5Fset_mpi_atomicity() */
/*-------------------------------------------------------------------------
@ -316,7 +316,7 @@ H5Fget_mpi_atomicity(hid_t file_id, hbool_t *flag /*out*/)
HGOTO_ERROR(H5E_FILE, H5E_CANTGET, FAIL, "unable to get MPI atomicity");
done:
FUNC_LEAVE_API(ret_value);
FUNC_LEAVE_API(ret_value)
} /* end H5Fget_mpi_atomicity() */
/*-------------------------------------------------------------------------

2
src/H5Fsfile.c
View File

@ -138,7 +138,7 @@ H5F__sfile_search(H5FD_t *lf)
while (curr) {
/* Check for match */
if (0 == H5FD_cmp(curr->shared->lf, lf))
HGOTO_DONE(curr->shared)
HGOTO_DONE(curr->shared);
/* Advance to next shared file node */
curr = curr->next;

4
src/H5Gcompact.c
View File

@ -261,7 +261,7 @@ H5G__compact_remove_common_cb(const void *_mesg, unsigned H5_ATTR_UNUSED idx, vo
HGOTO_ERROR(H5E_SYM, H5E_CANTGET, H5_ITER_ERROR, "unable to get object type")
/* Stop the iteration, we found the correct link */
HGOTO_DONE(H5_ITER_STOP)
HGOTO_DONE(H5_ITER_STOP);
} /* end if */
done:
@ -423,7 +423,7 @@ H5G__compact_lookup_cb(const void *_mesg, unsigned H5_ATTR_UNUSED idx, void *_ud
*udata->found = TRUE;
/* Stop iteration now */
HGOTO_DONE(H5_ITER_STOP)
HGOTO_DONE(H5_ITER_STOP);
} /* end if */
done:

2
src/H5Gdeprec.c
View File

@ -962,7 +962,7 @@ H5Gget_objinfo(hid_t loc_id, const char *name, hbool_t follow_link, H5G_stat_t *
HGOTO_ERROR(H5E_SYM, H5E_CANTGET, FAIL, "can't get info for object: '%s'", name);
done:
FUNC_LEAVE_API(ret_value);
FUNC_LEAVE_API(ret_value)
} /* end H5Gget_objinfo() */
/*-------------------------------------------------------------------------

12
src/H5Gname.c
View File

@ -229,10 +229,10 @@ H5G__common_path(const H5RS_str_t *fullpath_r, const H5RS_str_t *prefix_r)
assert(prefix);
} /* end if */
else
HGOTO_DONE(FALSE)
HGOTO_DONE(FALSE);
} /* end if */
else
HGOTO_DONE(FALSE)
HGOTO_DONE(FALSE);
} /* end while */
/* If we reached the end of the prefix path to check, it must be a valid prefix */
@ -665,7 +665,7 @@ H5G__name_replace_cb(void *obj_ptr, hid_t obj_id, void *key)
case H5I_DATATYPE:
/* Avoid non-named datatypes */
if (!H5T_is_named((H5T_t *)obj_ptr))
HGOTO_DONE(SUCCEED) /* Do not exit search over IDs */
HGOTO_DONE(SUCCEED); /* Do not exit search over IDs */
oloc = H5T_oloc((H5T_t *)obj_ptr);
obj_path = H5T_nameof((H5T_t *)obj_ptr);
@ -697,7 +697,7 @@ H5G__name_replace_cb(void *obj_ptr, hid_t obj_id, void *key)
/* Check if the object has a full path still */
if (!obj_path->full_path_r)
HGOTO_DONE(SUCCEED) /* No need to look at object, it's path is already invalid */
HGOTO_DONE(SUCCEED); /* No need to look at object, it's path is already invalid */
/* Find the top file in object's mount hier. */
if (H5F_PARENT(oloc->file)) {
@ -724,7 +724,7 @@ H5G__name_replace_cb(void *obj_ptr, hid_t obj_id, void *key)
/* Check if the object is in same file mount hier. */
if (!H5F_SAME_SHARED(top_obj_file, names->src_file))
HGOTO_DONE(SUCCEED) /* No need to look at object, it's path is already invalid */
HGOTO_DONE(SUCCEED); /* No need to look at object, it's path is already invalid */
switch (names->op) {
/*-------------------------------------------------------------------------
@ -1075,7 +1075,7 @@ H5G__get_name_by_addr_cb(hid_t gid, const char *path, const H5L_info2_t *linfo,
HGOTO_ERROR(H5E_SYM, H5E_CANTALLOC, H5_ITER_ERROR, "can't duplicate path string")
/* We found a match so we return immediately */
HGOTO_DONE(H5_ITER_STOP)
HGOTO_DONE(H5_ITER_STOP);
} /* end if */
} /* end if */
} /* end if */

2
src/H5Gobj.c
View File

@ -531,7 +531,7 @@ H5G_obj_insert(const H5O_loc_t *grp_oloc, const char *name, H5O_link_t *obj_lnk,
HGOTO_ERROR(H5E_SYM, H5E_CANTINSERT, FAIL, "unable to insert link into group")
/* Done with insertion now */
HGOTO_DONE(SUCCEED)
HGOTO_DONE(SUCCEED);
} /* end if */
else
use_old_format = TRUE;

2
src/H5Groot.c
View File

@ -140,7 +140,7 @@ H5G_mkroot(H5F_t *f, hbool_t create_root)
/* Check if the root group is already initialized */
if (f->shared->root_grp)
HGOTO_DONE(SUCCEED)
HGOTO_DONE(SUCCEED);
/* Create information needed for group nodes */
if (H5G__node_init(f) < 0)

24
src/H5Gtest.c
View File

@ -112,7 +112,7 @@ H5G__is_empty_test(hid_t gid)
if (msg_exists > 0)
HGOTO_ERROR(H5E_SYM, H5E_BADVALUE, FAIL, "both symbol table and link messages found")
HGOTO_DONE(FALSE)
HGOTO_DONE(FALSE);
} /* end if */
/* Check for a link info message */
@ -133,15 +133,15 @@ H5G__is_empty_test(hid_t gid)
/* Check for 'dense' link storage file addresses being defined */
if (H5_addr_defined(linfo.fheap_addr))
HGOTO_DONE(FALSE)
HGOTO_DONE(FALSE);
if (H5_addr_defined(linfo.name_bt2_addr))
HGOTO_DONE(FALSE)
HGOTO_DONE(FALSE);
if (H5_addr_defined(linfo.corder_bt2_addr))
HGOTO_DONE(FALSE)
HGOTO_DONE(FALSE);
/* Check for link count */
if (linfo.nlinks > 0)
HGOTO_DONE(FALSE)
HGOTO_DONE(FALSE);
} /* end if */
/* "Old format" checks */
@ -171,7 +171,7 @@ H5G__is_empty_test(hid_t gid)
/* Check for link count */
if (nlinks > 0)
HGOTO_DONE(FALSE)
HGOTO_DONE(FALSE);
} /* end if */
done:
@ -223,7 +223,7 @@ H5G__has_links_test(hid_t gid, unsigned *nmsgs)
if ((msg_exists = H5O_msg_exists(&(grp->oloc), H5O_LINK_ID)) < 0)
HGOTO_ERROR(H5E_SYM, H5E_CANTINIT, FAIL, "unable to read object header")
if (msg_exists == 0)
HGOTO_DONE(FALSE)
HGOTO_DONE(FALSE);
/* Check if the group has a symbol table message */
if ((msg_exists = H5O_msg_exists(&(grp->oloc), H5O_STAB_ID)) < 0)
@ -289,7 +289,7 @@ H5G__has_stab_test(hid_t gid)
if ((msg_exists = H5O_msg_exists(&(grp->oloc), H5O_STAB_ID)) < 0)
HGOTO_ERROR(H5E_SYM, H5E_CANTINIT, FAIL, "unable to read object header")
if (msg_exists == 0)
HGOTO_DONE(FALSE)
HGOTO_DONE(FALSE);
/* Check if the group has any link messages */
if ((msg_exists = H5O_msg_exists(&(grp->oloc), H5O_LINK_ID)) < 0)
@ -347,13 +347,13 @@ H5G__is_new_dense_test(hid_t gid)
if ((msg_exists = H5O_msg_exists(&(grp->oloc), H5O_STAB_ID)) < 0)
HGOTO_ERROR(H5E_SYM, H5E_CANTINIT, FAIL, "unable to read object header")
if (msg_exists > 0)
HGOTO_DONE(FALSE)
HGOTO_DONE(FALSE);
/* Check if the group has any link messages */
if ((msg_exists = H5O_msg_exists(&(grp->oloc), H5O_LINK_ID)) < 0)
HGOTO_ERROR(H5E_SYM, H5E_CANTINIT, FAIL, "unable to read object header")
if (msg_exists > 0)
HGOTO_DONE(FALSE)
HGOTO_DONE(FALSE);
/* Check if the group has link info message */
if ((msg_exists = H5O_msg_exists(&(grp->oloc), H5O_LINFO_ID)) < 0)
@ -367,9 +367,9 @@ H5G__is_new_dense_test(hid_t gid)
/* Check for 'dense' link storage file addresses being defined */
if (!H5_addr_defined(linfo.fheap_addr))
HGOTO_DONE(FALSE)
HGOTO_DONE(FALSE);
if (!H5_addr_defined(linfo.name_bt2_addr))
HGOTO_DONE(FALSE)
HGOTO_DONE(FALSE);
} /* end if */
done:

2
src/H5Gtraverse.c
View File

@ -595,7 +595,7 @@ H5G__traverse_real(const H5G_loc_t *_loc, const char *name, unsigned target, H5G
if ((op)(&grp_loc, comp, cb_lnk, cb_loc, op_data, &own_loc) < 0)
HGOTO_ERROR(H5E_SYM, H5E_CALLBACK, FAIL, "traversal operator failed")
HGOTO_DONE(SUCCEED)
HGOTO_DONE(SUCCEED);
} /* end if */
/* Handle lookup failures now */

10
src/H5HFsection.c
View File

@ -840,7 +840,7 @@ H5HF__sect_single_can_merge(const H5FS_section_info_t *_sect1, const H5FS_sectio
* are actually within the same direct block)
*/
if (H5_addr_eq(sect1->sect_info.addr + sect1->sect_info.size, sect2->sect_info.addr))
HGOTO_DONE(TRUE)
HGOTO_DONE(TRUE);
done:
FUNC_LEAVE_NOAPI(ret_value)
@ -939,14 +939,14 @@ H5HF__sect_single_can_shrink(const H5FS_section_info_t *_sect, void *_udata)
dblock_size = hdr->man_dtable.cparam.start_block_size;
dblock_overhead = H5HF_MAN_ABS_DIRECT_OVERHEAD(hdr);
if ((dblock_size - dblock_overhead) == sect->sect_info.size)
HGOTO_DONE(TRUE)
HGOTO_DONE(TRUE);
} /* end if */
else {
/* We shouldn't have a situation where the 'next block' iterator
* is moved before a direct block that still has objects within it.
*/
assert(hdr->man_iter_off > sect->sect_info.addr);
HGOTO_DONE(FALSE)
HGOTO_DONE(FALSE);
} /* end else */
done:
@ -1645,7 +1645,7 @@ H5HF__sect_row_can_merge(const H5FS_section_info_t *_sect1, const H5FS_section_i
/* Check if second section adjoins first section */
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)
HGOTO_DONE(TRUE);
done:
FUNC_LEAVE_NOAPI(ret_value)
@ -1732,7 +1732,7 @@ H5HF__sect_row_can_shrink(const H5FS_section_info_t *_sect, void H5_ATTR_UNUSED
/* Check if section is past end of "next block" iterator */
if (sect->sect_info.addr >= hdr->man_iter_off)
HGOTO_DONE(TRUE)
HGOTO_DONE(TRUE);
done:
FUNC_LEAVE_NOAPI(ret_value)

54
src/H5HFtest.c
View File

@ -115,41 +115,41 @@ H5HF_cmp_cparam_test(const H5HF_create_t *cparam1, const H5HF_create_t *cparam2)
/* Compare doubling table parameters */
if (cparam1->managed.width < cparam2->managed.width)
HGOTO_DONE(-1)
HGOTO_DONE(-1);
else if (cparam1->managed.width > cparam2->managed.width)
HGOTO_DONE(1)
HGOTO_DONE(1);
if (cparam1->managed.start_block_size < cparam2->managed.start_block_size)
HGOTO_DONE(-1)
HGOTO_DONE(-1);
else if (cparam1->managed.start_block_size > cparam2->managed.start_block_size)
HGOTO_DONE(1)
HGOTO_DONE(1);
if (cparam1->managed.max_direct_size < cparam2->managed.max_direct_size)
HGOTO_DONE(-1)
HGOTO_DONE(-1);
else if (cparam1->managed.max_direct_size > cparam2->managed.max_direct_size)
HGOTO_DONE(1)
HGOTO_DONE(1);
if (cparam1->managed.max_index < cparam2->managed.max_index)
HGOTO_DONE(-1)
HGOTO_DONE(-1);
else if (cparam1->managed.max_index > cparam2->managed.max_index)
HGOTO_DONE(1)
HGOTO_DONE(1);
if (cparam1->managed.start_root_rows < cparam2->managed.start_root_rows)
HGOTO_DONE(-1)
HGOTO_DONE(-1);
else if (cparam1->managed.start_root_rows > cparam2->managed.start_root_rows)
HGOTO_DONE(1)
HGOTO_DONE(1);
/* Compare other general parameters for heap */
if (cparam1->max_man_size < cparam2->max_man_size)
HGOTO_DONE(-1)
HGOTO_DONE(-1);
else if (cparam1->max_man_size > cparam2->max_man_size)
HGOTO_DONE(1)
HGOTO_DONE(1);
if (cparam1->id_len < cparam2->id_len)
HGOTO_DONE(-1)
HGOTO_DONE(-1);
else if (cparam1->id_len > cparam2->id_len)
HGOTO_DONE(1)
HGOTO_DONE(1);
/* Compare "important" parameters for any I/O pipeline filters */
if (cparam1->pline.nused < cparam2->pline.nused)
HGOTO_DONE(-1)
HGOTO_DONE(-1);
else if (cparam1->pline.nused > cparam2->pline.nused)
HGOTO_DONE(1)
HGOTO_DONE(1);
else {
size_t u, v; /* Local index variables */
@ -157,15 +157,15 @@ H5HF_cmp_cparam_test(const H5HF_create_t *cparam1, const H5HF_create_t *cparam2)
for (u = 0; u < cparam1->pline.nused; u++) {
/* Check filter ID */
if (cparam1->pline.filter[u].id < cparam2->pline.filter[u].id)
HGOTO_DONE(-1)
HGOTO_DONE(-1);
else if (cparam1->pline.filter[u].id > cparam2->pline.filter[u].id)
HGOTO_DONE(1)
HGOTO_DONE(1);
/* Check filter flags */
if (cparam1->pline.filter[u].flags < cparam2->pline.filter[u].flags)
HGOTO_DONE(-1)
HGOTO_DONE(-1);
else if (cparam1->pline.filter[u].flags > cparam2->pline.filter[u].flags)
HGOTO_DONE(1)
HGOTO_DONE(1);
/* Don't worry about comparing the filter names right now... */
/* (they are expanded during the encode/decode process, but aren't copied
@ -174,27 +174,27 @@ H5HF_cmp_cparam_test(const H5HF_create_t *cparam1, const H5HF_create_t *cparam2)
#if 0
/* Check filter name */
if(!cparam1->pline.filter[u].name && cparam2->pline.filter[u].name)
HGOTO_DONE(-1)
HGOTO_DONE(-1);
else if(cparam1->pline.filter[u].name && !cparam2->pline.filter[u].name)
HGOTO_DONE(1)
HGOTO_DONE(1);
else if(cparam1->pline.filter[u].name && cparam2->pline.filter[u].name) {
if((ret_value = HDstrcmp(cparam1->pline.filter[u].name, cparam2->pline.filter[u].name)))
HGOTO_DONE(ret_value)
HGOTO_DONE(ret_value);
} /* end if */
#endif
/* Check # of filter parameters */
if (cparam1->pline.filter[u].cd_nelmts < cparam2->pline.filter[u].cd_nelmts)
HGOTO_DONE(-1)
HGOTO_DONE(-1);
else if (cparam1->pline.filter[u].cd_nelmts > cparam2->pline.filter[u].cd_nelmts)
HGOTO_DONE(1)
HGOTO_DONE(1);
/* Check filter parameters */
for (v = 0; v < cparam1->pline.filter[u].cd_nelmts; v++) {
if (cparam1->pline.filter[u].cd_values[v] < cparam2->pline.filter[u].cd_values[v])
HGOTO_DONE(-1)
HGOTO_DONE(-1);
else if (cparam1->pline.filter[u].cd_values[v] > cparam2->pline.filter[u].cd_values[v])
HGOTO_DONE(1)
HGOTO_DONE(1);
} /* end for */
} /* end for */

2
src/H5HG.c
View File

@ -728,7 +728,7 @@ H5HG_remove(H5F_t *f, H5HG_t *hobj)
* the entry and let the second rewrite happen (see HDFFV-10635). In the future, it'd be nice to handle
* this situation in H5T_conv_vlen in H5Tconv.c instead of this level (HDFFV-10648). */
if (heap->obj[hobj->idx].nrefs == 0 && heap->obj[hobj->idx].size == 0 && !heap->obj[hobj->idx].begin)
HGOTO_DONE(ret_value)
HGOTO_DONE(ret_value);
obj_start = heap->obj[hobj->idx].begin;
/* Include object header size */

10
src/H5HL.c
View File

@ -781,7 +781,7 @@ H5HL_remove(H5F_t *f, H5HL_t *heap, size_t offset, size_t size)
if (FAIL == H5HL__minimize_heap_space(f, heap))
HGOTO_ERROR(H5E_HEAP, H5E_CANTFREE, FAIL, "heap size minimization failed");
}
HGOTO_DONE(SUCCEED)
HGOTO_DONE(SUCCEED);
}
fl2 = fl2->next;
}
@ -789,7 +789,7 @@ H5HL_remove(H5F_t *f, H5HL_t *heap, size_t offset, size_t size)
if (FAIL == H5HL__minimize_heap_space(f, heap))
HGOTO_ERROR(H5E_HEAP, H5E_CANTFREE, FAIL, "heap size minimization failed");
}
HGOTO_DONE(SUCCEED)
HGOTO_DONE(SUCCEED);
}
else if (fl->offset + fl->size == offset) {
fl->size += size;
@ -804,7 +804,7 @@ H5HL_remove(H5F_t *f, H5HL_t *heap, size_t offset, size_t size)
if (FAIL == H5HL__minimize_heap_space(f, heap))
HGOTO_ERROR(H5E_HEAP, H5E_CANTFREE, FAIL, "heap size minimization failed");
}
HGOTO_DONE(SUCCEED)
HGOTO_DONE(SUCCEED);
}
fl2 = fl2->next;
}
@ -812,7 +812,7 @@ H5HL_remove(H5F_t *f, H5HL_t *heap, size_t offset, size_t size)
if (FAIL == H5HL__minimize_heap_space(f, heap))
HGOTO_ERROR(H5E_HEAP, H5E_CANTFREE, FAIL, "heap size minimization failed");
}
HGOTO_DONE(SUCCEED)
HGOTO_DONE(SUCCEED);
}
fl = fl->next;
}
@ -828,7 +828,7 @@ H5HL_remove(H5F_t *f, H5HL_t *heap, size_t offset, size_t size)
fprintf(H5DEBUG(HL), "H5HL: lost %lu bytes\n", (unsigned long)size);
}
#endif
HGOTO_DONE(SUCCEED)
HGOTO_DONE(SUCCEED);
}
/* Add an entry to the free list */

12
src/H5Iint.c
View File

@ -1591,10 +1591,10 @@ H5I__find_id(hid_t id)
/* Check arguments */
type = H5I_TYPE(id);
if (type <= H5I_BADID || (int)type >= H5I_next_type_g)
HGOTO_DONE(NULL)
HGOTO_DONE(NULL);
type_info = H5I_type_info_array_g[type];
if (!type_info || type_info->init_count <= 0)
HGOTO_DONE(NULL)
HGOTO_DONE(NULL);
/* Check for same ID as we have looked up last time */
if (type_info->last_id_info && type_info->last_id_info->id == id)
@ -1615,13 +1615,13 @@ H5I__find_id(hid_t id)
/* Invoke the realize callback, to get the actual object */
if ((id_info->realize_cb)((void *)id_info->object, &actual_id) < 0)
HGOTO_DONE(NULL)
HGOTO_DONE(NULL);
/* Verify that we received a valid ID, of the same type */
if (H5I_INVALID_HID == actual_id)
HGOTO_DONE(NULL)
HGOTO_DONE(NULL);
if (H5I_TYPE(id) != H5I_TYPE(actual_id))
HGOTO_DONE(NULL)
HGOTO_DONE(NULL);
/* Swap the actual object in for the future object */
future_object = (void *)id_info->object;
@ -1631,7 +1631,7 @@ H5I__find_id(hid_t id)
/* Discard the future object */
if ((id_info->discard_cb)(future_object) < 0)
HGOTO_DONE(NULL)
HGOTO_DONE(NULL);
future_object = NULL;
/* Change the ID from 'future' to 'actual' */

2
src/H5Lint.c
View File

@ -261,7 +261,7 @@ H5L__find_class_idx(H5L_type_t id)
for (i = 0; i < H5L_table_used_g; i++)
if (H5L_table_g[i].id == id)
HGOTO_DONE((int)i)
HGOTO_DONE((int)i);
done:
FUNC_LEAVE_NOAPI(ret_value)

8
src/H5MF.c
View File

@ -1057,7 +1057,7 @@ H5MF_xfree(H5F_t *f, H5FD_mem_t alloc_type, haddr_t addr, hsize_t size)
/* check arguments */
assert(f);
if (!H5_addr_defined(addr) || 0 == size)
HGOTO_DONE(SUCCEED)
HGOTO_DONE(SUCCEED);
assert(addr != 0); /* Can't deallocate the superblock :-) */
H5MF__alloc_to_fs_type(f->shared, alloc_type, size, &fs_type);
@ -1113,13 +1113,13 @@ H5MF_xfree(H5F_t *f, H5FD_mem_t alloc_type, haddr_t addr, hsize_t size)
HGOTO_ERROR(H5E_RESOURCE, H5E_CANTMERGE, FAIL, "can't check for absorbing block")
else if (status > 0)
/* Indicate success */
HGOTO_DONE(SUCCEED)
HGOTO_DONE(SUCCEED);
else if (size < f->shared->fs_threshold) {
#ifdef H5MF_ALLOC_DEBUG_MORE
fprintf(stderr, "%s: dropping addr = %" PRIuHADDR ", size = %" PRIuHSIZE ", on the floor!\n",
__func__, addr, size);
#endif /* H5MF_ALLOC_DEBUG_MORE */
HGOTO_DONE(SUCCEED)
HGOTO_DONE(SUCCEED);
} /* end else-if */
} /* end if */
@ -1137,7 +1137,7 @@ H5MF_xfree(H5F_t *f, H5FD_mem_t alloc_type, haddr_t addr, hsize_t size)
fprintf(stderr, "%s: dropping addr = %" PRIuHADDR ", size = %" PRIuHSIZE ", on the floor!\n",
__func__, addr, size);
#endif /* H5MF_ALLOC_DEBUG_MORE */
HGOTO_DONE(SUCCEED)
HGOTO_DONE(SUCCEED);
} /* end if */
/* There's either already a free space manager, or the freed

2
src/H5MFaggr.c
View File

@ -534,7 +534,7 @@ done:
*shrink = H5MF_SHRINK_AGGR_ABSORB_SECT;
/* Indicate success */
HGOTO_DONE(TRUE)
HGOTO_DONE(TRUE);
} /* end if */
} /* end if */

4
src/H5MFpkg.h
View File

@ -67,14 +67,14 @@
/* Calculate the mis-aligned fragment */
#define H5MF_EOA_MISALIGN(F, E, A, FR) \
{ \
do { \
hsize_t m; \
\
if (H5_addr_gt((E), 0) && ((m) = ((E) + H5F_BASE_ADDR(F)) % (A))) \
(FR) = (A)-m; \
else \
(FR) = 0; \
}
} while (0)
/****************************/
/* Package Private Typedefs */

10
src/H5MFsection.c
View File

@ -450,12 +450,12 @@ H5MF__sect_simple_can_shrink(const H5FS_section_info_t *_sect, void *_udata)
#endif /* H5MF_ALLOC_DEBUG_MORE */
/* Indicate shrinking can occur */
HGOTO_DONE(TRUE)
HGOTO_DONE(TRUE);
} /* end if */
else {
/* Shrinking can't occur if the 'eoa_shrink_only' flag is set and we're not shrinking the EOA */
if (udata->allow_eoa_shrink_only)
HGOTO_DONE(FALSE)
HGOTO_DONE(FALSE);
/* Check if this section is allowed to merge with metadata aggregation block */
if (udata->f->shared->fs_aggr_merge[udata->alloc_type] & H5F_FS_MERGE_METADATA) {
@ -474,7 +474,7 @@ H5MF__sect_simple_can_shrink(const H5FS_section_info_t *_sect, void *_udata)
#endif /* H5MF_ALLOC_DEBUG_MORE */
/* Indicate shrinking can occur */
HGOTO_DONE(TRUE)
HGOTO_DONE(TRUE);
} /* end if */
} /* end if */
@ -496,7 +496,7 @@ H5MF__sect_simple_can_shrink(const H5FS_section_info_t *_sect, void *_udata)
#endif /* H5MF_ALLOC_DEBUG_MORE */
/* Indicate shrinking can occur */
HGOTO_DONE(TRUE)
HGOTO_DONE(TRUE);
} /* end if */
} /* end if */
} /* end else */
@ -858,7 +858,7 @@ H5MF__sect_large_can_shrink(const H5FS_section_info_t *_sect, void *_udata)
#endif /* H5MF_ALLOC_DEBUG_MORE */
/* Indicate shrinking can occur */
HGOTO_DONE(TRUE)
HGOTO_DONE(TRUE);
} /* end if */
done:

4
src/H5O.c
View File

@ -2074,7 +2074,7 @@ H5Odisable_mdc_flushes(hid_t object_id)
HGOTO_ERROR(H5E_OHDR, H5E_CANTCORK, FAIL, "unable to cork object");
done:
FUNC_LEAVE_API(ret_value);
FUNC_LEAVE_API(ret_value)
} /* H5Odisable_mdc_flushes() */
/*-------------------------------------------------------------------------
@ -2144,7 +2144,7 @@ H5Oenable_mdc_flushes(hid_t object_id)
HGOTO_ERROR(H5E_OHDR, H5E_CANTUNCORK, FAIL, "unable to uncork object");
done:
FUNC_LEAVE_API(ret_value);
FUNC_LEAVE_API(ret_value)
} /* H5Oenable_mdc_flushes() */
/*-------------------------------------------------------------------------

2
src/H5Oalloc.c
View File

@ -564,7 +564,7 @@ H5O__alloc_extend_chunk(H5F_t *f, H5O_t *oh, unsigned chunkno, size_t size, size
if (was_extended < 0) /* error */
HGOTO_ERROR(H5E_OHDR, H5E_CANTEXTEND, FAIL, "can't tell if we can extend chunk")
else if (was_extended == FALSE) /* can't extend -- we are done */
HGOTO_DONE(FALSE)
HGOTO_DONE(FALSE);
/* Adjust object header prefix flags */
if (adjust_size_flags) {

6
src/H5Ocopy.c
View File

@ -281,7 +281,7 @@ H5O__copy_header_real(const H5O_loc_t *oloc_src, H5O_loc_t *oloc_dst /*out*/, H5
HGOTO_ERROR(H5E_OHDR, H5E_CANTINSERT, FAIL, "can't insert object into skip list")
} /* end if */
HGOTO_DONE(SUCCEED)
HGOTO_DONE(SUCCEED);
} /* end if */
} /* end if */
@ -1122,9 +1122,9 @@ H5O__copy_comm_dt_cmp(const void *_key1, const void *_key2)
* first so only one comparison needs to be made. */
if (key1->fileno != key2->fileno) {
if (key1->fileno < key2->fileno)
HGOTO_DONE(-1)
HGOTO_DONE(-1);
if (key1->fileno > key2->fileno)
HGOTO_DONE(1)
HGOTO_DONE(1);
} /* end if */
ret_value = H5T_cmp(key1->dt, key2->dt, FALSE);

4
src/H5Odtype.c
View File

@ -1691,13 +1691,13 @@ H5O__dtype_can_share(const void *_mesg)
/* Don't share immutable datatypes */
if ((tri_ret = H5T_is_immutable(mesg)) > 0)
HGOTO_DONE(FALSE)
HGOTO_DONE(FALSE);
else if (tri_ret < 0)
HGOTO_ERROR(H5E_OHDR, H5E_BADTYPE, FAIL, "can't tell if datatype is immutable")
/* Don't share committed datatypes */
if ((tri_ret = H5T_is_named(mesg)) > 0)
HGOTO_DONE(FALSE)
HGOTO_DONE(FALSE);
else if (tri_ret < 0)
HGOTO_ERROR(H5E_OHDR, H5E_BADTYPE, FAIL, "can't tell if datatype is shared")

2
src/H5Oint.c
View File

@ -1689,7 +1689,7 @@ H5O__obj_class_real(const H5O_t *oh)
if ((isa = (H5O_obj_class_g[i - 1]->isa)(oh)) < 0)
HGOTO_ERROR(H5E_OHDR, H5E_CANTINIT, NULL, "unable to determine object type")
else if (isa)
HGOTO_DONE(H5O_obj_class_g[i - 1])
HGOTO_DONE(H5O_obj_class_g[i - 1]);
}
if (0 == i)

2
src/H5Olinfo.c
View File

@ -484,7 +484,7 @@ H5O__linfo_post_copy_file(const H5O_loc_t *src_oloc, const void *mesg_src, H5O_l
/* If we are performing a 'shallow hierarchy' copy, get out now */
if (cpy_info->max_depth >= 0 && cpy_info->curr_depth >= cpy_info->max_depth)
HGOTO_DONE(SUCCEED)
HGOTO_DONE(SUCCEED);
/* Check for copying dense link storage */
if (H5_addr_defined(linfo_src->fheap_addr)) {

4
src/H5Omessage.c
View File

@ -833,7 +833,7 @@ H5O_msg_exists_oh(const H5O_t *oh, unsigned type_id)
/* Scan through the messages looking for the right one */
for (u = 0; u < oh->nmesgs; u++)
if (type == oh->mesg[u].type)
HGOTO_DONE(TRUE)
HGOTO_DONE(TRUE);
done:
FUNC_LEAVE_NOAPI(ret_value)
@ -988,7 +988,7 @@ H5O__msg_remove_cb(H5O_t *oh, H5O_mesg_t *mesg /*in,out*/, unsigned sequence, un
/* Break out now, if we've found the correct message */
if (udata->sequence == H5O_FIRST || udata->sequence != H5O_ALL)
HGOTO_DONE(H5_ITER_STOP)
HGOTO_DONE(H5_ITER_STOP);
} /* end if */
done:

2
src/H5Ostab.c
View File

@ -343,7 +343,7 @@ H5O__stab_post_copy_file(const H5O_loc_t *src_oloc, const void *mesg_src, H5O_lo
/* If we are performing a 'shallow hierarchy' copy, get out now */
if (cpy_info->max_depth >= 0 && cpy_info->curr_depth >= cpy_info->max_depth)
HGOTO_DONE(SUCCEED)
HGOTO_DONE(SUCCEED);
/* Set up B-tree iteration user data */
udata.src_oloc = src_oloc;

10
src/H5PB.c
View File

@ -705,7 +705,7 @@ H5PB_read(H5F_shared_t *f_sh, H5FD_mem_t type, haddr_t addr, size_t size, void *
*/
if (NULL == page_buf || (size >= page_buf->page_size && H5FD_MEM_DRAW != type) ||
(bypass_pb && H5FD_MEM_DRAW == type))
HGOTO_DONE(SUCCEED)
HGOTO_DONE(SUCCEED);
} /* end if */
/* Update statistics */
@ -1003,13 +1003,13 @@ H5PB_write(H5F_shared_t *f_sh, H5FD_mem_t type, haddr_t addr, size_t size, const
*/
if (NULL == page_buf || (size >= page_buf->page_size && H5FD_MEM_DRAW != type) ||
(bypass_pb && H5FD_MEM_DRAW == type))
HGOTO_DONE(SUCCEED)
HGOTO_DONE(SUCCEED);
#ifdef H5_HAVE_PARALLEL
if (bypass_pb) {
if (H5PB_update_entry(page_buf, addr, size, buf) > 0)
HGOTO_ERROR(H5E_PAGEBUF, H5E_CANTUPDATE, FAIL, "failed to update PB with metadata cache")
HGOTO_DONE(SUCCEED)
HGOTO_DONE(SUCCEED);
} /* end if */
#endif
} /* end if */
@ -1424,7 +1424,7 @@ H5PB__make_space(H5F_shared_t *f_sh, H5PB_t *page_buf, H5FD_mem_t inserted_type)
metadata, then we can't make space for raw data */
if (0 == page_buf->raw_count && page_buf->min_meta_count == page_buf->meta_count) {
assert(page_buf->meta_count * page_buf->page_size == page_buf->max_size);
HGOTO_DONE(FALSE)
HGOTO_DONE(FALSE);
} /* end if */
/* check the metadata threshold before evicting metadata items */
@ -1441,7 +1441,7 @@ H5PB__make_space(H5F_shared_t *f_sh, H5PB_t *page_buf, H5FD_mem_t inserted_type)
raw data, then we can't make space for meta data */
if (0 == page_buf->meta_count && page_buf->min_raw_count == page_buf->raw_count) {
assert(page_buf->raw_count * page_buf->page_size == page_buf->max_size);
HGOTO_DONE(FALSE)
HGOTO_DONE(FALSE);
} /* end if */
/* check the raw data threshold before evicting raw data items */

8
src/H5PLint.c
View File

@ -346,25 +346,25 @@ H5PL__open(const char *path, H5PL_type_t type, const H5PL_key_t *key, hbool_t *s
*/
if (NULL == (handle = H5PL_OPEN_DLIB(path))) {
H5PL_CLR_ERROR; /* clear error */
HGOTO_DONE(SUCCEED)
HGOTO_DONE(SUCCEED);
}
/* Return a handle for the function H5PLget_plugin_type in the dynamic library.
* The plugin library is supposed to define this function.
*/
if (NULL == (get_plugin_type = (H5PL_get_plugin_type_t)H5PL_GET_LIB_FUNC(handle, "H5PLget_plugin_type")))
HGOTO_DONE(SUCCEED)
HGOTO_DONE(SUCCEED);
/* Return a handle for the function H5PLget_plugin_info in the dynamic library.
* The plugin library is supposed to define this function.
*/
if (NULL == (get_plugin_info = (H5PL_get_plugin_info_t)H5PL_GET_LIB_FUNC(handle, "H5PLget_plugin_info")))
HGOTO_DONE(SUCCEED)
HGOTO_DONE(SUCCEED);
/* Check the plugin type and return if it doesn't match the one passed in */
loaded_plugin_type = (H5PL_type_t)(*get_plugin_type)();
if ((type != H5PL_TYPE_NONE) && (type != loaded_plugin_type))
HGOTO_DONE(SUCCEED)
HGOTO_DONE(SUCCEED);
/* Get the plugin information */
switch (loaded_plugin_type) {

8
src/H5PLpath.c
View File

@ -617,7 +617,7 @@ H5PL__path_table_iterate_process_path(const char *plugin_path, H5PL_iterate_type
/* Open the directory - skip the path if the directory can't be opened */
if (!(dirp = HDopendir(plugin_path)))
HGOTO_DONE(H5_ITER_CONT)
HGOTO_DONE(H5_ITER_CONT);
/* Iterate through all entries in the directory */
while (NULL != (dp = HDreaddir(dirp))) {
@ -711,7 +711,7 @@ H5PL__path_table_iterate_process_path(const char *plugin_path, H5PL_iterate_type
* skip the path if the directory can't be opened */
HDsnprintf(service, sizeof(service), "%s\\*.dll", plugin_path);
if ((hFind = FindFirstFileA(service, &fdFile)) == INVALID_HANDLE_VALUE)
HGOTO_DONE(H5_ITER_CONT)
HGOTO_DONE(H5_ITER_CONT);
/* Loop over all the files */
do {
@ -897,7 +897,7 @@ H5PL__find_plugin_in_path(const H5PL_search_params_t *search_params, hbool_t *fo
if (H5PL__open(path, search_params->type, search_params->key, found, NULL, plugin_info) < 0)
HGOTO_ERROR(H5E_PLUGIN, H5E_CANTGET, FAIL, "search in directory failed")
if (*found)
HGOTO_DONE(SUCCEED)
HGOTO_DONE(SUCCEED);
path = (char *)H5MM_xfree(path);
} /* end if */
@ -964,7 +964,7 @@ H5PL__find_plugin_in_path(const H5PL_search_params_t *search_params, hbool_t *fo
if (H5PL__open(path, search_params->type, search_params->key, found, NULL, plugin_info) < 0)
HGOTO_ERROR(H5E_PLUGIN, H5E_CANTGET, FAIL, "search in directory failed")
if (*found)
HGOTO_DONE(SUCCEED)
HGOTO_DONE(SUCCEED);
path = (char *)H5MM_xfree(path);
}

40
src/H5Pdcpl.c
View File

@ -825,9 +825,9 @@ H5P__dcrt_layout_cmp(const void *_layout1, const void *_layout2, size_t H5_ATTR_
/* Check for different layout type */
if (layout1->type < layout2->type)
HGOTO_DONE(-1)
HGOTO_DONE(-1);
if (layout1->type > layout2->type)
HGOTO_DONE(1)
HGOTO_DONE(1);
/* Compare non-dataset-specific fields in layout info */
switch (layout1->type) {
@ -840,16 +840,16 @@ H5P__dcrt_layout_cmp(const void *_layout1, const void *_layout2, size_t H5_ATTR_
/* Check the number of dimensions */
if (layout1->u.chunk.ndims < layout2->u.chunk.ndims)
HGOTO_DONE(-1)
HGOTO_DONE(-1);
if (layout1->u.chunk.ndims > layout2->u.chunk.ndims)
HGOTO_DONE(1)
HGOTO_DONE(1);
/* Compare the chunk dims */
for (u = 0; u < layout1->u.chunk.ndims - 1; u++) {
if (layout1->u.chunk.dim[u] < layout2->u.chunk.dim[u])
HGOTO_DONE(-1)
HGOTO_DONE(-1);
if (layout1->u.chunk.dim[u] > layout2->u.chunk.dim[u])
HGOTO_DONE(1)
HGOTO_DONE(1);
} /* end for */
} /* end case */
break;
@ -861,9 +861,9 @@ H5P__dcrt_layout_cmp(const void *_layout1, const void *_layout2, size_t H5_ATTR_
/* Compare number of mappings */
if (layout1->storage.u.virt.list_nused < layout2->storage.u.virt.list_nused)
HGOTO_DONE(-1)
HGOTO_DONE(-1);
if (layout1->storage.u.virt.list_nused > layout2->storage.u.virt.list_nused)
HGOTO_DONE(1)
HGOTO_DONE(1);
/* Iterate over mappings */
for (u = 0; u < layout1->storage.u.virt.list_nused; u++) {
@ -873,45 +873,45 @@ H5P__dcrt_layout_cmp(const void *_layout1, const void *_layout2, size_t H5_ATTR_
if ((equal = H5S_extent_equal(layout1->storage.u.virt.list[u].source_dset.virtual_select,
layout2->storage.u.virt.list[u].source_dset.virtual_select)) <
0)
HGOTO_DONE(-1)
HGOTO_DONE(-1);
if (!equal)
HGOTO_DONE(1)
HGOTO_DONE(1);
if ((equal = H5S_SELECT_SHAPE_SAME(
layout1->storage.u.virt.list[u].source_dset.virtual_select,
layout2->storage.u.virt.list[u].source_dset.virtual_select)) < 0)
HGOTO_DONE(-1)
HGOTO_DONE(-1);
if (!equal)
HGOTO_DONE(1)
HGOTO_DONE(1);
/* Compare source file names */
strcmp_ret = HDstrcmp(layout1->storage.u.virt.list[u].source_file_name,
layout2->storage.u.virt.list[u].source_file_name);
if (strcmp_ret < 0)
HGOTO_DONE(-1)
HGOTO_DONE(-1);
if (strcmp_ret > 0)
HGOTO_DONE(1)
HGOTO_DONE(1);
/* Compare source dataset names */
strcmp_ret = HDstrcmp(layout1->storage.u.virt.list[u].source_dset_name,
layout2->storage.u.virt.list[u].source_dset_name);
if (strcmp_ret < 0)
HGOTO_DONE(-1)
HGOTO_DONE(-1);
if (strcmp_ret > 0)
HGOTO_DONE(1)
HGOTO_DONE(1);
/* Compare source spaces. Note we cannot tell which is
* "greater", so just return 1 if different, -1 on failure.
*/
if ((equal = H5S_extent_equal(layout1->storage.u.virt.list[u].source_select,
layout2->storage.u.virt.list[u].source_select)) < 0)
HGOTO_DONE(-1)
HGOTO_DONE(-1);
if (!equal)
HGOTO_DONE(1)
HGOTO_DONE(1);
if ((equal = H5S_SELECT_SHAPE_SAME(layout1->storage.u.virt.list[u].source_select,
layout2->storage.u.virt.list[u].source_select)) < 0)
HGOTO_DONE(-1)
HGOTO_DONE(-1);
if (!equal)
HGOTO_DONE(1)
HGOTO_DONE(1);
} /* end for */
} /* end block */
break;

36
src/H5Pfapl.c
View File

@ -1910,9 +1910,9 @@ H5P__facc_file_driver_cmp(const void *_info1, const void *_info2, size_t H5_ATTR
/* Compare drivers */
if (NULL == (cls1 = H5FD_get_class(info1->driver_id)))
HGOTO_DONE(-1)
HGOTO_DONE(-1);
if (NULL == (cls2 = H5FD_get_class(info2->driver_id)))
HGOTO_DONE(1)
HGOTO_DONE(1);
if (cls1->name == NULL && cls2->name != NULL)
HGOTO_DONE(-1);
if (cls1->name != NULL && cls2->name == NULL)
@ -1922,9 +1922,9 @@ H5P__facc_file_driver_cmp(const void *_info1, const void *_info2, size_t H5_ATTR
/* Compare driver infos */
if (cls1->fapl_size < cls2->fapl_size)
HGOTO_DONE(-1)
HGOTO_DONE(-1);
if (cls1->fapl_size > cls2->fapl_size)
HGOTO_DONE(1)
HGOTO_DONE(1);
assert(cls1->fapl_size == cls2->fapl_size);
if (info1->driver_info == NULL && info2->driver_info != NULL)
HGOTO_DONE(-1);
@ -3677,37 +3677,37 @@ H5P__facc_file_image_info_cmp(const void *_info1, const void *_info2, size_t H5_
/* Check for different buffer sizes */
if (info1->size < info2->size)
HGOTO_DONE(-1)
HGOTO_DONE(-1);
if (info1->size > info2->size)
HGOTO_DONE(1)
HGOTO_DONE(1);
/* Check for different callbacks */
/* (Order in memory is fairly meaningless, so just check for equality) */
if (info1->callbacks.image_malloc != info2->callbacks.image_malloc)
HGOTO_DONE(1)
HGOTO_DONE(1);
if (info1->callbacks.image_memcpy != info2->callbacks.image_memcpy)
HGOTO_DONE(-1)
HGOTO_DONE(-1);
if (info1->callbacks.image_realloc != info2->callbacks.image_realloc)
HGOTO_DONE(1)
HGOTO_DONE(1);
if (info1->callbacks.image_free != info2->callbacks.image_free)
HGOTO_DONE(-1)
HGOTO_DONE(-1);
if (info1->callbacks.udata_copy != info2->callbacks.udata_copy)
HGOTO_DONE(1)
HGOTO_DONE(1);
if (info1->callbacks.udata_free != info2->callbacks.udata_free)
HGOTO_DONE(-1)
HGOTO_DONE(-1);
/* Check for different udata */
/* (Don't know how big it is, so can't check contents) */
if (info1->callbacks.udata < info2->callbacks.udata)
HGOTO_DONE(-1)
HGOTO_DONE(-1);
if (info1->callbacks.udata > info2->callbacks.udata)
HGOTO_DONE(1)
HGOTO_DONE(1);
/* Check buffer contents (instead of buffer pointers) */
if (info1->buffer != NULL && info2->buffer == NULL)
HGOTO_DONE(-1)
HGOTO_DONE(-1);
if (info1->buffer == NULL && info2->buffer != NULL)
HGOTO_DONE(1)
HGOTO_DONE(1);
if (info1->buffer != NULL && info2->buffer != NULL)
ret_value = memcmp(info1->buffer, info2->buffer, size);
@ -6210,9 +6210,9 @@ H5P__facc_vol_cmp(const void *_info1, const void *_info2, size_t H5_ATTR_UNUSED
/* Compare connectors */
if (NULL == (cls1 = (H5VL_class_t *)H5I_object(info1->connector_id)))
HGOTO_DONE(-1)
HGOTO_DONE(-1);
if (NULL == (cls2 = (H5VL_class_t *)H5I_object(info2->connector_id)))
HGOTO_DONE(1)
HGOTO_DONE(1);
status = H5VL_cmp_connector_cls(&cmp_value, cls1, cls2);
assert(status >= 0);
if (cmp_value != 0)

4
src/H5Pint.c
View File

@ -3332,7 +3332,7 @@ H5P_exist_plist(const H5P_genplist_t *plist, const char *name)
tclass = plist->pclass;
while (tclass != NULL) {
if (H5SL_search(tclass->props, name) != NULL)
HGOTO_DONE(TRUE)
HGOTO_DONE(TRUE);
/* Go up to parent class */
tclass = tclass->parent;
@ -3387,7 +3387,7 @@ H5P__exist_pclass(H5P_genclass_t *pclass, const char *name)
tclass = pclass->parent;
while (tclass != NULL) {
if (H5SL_search(tclass->props, name) != NULL)
HGOTO_DONE(TRUE)
HGOTO_DONE(TRUE);
/* Go up to parent class */
tclass = tclass->parent;

2
src/H5Plapl.c
View File

@ -1051,7 +1051,7 @@ H5Pget_elink_fapl(hid_t lapl_id)
HGOTO_ERROR(H5E_PLIST, H5E_CANTGET, FAIL, "can't get fapl for links")
done:
FUNC_LEAVE_API(ret_value);
FUNC_LEAVE_API(ret_value)
} /* end H5Pget_elink_fapl() */
/*-------------------------------------------------------------------------

6
src/H5Pocpypl.c
View File

@ -545,7 +545,7 @@ H5P__ocpy_merge_comm_dt_list_cmp(const void *_dt_list1, const void *_dt_list2, s
/* Compare paths */
ret_value = HDstrcmp(dt_list1->path, dt_list2->path);
if (ret_value != 0)
HGOTO_DONE(ret_value)
HGOTO_DONE(ret_value);
/* Advance to next node */
dt_list1 = dt_list1->next;
@ -554,9 +554,9 @@ H5P__ocpy_merge_comm_dt_list_cmp(const void *_dt_list1, const void *_dt_list2, s
/* Check if one list is longer than the other */
if (dt_list1)
HGOTO_DONE(1)
HGOTO_DONE(1);
if (dt_list2)
HGOTO_DONE(-1)
HGOTO_DONE(-1);
done:
FUNC_LEAVE_NOAPI(ret_value)

10
src/H5S.c
View File

@ -1862,11 +1862,11 @@ H5S_extent_equal(const H5S_t *ds1, const H5S_t *ds2)
/* Make certain the dataspaces are the same type */
if (ds1->extent.type != ds2->extent.type)
HGOTO_DONE(FALSE)
HGOTO_DONE(FALSE);
/* Make certain the dataspaces are the same rank */
if (ds1->extent.rank != ds2->extent.rank)
HGOTO_DONE(FALSE)
HGOTO_DONE(FALSE);
/* Make certain the dataspaces' current dimensions are the same size */
if (ds1->extent.rank > 0) {
@ -1874,7 +1874,7 @@ H5S_extent_equal(const H5S_t *ds1, const H5S_t *ds2)
assert(ds2->extent.size);
for (u = 0; u < ds1->extent.rank; u++)
if (ds1->extent.size[u] != ds2->extent.size[u])
HGOTO_DONE(FALSE)
HGOTO_DONE(FALSE);
} /* end if */
/* Make certain the dataspaces' maximum dimensions are the same size */
@ -1883,11 +1883,11 @@ H5S_extent_equal(const H5S_t *ds1, const H5S_t *ds2)
if (ds1->extent.max != NULL && ds2->extent.max != NULL) {
for (u = 0; u < ds1->extent.rank; u++)
if (ds1->extent.max[u] != ds2->extent.max[u])
HGOTO_DONE(FALSE)
HGOTO_DONE(FALSE);
} /* end if */
else if ((ds1->extent.max == NULL && ds2->extent.max != NULL) ||
(ds1->extent.max != NULL && ds2->extent.max == NULL))
HGOTO_DONE(FALSE)
HGOTO_DONE(FALSE);
} /* end if */
done:

24
src/H5SM.c
View File

@ -306,7 +306,7 @@ H5SM__get_index(const H5SM_master_table_t *table, unsigned type_id)
*/
for (x = 0; x < table->num_indexes; ++x)
if (table->indexes[x].mesg_types & type_flag)
HGOTO_DONE((ssize_t)x)
HGOTO_DONE((ssize_t)x);
/* At this point, ret_value is either the location of the correct
* index or it's still FAIL because we didn't find an index.
@ -351,14 +351,14 @@ H5SM_type_shared(H5F_t *f, unsigned type_id)
} /* end if */
else
/* No shared messages of any type */
HGOTO_DONE(FALSE)
HGOTO_DONE(FALSE);
/* Search the indexes until we find one that matches this flag or we've
* searched them all.
*/
for (u = 0; u < table->num_indexes; u++)
if (table->indexes[u].mesg_types & type_flag)
HGOTO_DONE(TRUE)
HGOTO_DONE(TRUE);
done:
/* Release the master SOHM table */
@ -876,13 +876,13 @@ 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 (!H5_addr_defined(H5F_SOHM_ADDR(f)))
HGOTO_DONE(FALSE)
HGOTO_DONE(FALSE);
/* Type-specific check */
if ((ret_value = H5O_msg_can_share(type_id, mesg)) < 0)
HGOTO_ERROR(H5E_SOHM, H5E_BADTYPE, FAIL, "can_share callback returned error")
if (ret_value == FALSE)
HGOTO_DONE(FALSE)
HGOTO_DONE(FALSE);
/* At this point, the message passes the "trivial" checks and is worth
* further checks.
@ -922,7 +922,7 @@ H5SM_can_share(H5F_t *f, H5SM_master_table_t *table, ssize_t *sohm_index_num, un
if ((tri_ret = H5SM__can_share_common(f, type_id, mesg)) < 0)
HGOTO_ERROR(H5E_SOHM, H5E_BADTYPE, FAIL, "'trivial' sharing checks returned error")
if (tri_ret == FALSE)
HGOTO_DONE(FALSE)
HGOTO_DONE(FALSE);
/* Look up the master SOHM table */
/* (use incoming master SOHM table if possible) */
@ -944,14 +944,14 @@ H5SM_can_share(H5F_t *f, H5SM_master_table_t *table, ssize_t *sohm_index_num, un
*/
if ((index_num = H5SM__get_index(my_table, type_id)) < 0) {
H5E_clear_stack(NULL); /*ignore error*/
HGOTO_DONE(FALSE)
HGOTO_DONE(FALSE);
} /* end if */
/* If the message isn't big enough, don't bother sharing it */
if (0 == (mesg_size = H5O_msg_raw_size(f, type_id, TRUE, mesg)))
HGOTO_ERROR(H5E_SOHM, H5E_BADMESG, FAIL, "unable to get OH message size")
if (mesg_size < my_table->indexes[index_num].min_mesg_size)
HGOTO_DONE(FALSE)
HGOTO_DONE(FALSE);
/* At this point, the message will be shared, set the index number if requested. */
if (sohm_index_num)
@ -1054,11 +1054,11 @@ H5SM_try_share(H5F_t *f, H5O_t *open_oh, unsigned defer_flags, unsigned type_id,
/* "trivial" sharing checks */
if (mesg_flags && (*mesg_flags & H5O_MSG_FLAG_DONTSHARE))
HGOTO_DONE(FALSE)
HGOTO_DONE(FALSE);
if ((tri_ret = H5SM__can_share_common(f, type_id, mesg)) < 0)
HGOTO_ERROR(H5E_SOHM, H5E_BADTYPE, FAIL, "'trivial' sharing checks returned error")
if (tri_ret == FALSE)
HGOTO_DONE(FALSE)
HGOTO_DONE(FALSE);
/* Set up user data for callback */
cache_udata.f = f;
@ -1072,7 +1072,7 @@ H5SM_try_share(H5F_t *f, H5O_t *open_oh, unsigned defer_flags, unsigned type_id,
if ((tri_ret = H5SM_can_share(f, table, &index_num, type_id, mesg)) < 0)
HGOTO_ERROR(H5E_SOHM, H5E_BADTYPE, FAIL, "'complex' sharing checks returned error")
if (tri_ret == FALSE)
HGOTO_DONE(FALSE)
HGOTO_DONE(FALSE);
/* At this point, the message will be shared. */
@ -1631,7 +1631,7 @@ H5SM__find_in_list(const H5SM_list_t *list, const H5SM_mesg_key_t *key, size_t *
if (0 == cmp) {
*pos = x;
HGOTO_DONE(SUCCEED)
HGOTO_DONE(SUCCEED);
}
}
else if (empty_pos && list->messages[x].location == H5SM_NO_LOC) {

4
src/H5Sall.c
View File

@ -918,7 +918,7 @@ H5S__all_shape_same(H5S_t *space1, H5S_t *space2)
*/
while (space2_dim >= 0) {
if (space1->extent.size[space1_dim] != space2->extent.size[space2_dim])
HGOTO_DONE(FALSE)
HGOTO_DONE(FALSE);
space1_dim--;
space2_dim--;
@ -929,7 +929,7 @@ H5S__all_shape_same(H5S_t *space1, H5S_t *space2)
*/
while (space1_dim >= 0) {
if (space1->extent.size[space1_dim] != 1)
HGOTO_DONE(FALSE)
HGOTO_DONE(FALSE);
space1_dim--;
} /* end while */

72
src/H5Shyper.c
View File

@ -3009,16 +3009,16 @@ H5S__hyper_cmp_spans(const H5S_hyper_span_info_t *span_info1, const H5S_hyper_sp
if (span_info1 != span_info2) {
/* Check for one span being NULL */
if (span_info1 == NULL || span_info2 == NULL)
HGOTO_DONE(FALSE)
HGOTO_DONE(FALSE);
else {
/* Compare low & high bounds for this span list */
/* (Could compare lower dimensions also, but not certain if
* that's worth it. - QAK, 2019/01/23)
*/
if (span_info1->low_bounds[0] != span_info2->low_bounds[0])
HGOTO_DONE(FALSE)
HGOTO_DONE(FALSE);
else if (span_info1->high_bounds[0] != span_info2->high_bounds[0])
HGOTO_DONE(FALSE)
HGOTO_DONE(FALSE);
else {
const H5S_hyper_span_t *span1;
const H5S_hyper_span_t *span2;
@ -3035,19 +3035,19 @@ H5S__hyper_cmp_spans(const H5S_hyper_span_info_t *span_info1, const H5S_hyper_sp
while (1) {
/* Check for both spans being NULL */
if (span1 == NULL && span2 == NULL)
HGOTO_DONE(TRUE)
HGOTO_DONE(TRUE);
else {
/* Check for one span being NULL */
if (span1 == NULL || span2 == NULL)
HGOTO_DONE(FALSE)
HGOTO_DONE(FALSE);
else {
/* Check if the actual low & high span information is the same */
if (span1->low != span2->low || span1->high != span2->high)
HGOTO_DONE(FALSE)
HGOTO_DONE(FALSE);
else {
if (span1->down != NULL || span2->down != NULL) {
if (!H5S__hyper_cmp_spans(span1->down, span2->down))
HGOTO_DONE(FALSE)
HGOTO_DONE(FALSE);
else {
/* Keep going... */
} /* end else */
@ -3283,7 +3283,7 @@ H5S__hyper_is_valid(const H5S_t *space)
/* Check for unlimited selection */
if (space->select.sel_info.hslab->unlim_dim >= 0)
HGOTO_DONE(FALSE)
HGOTO_DONE(FALSE);
/* Check which set of low & high bounds we should be using */
if (space->select.sel_info.hslab->diminfo_valid == H5S_DIMINFO_VALID_YES) {
@ -3299,9 +3299,9 @@ H5S__hyper_is_valid(const H5S_t *space)
for (u = 0; u < space->extent.rank; u++) {
/* Bounds check the selected point + offset against the extent */
if (((hssize_t)low_bounds[u] + space->select.offset[u]) < 0)
HGOTO_DONE(FALSE)
HGOTO_DONE(FALSE);
if ((high_bounds[u] + (hsize_t)space->select.offset[u]) >= space->extent.size[u])
HGOTO_DONE(FALSE)
HGOTO_DONE(FALSE);
} /* end for */
done:
@ -5331,7 +5331,7 @@ H5S__hyper_is_single(const H5S_t *space)
/* Check for a single block */
for (u = 0; u < space->extent.rank; u++)
if (space->select.sel_info.hslab->diminfo.opt[u].count > 1)
HGOTO_DONE(FALSE)
HGOTO_DONE(FALSE);
} /* end if */
else {
H5S_hyper_span_info_t *spans; /* Hyperslab span info node */
@ -5350,7 +5350,7 @@ H5S__hyper_is_single(const H5S_t *space)
/* Check that this is the only span and it spans the entire dimension */
if (span->next != NULL)
HGOTO_DONE(FALSE)
HGOTO_DONE(FALSE);
else
/* Walk down to the next span */
spans = span->down;
@ -5450,9 +5450,9 @@ H5S__hyper_spans_shape_same_helper(const H5S_hyper_span_info_t *span_info1,
* that's worth it. - QAK, 2019/01/23)
*/
if ((hsize_t)((hssize_t)span_info1->low_bounds[0] + offset[0]) != span_info2->low_bounds[0])
HGOTO_DONE(FALSE)
HGOTO_DONE(FALSE);
else if ((hsize_t)((hssize_t)span_info1->high_bounds[0] + offset[0]) != span_info2->high_bounds[0])
HGOTO_DONE(FALSE)
HGOTO_DONE(FALSE);
else {
const H5S_hyper_span_t *span1;
const H5S_hyper_span_t *span2;
@ -5469,23 +5469,23 @@ H5S__hyper_spans_shape_same_helper(const H5S_hyper_span_info_t *span_info1,
while (1) {
/* Check for both spans being NULL */
if (span1 == NULL && span2 == NULL)
HGOTO_DONE(TRUE)
HGOTO_DONE(TRUE);
/* Check for one span being NULL */
if (span1 == NULL || span2 == NULL)
HGOTO_DONE(FALSE)
HGOTO_DONE(FALSE);
/* Check if the actual low & high span information is the same */
if ((hsize_t)((hssize_t)span1->low + offset[0]) != span2->low ||
(hsize_t)((hssize_t)span1->high + offset[0]) != span2->high)
HGOTO_DONE(FALSE)
HGOTO_DONE(FALSE);
/* Check for down tree for this span */
if (span1->down != NULL || span2->down != NULL) {
/* If the rest of the span trees have a zero offset, use the faster comparison routine */
if (rest_zeros[0]) {
if (!H5S__hyper_cmp_spans(span1->down, span2->down))
HGOTO_DONE(FALSE)
HGOTO_DONE(FALSE);
else {
/* Keep going... */
} /* end else */
@ -5493,7 +5493,7 @@ H5S__hyper_spans_shape_same_helper(const H5S_hyper_span_info_t *span_info1,
else {
if (!H5S__hyper_spans_shape_same_helper(span1->down, span2->down, &offset[1],
&rest_zeros[1]))
HGOTO_DONE(FALSE)
HGOTO_DONE(FALSE);
else {
/* Keep going... */
} /* end else */
@ -5679,15 +5679,15 @@ H5S__hyper_shape_same(H5S_t *space1, H5S_t *space2)
while (space2_dim >= 0) {
if (space1->select.sel_info.hslab->diminfo.opt[space1_dim].stride !=
space2->select.sel_info.hslab->diminfo.opt[space2_dim].stride)
HGOTO_DONE(FALSE)
HGOTO_DONE(FALSE);
if (space1->select.sel_info.hslab->diminfo.opt[space1_dim].count !=
space2->select.sel_info.hslab->diminfo.opt[space2_dim].count)
HGOTO_DONE(FALSE)
HGOTO_DONE(FALSE);
if (space1->select.sel_info.hslab->diminfo.opt[space1_dim].block !=
space2->select.sel_info.hslab->diminfo.opt[space2_dim].block)
HGOTO_DONE(FALSE)
HGOTO_DONE(FALSE);
space1_dim--;
space2_dim--;
@ -5695,7 +5695,7 @@ H5S__hyper_shape_same(H5S_t *space1, H5S_t *space2)
while (space1_dim >= 0) {
if (space1->select.sel_info.hslab->diminfo.opt[space1_dim].block != 1)
HGOTO_DONE(FALSE)
HGOTO_DONE(FALSE);
space1_dim--;
} /* end while */
@ -5731,11 +5731,11 @@ H5S__hyper_shape_same(H5S_t *space1, H5S_t *space2)
/* Check for more spans in this dimension */
if (span->next)
HGOTO_DONE(FALSE)
HGOTO_DONE(FALSE);
/* Check for span size > 1 element */
if (span->low != span->high)
HGOTO_DONE(FALSE)
HGOTO_DONE(FALSE);
/* Walk down to the next dimension */
spans1 = span->down;
@ -6254,7 +6254,7 @@ H5S__hyper_intersect_block_helper(H5S_hyper_span_info_t *spans, unsigned rank, c
*/
for (u = 0; u < rank; u++)
if (start[u] > spans->high_bounds[u] || end[u] < spans->low_bounds[u])
HGOTO_DONE(FALSE)
HGOTO_DONE(FALSE);
/* Get the span list for spans in this tree */
curr = spans->head;
@ -6267,12 +6267,12 @@ H5S__hyper_intersect_block_helper(H5S_hyper_span_info_t *spans, unsigned rank, c
curr = curr->next;
/* If this span is past the end of the block, then we're done in this dimension */
else if (curr->low > *end)
HGOTO_DONE(FALSE)
HGOTO_DONE(FALSE);
/* block & span overlap */
else {
/* If this is the bottom dimension, then the span tree overlaps the block */
if (curr->down == NULL)
HGOTO_DONE(TRUE)
HGOTO_DONE(TRUE);
/* Recursively check spans in next dimension down */
else {
/* If there is an intersection in the "down" dimensions,
@ -6280,7 +6280,7 @@ H5S__hyper_intersect_block_helper(H5S_hyper_span_info_t *spans, unsigned rank, c
*/
if (H5S__hyper_intersect_block_helper(curr->down, rank - 1, start + 1, end + 1, op_info_i,
op_gen))
HGOTO_DONE(TRUE)
HGOTO_DONE(TRUE);
/* No intersection in down dimensions, advance to next span */
curr = curr->next;
@ -6357,7 +6357,7 @@ H5S__hyper_intersect_block(H5S_t *space, const hsize_t *start, const hsize_t *en
* would have been rejected earlier, if they didn't intersect.
*/
if (single_block)
HGOTO_DONE(TRUE)
HGOTO_DONE(TRUE);
else {
/* Loop over the dimensions, checking for an intersection */
for (u = 0; u < space->extent.rank; u++) {
@ -6402,7 +6402,7 @@ H5S__hyper_intersect_block(H5S_t *space, const hsize_t *start, const hsize_t *en
* it doesn't intersect.
*/
if (adj_end < space->select.sel_info.hslab->diminfo.opt[u].stride)
HGOTO_DONE(FALSE)
HGOTO_DONE(FALSE);
} /* end if */
} /* end if */
} /* end for */
@ -6410,7 +6410,7 @@ H5S__hyper_intersect_block(H5S_t *space, const hsize_t *start, const hsize_t *en
/* If we've looped through all dimensions and none of them didn't
* overlap, then all of them do, so we report TRUE.
*/
HGOTO_DONE(TRUE)
HGOTO_DONE(TRUE);
} /* end else */
} /* end if */
else {
@ -8977,7 +8977,7 @@ H5S__hyper_rebuild_helper(const H5S_hyper_span_info_t *spans, H5S_hyper_dim_t sp
if (span->down)
/* Go to the next down span and check whether the selection can be rebuilt */
if (!H5S__hyper_rebuild_helper(span->down, &span_slab_info[1]))
HGOTO_DONE(FALSE)
HGOTO_DONE(FALSE);
/* Assign the initial starting point & block size for this dimension */
start = span->low;
@ -8997,7 +8997,7 @@ H5S__hyper_rebuild_helper(const H5S_hyper_span_info_t *spans, H5S_hyper_dim_t sp
/* (Can skip check if previous span's down pointer is same as current one) */
if (span->down && prev_span->down != span->down)
if (!H5S__hyper_cmp_spans(span->down, prev_span->down))
HGOTO_DONE(FALSE)
HGOTO_DONE(FALSE);
/* Obtain values for stride and block */
curr_stride = span->low - prev_low;
@ -9007,10 +9007,10 @@ H5S__hyper_rebuild_helper(const H5S_hyper_span_info_t *spans, H5S_hyper_dim_t sp
* three spans are needed. Account for the first two spans.
*/
if (curr_block != block)
HGOTO_DONE(FALSE)
HGOTO_DONE(FALSE);
if (spancount > 1) {
if (stride != curr_stride)
HGOTO_DONE(FALSE)
HGOTO_DONE(FALSE);
} /* end if */
else
stride = curr_stride;

10
src/H5Smpio.c
View File

@ -695,7 +695,7 @@ H5S__mpio_reg_hyper_type(H5S_t *space, size_t elmt_size, MPI_Datatype *new_type,
fprintf(H5DEBUG(S), "%s: Flattened selection\n", __func__);
#endif
for (u = 0; u < rank; ++u) {
H5_CHECK_OVERFLOW(diminfo[u].start, hsize_t, hssize_t)
H5_CHECK_OVERFLOW(diminfo[u].start, hsize_t, hssize_t);
d[u].start = (hssize_t)diminfo[u].start + sel_iter->u.hyp.sel_off[u];
d[u].strid = diminfo[u].stride;
d[u].block = diminfo[u].block;
@ -729,7 +729,7 @@ H5S__mpio_reg_hyper_type(H5S_t *space, size_t elmt_size, MPI_Datatype *new_type,
fprintf(H5DEBUG(S), "%s: Non-flattened selection\n", __func__);
#endif
for (u = 0; u < rank; ++u) {
H5_CHECK_OVERFLOW(diminfo[u].start, hsize_t, hssize_t)
H5_CHECK_OVERFLOW(diminfo[u].start, hsize_t, hssize_t);
d[u].start = (hssize_t)diminfo[u].start + space->select.offset[u];
d[u].strid = diminfo[u].stride;
d[u].block = diminfo[u].block;
@ -1178,7 +1178,7 @@ H5S__obtain_datatype(H5S_hyper_span_info_t *spans, const hsize_t *down, size_t e
/* Store displacement & block length */
disp[outercount] = (MPI_Aint)elmt_size * (MPI_Aint)span->low;
H5_CHECK_OVERFLOW(nelmts, hsize_t, int)
H5_CHECK_OVERFLOW(nelmts, hsize_t, int);
blocklen[outercount] = (int)nelmts;
if (bigio_count < (hsize_t)blocklen[outercount])
@ -1287,7 +1287,7 @@ H5S__obtain_datatype(H5S_hyper_span_info_t *spans, const hsize_t *down, size_t e
nelmts = (span->high - span->low) + 1;
/* Build the MPI datatype for this node */
H5_CHECK_OVERFLOW(nelmts, hsize_t, int)
H5_CHECK_OVERFLOW(nelmts, hsize_t, int);
if (MPI_SUCCESS != (mpi_code = MPI_Type_create_hvector((int)nelmts, 1, stride, down_type,
&inner_type[outercount])))
HMPI_GOTO_ERROR(FAIL, "MPI_Type_create_hvector failed", mpi_code)
@ -1297,7 +1297,7 @@ H5S__obtain_datatype(H5S_hyper_span_info_t *spans, const hsize_t *down, size_t e
} /* end while */
/* Building the whole vector datatype */
H5_CHECK_OVERFLOW(outercount, size_t, int)
H5_CHECK_OVERFLOW(outercount, size_t, int);
if (MPI_SUCCESS != (mpi_code = MPI_Type_create_struct((int)outercount, blocklen, disp, inner_type,
&spans->op_info[op_info_i].u.down_type)))
HMPI_GOTO_ERROR(FAIL, "MPI_Type_create_struct failed", mpi_code)

10
src/H5Spoint.c
View File

@ -958,9 +958,9 @@ H5S__point_is_valid(const H5S_t *space)
/* Bounds check the selected point + offset against the extent */
if ((space->select.sel_info.pnt_lst->high_bounds[u] + (hsize_t)space->select.offset[u]) >
space->extent.size[u])
HGOTO_DONE(FALSE)
HGOTO_DONE(FALSE);
if (((hssize_t)space->select.sel_info.pnt_lst->low_bounds[u] + space->select.offset[u]) < 0)
HGOTO_DONE(FALSE)
HGOTO_DONE(FALSE);
} /* end for */
done:
@ -1988,7 +1988,7 @@ H5S__point_shape_same(H5S_t *space1, H5S_t *space2)
/* Compare locations in common dimensions, including relative offset */
while (space2_dim >= 0) {
if ((hsize_t)((hssize_t)pnt1->pnt[space1_dim] + offset[space1_dim]) != pnt2->pnt[space2_dim])
HGOTO_DONE(FALSE)
HGOTO_DONE(FALSE);
space1_dim--;
space2_dim--;
@ -1998,7 +1998,7 @@ H5S__point_shape_same(H5S_t *space1, H5S_t *space2)
while (space1_dim >= 0) {
/* Compare the absolute offset in the remaining dimensions */
if ((hssize_t)pnt1->pnt[space1_dim] != offset[space1_dim])
HGOTO_DONE(FALSE)
HGOTO_DONE(FALSE);
space1_dim--;
} /* end while */
@ -2057,7 +2057,7 @@ H5S__point_intersect_block(H5S_t *space, const hsize_t *start, const hsize_t *en
/* Check if point was within block for all dimensions */
if (u == space->extent.rank)
HGOTO_DONE(TRUE)
HGOTO_DONE(TRUE);
/* Advance to next point */
pnt = pnt->next;

22
src/H5Sselect.c
View File

@ -1613,7 +1613,7 @@ H5S_select_shape_same(H5S_t *space1, H5S_t *space2)
/* Check for different number of elements selected */
if (H5S_GET_SELECT_NPOINTS(space1) != H5S_GET_SELECT_NPOINTS(space2))
HGOTO_DONE(FALSE)
HGOTO_DONE(FALSE);
/* Check special cases if both dataspaces aren't scalar */
/* (If only one is, the number of selected points check is sufficient) */
@ -1683,7 +1683,7 @@ H5S_select_shape_same(H5S_t *space1, H5S_t *space2)
/* Verify that the ranges are the same */
if ((high_a[space_a_dim] - low_a[space_a_dim]) != (high_b[space_b_dim] - low_b[space_b_dim]))
HGOTO_DONE(FALSE)
HGOTO_DONE(FALSE);
/* Go to next dimension */
space_a_dim--;
@ -1697,7 +1697,7 @@ H5S_select_shape_same(H5S_t *space1, H5S_t *space2)
/* This range should be flat to be the same in a lower dimension */
if (low_a[space_a_dim] != high_a[space_a_dim])
HGOTO_DONE(FALSE)
HGOTO_DONE(FALSE);
space_a_dim--;
} /* end while */
@ -1708,7 +1708,7 @@ H5S_select_shape_same(H5S_t *space1, H5S_t *space2)
* the same, then the selections are the same, even if the
* selection types are different.
*/
HGOTO_DONE(TRUE)
HGOTO_DONE(TRUE);
} /* end if */
} /* end if */
@ -1767,7 +1767,7 @@ H5S_select_shape_same(H5S_t *space1, H5S_t *space2)
while (space_b_dim >= 0) {
if ((end_a[space_a_dim] - start_a[space_a_dim]) !=
(end_b[space_b_dim] - start_b[space_b_dim]))
HGOTO_DONE(FALSE)
HGOTO_DONE(FALSE);
/* Set the relative locations of the selections */
offset[space_a_dim] = (hssize_t)start_b[space_b_dim] - (hssize_t)start_a[space_a_dim];
@ -1781,7 +1781,7 @@ H5S_select_shape_same(H5S_t *space1, H5S_t *space2)
*/
while (space_a_dim >= 0) {
if (start_a[space_a_dim] != end_a[space_a_dim])
HGOTO_DONE(FALSE)
HGOTO_DONE(FALSE);
space_a_dim--;
} /* end while */
@ -1796,12 +1796,12 @@ H5S_select_shape_same(H5S_t *space1, H5S_t *space2)
/* Check if the blocks are in the same relative location */
if ((hsize_t)((hssize_t)start_a[space_a_dim] + offset[space_a_dim]) !=
start_b[space_b_dim])
HGOTO_DONE(FALSE)
HGOTO_DONE(FALSE);
/* If the block sizes from each selection doesn't match, get out */
if ((end_a[space_a_dim] - start_a[space_a_dim]) !=
(end_b[space_b_dim] - start_b[space_b_dim]))
HGOTO_DONE(FALSE)
HGOTO_DONE(FALSE);
space_a_dim--;
space_b_dim--;
@ -1811,7 +1811,7 @@ H5S_select_shape_same(H5S_t *space1, H5S_t *space2)
while (space_a_dim >= 0) {
/* If the block size isn't 1, get out */
if (start_a[space_a_dim] != end_a[space_a_dim])
HGOTO_DONE(FALSE)
HGOTO_DONE(FALSE);
space_a_dim--;
} /* end while */
@ -1828,7 +1828,7 @@ H5S_select_shape_same(H5S_t *space1, H5S_t *space2)
if ((status_a == FALSE) && (status_b == FALSE))
break;
else if (status_a != status_b)
HGOTO_DONE(FALSE)
HGOTO_DONE(FALSE);
else {
/* Advance to next block in selection iterators */
if (H5S_SELECT_ITER_NEXT_BLOCK(iter_a) < 0)
@ -1946,7 +1946,7 @@ H5S_select_intersect_block(H5S_t *space, const hsize_t *start, const hsize_t *en
for (u = 0; u < space->extent.rank; u++)
/* If selection bounds & block don't overlap, can leave now */
if (!H5S_RANGE_OVERLAP(low[u], high[u], start[u], end[u]))
HGOTO_DONE(FALSE)
HGOTO_DONE(FALSE);
} /* end if */
/* Call selection type's intersect routine */

2
src/H5Tcompound.c
View File

@ -496,7 +496,7 @@ H5T__pack(const H5T_t *dt)
if (H5T_detect_class(dt, H5T_COMPOUND, FALSE) > 0) {
/* If datatype has been packed, skip packing it and indicate success */
if (TRUE == H5T__is_packed(dt))
HGOTO_DONE(SUCCEED)
HGOTO_DONE(SUCCEED);
/* Check for packing unmodifiable datatype */
if (H5T_STATE_TRANSIENT != dt->shared->state)

1401
src/H5Tconv.c
View File

File diff suppressed because it is too large Load Diff

4
src/H5Tfields.c
View File

@ -216,12 +216,12 @@ H5Tget_member_index(hid_t type_id, const char *name)
case H5T_COMPOUND:
for (i = 0; i < dt->shared->u.compnd.nmembs; i++)
if (!HDstrcmp(dt->shared->u.compnd.memb[i].name, name))
HGOTO_DONE((int)i)
HGOTO_DONE((int)i);
break;
case H5T_ENUM:
for (i = 0; i < dt->shared->u.enumer.nmembs; i++)
if (!HDstrcmp(dt->shared->u.enumer.name[i], name))
HGOTO_DONE((int)i)
HGOTO_DONE((int)i);
break;
case H5T_NO_CLASS:

2
src/H5Tref.c
View File

@ -170,7 +170,7 @@ H5T__ref_set_loc(H5T_t *dt, H5VL_object_t *file, H5T_loc_t loc)
/* Only change the location if it's different */
if (loc == dt->shared->u.atomic.u.r.loc && file == dt->shared->u.atomic.u.r.file)
HGOTO_DONE(FALSE)
HGOTO_DONE(FALSE);
switch (loc) {
case H5T_LOC_MEMORY: /* Memory based reference datatype */

18
src/H5VLint.c
View File

@ -1953,45 +1953,45 @@ H5VL_cmp_connector_cls(int *cmp_value, const H5VL_class_t *cls1, const H5VL_clas
/* Compare connector "values" */
if (cls1->value < cls2->value) {
*cmp_value = -1;
HGOTO_DONE(SUCCEED)
HGOTO_DONE(SUCCEED);
} /* end if */
if (cls1->value > cls2->value) {
*cmp_value = 1;
HGOTO_DONE(SUCCEED)
HGOTO_DONE(SUCCEED);
} /* end if */
assert(cls1->value == cls2->value);
/* Compare connector names */
if (cls1->name == NULL && cls2->name != NULL) {
*cmp_value = -1;
HGOTO_DONE(SUCCEED)
HGOTO_DONE(SUCCEED);
} /* end if */
if (cls1->name != NULL && cls2->name == NULL) {
*cmp_value = 1;
HGOTO_DONE(SUCCEED)
HGOTO_DONE(SUCCEED);
} /* end if */
if (0 != (*cmp_value = HDstrcmp(cls1->name, cls2->name)))
HGOTO_DONE(SUCCEED)
HGOTO_DONE(SUCCEED);
/* Compare connector VOL API versions */
if (cls1->version < cls2->version) {
*cmp_value = -1;
HGOTO_DONE(SUCCEED)
HGOTO_DONE(SUCCEED);
} /* end if */
if (cls1->version > cls2->version) {
*cmp_value = 1;
HGOTO_DONE(SUCCEED)
HGOTO_DONE(SUCCEED);
} /* end if */
assert(cls1->version == cls2->version);
/* Compare connector info */
if (cls1->info_cls.size < cls2->info_cls.size) {
*cmp_value = -1;
HGOTO_DONE(SUCCEED)
HGOTO_DONE(SUCCEED);
} /* end if */
if (cls1->info_cls.size > cls2->info_cls.size) {
*cmp_value = 1;
HGOTO_DONE(SUCCEED)
HGOTO_DONE(SUCCEED);
} /* end if */
assert(cls1->info_cls.size == cls2->info_cls.size);

10
src/H5VM.c
View File

@ -307,17 +307,17 @@ H5VM_hyper_eq(unsigned n, const hsize_t *offset1, const hsize_t *size1, const hs
FUNC_ENTER_NOAPI_NOINIT_NOERR
if (n == 0)
HGOTO_DONE(TRUE)
HGOTO_DONE(TRUE);
for (i = 0; i < n; i++) {
if ((offset1 ? offset1[i] : 0) != (offset2 ? offset2[i] : 0))
HGOTO_DONE(FALSE)
HGOTO_DONE(FALSE);
if ((size1 ? size1[i] : 0) != (size2 ? size2[i] : 0))
HGOTO_DONE(FALSE)
HGOTO_DONE(FALSE);
if (0 == (nelmts1 *= (size1 ? size1[i] : 0)))
HGOTO_DONE(FALSE)
HGOTO_DONE(FALSE);
if (0 == (nelmts2 *= (size2 ? size2[i] : 0)))
HGOTO_DONE(FALSE)
HGOTO_DONE(FALSE);
}
done:

30
src/H5VMprivate.h
View File

@ -142,7 +142,7 @@ H5VM_vector_reduce_product(unsigned n, const hsize_t *v)
FUNC_ENTER_NOAPI_NOINIT_NOERR
if (n && !v)
HGOTO_DONE(0)
HGOTO_DONE(0);
while (n--)
ret_value *= *v++;
@ -172,10 +172,10 @@ H5VM_vector_zerop_u(int n, const hsize_t *v)
FUNC_ENTER_NOAPI_NOINIT_NOERR
if (!v)
HGOTO_DONE(TRUE)
HGOTO_DONE(TRUE);
while (n--)
if (*v++)
HGOTO_DONE(FALSE)
HGOTO_DONE(FALSE);
done:
FUNC_LEAVE_NOAPI(ret_value)
@ -204,10 +204,10 @@ H5VM_vector_zerop_s(int n, const hssize_t *v)
FUNC_ENTER_NOAPI_NOINIT_NOERR
if (!v)
HGOTO_DONE(TRUE)
HGOTO_DONE(TRUE);
while (n--)
if (*v++)
HGOTO_DONE(FALSE)
HGOTO_DONE(FALSE);
done:
FUNC_LEAVE_NOAPI(ret_value)
@ -239,16 +239,16 @@ H5VM_vector_cmp_u(unsigned n, const hsize_t *v1, const hsize_t *v2)
FUNC_ENTER_NOAPI_NOINIT_NOERR
if (v1 == v2)
HGOTO_DONE(0)
HGOTO_DONE(0);
if (v1 == NULL)
HGOTO_DONE(-1)
HGOTO_DONE(-1);
if (v2 == NULL)
HGOTO_DONE(1)
HGOTO_DONE(1);
while (n--) {
if (*v1 < *v2)
HGOTO_DONE(-1)
HGOTO_DONE(-1);
if (*v1 > *v2)
HGOTO_DONE(1)
HGOTO_DONE(1);
v1++;
v2++;
}
@ -283,16 +283,16 @@ H5VM_vector_cmp_s(unsigned n, const hssize_t *v1, const hssize_t *v2)
FUNC_ENTER_NOAPI_NOINIT_NOERR
if (v1 == v2)
HGOTO_DONE(0)
HGOTO_DONE(0);
if (v1 == NULL)
HGOTO_DONE(-1)
HGOTO_DONE(-1);
if (v2 == NULL)
HGOTO_DONE(1)
HGOTO_DONE(1);
while (n--) {
if (*v1 < *v2)
HGOTO_DONE(-1)
HGOTO_DONE(-1);
if (*v1 > *v2)
HGOTO_DONE(1)
HGOTO_DONE(1);
v1++;
v2++;
}

Some files were not shown because too many files have changed in this diff Show More