diff options
Diffstat (limited to 'src/H5Shyper.c')
| -rw-r--r-- | src/H5Shyper.c | 5543 |
1 files changed, 2806 insertions, 2737 deletions
diff --git a/src/H5Shyper.c b/src/H5Shyper.c index e5de33a..56a8b14 100644 --- a/src/H5Shyper.c +++ b/src/H5Shyper.c @@ -22,21 +22,19 @@ /* Module Setup */ /****************/ -#include "H5Smodule.h" /* This source code file is part of the H5S module */ - +#include "H5Smodule.h" /* This source code file is part of the H5S module */ /***********/ /* Headers */ /***********/ -#include "H5private.h" /* Generic Functions */ -#include "H5CXprivate.h" /* API Contexts */ -#include "H5Eprivate.h" /* Error handling */ -#include "H5FLprivate.h" /* Free Lists */ -#include "H5Iprivate.h" /* ID Functions */ -#include "H5MMprivate.h" /* Memory management */ -#include "H5Spkg.h" /* Dataspace functions */ -#include "H5VMprivate.h" /* Vector functions */ - +#include "H5private.h" /* Generic Functions */ +#include "H5CXprivate.h" /* API Contexts */ +#include "H5Eprivate.h" /* Error handling */ +#include "H5FLprivate.h" /* Free Lists */ +#include "H5Iprivate.h" /* ID Functions */ +#include "H5MMprivate.h" /* Memory management */ +#include "H5Spkg.h" /* Dataspace functions */ +#include "H5VMprivate.h" /* Vector functions */ /****************/ /* Local Macros */ @@ -48,32 +46,31 @@ #define H5S_HYPER_COMPUTE_A_NOT_B 0x04 /* Macro to advance a span, possibly recycling it first */ -#define H5S_HYPER_ADVANCE_SPAN(recover, curr_span, next_span) \ - do { \ - H5S_hyper_span_t *saved_next_span = (next_span); \ - \ - /* Check if the span should be recovered */ \ - if(recover) { \ - H5S__hyper_free_span(curr_span); \ - (recover) = FALSE; \ - } /* end if */ \ - \ - /* Set the current span to saved next span */ \ - (curr_span) = saved_next_span; \ - } while(0) +#define H5S_HYPER_ADVANCE_SPAN(recover, curr_span, next_span) \ + do { \ + H5S_hyper_span_t *saved_next_span = (next_span); \ + \ + /* Check if the span should be recovered */ \ + if (recover) { \ + H5S__hyper_free_span(curr_span); \ + (recover) = FALSE; \ + } /* end if */ \ + \ + /* Set the current span to saved next span */ \ + (curr_span) = saved_next_span; \ + } while (0) /* Macro to add "skipped" elements to projection during the execution of * H5S__hyper_project_intersect() */ -#define H5S_HYPER_PROJ_INT_ADD_SKIP(UDATA, ADD, ERR) \ - do { \ - /* If there are any elements to add, we must add them \ - * to the projection first before adding skip */ \ - if((UDATA)->nelem > 0) \ - if(H5S__hyper_proj_int_build_proj(UDATA) < 0) \ +#define H5S_HYPER_PROJ_INT_ADD_SKIP(UDATA, ADD, ERR) \ + do { \ + /* If there are any elements to add, we must add them \ + * to the projection first before adding skip */ \ + if ((UDATA)->nelem > 0) \ + if (H5S__hyper_proj_int_build_proj(UDATA) < 0) \ HGOTO_ERROR(H5E_DATASPACE, H5E_CANTAPPEND, ERR, "can't add elements to projected selection") \ - (UDATA)->skip += (ADD); \ - } while(0) /* end H5S_HYPER_PROJ_INT_ADD_SKIP() */ - + (UDATA)->skip += (ADD); \ + } while (0) /* end H5S_HYPER_PROJ_INT_ADD_SKIP() */ /******************/ /* Local Typedefs */ @@ -86,17 +83,20 @@ typedef hsize_t hbounds_t; /* Struct for holding persistent information during iteration for * H5S__hyper_project_intersect() */ typedef struct { - const H5S_hyper_span_t *ds_span[H5S_MAX_RANK]; /* Array of the current spans in the destination space in each dimension */ + const H5S_hyper_span_t + * ds_span[H5S_MAX_RANK]; /* Array of the current spans in the destination space in each dimension */ hsize_t ds_low[H5S_MAX_RANK]; /* Array of current low bounds (of iteration) for each element in ds_span */ - H5S_hyper_span_info_t *ps_span_info[H5S_MAX_RANK]; /* Array of span info structs for projected space during iteration */ - uint32_t ps_clean_bitmap; /* Bitmap of whether the nth rank has a clean projected space since the last time it was set to 1 */ - unsigned ss_rank; /* Rank of source space */ - unsigned ds_rank; /* Rank of destination space */ - unsigned depth; /* Current depth of iterator in destination space */ - hsize_t skip; /* Number of elements to skip in projected space */ - hsize_t nelem; /* Number of elements to add to projected space (after skip) */ - uint64_t op_gen; /* Operation generation for counting elements */ - hbool_t share_selection; /* Whether span trees in dst_space can be shared with proj_space */ + H5S_hyper_span_info_t + * ps_span_info[H5S_MAX_RANK]; /* Array of span info structs for projected space during iteration */ + uint32_t ps_clean_bitmap; /* Bitmap of whether the nth rank has a clean projected space since the last + time it was set to 1 */ + unsigned ss_rank; /* Rank of source space */ + unsigned ds_rank; /* Rank of destination space */ + unsigned depth; /* Current depth of iterator in destination space */ + hsize_t skip; /* Number of elements to skip in projected space */ + hsize_t nelem; /* Number of elements to add to projected space (after skip) */ + uint64_t op_gen; /* Operation generation for counting elements */ + hbool_t share_selection; /* Whether span trees in dst_space can be shared with proj_space */ } H5S_hyper_project_intersect_ud_t; /* Assert that H5S_MAX_RANK is <= 32 so our trick with using a 32 bit bitmap @@ -106,116 +106,106 @@ typedef struct { #error H5S_MAX_RANK too large for ps_clean_bitmap field in H5S_hyper_project_intersect_ud_t struct #endif - /********************/ /* Local Prototypes */ /********************/ -static H5S_hyper_span_t *H5S__hyper_new_span(hsize_t low, hsize_t high, - H5S_hyper_span_info_t *down, H5S_hyper_span_t *next); +static H5S_hyper_span_t * H5S__hyper_new_span(hsize_t low, hsize_t high, H5S_hyper_span_info_t *down, + H5S_hyper_span_t *next); static H5S_hyper_span_info_t *H5S__hyper_new_span_info(unsigned rank); -static H5S_hyper_span_info_t *H5S__hyper_copy_span_helper( - H5S_hyper_span_info_t *spans, unsigned rank, unsigned op_info_i, - uint64_t op_gen); -static H5S_hyper_span_info_t *H5S__hyper_copy_span(H5S_hyper_span_info_t *spans, - unsigned rank); -static hbool_t H5S__hyper_cmp_spans(const H5S_hyper_span_info_t *span_info1, - const H5S_hyper_span_info_t *span_info2); -static void H5S__hyper_free_span_info(H5S_hyper_span_info_t *span_info); -static void H5S__hyper_free_span(H5S_hyper_span_t *span); -static herr_t H5S__hyper_span_blocklist(const H5S_hyper_span_info_t *spans, - hsize_t start[], hsize_t end[], hsize_t rank, hsize_t *startblock, hsize_t *numblocks, - hsize_t **buf); -static herr_t H5S__get_select_hyper_blocklist(H5S_t *space, hsize_t startblock, - hsize_t numblocks, hsize_t *buf); +static H5S_hyper_span_info_t *H5S__hyper_copy_span_helper(H5S_hyper_span_info_t *spans, unsigned rank, + unsigned op_info_i, uint64_t op_gen); +static H5S_hyper_span_info_t *H5S__hyper_copy_span(H5S_hyper_span_info_t *spans, unsigned rank); +static hbool_t H5S__hyper_cmp_spans(const H5S_hyper_span_info_t *span_info1, + const H5S_hyper_span_info_t *span_info2); +static void H5S__hyper_free_span_info(H5S_hyper_span_info_t *span_info); +static void H5S__hyper_free_span(H5S_hyper_span_t *span); +static herr_t H5S__hyper_span_blocklist(const H5S_hyper_span_info_t *spans, hsize_t start[], hsize_t end[], + hsize_t rank, hsize_t *startblock, hsize_t *numblocks, hsize_t **buf); +static herr_t H5S__get_select_hyper_blocklist(H5S_t *space, hsize_t startblock, hsize_t numblocks, + hsize_t *buf); static H5S_hyper_span_t *H5S__hyper_coord_to_span(unsigned rank, const hsize_t *coords); -static herr_t H5S__hyper_append_span(H5S_hyper_span_info_t **span_tree, - unsigned ndims, hsize_t low, hsize_t high, H5S_hyper_span_info_t *down); -static herr_t H5S__hyper_clip_spans(H5S_hyper_span_info_t *a_spans, - H5S_hyper_span_info_t *b_spans, unsigned selector, - unsigned ndims, H5S_hyper_span_info_t **a_not_b, - H5S_hyper_span_info_t **a_and_b, H5S_hyper_span_info_t **b_not_a); -static herr_t H5S__hyper_merge_spans(H5S_t *space, H5S_hyper_span_info_t *new_spans); -static hsize_t H5S__hyper_spans_nelem_helper(H5S_hyper_span_info_t *spans, - unsigned op_info_i, uint64_t op_gen); +static herr_t H5S__hyper_append_span(H5S_hyper_span_info_t **span_tree, unsigned ndims, hsize_t low, + hsize_t high, H5S_hyper_span_info_t *down); +static herr_t H5S__hyper_clip_spans(H5S_hyper_span_info_t *a_spans, H5S_hyper_span_info_t *b_spans, + unsigned selector, unsigned ndims, H5S_hyper_span_info_t **a_not_b, + H5S_hyper_span_info_t **a_and_b, H5S_hyper_span_info_t **b_not_a); +static herr_t H5S__hyper_merge_spans(H5S_t *space, H5S_hyper_span_info_t *new_spans); +static hsize_t H5S__hyper_spans_nelem_helper(H5S_hyper_span_info_t *spans, unsigned op_info_i, + uint64_t op_gen); static hsize_t H5S__hyper_spans_nelem(H5S_hyper_span_info_t *spans); -static herr_t H5S__hyper_add_disjoint_spans(H5S_t *space, H5S_hyper_span_info_t *new_spans); -static H5S_hyper_span_info_t *H5S__hyper_make_spans(unsigned rank, - const hsize_t *start, const hsize_t *stride, - const hsize_t *count, const hsize_t *block); -static herr_t H5S__hyper_update_diminfo(H5S_t *space, H5S_seloper_t op, - const H5S_hyper_dim_t *new_hyper_diminfo); -static herr_t H5S__hyper_generate_spans(H5S_t *space); -static hbool_t H5S__check_spans_overlap(const H5S_hyper_span_info_t *spans1, - const H5S_hyper_span_info_t *spans2); -static herr_t H5S__fill_in_new_space(H5S_t *space1, H5S_seloper_t op, - H5S_hyper_span_info_t *space2_span_lst, hbool_t can_own_span2, - hbool_t *span2_owned, hbool_t *updated_spans, H5S_t **result); -static herr_t H5S__generate_hyperslab(H5S_t *space, H5S_seloper_t op, - const hsize_t start[], const hsize_t stride[], const hsize_t count[], - const hsize_t block[]); -static herr_t H5S__set_regular_hyperslab(H5S_t *space, const hsize_t start[], - const hsize_t *app_stride, const hsize_t app_count[], const hsize_t *app_block, - const hsize_t *opt_stride, const hsize_t opt_count[], const hsize_t *opt_block); -static herr_t H5S__fill_in_select(H5S_t *space1, H5S_seloper_t op, H5S_t *space2, - H5S_t **result); -static H5S_t *H5S__combine_select(H5S_t *space1, H5S_seloper_t op, H5S_t *space2); -static herr_t H5S__hyper_iter_get_seq_list_gen(H5S_sel_iter_t *iter, size_t maxseq, - size_t maxelem, size_t *nseq, size_t *nelem, hsize_t *off, size_t *len); -static herr_t H5S__hyper_iter_get_seq_list_opt(H5S_sel_iter_t *iter, size_t maxseq, - size_t maxelem, size_t *nseq, size_t *nelem, hsize_t *off, size_t *len); -static herr_t H5S__hyper_iter_get_seq_list_single(H5S_sel_iter_t *iter, size_t maxseq, - size_t maxelem, size_t *nseq, size_t *nelem, hsize_t *off, size_t *len); -static herr_t H5S__hyper_proj_int_build_proj(H5S_hyper_project_intersect_ud_t *udata); -static herr_t H5S__hyper_proj_int_iterate(const H5S_hyper_span_info_t *ss_span_info, - const H5S_hyper_span_info_t *sis_span_info, hsize_t count, unsigned depth, - H5S_hyper_project_intersect_ud_t *udata); -static void H5S__hyper_get_clip_diminfo(hsize_t start, hsize_t stride, - hsize_t *count, hsize_t *block, hsize_t clip_size); -static hsize_t H5S__hyper_get_clip_extent_real(const H5S_t *clip_space, - hsize_t num_slices, hbool_t incl_trail); +static herr_t H5S__hyper_add_disjoint_spans(H5S_t *space, H5S_hyper_span_info_t *new_spans); +static H5S_hyper_span_info_t *H5S__hyper_make_spans(unsigned rank, const hsize_t *start, + const hsize_t *stride, const hsize_t *count, + const hsize_t *block); +static herr_t H5S__hyper_update_diminfo(H5S_t *space, H5S_seloper_t op, + const H5S_hyper_dim_t *new_hyper_diminfo); +static herr_t H5S__hyper_generate_spans(H5S_t *space); +static hbool_t H5S__check_spans_overlap(const H5S_hyper_span_info_t *spans1, + const H5S_hyper_span_info_t *spans2); +static herr_t H5S__fill_in_new_space(H5S_t *space1, H5S_seloper_t op, H5S_hyper_span_info_t *space2_span_lst, + hbool_t can_own_span2, hbool_t *span2_owned, hbool_t *updated_spans, + H5S_t **result); +static herr_t H5S__generate_hyperslab(H5S_t *space, H5S_seloper_t op, const hsize_t start[], + const hsize_t stride[], const hsize_t count[], const hsize_t block[]); +static herr_t H5S__set_regular_hyperslab(H5S_t *space, const hsize_t start[], const hsize_t *app_stride, + const hsize_t app_count[], const hsize_t *app_block, + const hsize_t *opt_stride, const hsize_t opt_count[], + const hsize_t *opt_block); +static herr_t H5S__fill_in_select(H5S_t *space1, H5S_seloper_t op, H5S_t *space2, H5S_t **result); +static H5S_t * H5S__combine_select(H5S_t *space1, H5S_seloper_t op, H5S_t *space2); +static herr_t H5S__hyper_iter_get_seq_list_gen(H5S_sel_iter_t *iter, size_t maxseq, size_t maxelem, + size_t *nseq, size_t *nelem, hsize_t *off, size_t *len); +static herr_t H5S__hyper_iter_get_seq_list_opt(H5S_sel_iter_t *iter, size_t maxseq, size_t maxelem, + size_t *nseq, size_t *nelem, hsize_t *off, size_t *len); +static herr_t H5S__hyper_iter_get_seq_list_single(H5S_sel_iter_t *iter, size_t maxseq, size_t maxelem, + size_t *nseq, size_t *nelem, hsize_t *off, size_t *len); +static herr_t H5S__hyper_proj_int_build_proj(H5S_hyper_project_intersect_ud_t *udata); +static herr_t H5S__hyper_proj_int_iterate(const H5S_hyper_span_info_t *ss_span_info, + const H5S_hyper_span_info_t *sis_span_info, hsize_t count, + unsigned depth, H5S_hyper_project_intersect_ud_t *udata); +static void H5S__hyper_get_clip_diminfo(hsize_t start, hsize_t stride, hsize_t *count, hsize_t *block, + hsize_t clip_size); +static hsize_t H5S__hyper_get_clip_extent_real(const H5S_t *clip_space, hsize_t num_slices, + hbool_t incl_trail); /* Selection callbacks */ -static herr_t H5S__hyper_copy(H5S_t *dst, const H5S_t *src, hbool_t share_selection); -static herr_t H5S__hyper_release(H5S_t *space); -static htri_t H5S__hyper_is_valid(const H5S_t *space); -static hsize_t H5S__hyper_span_nblocks(H5S_hyper_span_info_t *spans); +static herr_t H5S__hyper_copy(H5S_t *dst, const H5S_t *src, hbool_t share_selection); +static herr_t H5S__hyper_release(H5S_t *space); +static htri_t H5S__hyper_is_valid(const H5S_t *space); +static hsize_t H5S__hyper_span_nblocks(H5S_hyper_span_info_t *spans); static hssize_t H5S__hyper_serial_size(const H5S_t *space); -static herr_t H5S__hyper_serialize(const H5S_t *space, uint8_t **p); -static herr_t H5S__hyper_deserialize(H5S_t **space, const uint8_t **p); -static herr_t H5S__hyper_bounds(const H5S_t *space, hsize_t *start, hsize_t *end); -static herr_t H5S__hyper_offset(const H5S_t *space, hsize_t *offset); -static int H5S__hyper_unlim_dim(const H5S_t *space); -static herr_t H5S__hyper_num_elem_non_unlim(const H5S_t *space, - hsize_t *num_elem_non_unlim); -static htri_t H5S__hyper_is_contiguous(const H5S_t *space); -static htri_t H5S__hyper_is_single(const H5S_t *space); -static htri_t H5S__hyper_is_regular(const H5S_t *space); -static htri_t H5S__hyper_shape_same(const H5S_t *space1, const H5S_t *space2); -static htri_t H5S__hyper_intersect_block(const H5S_t *space, const hsize_t *start, - const hsize_t *end); -static herr_t H5S__hyper_adjust_u(H5S_t *space, const hsize_t *offset); -static herr_t H5S__hyper_adjust_s(H5S_t *space, const hssize_t *offset); -static herr_t H5S__hyper_project_scalar(const H5S_t *space, hsize_t *offset); -static herr_t H5S__hyper_project_simple(const H5S_t *space, H5S_t *new_space, hsize_t *offset); -static herr_t H5S__hyper_iter_init(const H5S_t *space, H5S_sel_iter_t *iter); +static herr_t H5S__hyper_serialize(const H5S_t *space, uint8_t **p); +static herr_t H5S__hyper_deserialize(H5S_t **space, const uint8_t **p); +static herr_t H5S__hyper_bounds(const H5S_t *space, hsize_t *start, hsize_t *end); +static herr_t H5S__hyper_offset(const H5S_t *space, hsize_t *offset); +static int H5S__hyper_unlim_dim(const H5S_t *space); +static herr_t H5S__hyper_num_elem_non_unlim(const H5S_t *space, hsize_t *num_elem_non_unlim); +static htri_t H5S__hyper_is_contiguous(const H5S_t *space); +static htri_t H5S__hyper_is_single(const H5S_t *space); +static htri_t H5S__hyper_is_regular(const H5S_t *space); +static htri_t H5S__hyper_shape_same(const H5S_t *space1, const H5S_t *space2); +static htri_t H5S__hyper_intersect_block(const H5S_t *space, const hsize_t *start, const hsize_t *end); +static herr_t H5S__hyper_adjust_u(H5S_t *space, const hsize_t *offset); +static herr_t H5S__hyper_adjust_s(H5S_t *space, const hssize_t *offset); +static herr_t H5S__hyper_project_scalar(const H5S_t *space, hsize_t *offset); +static herr_t H5S__hyper_project_simple(const H5S_t *space, H5S_t *new_space, hsize_t *offset); +static herr_t H5S__hyper_iter_init(const H5S_t *space, H5S_sel_iter_t *iter); /* Selection iteration callbacks */ -static herr_t H5S__hyper_iter_coords(const H5S_sel_iter_t *iter, hsize_t *coords); -static herr_t H5S__hyper_iter_block(const H5S_sel_iter_t *iter, hsize_t *start, hsize_t *end); +static herr_t H5S__hyper_iter_coords(const H5S_sel_iter_t *iter, hsize_t *coords); +static herr_t H5S__hyper_iter_block(const H5S_sel_iter_t *iter, hsize_t *start, hsize_t *end); static hsize_t H5S__hyper_iter_nelmts(const H5S_sel_iter_t *iter); -static htri_t H5S__hyper_iter_has_next_block(const H5S_sel_iter_t *sel_iter); -static herr_t H5S__hyper_iter_next(H5S_sel_iter_t *sel_iter, size_t nelem); -static herr_t H5S__hyper_iter_next_block(H5S_sel_iter_t *sel_iter); -static herr_t H5S__hyper_iter_get_seq_list(H5S_sel_iter_t *iter, size_t maxseq, - size_t maxbytes, size_t *nseq, size_t *nbytes, hsize_t *off, size_t *len); +static htri_t H5S__hyper_iter_has_next_block(const H5S_sel_iter_t *sel_iter); +static herr_t H5S__hyper_iter_next(H5S_sel_iter_t *sel_iter, size_t nelem); +static herr_t H5S__hyper_iter_next_block(H5S_sel_iter_t *sel_iter); +static herr_t H5S__hyper_iter_get_seq_list(H5S_sel_iter_t *iter, size_t maxseq, size_t maxbytes, size_t *nseq, + size_t *nbytes, hsize_t *off, size_t *len); static herr_t H5S__hyper_iter_release(H5S_sel_iter_t *sel_iter); - /*****************************/ /* Library Private Variables */ /*****************************/ - /*********************/ /* Package Variables */ /*********************/ @@ -249,10 +239,10 @@ const H5S_select_class_t H5S_sel_hyper[1] = {{ /* Format version bounds for dataspace hyperslab selection */ const unsigned H5O_sds_hyper_ver_bounds[] = { - H5S_HYPER_VERSION_1, /* H5F_LIBVER_EARLIEST */ - H5S_HYPER_VERSION_1, /* H5F_LIBVER_V18 */ - H5S_HYPER_VERSION_2, /* H5F_LIBVER_V110 */ - H5S_HYPER_VERSION_3 /* H5F_LIBVER_LATEST */ + H5S_HYPER_VERSION_1, /* H5F_LIBVER_EARLIEST */ + H5S_HYPER_VERSION_1, /* H5F_LIBVER_V18 */ + H5S_HYPER_VERSION_2, /* H5F_LIBVER_V110 */ + H5S_HYPER_VERSION_3 /* H5F_LIBVER_LATEST */ }; /*******************/ @@ -275,16 +265,10 @@ static const H5S_sel_iter_class_t H5S_sel_iter_hyper[1] = {{ }}; /* Arrays for default stride, block, etc. */ -static const hsize_t H5S_hyper_zeros_g[H5S_MAX_RANK] = { - 0,0,0,0, 0,0,0,0, - 0,0,0,0, 0,0,0,0, - 0,0,0,0, 0,0,0,0, - 0,0,0,0, 0,0,0,0}; -static const hsize_t H5S_hyper_ones_g[H5S_MAX_RANK] = { - 1,1,1,1, 1,1,1,1, - 1,1,1,1, 1,1,1,1, - 1,1,1,1, 1,1,1,1, - 1,1,1,1, 1,1,1,1}; +static const hsize_t H5S_hyper_zeros_g[H5S_MAX_RANK] = {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}; +static const hsize_t H5S_hyper_ones_g[H5S_MAX_RANK] = {1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1}; /* Declare a free list to manage the H5S_hyper_sel_t struct */ H5FL_DEFINE_STATIC(H5S_hyper_sel_t); @@ -302,7 +286,6 @@ H5FL_EXTERN(H5S_sel_iter_t); /* (Start with '1' to avoid clashing with '0' value in newly allocated structs) */ static uint64_t H5S_hyper_op_gen_g = 1; - /* Uncomment this to provide the debugging routines for printing selection info */ /* #define H5S_HYPER_DEBUG */ #ifdef H5S_HYPER_DEBUG @@ -311,10 +294,13 @@ H5S__hyper_print_spans_helper(FILE *f, const H5S_hyper_span_t *span, unsigned de { FUNC_ENTER_STATIC_NOERR - while(span) { - HDfprintf(f,"%s: %*sdepth=%u, span=%p, (%Hu, %Hu), next=%p\n", FUNC, depth * 2, "", depth, span, span->low, span->high, span->next); - if(span->down) { - HDfprintf(f,"%s: %*sspans=%p, count=%u, bounds[0]={%Hu, %Hu}, head=%p\n", FUNC, (depth + 1) * 2, "", span->down, span->down->count, span->down->low_bounds[0], span->down->high_bounds[0], span->down->head); + while (span) { + HDfprintf(f, "%s: %*sdepth=%u, span=%p, (%Hu, %Hu), next=%p\n", FUNC, depth * 2, "", depth, span, + span->low, span->high, span->next); + if (span->down) { + HDfprintf(f, "%s: %*sspans=%p, count=%u, bounds[0]={%Hu, %Hu}, head=%p\n", FUNC, (depth + 1) * 2, + "", span->down, span->down->count, span->down->low_bounds[0], + span->down->high_bounds[0], span->down->head); H5S__hyper_print_spans_helper(f, span->down->head, depth + 1); } /* end if */ span = span->next; @@ -328,8 +314,9 @@ H5S__hyper_print_spans(FILE *f, const H5S_hyper_span_info_t *span_lst) { FUNC_ENTER_STATIC_NOERR - if(span_lst != NULL) { - HDfprintf(f, "%s: spans=%p, count=%u, bounds[0]={%Hu, %Hu}, head=%p\n", FUNC, span_lst, span_lst->count, span_lst->low_bounds[0], span_lst->high_bounds[0], span_lst->head); + if (span_lst != NULL) { + HDfprintf(f, "%s: spans=%p, count=%u, bounds[0]={%Hu, %Hu}, head=%p\n", FUNC, span_lst, + span_lst->count, span_lst->low_bounds[0], span_lst->high_bounds[0], span_lst->head); H5S__hyper_print_spans_helper(f, span_lst->head, 0); } /* end if */ @@ -349,22 +336,22 @@ H5S__space_print_spans(FILE *f, const H5S_t *space) static herr_t H5S__hyper_print_diminfo_helper(FILE *f, const char *field, unsigned ndims, const H5S_hyper_dim_t *dinfo) { - unsigned u; /* Local index variable */ + unsigned u; /* Local index variable */ FUNC_ENTER_STATIC_NOERR - if(dinfo != NULL) { + if (dinfo != NULL) { HDfprintf(f, "%s: %s: start=[", FUNC, field); - for(u = 0; u < ndims; u++) + for (u = 0; u < ndims; u++) HDfprintf(f, "%Hd%s", dinfo[u].start, (u < (ndims - 1) ? ", " : "]\n")); HDfprintf(f, "%s: %s: stride=[", FUNC, field); - for(u = 0; u < ndims; u++) + for (u = 0; u < ndims; u++) HDfprintf(f, "%Hu%s", dinfo[u].stride, (u < (ndims - 1) ? ", " : "]\n")); HDfprintf(f, "%s: %s: count=[", FUNC, field); - for(u = 0; u < ndims; u++) + for (u = 0; u < ndims; u++) HDfprintf(f, "%Hu%s", dinfo[u].count, (u < (ndims - 1) ? ", " : "]\n")); HDfprintf(f, "%s: %s: block=[", FUNC, field); - for(u = 0; u < ndims; u++) + for (u = 0; u < ndims; u++) HDfprintf(f, "%Hu%s", dinfo[u].block, (u < (ndims - 1) ? ", " : "]\n")); } /* end if */ else @@ -378,13 +365,14 @@ H5S__hyper_print_diminfo(FILE *f, const H5S_t *space) { FUNC_ENTER_STATIC_NOERR - H5S__hyper_print_diminfo_helper(f, "diminfo.opt", space->extent.rank, space->select.sel_info.hslab->diminfo.opt); - H5S__hyper_print_diminfo_helper(f, "diminfo.app", space->extent.rank, space->select.sel_info.hslab->diminfo.app); + H5S__hyper_print_diminfo_helper(f, "diminfo.opt", space->extent.rank, + space->select.sel_info.hslab->diminfo.opt); + H5S__hyper_print_diminfo_helper(f, "diminfo.app", space->extent.rank, + space->select.sel_info.hslab->diminfo.app); FUNC_LEAVE_NOAPI(SUCCEED) } - /*-------------------------------------------------------------------------- NAME H5S__hyper_print_spans_dfs @@ -403,53 +391,52 @@ H5S__hyper_print_diminfo(FILE *f, const H5S_t *space) REVISION LOG --------------------------------------------------------------------------*/ static herr_t -H5S__hyper_print_spans_dfs(FILE *f, const H5S_hyper_span_info_t *span_lst, - unsigned depth, unsigned dims) +H5S__hyper_print_spans_dfs(FILE *f, const H5S_hyper_span_info_t *span_lst, unsigned depth, unsigned dims) { H5S_hyper_span_t *actual_tail = NULL; H5S_hyper_span_t *cur_elem; - unsigned num_elems = 0; - unsigned u, elem_idx; + unsigned num_elems = 0; + unsigned u, elem_idx; FUNC_ENTER_STATIC_NOERR /* get the actual tail from head */ cur_elem = span_lst->head; HDassert(cur_elem); /* at least 1 element */ - while(cur_elem) { + while (cur_elem) { actual_tail = cur_elem; - cur_elem = cur_elem->next; + cur_elem = cur_elem->next; num_elems++; } /* end while */ - for(u = 0; u < depth; u++) + for (u = 0; u < depth; u++) HDfprintf(f, "\t"); HDfprintf(f, "DIM[%u]: ref_count=%u, #elems=%u, head=%p, tail=%p, actual_tail=%p, matched=%t\n", depth, - span_lst->count, num_elems, span_lst->head, - span_lst->tail, actual_tail, (span_lst->tail == actual_tail)); + span_lst->count, num_elems, span_lst->head, span_lst->tail, actual_tail, + (span_lst->tail == actual_tail)); - for(u = 0; u < depth; u++) + for (u = 0; u < depth; u++) HDfprintf(f, "\t"); HDfprintf(f, "low_bounds=["); - for(u = 0; u < dims - 1; u++) + for (u = 0; u < dims - 1; u++) HDfprintf(f, "%llu,", span_lst->low_bounds[u]); HDfprintf(f, "%llu]\n", span_lst->low_bounds[dims - 1]); - for(u = 0; u < depth; u++) + for (u = 0; u < depth; u++) HDfprintf(f, "\t"); HDfprintf(f, "high_bounds=["); - for(u = 0; u < dims - 1; u++) + for (u = 0; u < dims - 1; u++) HDfprintf(f, "%llu,", span_lst->high_bounds[u]); HDfprintf(f, "%llu]\n", span_lst->high_bounds[dims - 1]); cur_elem = span_lst->head; elem_idx = 0; - while(cur_elem) { - for(u = 0; u < depth; u++) + while (cur_elem) { + for (u = 0; u < depth; u++) HDfprintf(f, "\t"); - HDfprintf(f, "ELEM[%u]: ptr=%p, low=%Hu, high=%Hu, down=%p\n", - elem_idx++, cur_elem, cur_elem->low, cur_elem->high, cur_elem->down); - if(cur_elem->down) + HDfprintf(f, "ELEM[%u]: ptr=%p, low=%Hu, high=%Hu, down=%p\n", elem_idx++, cur_elem, cur_elem->low, + cur_elem->high, cur_elem->down); + if (cur_elem->down) H5S__hyper_print_spans_dfs(f, cur_elem->down, depth + 1, dims); cur_elem = cur_elem->next; } /* end while */ @@ -457,7 +444,6 @@ H5S__hyper_print_spans_dfs(FILE *f, const H5S_hyper_span_info_t *span_lst, FUNC_LEAVE_NOAPI(SUCCEED) } /* end H5S__hyper_print_spans_dfs() */ - /*-------------------------------------------------------------------------- NAME H5S__hyper_print_space_dfs @@ -478,51 +464,52 @@ static herr_t H5S__hyper_print_space_dfs(FILE *f, const H5S_t *space) { const H5S_hyper_sel_t *hslab = space->select.sel_info.hslab; - const unsigned dims = space->extent.rank; - unsigned u; + const unsigned dims = space->extent.rank; + unsigned u; FUNC_ENTER_STATIC_NOERR HDassert(hslab); HDfprintf(f, "=======================\n"); - HDfprintf(f, "SPACE: span_lst=%p, #dims=%u, offset_changed=%d\n", hslab->span_lst, dims, space->select.offset_changed); + HDfprintf(f, "SPACE: span_lst=%p, #dims=%u, offset_changed=%d\n", hslab->span_lst, dims, + space->select.offset_changed); HDfprintf(f, " offset=["); - for(u = 0; u < dims - 1; u++) + for (u = 0; u < dims - 1; u++) HDfprintf(f, "%lld,", space->select.offset[u]); HDfprintf(f, "%lld]\n", space->select.offset[dims - 1]); HDfprintf(f, " low_bounds=["); - if(space->select.sel_info.hslab->diminfo_valid == H5S_DIMINFO_VALID_YES) { - for(u = 0; u < dims - 1; u++) + if (space->select.sel_info.hslab->diminfo_valid == H5S_DIMINFO_VALID_YES) { + for (u = 0; u < dims - 1; u++) HDfprintf(f, "%llu,", space->select.sel_info.hslab->diminfo.low_bounds[u]); HDfprintf(f, "%llu]\n", space->select.sel_info.hslab->diminfo.low_bounds[dims - 1]); } /* end if */ else { - for(u = 0; u < dims - 1; u++) + for (u = 0; u < dims - 1; u++) HDfprintf(f, "%llu,", space->select.sel_info.hslab->span_lst->low_bounds[u]); HDfprintf(f, "%llu]\n", space->select.sel_info.hslab->span_lst->low_bounds[dims - 1]); } /* end else */ HDfprintf(f, " high_bounds=["); - if(space->select.sel_info.hslab->diminfo_valid == H5S_DIMINFO_VALID_YES) { - for(u = 0; u < dims - 1; u++) + if (space->select.sel_info.hslab->diminfo_valid == H5S_DIMINFO_VALID_YES) { + for (u = 0; u < dims - 1; u++) HDfprintf(f, "%llu,", space->select.sel_info.hslab->diminfo.high_bounds[u]); HDfprintf(f, "%llu]\n", space->select.sel_info.hslab->diminfo.high_bounds[dims - 1]); } /* end if */ else { - for(u = 0; u < dims - 1; u++) + for (u = 0; u < dims - 1; u++) HDfprintf(f, "%llu,", space->select.sel_info.hslab->span_lst->high_bounds[u]); HDfprintf(f, "%llu]\n", space->select.sel_info.hslab->span_lst->high_bounds[dims - 1]); } /* end else */ /* Print out diminfo, if it's valid */ - if(space->select.sel_info.hslab->diminfo_valid == H5S_DIMINFO_VALID_YES) + if (space->select.sel_info.hslab->diminfo_valid == H5S_DIMINFO_VALID_YES) H5S__hyper_print_diminfo(f, space); /* Start print out the highest-order of dimension */ - if(hslab->span_lst) + if (hslab->span_lst) H5S__hyper_print_spans_dfs(f, hslab->span_lst, 0, dims); HDfprintf(f, "=======================\n\n"); @@ -530,7 +517,6 @@ H5S__hyper_print_space_dfs(FILE *f, const H5S_t *space) } /* end H5S__hyper_print_space_dfs() */ #endif /* H5S_HYPER_DEBUG */ - /*------------------------------------------------------------------------- * Function: H5S__hyper_get_op_gen * @@ -554,7 +540,6 @@ H5S__hyper_get_op_gen(void) FUNC_LEAVE_NOAPI(H5S_hyper_op_gen_g++); } /* end H5S__hyper_op_gen() */ - /*------------------------------------------------------------------------- * Function: H5S__hyper_iter_init * @@ -575,13 +560,13 @@ H5S__hyper_get_op_gen(void) static herr_t H5S__hyper_iter_init(const H5S_t *space, H5S_sel_iter_t *iter) { - hsize_t *slab_size; /* Pointer to the dataspace dimensions to use for calc. slab */ - hsize_t acc; /* Accumulator for computing cumulative sizes */ - unsigned slab_dim; /* Rank of the fastest changing dimension for calc. slab */ - unsigned rank; /* Dataspace's dimension rank */ - unsigned u; /* Index variable */ - int i; /* Index variable */ - herr_t ret_value = SUCCEED; /* return value */ + hsize_t *slab_size; /* Pointer to the dataspace dimensions to use for calc. slab */ + hsize_t acc; /* Accumulator for computing cumulative sizes */ + unsigned slab_dim; /* Rank of the fastest changing dimension for calc. slab */ + unsigned rank; /* Dataspace's dimension rank */ + unsigned u; /* Index variable */ + int i; /* Index variable */ + herr_t ret_value = SUCCEED; /* return value */ FUNC_ENTER_STATIC @@ -599,15 +584,15 @@ H5S__hyper_iter_init(const H5S_t *space, H5S_sel_iter_t *iter) /* Attempt to rebuild diminfo if it is invalid and has not been confirmed * to be impossible. */ - if(space->select.sel_info.hslab->diminfo_valid == H5S_DIMINFO_VALID_NO) - H5S__hyper_rebuild((H5S_t *)space); /* Casting away const OK -NAF */ + if (space->select.sel_info.hslab->diminfo_valid == H5S_DIMINFO_VALID_NO) + H5S__hyper_rebuild((H5S_t *)space); /* Casting away const OK -NAF */ /* Check for the special case of just one H5Sselect_hyperslab call made */ - if(space->select.sel_info.hslab->diminfo_valid == H5S_DIMINFO_VALID_YES) { -/* Initialize the information needed for regular hyperslab I/O */ - const H5S_hyper_dim_t *tdiminfo; /* Temporary pointer to diminfo information */ - const hsize_t *mem_size; /* Temporary pointer to dataspace extent's dimension sizes */ - unsigned cont_dim = 0; /* # of contiguous dimensions */ + if (space->select.sel_info.hslab->diminfo_valid == H5S_DIMINFO_VALID_YES) { + /* Initialize the information needed for regular hyperslab I/O */ + const H5S_hyper_dim_t *tdiminfo; /* Temporary pointer to diminfo information */ + const hsize_t * mem_size; /* Temporary pointer to dataspace extent's dimension sizes */ + unsigned cont_dim = 0; /* # of contiguous dimensions */ /* Set the temporary pointer to the dimension information */ tdiminfo = space->select.sel_info.hslab->diminfo.opt; @@ -625,10 +610,10 @@ H5S__hyper_iter_init(const H5S_t *space, H5S_sel_iter_t *iter) /* Don't flatten adjacent elements into contiguous block if the * element size is 0. This is for the H5S_select_shape_same() code. */ - if(iter->elmt_size > 0) { + if (iter->elmt_size > 0) { /* Check for any "contiguous" blocks that can be flattened */ - for(u = (rank - 1); u > 0; u--) { - if(tdiminfo[u].count == 1 && tdiminfo[u].block == mem_size[u]) { + for (u = (rank - 1); u > 0; u--) { + if (tdiminfo[u].count == 1 && tdiminfo[u].block == mem_size[u]) { cont_dim++; iter->u.hyp.flattened[u] = TRUE; } /* end if */ @@ -639,18 +624,18 @@ H5S__hyper_iter_init(const H5S_t *space, H5S_sel_iter_t *iter) } /* end if */ /* Check if the regular selection can be "flattened" */ - if(cont_dim > 0) { - hbool_t last_dim_flattened = TRUE; /* Flag to indicate that the last dimension was flattened */ - unsigned flat_rank = rank-cont_dim; /* Number of dimensions after flattening */ - unsigned curr_dim; /* Current dimension */ + if (cont_dim > 0) { + hbool_t last_dim_flattened = TRUE; /* Flag to indicate that the last dimension was flattened */ + unsigned flat_rank = rank - cont_dim; /* Number of dimensions after flattening */ + unsigned curr_dim; /* Current dimension */ /* Set the iterator's rank to the contiguous dimensions */ iter->u.hyp.iter_rank = flat_rank; /* "Flatten" dataspace extent and selection information */ curr_dim = flat_rank - 1; - for(i = (int)rank - 1, acc = 1; i >= 0; i--) { - if(tdiminfo[i].block == mem_size[i] && i > 0) { + for (i = (int)rank - 1, acc = 1; i >= 0; i--) { + if (tdiminfo[i].block == mem_size[i] && i > 0) { /* "Flatten" this dimension */ HDassert(tdiminfo[i].start == 0); acc *= mem_size[i]; @@ -659,19 +644,19 @@ H5S__hyper_iter_init(const H5S_t *space, H5S_sel_iter_t *iter) last_dim_flattened = TRUE; } /* end if */ else { - if(last_dim_flattened) { + if (last_dim_flattened) { /* First dimension after flattened dimensions */ iter->u.hyp.diminfo[curr_dim].start = tdiminfo[i].start * acc; /* Special case for single block regular selections */ - if(tdiminfo[i].count == 1) + if (tdiminfo[i].count == 1) iter->u.hyp.diminfo[curr_dim].stride = 1; else iter->u.hyp.diminfo[curr_dim].stride = tdiminfo[i].stride * acc; iter->u.hyp.diminfo[curr_dim].count = tdiminfo[i].count; iter->u.hyp.diminfo[curr_dim].block = tdiminfo[i].block * acc; - iter->u.hyp.size[curr_dim] = mem_size[i] * acc; - iter->u.hyp.sel_off[curr_dim] = iter->sel_off[i] * (hssize_t)acc; + iter->u.hyp.size[curr_dim] = mem_size[i] * acc; + iter->u.hyp.sel_off[curr_dim] = iter->sel_off[i] * (hssize_t)acc; /* Reset the "last dim flattened" flag to avoid flattened any further dimensions */ last_dim_flattened = FALSE; @@ -681,38 +666,40 @@ H5S__hyper_iter_init(const H5S_t *space, H5S_sel_iter_t *iter) } /* end if */ else { /* All other dimensions */ - iter->u.hyp.diminfo[curr_dim].start = tdiminfo[i].start; + iter->u.hyp.diminfo[curr_dim].start = tdiminfo[i].start; iter->u.hyp.diminfo[curr_dim].stride = tdiminfo[i].stride; - iter->u.hyp.diminfo[curr_dim].count = tdiminfo[i].count; - iter->u.hyp.diminfo[curr_dim].block = tdiminfo[i].block; - iter->u.hyp.size[curr_dim] = mem_size[i]; - iter->u.hyp.sel_off[curr_dim] = iter->sel_off[i]; + iter->u.hyp.diminfo[curr_dim].count = tdiminfo[i].count; + iter->u.hyp.diminfo[curr_dim].block = tdiminfo[i].block; + iter->u.hyp.size[curr_dim] = mem_size[i]; + iter->u.hyp.sel_off[curr_dim] = iter->sel_off[i]; } /* end else */ /* Decrement "current" flattened dimension */ curr_dim--; } /* end if */ - } /* end for */ + } /* end for */ - /* Initialize "flattened" iterator offset to initial location and dataspace extent and selection information to correct values */ - for(u = 0; u < flat_rank; u++) + /* Initialize "flattened" iterator offset to initial location and dataspace extent and selection + * information to correct values */ + for (u = 0; u < flat_rank; u++) iter->u.hyp.off[u] = iter->u.hyp.diminfo[u].start; /* Set up information for computing slab sizes */ - slab_dim = iter->u.hyp.iter_rank - 1; + slab_dim = iter->u.hyp.iter_rank - 1; slab_size = iter->u.hyp.size; } /* end if */ else { /* Make local copy of the regular selection information */ - HDcompile_assert(sizeof(iter->u.hyp.diminfo) == sizeof(space->select.sel_info.hslab->diminfo.opt)); + HDcompile_assert(sizeof(iter->u.hyp.diminfo) == + sizeof(space->select.sel_info.hslab->diminfo.opt)); H5MM_memcpy(iter->u.hyp.diminfo, tdiminfo, sizeof(iter->u.hyp.diminfo)); /* Initialize position to initial location */ - for(u = 0; u < rank; u++) + for (u = 0; u < rank; u++) iter->u.hyp.off[u] = tdiminfo[u].start; /* Set up information for computing slab sizes */ - slab_dim = iter->rank - 1; + slab_dim = iter->rank - 1; slab_size = iter->dims; } /* end else */ @@ -721,9 +708,9 @@ H5S__hyper_iter_init(const H5S_t *space, H5S_sel_iter_t *iter) /* Initialize irregular region information also (for release) */ iter->u.hyp.spans = NULL; - } /* end if */ - else { /* Initialize the information needed for non-regular hyperslab I/O */ - H5S_hyper_span_info_t *spans; /* Pointer to hyperslab span info node */ + } /* end if */ + else { /* Initialize the information needed for non-regular hyperslab I/O */ + H5S_hyper_span_info_t *spans; /* Pointer to hyperslab span info node */ /* If this iterator is created from an API call, by default we clone the * selection now, as the dataspace could be modified or go out of scope. @@ -734,10 +721,10 @@ H5S__hyper_iter_init(const H5S_t *space, H5S_sel_iter_t *iter) * close the dataspace that the iterator is operating on, or undefined * behavior will occur. */ - if((iter->flags & H5S_SEL_ITER_API_CALL) && - !(iter->flags & H5S_SEL_ITER_SHARE_WITH_DATASPACE)) { + if ((iter->flags & H5S_SEL_ITER_API_CALL) && !(iter->flags & H5S_SEL_ITER_SHARE_WITH_DATASPACE)) { /* Copy the span tree */ - if(NULL == (iter->u.hyp.spans = H5S__hyper_copy_span(space->select.sel_info.hslab->span_lst, space->extent.rank))) + if (NULL == (iter->u.hyp.spans = H5S__hyper_copy_span(space->select.sel_info.hslab->span_lst, + space->extent.rank))) HGOTO_ERROR(H5E_DATASPACE, H5E_CANTCOPY, FAIL, "can't copy span tree") } /* end if */ else { @@ -749,7 +736,7 @@ H5S__hyper_iter_init(const H5S_t *space, H5S_sel_iter_t *iter) /* Initialize the starting span_info's and spans */ spans = iter->u.hyp.spans; - for(u = 0; u < rank; u++) { + for (u = 0; u < rank; u++) { /* Set the pointers to the initial span in each dimension */ HDassert(spans); HDassert(spans->head); @@ -765,7 +752,7 @@ H5S__hyper_iter_init(const H5S_t *space, H5S_sel_iter_t *iter) } /* end for */ /* Set up information for computing slab sizes */ - slab_dim = iter->rank - 1; + slab_dim = iter->rank - 1; slab_size = iter->dims; /* Flag the diminfo information as not valid in the iterator */ @@ -773,17 +760,18 @@ H5S__hyper_iter_init(const H5S_t *space, H5S_sel_iter_t *iter) } /* end else */ /* Compute the cumulative size of dataspace dimensions */ - for(i = (int)slab_dim, acc = iter->elmt_size; i >= 0; i--) { + for (i = (int)slab_dim, acc = iter->elmt_size; i >= 0; i--) { iter->u.hyp.slab[i] = acc; acc *= slab_size[i]; } /* end for */ /* Initialize more information for irregular hyperslab selections */ - if(!iter->u.hyp.diminfo_valid) { + if (!iter->u.hyp.diminfo_valid) { /* Set the offset of the first element iterated on, in each dimension */ - for(u = 0; u < rank; u++) + for (u = 0; u < rank; u++) /* Compute the sequential element offset */ - iter->u.hyp.loc_off[u] = ((hsize_t)((hssize_t)iter->u.hyp.off[u] + iter->sel_off[u])) * iter->u.hyp.slab[u]; + iter->u.hyp.loc_off[u] = + ((hsize_t)((hssize_t)iter->u.hyp.off[u] + iter->sel_off[u])) * iter->u.hyp.slab[u]; } /* end if */ /* Initialize type of selection iterator */ @@ -793,7 +781,6 @@ done: FUNC_LEAVE_NOAPI(ret_value) } /* end H5S__hyper_iter_init() */ - /*------------------------------------------------------------------------- * Function: H5S__hyper_iter_coords * @@ -819,34 +806,35 @@ H5S__hyper_iter_coords(const H5S_sel_iter_t *iter, hsize_t *coords) /* Copy the offset of the current point */ /* Check for a single "regular" hyperslab */ - if(iter->u.hyp.diminfo_valid) { + if (iter->u.hyp.diminfo_valid) { /* Check if this is a "flattened" regular hyperslab selection */ - if(iter->u.hyp.iter_rank != 0 && iter->u.hyp.iter_rank < iter->rank) { - int u, v; /* Dimension indices */ + if (iter->u.hyp.iter_rank != 0 && iter->u.hyp.iter_rank < iter->rank) { + int u, v; /* Dimension indices */ /* Set the starting rank of both the "natural" & "flattened" dimensions */ u = (int)iter->rank - 1; v = (int)iter->u.hyp.iter_rank - 1; /* Construct the "natural" dimensions from a set of flattened coordinates */ - while(u >= 0) { - if(iter->u.hyp.flattened[u]) { - int begin = u; /* The rank of the first flattened dimension */ + while (u >= 0) { + if (iter->u.hyp.flattened[u]) { + int begin = u; /* The rank of the first flattened dimension */ /* Walk up through as many flattened dimensions as possible */ do { u--; - } while(u >= 0 && iter->u.hyp.flattened[u]); + } while (u >= 0 && iter->u.hyp.flattened[u]); /* Compensate for possibly overshooting dim 0 */ - if(u < 0) + if (u < 0) u = 0; /* Sanity check */ HDassert(v >= 0); /* Compute the coords for the flattened dimensions */ - H5VM_array_calc(iter->u.hyp.off[v], (unsigned)((begin - u) + 1), &(iter->dims[u]), &(coords[u])); + H5VM_array_calc(iter->u.hyp.off[v], (unsigned)((begin - u) + 1), &(iter->dims[u]), + &(coords[u])); /* Continue to faster dimension in both indices */ u--; @@ -854,7 +842,7 @@ H5S__hyper_iter_coords(const H5S_sel_iter_t *iter, hsize_t *coords) } /* end if */ else { /* Walk up through as many non-flattened dimensions as possible */ - while(u >= 0 && !iter->u.hyp.flattened[u]) { + while (u >= 0 && !iter->u.hyp.flattened[u]) { /* Sanity check */ HDassert(v >= 0); @@ -865,8 +853,8 @@ H5S__hyper_iter_coords(const H5S_sel_iter_t *iter, hsize_t *coords) u--; v--; } /* end while */ - } /* end else */ - } /* end while */ + } /* end else */ + } /* end while */ HDassert(v < 0); } /* end if */ else @@ -878,7 +866,6 @@ H5S__hyper_iter_coords(const H5S_sel_iter_t *iter, hsize_t *coords) FUNC_LEAVE_NOAPI(SUCCEED) } /* end H5S__hyper_iter_coords() */ - /*------------------------------------------------------------------------- * Function: H5S__hyper_iter_block * @@ -898,7 +885,7 @@ H5S__hyper_iter_coords(const H5S_sel_iter_t *iter, hsize_t *coords) static herr_t H5S__hyper_iter_block(const H5S_sel_iter_t *iter, hsize_t *start, hsize_t *end) { - unsigned u; /* Local index variable */ + unsigned u; /* Local index variable */ FUNC_ENTER_STATIC_NOERR @@ -910,25 +897,24 @@ H5S__hyper_iter_block(const H5S_sel_iter_t *iter, hsize_t *start, hsize_t *end) /* Copy the offset of the current point */ /* Check for a single "regular" hyperslab */ - if(iter->u.hyp.diminfo_valid) { + if (iter->u.hyp.diminfo_valid) { /* Copy the start and compute the end of the block */ - for(u = 0; u < iter->rank; u++) { + for (u = 0; u < iter->rank; u++) { start[u] = iter->u.hyp.off[u]; - end[u] = (start[u] + iter->u.hyp.diminfo[u].block) - 1; + end[u] = (start[u] + iter->u.hyp.diminfo[u].block) - 1; } } /* end if */ else { /* Copy the start & end of the block */ - for(u = 0; u < iter->rank; u++) { + for (u = 0; u < iter->rank; u++) { start[u] = iter->u.hyp.span[u]->low; - end[u] = iter->u.hyp.span[u]->high; + end[u] = iter->u.hyp.span[u]->high; } } /* end else */ FUNC_LEAVE_NOAPI(SUCCEED) } /* end H5S__hyper_iter_block() */ - /*------------------------------------------------------------------------- * Function: H5S__hyper_iter_nelmts * @@ -952,7 +938,6 @@ H5S__hyper_iter_nelmts(const H5S_sel_iter_t *iter) FUNC_LEAVE_NOAPI(iter->elmt_left) } /* end H5S__hyper_iter_nelmts() */ - /*-------------------------------------------------------------------------- NAME H5S__hyper_iter_has_next_block @@ -974,7 +959,7 @@ static H5_ATTR_PURE htri_t H5S__hyper_iter_has_next_block(const H5S_sel_iter_t *iter) { unsigned u; /* Local index variable */ - htri_t ret_value = FALSE; /* Return value */ + htri_t ret_value = FALSE; /* Return value */ FUNC_ENTER_STATIC_NOERR @@ -982,25 +967,25 @@ H5S__hyper_iter_has_next_block(const H5S_sel_iter_t *iter) HDassert(iter); /* Check for a single "regular" hyperslab */ - if(iter->u.hyp.diminfo_valid) { - const H5S_hyper_dim_t *tdiminfo; /* Temporary pointer to diminfo information */ - const hsize_t *toff; /* Temporary offset in selection */ + if (iter->u.hyp.diminfo_valid) { + const H5S_hyper_dim_t *tdiminfo; /* Temporary pointer to diminfo information */ + const hsize_t * toff; /* Temporary offset in selection */ /* Check if the offset of the iterator is at the last location in all dimensions */ tdiminfo = iter->u.hyp.diminfo; - toff = iter->u.hyp.off; - for(u = 0; u < iter->rank; u++) { + toff = iter->u.hyp.off; + for (u = 0; u < iter->rank; u++) { /* If there is only one block, continue */ - if(tdiminfo[u].count == 1) + if (tdiminfo[u].count == 1) continue; - if(toff[u] != (tdiminfo[u].start + ((tdiminfo[u].count - 1) * tdiminfo[u].stride))) + if (toff[u] != (tdiminfo[u].start + ((tdiminfo[u].count - 1) * tdiminfo[u].stride))) HGOTO_DONE(TRUE); } /* end for */ - } /* end if */ + } /* end if */ else { /* Check for any levels of the tree with more sequences in them */ - for(u = 0; u < iter->rank; u++) - if(iter->u.hyp.span[u]->next != NULL) + for (u = 0; u < iter->rank; u++) + if (iter->u.hyp.span[u]->next != NULL) HGOTO_DONE(TRUE); } /* end else */ @@ -1008,7 +993,6 @@ done: FUNC_LEAVE_NOAPI(ret_value) } /* end H5S__hyper_iter_has_next_block() */ - /*------------------------------------------------------------------------- * Function: H5S__hyper_iter_next * @@ -1026,22 +1010,22 @@ done: static herr_t H5S__hyper_iter_next(H5S_sel_iter_t *iter, size_t nelem) { - unsigned ndims; /* Number of dimensions of dataset */ - int fast_dim; /* Rank of the fastest changing dimension for the dataspace */ - unsigned u; /* Counters */ + unsigned ndims; /* Number of dimensions of dataset */ + int fast_dim; /* Rank of the fastest changing dimension for the dataspace */ + unsigned u; /* Counters */ FUNC_ENTER_STATIC_NOERR /* Check for the special case of just one H5Sselect_hyperslab call made */ /* (i.e. a regular hyperslab selection */ - if(iter->u.hyp.diminfo_valid) { - const H5S_hyper_dim_t *tdiminfo; /* Temporary pointer to diminfo information */ - hsize_t iter_offset[H5S_MAX_RANK]; - hsize_t iter_count[H5S_MAX_RANK]; - int temp_dim; /* Temporary rank holder */ + if (iter->u.hyp.diminfo_valid) { + const H5S_hyper_dim_t *tdiminfo; /* Temporary pointer to diminfo information */ + hsize_t iter_offset[H5S_MAX_RANK]; + hsize_t iter_count[H5S_MAX_RANK]; + int temp_dim; /* Temporary rank holder */ /* Check if this is a "flattened" regular hyperslab selection */ - if(iter->u.hyp.iter_rank != 0 && iter->u.hyp.iter_rank < iter->rank) + if (iter->u.hyp.iter_rank != 0 && iter->u.hyp.iter_rank < iter->rank) /* Set the aliases for the dimension rank */ ndims = iter->u.hyp.iter_rank; else @@ -1055,25 +1039,25 @@ H5S__hyper_iter_next(H5S_sel_iter_t *iter, size_t nelem) tdiminfo = iter->u.hyp.diminfo; /* Calculate the offset and block count for each dimension */ - for(u = 0; u < ndims; u++) { - if(tdiminfo[u].count == 1) { + for (u = 0; u < ndims; u++) { + if (tdiminfo[u].count == 1) { iter_offset[u] = iter->u.hyp.off[u] - tdiminfo[u].start; - iter_count[u] = 0; + iter_count[u] = 0; } /* end if */ else { iter_offset[u] = (iter->u.hyp.off[u] - tdiminfo[u].start) % tdiminfo[u].stride; - iter_count[u] = (iter->u.hyp.off[u] - tdiminfo[u].start) / tdiminfo[u].stride; + iter_count[u] = (iter->u.hyp.off[u] - tdiminfo[u].start) / tdiminfo[u].stride; } /* end else */ - } /* end for */ + } /* end for */ /* Loop through, advancing the offset & counts, until all the nelements are accounted for */ - while(nelem > 0) { + while (nelem > 0) { /* Start with the fastest changing dimension */ temp_dim = fast_dim; - while(temp_dim >= 0) { - if(temp_dim == fast_dim) { - size_t actual_elem; /* Actual # of elements advanced on each iteration through loop */ - hsize_t block_elem; /* Number of elements left in a block */ + while (temp_dim >= 0) { + if (temp_dim == fast_dim) { + size_t actual_elem; /* Actual # of elements advanced on each iteration through loop */ + hsize_t block_elem; /* Number of elements left in a block */ /* Compute the number of elements left in block */ block_elem = tdiminfo[temp_dim].block - iter_offset[temp_dim]; @@ -1091,59 +1075,61 @@ H5S__hyper_iter_next(H5S_sel_iter_t *iter, size_t nelem) /* Move to the next row in the current dimension */ iter_offset[temp_dim]++; - /* If this block is still in the range of blocks to output for the dimension, break out of loop */ - if(iter_offset[temp_dim] < tdiminfo[temp_dim].block) + /* If this block is still in the range of blocks to output for the dimension, break out of + * loop */ + if (iter_offset[temp_dim] < tdiminfo[temp_dim].block) break; else { /* Move to the next block in the current dimension */ iter_offset[temp_dim] = 0; iter_count[temp_dim]++; - /* If this block is still in the range of blocks to output for the dimension, break out of loop */ - if(iter_count[temp_dim] < tdiminfo[temp_dim].count) + /* If this block is still in the range of blocks to output for the dimension, break out of + * loop */ + if (iter_count[temp_dim] < tdiminfo[temp_dim].count) break; else iter_count[temp_dim] = 0; /* reset back to the beginning of the line */ - } /* end else */ + } /* end else */ /* Decrement dimension count */ temp_dim--; } /* end while */ - } /* end while */ + } /* end while */ /* Translate current iter_offset and iter_count into iterator position */ - for(u = 0; u < ndims; u++) + for (u = 0; u < ndims; u++) iter->u.hyp.off[u] = tdiminfo[u].start + (tdiminfo[u].stride * iter_count[u]) + iter_offset[u]; } /* end if */ /* Must be an irregular hyperslab selection */ else { - H5S_hyper_span_t *curr_span; /* Current hyperslab span node */ - H5S_hyper_span_t **ispan; /* Iterator's hyperslab span nodes */ - hsize_t *abs_arr; /* Absolute hyperslab span position */ - int curr_dim; /* Temporary rank holder */ + H5S_hyper_span_t * curr_span; /* Current hyperslab span node */ + H5S_hyper_span_t **ispan; /* Iterator's hyperslab span nodes */ + hsize_t * abs_arr; /* Absolute hyperslab span position */ + int curr_dim; /* Temporary rank holder */ /* Set the rank of the fastest changing dimension */ - ndims = iter->rank; + ndims = iter->rank; fast_dim = (int)ndims - 1; /* Get the pointers to the current span info and span nodes */ abs_arr = iter->u.hyp.off; - ispan = iter->u.hyp.span; + ispan = iter->u.hyp.span; /* Loop through, advancing the span information, until all the nelements are accounted for */ - while(nelem > 0) { + while (nelem > 0) { /* Start at the fastest dim */ curr_dim = fast_dim; /* Work back up through the dimensions */ - while(curr_dim >= 0) { + while (curr_dim >= 0) { /* Reset the current span */ curr_span = ispan[curr_dim]; /* Increment absolute position */ - if(curr_dim == fast_dim) { - size_t actual_elem; /* Actual # of elements advanced on each iteration through loop */ - hsize_t span_elem; /* Number of elements left in a span */ + if (curr_dim == fast_dim) { + size_t actual_elem; /* Actual # of elements advanced on each iteration through loop */ + hsize_t span_elem; /* Number of elements left in a span */ /* Compute the number of elements left in block */ span_elem = (curr_span->high - abs_arr[curr_dim]) + 1; @@ -1162,7 +1148,7 @@ H5S__hyper_iter_next(H5S_sel_iter_t *iter, size_t nelem) abs_arr[curr_dim]++; /* Check if we are still within the span */ - if(abs_arr[curr_dim] <= curr_span->high) + if (abs_arr[curr_dim] <= curr_span->high) break; /* If we walked off that span, advance to the next span */ else { @@ -1170,7 +1156,7 @@ H5S__hyper_iter_next(H5S_sel_iter_t *iter, size_t nelem) curr_span = curr_span->next; /* Check if we have a valid span in this dimension still */ - if(curr_span != NULL) { + if (curr_span != NULL) { /* Reset the span in the current dimension */ ispan[curr_dim] = curr_span; @@ -1180,15 +1166,16 @@ H5S__hyper_iter_next(H5S_sel_iter_t *iter, size_t nelem) break; } /* end if */ else - /* If we finished the span list in this dimension, decrement the dimension worked on and loop again */ + /* If we finished the span list in this dimension, decrement the dimension worked on + * and loop again */ curr_dim--; } /* end else */ - } /* end while */ + } /* end while */ /* Check if we are finished with the spans in the tree */ - if(curr_dim >= 0) { + if (curr_dim >= 0) { /* Walk back down the iterator positions, resetting them */ - while(curr_dim < fast_dim) { + while (curr_dim < fast_dim) { HDassert(curr_span); HDassert(curr_span->down); HDassert(curr_span->down->head); @@ -1209,13 +1196,12 @@ H5S__hyper_iter_next(H5S_sel_iter_t *iter, size_t nelem) /* Verify that the curr_span points to the fastest dim */ HDassert(curr_span == ispan[fast_dim]); } /* end if */ - } /* end while */ - } /* end else */ + } /* end while */ + } /* end else */ FUNC_LEAVE_NOAPI(SUCCEED) } /* end H5S__hyper_iter_next() */ - /*------------------------------------------------------------------------- * Function: H5S__hyper_iter_next_block * @@ -1233,22 +1219,22 @@ H5S__hyper_iter_next(H5S_sel_iter_t *iter, size_t nelem) static herr_t H5S__hyper_iter_next_block(H5S_sel_iter_t *iter) { - unsigned ndims; /* Number of dimensions of dataset */ - int fast_dim; /* Rank of the fastest changing dimension for the dataspace */ - unsigned u; /* Counters */ + unsigned ndims; /* Number of dimensions of dataset */ + int fast_dim; /* Rank of the fastest changing dimension for the dataspace */ + unsigned u; /* Counters */ FUNC_ENTER_STATIC_NOERR /* Check for the special case of just one H5Sselect_hyperslab call made */ /* (i.e. a regular hyperslab selection) */ - if(iter->u.hyp.diminfo_valid) { - const H5S_hyper_dim_t *tdiminfo; /* Temporary pointer to diminfo information */ - hsize_t iter_offset[H5S_MAX_RANK]; - hsize_t iter_count[H5S_MAX_RANK]; - int temp_dim; /* Temporary rank holder */ + if (iter->u.hyp.diminfo_valid) { + const H5S_hyper_dim_t *tdiminfo; /* Temporary pointer to diminfo information */ + hsize_t iter_offset[H5S_MAX_RANK]; + hsize_t iter_count[H5S_MAX_RANK]; + int temp_dim; /* Temporary rank holder */ /* Check if this is a "flattened" regular hyperslab selection */ - if(iter->u.hyp.iter_rank != 0 && iter->u.hyp.iter_rank < iter->rank) + if (iter->u.hyp.iter_rank != 0 && iter->u.hyp.iter_rank < iter->rank) /* Set the aliases for the dimension rank */ ndims = iter->u.hyp.iter_rank; else @@ -1262,21 +1248,21 @@ H5S__hyper_iter_next_block(H5S_sel_iter_t *iter) tdiminfo = iter->u.hyp.diminfo; /* Calculate the offset and block count for each dimension */ - for(u = 0; u < ndims; u++) { - if(tdiminfo[u].count == 1) { + for (u = 0; u < ndims; u++) { + if (tdiminfo[u].count == 1) { iter_offset[u] = iter->u.hyp.off[u] - tdiminfo[u].start; - iter_count[u] = 0; + iter_count[u] = 0; } /* end if */ else { iter_offset[u] = (iter->u.hyp.off[u] - tdiminfo[u].start) % tdiminfo[u].stride; - iter_count[u] = (iter->u.hyp.off[u] - tdiminfo[u].start) / tdiminfo[u].stride; + iter_count[u] = (iter->u.hyp.off[u] - tdiminfo[u].start) / tdiminfo[u].stride; } /* end else */ - } /* end for */ + } /* end for */ /* Advance one block */ temp_dim = fast_dim; /* Start with the fastest changing dimension */ - while(temp_dim >= 0) { - if(temp_dim == fast_dim) + while (temp_dim >= 0) { + if (temp_dim == fast_dim) /* Move iterator over current block */ iter_offset[temp_dim] += tdiminfo[temp_dim].block; else @@ -1284,53 +1270,54 @@ H5S__hyper_iter_next_block(H5S_sel_iter_t *iter) iter_offset[temp_dim]++; /* If this block is still in the range of blocks to output for the dimension, break out of loop */ - if(iter_offset[temp_dim] < tdiminfo[temp_dim].block) + if (iter_offset[temp_dim] < tdiminfo[temp_dim].block) break; else { /* Move to the next block in the current dimension */ iter_offset[temp_dim] = 0; iter_count[temp_dim]++; - /* If this block is still in the range of blocks to output for the dimension, break out of loop */ - if(iter_count[temp_dim] < tdiminfo[temp_dim].count) + /* If this block is still in the range of blocks to output for the dimension, break out of + * loop */ + if (iter_count[temp_dim] < tdiminfo[temp_dim].count) break; else iter_count[temp_dim] = 0; /* reset back to the beginning of the line */ - } /* end else */ + } /* end else */ /* Decrement dimension count */ temp_dim--; } /* end while */ /* Translate current iter_offset and iter_count into iterator position */ - for(u = 0; u < ndims; u++) + for (u = 0; u < ndims; u++) iter->u.hyp.off[u] = tdiminfo[u].start + (tdiminfo[u].stride * iter_count[u]) + iter_offset[u]; } /* end if */ /* Must be an irregular hyperslab selection */ else { - H5S_hyper_span_t *curr_span; /* Current hyperslab span node */ - H5S_hyper_span_t **ispan; /* Iterator's hyperslab span nodes */ - hsize_t *abs_arr; /* Absolute hyperslab span position */ - int curr_dim; /* Temporary rank holder */ + H5S_hyper_span_t * curr_span; /* Current hyperslab span node */ + H5S_hyper_span_t **ispan; /* Iterator's hyperslab span nodes */ + hsize_t * abs_arr; /* Absolute hyperslab span position */ + int curr_dim; /* Temporary rank holder */ /* Set the rank of the fastest changing dimension */ - ndims = iter->rank; + ndims = iter->rank; fast_dim = (int)ndims - 1; /* Get the pointers to the current span info and span nodes */ abs_arr = iter->u.hyp.off; - ispan = iter->u.hyp.span; + ispan = iter->u.hyp.span; /* Loop through, advancing the span information, until all the nelements are accounted for */ curr_dim = fast_dim; /* Start at the fastest dim */ /* Work back up through the dimensions */ - while(curr_dim >= 0) { + while (curr_dim >= 0) { /* Reset the current span */ curr_span = ispan[curr_dim]; /* Increment absolute position */ - if(curr_dim == fast_dim) + if (curr_dim == fast_dim) /* Move the iterator over rest of element in span */ abs_arr[curr_dim] = curr_span->high + 1; else @@ -1338,7 +1325,7 @@ H5S__hyper_iter_next_block(H5S_sel_iter_t *iter) abs_arr[curr_dim]++; /* Check if we are still within the span */ - if(abs_arr[curr_dim] <= curr_span->high) + if (abs_arr[curr_dim] <= curr_span->high) break; /* If we walked off that span, advance to the next span */ else { @@ -1346,7 +1333,7 @@ H5S__hyper_iter_next_block(H5S_sel_iter_t *iter) curr_span = curr_span->next; /* Check if we have a valid span in this dimension still */ - if(curr_span != NULL) { + if (curr_span != NULL) { /* Reset the span in the current dimension */ ispan[curr_dim] = curr_span; @@ -1356,15 +1343,16 @@ H5S__hyper_iter_next_block(H5S_sel_iter_t *iter) break; } /* end if */ else - /* If we finished the span list in this dimension, decrement the dimension worked on and loop again */ + /* If we finished the span list in this dimension, decrement the dimension worked on and + * loop again */ curr_dim--; } /* end else */ - } /* end while */ + } /* end while */ /* Check if we are finished with the spans in the tree */ - if(curr_dim >= 0) { + if (curr_dim >= 0) { /* Walk back down the iterator positions, resetting them */ - while(curr_dim < fast_dim) { + while (curr_dim < fast_dim) { HDassert(curr_span); HDassert(curr_span->down); HDassert(curr_span->down->head); @@ -1385,12 +1373,11 @@ H5S__hyper_iter_next_block(H5S_sel_iter_t *iter) /* Verify that the curr_span points to the fastest dim */ HDassert(curr_span == ispan[fast_dim]); } /* end if */ - } /* end else */ + } /* end else */ FUNC_LEAVE_NOAPI(SUCCEED) } /* end H5S__hyper_iter_next_block() */ - /*-------------------------------------------------------------------------- NAME H5S__hyper_iter_get_seq_list_gen @@ -1421,28 +1408,28 @@ H5S__hyper_iter_next_block(H5S_sel_iter_t *iter) REVISION LOG --------------------------------------------------------------------------*/ static herr_t -H5S__hyper_iter_get_seq_list_gen(H5S_sel_iter_t *iter, size_t maxseq, size_t maxelem, - size_t *nseq, size_t *nelem, hsize_t *off, size_t *len) +H5S__hyper_iter_get_seq_list_gen(H5S_sel_iter_t *iter, size_t maxseq, size_t maxelem, size_t *nseq, + size_t *nelem, hsize_t *off, size_t *len) { - H5S_hyper_span_t *curr_span; /* Current hyperslab span node */ - H5S_hyper_span_t **ispan; /* Iterator's hyperslab span nodes */ - hsize_t *slab; /* Cumulative size of each dimension in bytes */ - hsize_t loc_off; /* Byte offset in the dataspace */ - hsize_t last_span_end = 0; /* The offset of the end of the last span */ - hsize_t *abs_arr; /* Absolute hyperslab span position, in elements */ - hsize_t *loc_arr; /* Byte offset of hyperslab span position within buffer */ - const hssize_t *sel_off; /* Offset within the dataspace extent */ - size_t span_elmts = 0; /* Number of elements to actually use for this span */ - size_t span_size = 0; /* Number of bytes in current span to actually process */ - size_t io_left; /* Initial number of elements to process */ - size_t io_elmts_left; /* Number of elements left to process */ - size_t io_used; /* Number of elements processed */ - size_t curr_seq = 0; /* Number of sequence/offsets stored in the arrays */ - size_t elem_size; /* Size of each element iterating over */ - unsigned ndims; /* Number of dimensions of dataset */ - unsigned fast_dim; /* Rank of the fastest changing dimension for the dataspace */ - int curr_dim; /* Current dimension being operated on */ - unsigned u; /* Index variable */ + H5S_hyper_span_t * curr_span; /* Current hyperslab span node */ + H5S_hyper_span_t **ispan; /* Iterator's hyperslab span nodes */ + hsize_t * slab; /* Cumulative size of each dimension in bytes */ + hsize_t loc_off; /* Byte offset in the dataspace */ + hsize_t last_span_end = 0; /* The offset of the end of the last span */ + hsize_t * abs_arr; /* Absolute hyperslab span position, in elements */ + hsize_t * loc_arr; /* Byte offset of hyperslab span position within buffer */ + const hssize_t * sel_off; /* Offset within the dataspace extent */ + size_t span_elmts = 0; /* Number of elements to actually use for this span */ + size_t span_size = 0; /* Number of bytes in current span to actually process */ + size_t io_left; /* Initial number of elements to process */ + size_t io_elmts_left; /* Number of elements left to process */ + size_t io_used; /* Number of elements processed */ + size_t curr_seq = 0; /* Number of sequence/offsets stored in the arrays */ + size_t elem_size; /* Size of each element iterating over */ + unsigned ndims; /* Number of dimensions of dataset */ + unsigned fast_dim; /* Rank of the fastest changing dimension for the dataspace */ + int curr_dim; /* Current dimension being operated on */ + unsigned u; /* Index variable */ FUNC_ENTER_STATIC_NOERR @@ -1456,16 +1443,16 @@ H5S__hyper_iter_get_seq_list_gen(H5S_sel_iter_t *iter, size_t maxseq, size_t max HDassert(len); /* Set the rank of the fastest changing dimension */ - ndims = iter->rank; + ndims = iter->rank; fast_dim = (ndims - 1); /* Get the pointers to the current span info and span nodes */ curr_span = iter->u.hyp.span[fast_dim]; - abs_arr = iter->u.hyp.off; - loc_arr = iter->u.hyp.loc_off; - slab = iter->u.hyp.slab; - sel_off = iter->sel_off; - ispan = iter->u.hyp.span; + abs_arr = iter->u.hyp.off; + loc_arr = iter->u.hyp.loc_off; + slab = iter->u.hyp.slab; + sel_off = iter->sel_off; + ispan = iter->u.hyp.span; elem_size = iter->elmt_size; /* Set the amount of elements to perform I/O on, etc. */ @@ -1473,18 +1460,18 @@ H5S__hyper_iter_get_seq_list_gen(H5S_sel_iter_t *iter, size_t maxseq, size_t max io_elmts_left = io_left = MIN(maxelem, (size_t)iter->elmt_left); /* Set the offset of the first element iterated on */ - for(u = 0, loc_off = 0; u < ndims; u++) + for (u = 0, loc_off = 0; u < ndims; u++) loc_off += loc_arr[u]; /* Take care of any partial spans leftover from previous I/Os */ - if(abs_arr[fast_dim] != curr_span->low) { + if (abs_arr[fast_dim] != curr_span->low) { /* Finish the span in the fastest changing dimension */ /* Compute the number of elements to attempt in this span */ H5_CHECKED_ASSIGN(span_elmts, size_t, ((curr_span->high - abs_arr[fast_dim]) + 1), hsize_t); /* Check number of elements against upper bounds allowed */ - if(span_elmts > io_elmts_left) + if (span_elmts > io_elmts_left) span_elmts = io_elmts_left; /* Set the span_size, in bytes */ @@ -1504,26 +1491,27 @@ H5S__hyper_iter_get_seq_list_gen(H5S_sel_iter_t *iter, size_t maxseq, size_t max io_elmts_left -= span_elmts; /* Check if we are done */ - if(io_elmts_left > 0) { + if (io_elmts_left > 0) { /* Move to next span in fastest changing dimension */ curr_span = curr_span->next; - if(NULL != curr_span) { + if (NULL != curr_span) { /* Move location offset of destination */ loc_off += (curr_span->low - abs_arr[fast_dim]) * elem_size; /* Move iterator for fastest changing dimension */ abs_arr[fast_dim] = curr_span->low; - loc_arr[fast_dim] = ((hsize_t)((hssize_t)curr_span->low + sel_off[fast_dim])) * slab[fast_dim]; + loc_arr[fast_dim] = + ((hsize_t)((hssize_t)curr_span->low + sel_off[fast_dim])) * slab[fast_dim]; ispan[fast_dim] = curr_span; } /* end if */ - } /* end if */ + } /* end if */ else { /* Advance the hyperslab iterator */ abs_arr[fast_dim] += span_elmts; /* Check if we are still within the span */ - if(abs_arr[fast_dim] <= curr_span->high) { + if (abs_arr[fast_dim] <= curr_span->high) { /* Sanity check */ HDassert(ispan[fast_dim] == curr_span); @@ -1536,28 +1524,29 @@ H5S__hyper_iter_get_seq_list_gen(H5S_sel_iter_t *iter, size_t maxseq, size_t max curr_span = curr_span->next; /* Check if we have a valid span in this dimension still */ - if(NULL != curr_span) { + if (NULL != curr_span) { /* Reset absolute position */ abs_arr[fast_dim] = curr_span->low; /* Update location offset */ - loc_arr[fast_dim] = ((hsize_t)((hssize_t)curr_span->low + sel_off[fast_dim])) * slab[fast_dim]; + loc_arr[fast_dim] = + ((hsize_t)((hssize_t)curr_span->low + sel_off[fast_dim])) * slab[fast_dim]; /* Reset the span in the current dimension */ ispan[fast_dim] = curr_span; } /* end if */ - } /* end else */ - } /* end else */ + } /* end else */ + } /* end else */ /* Adjust iterator pointers */ - if(NULL == curr_span) { -/* Same as code in main loop */ + if (NULL == curr_span) { + /* Same as code in main loop */ /* Start at the next fastest dim */ curr_dim = (int)(fast_dim - 1); /* Work back up through the dimensions */ - while(curr_dim >= 0) { + while (curr_dim >= 0) { /* Reset the current span */ curr_span = ispan[curr_dim]; @@ -1565,7 +1554,7 @@ H5S__hyper_iter_get_seq_list_gen(H5S_sel_iter_t *iter, size_t maxseq, size_t max abs_arr[curr_dim]++; /* Check if we are still within the span */ - if(abs_arr[curr_dim] <= curr_span->high) { + if (abs_arr[curr_dim] <= curr_span->high) { /* Update location offset */ loc_arr[curr_dim] += slab[curr_dim]; @@ -1577,7 +1566,7 @@ H5S__hyper_iter_get_seq_list_gen(H5S_sel_iter_t *iter, size_t maxseq, size_t max curr_span = curr_span->next; /* Check if we have a valid span in this dimension still */ - if(NULL != curr_span) { + if (NULL != curr_span) { /* Reset the span in the current dimension */ ispan[curr_dim] = curr_span; @@ -1585,20 +1574,22 @@ H5S__hyper_iter_get_seq_list_gen(H5S_sel_iter_t *iter, size_t maxseq, size_t max abs_arr[curr_dim] = curr_span->low; /* Update byte location */ - loc_arr[curr_dim] = ((hsize_t)((hssize_t)curr_span->low + sel_off[curr_dim])) * slab[curr_dim]; + loc_arr[curr_dim] = + ((hsize_t)((hssize_t)curr_span->low + sel_off[curr_dim])) * slab[curr_dim]; break; } /* end if */ else - /* If we finished the span list in this dimension, decrement the dimension worked on and loop again */ + /* If we finished the span list in this dimension, decrement the dimension worked on + * and loop again */ curr_dim--; } /* end else */ - } /* end while */ + } /* end while */ /* Check if we have more spans in the tree */ - if(curr_dim >= 0) { + if (curr_dim >= 0) { /* Walk back down the iterator positions, resetting them */ - while((unsigned)curr_dim < fast_dim) { + while ((unsigned)curr_dim < fast_dim) { HDassert(curr_span); HDassert(curr_span->down); HDassert(curr_span->down->head); @@ -1616,25 +1607,26 @@ H5S__hyper_iter_get_seq_list_gen(H5S_sel_iter_t *iter, size_t maxseq, size_t max abs_arr[curr_dim] = curr_span->low; /* Update the location offset */ - loc_arr[curr_dim] = ((hsize_t)((hssize_t)curr_span->low + sel_off[curr_dim])) * slab[curr_dim]; + loc_arr[curr_dim] = + ((hsize_t)((hssize_t)curr_span->low + sel_off[curr_dim])) * slab[curr_dim]; } /* end while */ /* Verify that the curr_span points to the fastest dim */ HDassert(curr_span == ispan[fast_dim]); /* Reset the buffer offset */ - for(u = 0, loc_off = 0; u < ndims; u++) + for (u = 0, loc_off = 0; u < ndims; u++) loc_off += loc_arr[u]; } /* end else */ else /* We had better be done with I/O or bad things are going to happen... */ HDassert(io_elmts_left == 0); } /* end if */ - } /* end if */ + } /* end if */ /* Perform the I/O on the elements, based on the position of the iterator */ - while(io_elmts_left > 0 && curr_seq < maxseq) { - H5S_hyper_span_t *prev_span; /* Previous hyperslab span node */ + while (io_elmts_left > 0 && curr_seq < maxseq) { + H5S_hyper_span_t *prev_span; /* Previous hyperslab span node */ /* Sanity check */ HDassert(curr_span); @@ -1643,8 +1635,8 @@ H5S__hyper_iter_get_seq_list_gen(H5S_sel_iter_t *iter, size_t maxseq, size_t max prev_span = curr_span; /* Loop over all the spans in the fastest changing dimension */ - while(curr_span != NULL) { - hsize_t nelmts; /* # of elements covered by current span */ + while (curr_span != NULL) { + hsize_t nelmts; /* # of elements covered by current span */ /* Move location offset of current span */ loc_off += (curr_span->low - prev_span->low) * elem_size; @@ -1654,17 +1646,17 @@ H5S__hyper_iter_get_seq_list_gen(H5S_sel_iter_t *iter, size_t maxseq, size_t max H5_CHECKED_ASSIGN(span_elmts, size_t, nelmts, hsize_t); /* Check number of elements against upper bounds allowed */ - if(span_elmts >= io_elmts_left) { + if (span_elmts >= io_elmts_left) { /* Trim the number of elements to output */ - span_elmts = io_elmts_left; - span_size = span_elmts * elem_size; + span_elmts = io_elmts_left; + span_size = span_elmts * elem_size; io_elmts_left = 0; -/* COMMON */ + /* COMMON */ /* Store the I/O information for the span */ /* Check if this is appending onto previous sequence */ - if(curr_seq > 0 && last_span_end == loc_off) + if (curr_seq > 0 && last_span_end == loc_off) len[curr_seq - 1] += span_size; else { off[curr_seq] = loc_off; @@ -1673,7 +1665,7 @@ H5S__hyper_iter_get_seq_list_gen(H5S_sel_iter_t *iter, size_t maxseq, size_t max /* Increment the number of sequences in arrays */ curr_seq++; } /* end else */ -/* end COMMON */ + /* end COMMON */ /* Break out now, we are finished with I/O */ break; @@ -1683,11 +1675,11 @@ H5S__hyper_iter_get_seq_list_gen(H5S_sel_iter_t *iter, size_t maxseq, size_t max span_size = span_elmts * elem_size; io_elmts_left -= span_elmts; -/* COMMON */ + /* COMMON */ /* Store the I/O information for the span */ /* Check if this is appending onto previous sequence */ - if(curr_seq > 0 && last_span_end == loc_off) + if (curr_seq > 0 && last_span_end == loc_off) len[curr_seq - 1] += span_size; else { off[curr_seq] = loc_off; @@ -1696,10 +1688,10 @@ H5S__hyper_iter_get_seq_list_gen(H5S_sel_iter_t *iter, size_t maxseq, size_t max /* Increment the number of sequences in arrays */ curr_seq++; } /* end else */ -/* end COMMON */ + /* end COMMON */ /* If the sequence & offset arrays are full, do what? */ - if(curr_seq >= maxseq) + if (curr_seq >= maxseq) /* Break out now, we are finished with sequences */ break; } /* end else */ @@ -1707,13 +1699,13 @@ H5S__hyper_iter_get_seq_list_gen(H5S_sel_iter_t *iter, size_t maxseq, size_t max /* Set the location of the last span's end */ last_span_end = loc_off + span_size; - /* Move to next span in fastest changing dimension */ + /* Move to next span in fastest changing dimension */ prev_span = curr_span; - curr_span = curr_span->next; + curr_span = curr_span->next; } /* end while */ /* Check if we are done */ - if(io_elmts_left == 0 || curr_seq >= maxseq) { + if (io_elmts_left == 0 || curr_seq >= maxseq) { /* Sanity checks */ HDassert(curr_span); @@ -1721,12 +1713,14 @@ H5S__hyper_iter_get_seq_list_gen(H5S_sel_iter_t *iter, size_t maxseq, size_t max abs_arr[fast_dim] = curr_span->low + span_elmts; /* Check if we are still within the span */ - if(abs_arr[fast_dim] <= curr_span->high) { + if (abs_arr[fast_dim] <= curr_span->high) { /* Reset the span for the fast dimension */ ispan[fast_dim] = curr_span; /* Update location offset */ - loc_arr[fast_dim] = ((hsize_t)((hssize_t)curr_span->low + (hssize_t)span_elmts + sel_off[fast_dim])) * slab[fast_dim]; + loc_arr[fast_dim] = + ((hsize_t)((hssize_t)curr_span->low + (hssize_t)span_elmts + sel_off[fast_dim])) * + slab[fast_dim]; break; } /* end if */ @@ -1736,16 +1730,17 @@ H5S__hyper_iter_get_seq_list_gen(H5S_sel_iter_t *iter, size_t maxseq, size_t max curr_span = curr_span->next; /* Check if we have a valid span in this dimension still */ - if(curr_span != NULL) { + if (curr_span != NULL) { /* Reset absolute position */ abs_arr[fast_dim] = curr_span->low; - loc_arr[fast_dim] = ((hsize_t)((hssize_t)curr_span->low + sel_off[fast_dim])) * slab[fast_dim]; + loc_arr[fast_dim] = + ((hsize_t)((hssize_t)curr_span->low + sel_off[fast_dim])) * slab[fast_dim]; ispan[fast_dim] = curr_span; break; } /* end if */ - } /* end else */ - } /* end if */ + } /* end else */ + } /* end if */ /* Adjust iterator pointers */ @@ -1753,7 +1748,7 @@ H5S__hyper_iter_get_seq_list_gen(H5S_sel_iter_t *iter, size_t maxseq, size_t max curr_dim = (int)(fast_dim - 1); /* Work back up through the dimensions */ - while(curr_dim >= 0) { + while (curr_dim >= 0) { /* Reset the current span */ curr_span = ispan[curr_dim]; @@ -1761,7 +1756,7 @@ H5S__hyper_iter_get_seq_list_gen(H5S_sel_iter_t *iter, size_t maxseq, size_t max abs_arr[curr_dim]++; /* Check if we are still within the span */ - if(abs_arr[curr_dim] <= curr_span->high) { + if (abs_arr[curr_dim] <= curr_span->high) { /* Update location offset */ loc_arr[curr_dim] += slab[curr_dim]; @@ -1773,7 +1768,7 @@ H5S__hyper_iter_get_seq_list_gen(H5S_sel_iter_t *iter, size_t maxseq, size_t max curr_span = curr_span->next; /* Check if we have a valid span in this dimension still */ - if(curr_span != NULL) { + if (curr_span != NULL) { /* Reset the span in the current dimension */ ispan[curr_dim] = curr_span; @@ -1781,25 +1776,27 @@ H5S__hyper_iter_get_seq_list_gen(H5S_sel_iter_t *iter, size_t maxseq, size_t max abs_arr[curr_dim] = curr_span->low; /* Update location offset */ - loc_arr[curr_dim] = ((hsize_t)((hssize_t)curr_span->low + sel_off[curr_dim])) * slab[curr_dim]; + loc_arr[curr_dim] = + ((hsize_t)((hssize_t)curr_span->low + sel_off[curr_dim])) * slab[curr_dim]; break; } /* end if */ else - /* If we finished the span list in this dimension, decrement the dimension worked on and loop again */ + /* If we finished the span list in this dimension, decrement the dimension worked on and + * loop again */ curr_dim--; } /* end else */ - } /* end while */ + } /* end while */ /* Check if we are finished with the spans in the tree */ - if(curr_dim < 0) { + if (curr_dim < 0) { /* We had better be done with I/O or bad things are going to happen... */ HDassert(io_elmts_left == 0); break; } /* end if */ else { /* Walk back down the iterator positions, resetting them */ - while((unsigned)curr_dim < fast_dim) { + while ((unsigned)curr_dim < fast_dim) { HDassert(curr_span); HDassert(curr_span->down); HDassert(curr_span->down->head); @@ -1817,7 +1814,8 @@ H5S__hyper_iter_get_seq_list_gen(H5S_sel_iter_t *iter, size_t maxseq, size_t max abs_arr[curr_dim] = curr_span->low; /* Update location offset */ - loc_arr[curr_dim] = ((hsize_t)((hssize_t)curr_span->low + sel_off[curr_dim])) * slab[curr_dim]; + loc_arr[curr_dim] = + ((hsize_t)((hssize_t)curr_span->low + sel_off[curr_dim])) * slab[curr_dim]; } /* end while */ /* Verify that the curr_span points to the fastest dim */ @@ -1825,7 +1823,7 @@ H5S__hyper_iter_get_seq_list_gen(H5S_sel_iter_t *iter, size_t maxseq, size_t max } /* end else */ /* Reset the buffer offset */ - for(u = 0, loc_off = 0; u < ndims; u++) + for (u = 0, loc_off = 0; u < ndims; u++) loc_off += loc_arr[u]; } /* end while */ @@ -1842,7 +1840,6 @@ H5S__hyper_iter_get_seq_list_gen(H5S_sel_iter_t *iter, size_t maxseq, size_t max FUNC_LEAVE_NOAPI(SUCCEED) } /* end H5S__hyper_iter_get_seq_list_gen() */ - /*-------------------------------------------------------------------------- NAME H5S__hyper_iter_get_seq_list_opt @@ -1873,39 +1870,37 @@ H5S__hyper_iter_get_seq_list_gen(H5S_sel_iter_t *iter, size_t maxseq, size_t max REVISION LOG --------------------------------------------------------------------------*/ static herr_t -H5S__hyper_iter_get_seq_list_opt(H5S_sel_iter_t *iter, size_t maxseq, size_t maxelem, - size_t *nseq, size_t *nelem, hsize_t *off, size_t *len) +H5S__hyper_iter_get_seq_list_opt(H5S_sel_iter_t *iter, size_t maxseq, size_t maxelem, size_t *nseq, + size_t *nelem, hsize_t *off, size_t *len) { - hsize_t *mem_size; /* Size of the source buffer */ - hsize_t *slab; /* Hyperslab size */ - const hssize_t *sel_off; /* Selection offset in dataspace */ - hsize_t offset[H5S_MAX_RANK]; /* Coordinate offset in dataspace */ - hsize_t tmp_count[H5S_MAX_RANK]; /* Temporary block count */ - hsize_t tmp_block[H5S_MAX_RANK]; /* Temporary block offset */ - hsize_t wrap[H5S_MAX_RANK]; /* Bytes to wrap around at the end of a row */ - hsize_t skip[H5S_MAX_RANK]; /* Bytes to skip between blocks */ - const H5S_hyper_dim_t *tdiminfo; /* Temporary pointer to diminfo information */ - hsize_t fast_dim_start, /* Local copies of fastest changing dimension info */ - fast_dim_stride, - fast_dim_block, - fast_dim_offset; - size_t fast_dim_buf_off; /* Local copy of amount to move fastest dimension buffer offset */ - size_t fast_dim_count; /* Number of blocks left in fastest changing dimension */ - size_t tot_blk_count; /* Total number of blocks left to output */ - size_t act_blk_count; /* Actual number of blocks to output */ - size_t total_rows; /* Total number of entire rows to output */ - size_t curr_rows; /* Current number of entire rows to output */ - unsigned fast_dim; /* Rank of the fastest changing dimension for the dataspace */ - unsigned ndims; /* Number of dimensions of dataset */ - int temp_dim; /* Temporary rank holder */ - hsize_t loc; /* Coordinate offset */ - size_t curr_seq = 0; /* Current sequence being operated on */ - size_t actual_elem; /* The actual number of elements to count */ - size_t actual_bytes;/* The actual number of bytes to copy */ - size_t io_left; /* The number of elements left in I/O operation */ - size_t start_io_left; /* The initial number of elements left in I/O operation */ - size_t elem_size; /* Size of each element iterating over */ - unsigned u; /* Local index variable */ + hsize_t * mem_size; /* Size of the source buffer */ + hsize_t * slab; /* Hyperslab size */ + const hssize_t * sel_off; /* Selection offset in dataspace */ + hsize_t offset[H5S_MAX_RANK]; /* Coordinate offset in dataspace */ + hsize_t tmp_count[H5S_MAX_RANK]; /* Temporary block count */ + hsize_t tmp_block[H5S_MAX_RANK]; /* Temporary block offset */ + hsize_t wrap[H5S_MAX_RANK]; /* Bytes to wrap around at the end of a row */ + hsize_t skip[H5S_MAX_RANK]; /* Bytes to skip between blocks */ + const H5S_hyper_dim_t *tdiminfo; /* Temporary pointer to diminfo information */ + hsize_t fast_dim_start, /* Local copies of fastest changing dimension info */ + fast_dim_stride, fast_dim_block, fast_dim_offset; + size_t fast_dim_buf_off; /* Local copy of amount to move fastest dimension buffer offset */ + size_t fast_dim_count; /* Number of blocks left in fastest changing dimension */ + size_t tot_blk_count; /* Total number of blocks left to output */ + size_t act_blk_count; /* Actual number of blocks to output */ + size_t total_rows; /* Total number of entire rows to output */ + size_t curr_rows; /* Current number of entire rows to output */ + unsigned fast_dim; /* Rank of the fastest changing dimension for the dataspace */ + unsigned ndims; /* Number of dimensions of dataset */ + int temp_dim; /* Temporary rank holder */ + hsize_t loc; /* Coordinate offset */ + size_t curr_seq = 0; /* Current sequence being operated on */ + size_t actual_elem; /* The actual number of elements to count */ + size_t actual_bytes; /* The actual number of bytes to copy */ + size_t io_left; /* The number of elements left in I/O operation */ + size_t start_io_left; /* The initial number of elements left in I/O operation */ + size_t elem_size; /* Size of each element iterating over */ + unsigned u; /* Local index variable */ FUNC_ENTER_STATIC_NOERR @@ -1922,7 +1917,7 @@ H5S__hyper_iter_get_seq_list_opt(H5S_sel_iter_t *iter, size_t maxseq, size_t max tdiminfo = iter->u.hyp.diminfo; /* Check if this is a "flattened" regular hyperslab selection */ - if(iter->u.hyp.iter_rank != 0 && iter->u.hyp.iter_rank < iter->rank) { + if (iter->u.hyp.iter_rank != 0 && iter->u.hyp.iter_rank < iter->rank) { /* Set the aliases for a few important dimension ranks */ ndims = iter->u.hyp.iter_rank; @@ -1944,9 +1939,9 @@ H5S__hyper_iter_get_seq_list_opt(H5S_sel_iter_t *iter, size_t maxseq, size_t max } /* end else */ /* Set up some local variables */ - fast_dim = ndims - 1; + fast_dim = ndims - 1; elem_size = iter->elmt_size; - slab = iter->u.hyp.slab; + slab = iter->u.hyp.slab; /* Calculate the number of elements to sequence through */ H5_CHECK_OVERFLOW(iter->elmt_left, hsize_t, size_t); @@ -1954,7 +1949,7 @@ H5S__hyper_iter_get_seq_list_opt(H5S_sel_iter_t *iter, size_t maxseq, size_t max /* Sanity check that there aren't any "remainder" sequences in process */ HDassert(!((iter->u.hyp.off[fast_dim] - tdiminfo[fast_dim].start) % tdiminfo[fast_dim].stride != 0 || - ((iter->u.hyp.off[fast_dim] != tdiminfo[fast_dim].start) && tdiminfo[fast_dim].count == 1))); + ((iter->u.hyp.off[fast_dim] != tdiminfo[fast_dim].start) && tdiminfo[fast_dim].count == 1))); /* We've cleared the "remainder" of the previous fastest dimension * sequence before calling this routine, so we must be at the beginning of @@ -1969,12 +1964,12 @@ H5S__hyper_iter_get_seq_list_opt(H5S_sel_iter_t *iter, size_t maxseq, size_t max /* Copy the location of the point to get */ /* (Add in the selection offset) */ - for(u = 0; u < ndims; u++) + for (u = 0; u < ndims; u++) offset[u] = (hsize_t)((hssize_t)iter->u.hyp.off[u] + sel_off[u]); /* Compute the current "counts" for this location */ - for(u = 0; u < ndims; u++) { - if(tdiminfo[u].count == 1) { + for (u = 0; u < ndims; u++) { + if (tdiminfo[u].count == 1) { tmp_count[u] = 0; tmp_block[u] = iter->u.hyp.off[u] - tdiminfo[u].start; } /* end if */ @@ -1982,10 +1977,10 @@ H5S__hyper_iter_get_seq_list_opt(H5S_sel_iter_t *iter, size_t maxseq, size_t max tmp_count[u] = (iter->u.hyp.off[u] - tdiminfo[u].start) / tdiminfo[u].stride; tmp_block[u] = (iter->u.hyp.off[u] - tdiminfo[u].start) % tdiminfo[u].stride; } /* end else */ - } /* end for */ + } /* end for */ /* Compute the initial buffer offset */ - for(u = 0, loc = 0; u < ndims; u++) + for (u = 0, loc = 0; u < ndims; u++) loc += offset[u] * slab[u]; /* Set the number of elements to write each time */ @@ -1995,9 +1990,9 @@ H5S__hyper_iter_get_seq_list_opt(H5S_sel_iter_t *iter, size_t maxseq, size_t max actual_bytes = actual_elem * elem_size; /* Set local copies of information for the fastest changing dimension */ - fast_dim_start = tdiminfo[fast_dim].start; + fast_dim_start = tdiminfo[fast_dim].start; fast_dim_stride = tdiminfo[fast_dim].stride; - fast_dim_block = tdiminfo[fast_dim].block; + fast_dim_block = tdiminfo[fast_dim].block; H5_CHECKED_ASSIGN(fast_dim_buf_off, size_t, slab[fast_dim] * fast_dim_stride, hsize_t); fast_dim_offset = (hsize_t)((hssize_t)fast_dim_start + sel_off[fast_dim]); @@ -2009,15 +2004,15 @@ H5S__hyper_iter_get_seq_list_opt(H5S_sel_iter_t *iter, size_t maxseq, size_t max tot_blk_count = MIN(tot_blk_count, (maxseq - curr_seq)); /* Compute the amount to wrap at the end of each row */ - for(u = 0; u < ndims; u++) + for (u = 0; u < ndims; u++) wrap[u] = (mem_size[u] - (tdiminfo[u].stride * tdiminfo[u].count)) * slab[u]; /* Compute the amount to skip between blocks */ - for(u = 0; u < ndims; u++) + for (u = 0; u < ndims; u++) skip[u] = (tdiminfo[u].stride - tdiminfo[u].block) * slab[u]; /* Check if there is a partial row left (with full blocks) */ - if(tmp_count[fast_dim] > 0) { + if (tmp_count[fast_dim] > 0) { /* Get number of blocks in fastest dimension */ H5_CHECKED_ASSIGN(fast_dim_count, size_t, tdiminfo[fast_dim].count - tmp_count[fast_dim], hsize_t); @@ -2028,7 +2023,7 @@ H5S__hyper_iter_get_seq_list_opt(H5S_sel_iter_t *iter, size_t maxseq, size_t max act_blk_count = fast_dim_count; /* Loop over all the blocks in the fastest changing dimension */ - while(fast_dim_count > 0) { + while (fast_dim_count > 0) { /* Store the sequence information */ off[curr_seq] = loc; len[curr_seq] = actual_bytes; @@ -2053,23 +2048,24 @@ H5S__hyper_iter_get_seq_list_opt(H5S_sel_iter_t *iter, size_t maxseq, size_t max tmp_count[fast_dim] += act_blk_count; /* Check if we finished the entire row of blocks */ - if(tmp_count[fast_dim] >= tdiminfo[fast_dim].count) { + if (tmp_count[fast_dim] >= tdiminfo[fast_dim].count) { /* Increment offset in destination buffer */ loc += wrap[fast_dim]; /* Increment information to reflect block just processed */ - offset[fast_dim] = fast_dim_offset; /* reset the offset in the fastest dimension */ + offset[fast_dim] = fast_dim_offset; /* reset the offset in the fastest dimension */ tmp_count[fast_dim] = 0; /* Increment the offset and count for the other dimensions */ temp_dim = (int)fast_dim - 1; - while(temp_dim >= 0) { + while (temp_dim >= 0) { /* Move to the next row in the curent dimension */ offset[temp_dim]++; tmp_block[temp_dim]++; - /* If this block is still in the range of blocks to output for the dimension, break out of loop */ - if(tmp_block[temp_dim] < tdiminfo[temp_dim].block) + /* If this block is still in the range of blocks to output for the dimension, break out of + * loop */ + if (tmp_block[temp_dim] < tdiminfo[temp_dim].block) break; else { /* Move to the next block in the current dimension */ @@ -2078,8 +2074,9 @@ H5S__hyper_iter_get_seq_list_opt(H5S_sel_iter_t *iter, size_t maxseq, size_t max tmp_block[temp_dim] = 0; tmp_count[temp_dim]++; - /* If this block is still in the range of blocks to output for the dimension, break out of loop */ - if(tmp_count[temp_dim] < tdiminfo[temp_dim].count) + /* If this block is still in the range of blocks to output for the dimension, break out of + * loop */ + if (tmp_count[temp_dim] < tdiminfo[temp_dim].count) break; else { offset[temp_dim] = (hsize_t)((hssize_t)tdiminfo[temp_dim].start + sel_off[temp_dim]); @@ -2087,17 +2084,17 @@ H5S__hyper_iter_get_seq_list_opt(H5S_sel_iter_t *iter, size_t maxseq, size_t max tmp_count[temp_dim] = 0; /* reset back to the beginning of the line */ tmp_block[temp_dim] = 0; } /* end else */ - } /* end else */ + } /* end else */ /* Decrement dimension count */ temp_dim--; } /* end while */ - } /* end if */ + } /* end if */ else { /* Update the offset in the fastest dimension */ offset[fast_dim] += (fast_dim_stride * act_blk_count); } /* end else */ - } /* end if */ + } /* end if */ /* Compute the number of entire rows to read in */ H5_CHECK_OVERFLOW(tot_blk_count / tdiminfo[fast_dim].count, hsize_t, size_t); @@ -2107,28 +2104,28 @@ H5S__hyper_iter_get_seq_list_opt(H5S_sel_iter_t *iter, size_t maxseq, size_t max H5_CHECKED_ASSIGN(fast_dim_count, size_t, tdiminfo[fast_dim].count, hsize_t); /* Read in data until an entire sequence can't be written out any longer */ - while(curr_rows > 0) { - -#define DUFF_GUTS \ -/* Store the sequence information */ \ -off[curr_seq] = loc; \ -len[curr_seq] = actual_bytes; \ - \ -/* Increment sequence count */ \ -curr_seq++; \ - \ -/* Increment information to reflect block just processed */ \ -loc += fast_dim_buf_off; + while (curr_rows > 0) { + +#define DUFF_GUTS \ + /* Store the sequence information */ \ + off[curr_seq] = loc; \ + len[curr_seq] = actual_bytes; \ + \ + /* Increment sequence count */ \ + curr_seq++; \ + \ + /* Increment information to reflect block just processed */ \ + loc += fast_dim_buf_off; #ifdef NO_DUFFS_DEVICE /* Loop over all the blocks in the fastest changing dimension */ - while(fast_dim_count > 0) { + while (fast_dim_count > 0) { DUFF_GUTS /* Decrement number of blocks */ fast_dim_count--; } /* end while */ -#else /* NO_DUFFS_DEVICE */ +#else /* NO_DUFFS_DEVICE */ { size_t duffs_index; /* Counting index for Duff's device */ @@ -2138,34 +2135,33 @@ loc += fast_dim_buf_off; HDassert(0 && "This Should never be executed!"); break; case 0: - do - { - DUFF_GUTS - H5_ATTR_FALLTHROUGH - case 7: - DUFF_GUTS - H5_ATTR_FALLTHROUGH - case 6: - DUFF_GUTS - H5_ATTR_FALLTHROUGH - case 5: - DUFF_GUTS - H5_ATTR_FALLTHROUGH - case 4: - DUFF_GUTS - H5_ATTR_FALLTHROUGH - case 3: - DUFF_GUTS - H5_ATTR_FALLTHROUGH - case 2: + do { DUFF_GUTS H5_ATTR_FALLTHROUGH - case 1: - DUFF_GUTS - } while (--duffs_index > 0); + case 7: + DUFF_GUTS + H5_ATTR_FALLTHROUGH + case 6: + DUFF_GUTS + H5_ATTR_FALLTHROUGH + case 5: + DUFF_GUTS + H5_ATTR_FALLTHROUGH + case 4: + DUFF_GUTS + H5_ATTR_FALLTHROUGH + case 3: + DUFF_GUTS + H5_ATTR_FALLTHROUGH + case 2: + DUFF_GUTS + H5_ATTR_FALLTHROUGH + case 1: + DUFF_GUTS + } while (--duffs_index > 0); } /* end switch */ } -#endif /* NO_DUFFS_DEVICE */ +#endif /* NO_DUFFS_DEVICE */ #undef DUFF_GUTS /* Increment offset in destination buffer */ @@ -2173,13 +2169,13 @@ loc += fast_dim_buf_off; /* Increment the offset and count for the other dimensions */ temp_dim = (int)fast_dim - 1; - while(temp_dim >= 0) { + while (temp_dim >= 0) { /* Move to the next row in the curent dimension */ offset[temp_dim]++; tmp_block[temp_dim]++; /* If this block is still in the range of blocks to output for the dimension, break out of loop */ - if(tmp_block[temp_dim] < tdiminfo[temp_dim].block) + if (tmp_block[temp_dim] < tdiminfo[temp_dim].block) break; else { /* Move to the next block in the current dimension */ @@ -2188,8 +2184,9 @@ loc += fast_dim_buf_off; tmp_block[temp_dim] = 0; tmp_count[temp_dim]++; - /* If this block is still in the range of blocks to output for the dimension, break out of loop */ - if(tmp_count[temp_dim] < tdiminfo[temp_dim].count) + /* If this block is still in the range of blocks to output for the dimension, break out of + * loop */ + if (tmp_count[temp_dim] < tdiminfo[temp_dim].count) break; else { offset[temp_dim] = (hsize_t)((hssize_t)tdiminfo[temp_dim].start + sel_off[temp_dim]); @@ -2197,7 +2194,7 @@ loc += fast_dim_buf_off; tmp_count[temp_dim] = 0; /* reset back to the beginning of the line */ tmp_block[temp_dim] = 0; } /* end else */ - } /* end else */ + } /* end else */ /* Decrement dimension count */ temp_dim--; @@ -2218,12 +2215,12 @@ loc += fast_dim_buf_off; tot_blk_count -= (size_t)(total_rows * tdiminfo[fast_dim].count); /* Read in partial row of blocks */ - if(io_left > 0 && curr_seq < maxseq) { + if (io_left > 0 && curr_seq < maxseq) { /* Get remaining number of blocks left to output */ fast_dim_count = tot_blk_count; /* Loop over all the blocks in the fastest changing dimension */ - while(fast_dim_count > 0) { + while (fast_dim_count > 0) { /* Store the sequence information */ off[curr_seq] = loc; len[curr_seq] = actual_bytes; @@ -2242,11 +2239,11 @@ loc += fast_dim_buf_off; io_left -= actual_elem * tot_blk_count; /* Increment information to reflect block just processed */ - offset[fast_dim] += (fast_dim_stride * tot_blk_count); /* move the offset in the fastest dimension */ + offset[fast_dim] += (fast_dim_stride * tot_blk_count); /* move the offset in the fastest dimension */ /* Handle any leftover, partial blocks in this row */ - if(io_left > 0 && curr_seq < maxseq) { - actual_elem = io_left; + if (io_left > 0 && curr_seq < maxseq) { + actual_elem = io_left; actual_bytes = actual_elem * elem_size; /* Store the sequence information */ @@ -2271,7 +2268,7 @@ loc += fast_dim_buf_off; /* Update the iterator with the location we stopped */ /* (Subtract out the selection offset) */ - for(u = 0; u < ndims; u++) + for (u = 0; u < ndims; u++) iter->u.hyp.off[u] = (hsize_t)((hssize_t)offset[u] - sel_off[u]); /* Decrement the number of elements left in selection */ @@ -2286,7 +2283,6 @@ loc += fast_dim_buf_off; FUNC_LEAVE_NOAPI(SUCCEED) } /* end H5S__hyper_iter_get_seq_list_opt() */ - /*-------------------------------------------------------------------------- NAME H5S__hyper_iter_get_seq_list_single @@ -2318,25 +2314,25 @@ loc += fast_dim_buf_off; REVISION LOG --------------------------------------------------------------------------*/ static herr_t -H5S__hyper_iter_get_seq_list_single(H5S_sel_iter_t *iter, size_t maxseq, size_t maxelem, - size_t *nseq, size_t *nelem, hsize_t *off, size_t *len) +H5S__hyper_iter_get_seq_list_single(H5S_sel_iter_t *iter, size_t maxseq, size_t maxelem, size_t *nseq, + size_t *nelem, hsize_t *off, size_t *len) { - const H5S_hyper_dim_t *tdiminfo; /* Temporary pointer to diminfo information */ - const hssize_t *sel_off; /* Selection offset in dataspace */ - hsize_t *mem_size; /* Size of the source buffer */ - hsize_t base_offset[H5S_MAX_RANK]; /* Base coordinate offset in dataspace */ - hsize_t offset[H5S_MAX_RANK]; /* Coordinate offset in dataspace */ - hsize_t *slab; /* Hyperslab size */ - hsize_t fast_dim_block; /* Local copies of fastest changing dimension info */ - hsize_t loc; /* Coordinate offset */ - size_t tot_blk_count; /* Total number of blocks left to output */ - size_t elem_size; /* Size of each element iterating over */ - size_t io_left; /* The number of elements left in I/O operation */ - size_t actual_elem; /* The actual number of elements to count */ - unsigned ndims; /* Number of dimensions of dataset */ - unsigned fast_dim; /* Rank of the fastest changing dimension for the dataspace */ - unsigned skip_dim; /* Rank of the dimension to skip along */ - unsigned u; /* Local index variable */ + const H5S_hyper_dim_t *tdiminfo; /* Temporary pointer to diminfo information */ + const hssize_t * sel_off; /* Selection offset in dataspace */ + hsize_t * mem_size; /* Size of the source buffer */ + hsize_t base_offset[H5S_MAX_RANK]; /* Base coordinate offset in dataspace */ + hsize_t offset[H5S_MAX_RANK]; /* Coordinate offset in dataspace */ + hsize_t * slab; /* Hyperslab size */ + hsize_t fast_dim_block; /* Local copies of fastest changing dimension info */ + hsize_t loc; /* Coordinate offset */ + size_t tot_blk_count; /* Total number of blocks left to output */ + size_t elem_size; /* Size of each element iterating over */ + size_t io_left; /* The number of elements left in I/O operation */ + size_t actual_elem; /* The actual number of elements to count */ + unsigned ndims; /* Number of dimensions of dataset */ + unsigned fast_dim; /* Rank of the fastest changing dimension for the dataspace */ + unsigned skip_dim; /* Rank of the dimension to skip along */ + unsigned u; /* Local index variable */ FUNC_ENTER_STATIC_NOERR @@ -2353,7 +2349,7 @@ H5S__hyper_iter_get_seq_list_single(H5S_sel_iter_t *iter, size_t maxseq, size_t tdiminfo = iter->u.hyp.diminfo; /* Check if this is a "flattened" regular hyperslab selection */ - if(iter->u.hyp.iter_rank != 0 && iter->u.hyp.iter_rank < iter->rank) { + if (iter->u.hyp.iter_rank != 0 && iter->u.hyp.iter_rank < iter->rank) { /* Set the aliases for a few important dimension ranks */ ndims = iter->u.hyp.iter_rank; @@ -2375,22 +2371,22 @@ H5S__hyper_iter_get_seq_list_single(H5S_sel_iter_t *iter, size_t maxseq, size_t } /* end else */ /* Set up some local variables */ - fast_dim = ndims - 1; + fast_dim = ndims - 1; elem_size = iter->elmt_size; - slab = iter->u.hyp.slab; + slab = iter->u.hyp.slab; /* Copy the base location of the block */ /* (Add in the selection offset) */ - for(u = 0; u < ndims; u++) + for (u = 0; u < ndims; u++) base_offset[u] = (hsize_t)((hssize_t)tdiminfo[u].start + sel_off[u]); /* Copy the location of the point to get */ /* (Add in the selection offset) */ - for(u = 0; u < ndims; u++) + for (u = 0; u < ndims; u++) offset[u] = (hsize_t)((hssize_t)iter->u.hyp.off[u] + sel_off[u]); /* Compute the initial buffer offset */ - for(u = 0, loc = 0; u < ndims; u++) + for (u = 0, loc = 0; u < ndims; u++) loc += offset[u] * slab[u]; /* Set local copies of information for the fastest changing dimension */ @@ -2411,14 +2407,14 @@ H5S__hyper_iter_get_seq_list_single(H5S_sel_iter_t *iter, size_t maxseq, size_t H5_CHECKED_ASSIGN(actual_elem, size_t, fast_dim_block, hsize_t); /* Check for blocks to operate on */ - if(tot_blk_count > 0) { - size_t actual_bytes; /* The actual number of bytes to copy */ + if (tot_blk_count > 0) { + size_t actual_bytes; /* The actual number of bytes to copy */ /* Set the number of actual bytes */ actual_bytes = actual_elem * elem_size; /* Check for 1-dim selection */ - if(0 == fast_dim) { + if (0 == fast_dim) { /* Sanity checks */ HDassert(1 == tot_blk_count); HDassert(io_left == actual_elem); @@ -2428,24 +2424,24 @@ H5S__hyper_iter_get_seq_list_single(H5S_sel_iter_t *iter, size_t maxseq, size_t *len++ = actual_bytes; } /* end if */ else { - hsize_t skip_slab; /* Temporary copy of slab[fast_dim - 1] */ - size_t blk_count; /* Total number of blocks left to output */ - int i; /* Local index variable */ + hsize_t skip_slab; /* Temporary copy of slab[fast_dim - 1] */ + size_t blk_count; /* Total number of blocks left to output */ + int i; /* Local index variable */ /* Find first dimension w/block >1 */ skip_dim = fast_dim; - for(i = (int)(fast_dim - 1); i >= 0; i--) - if(tdiminfo[i].block > 1) { + for (i = (int)(fast_dim - 1); i >= 0; i--) + if (tdiminfo[i].block > 1) { skip_dim = (unsigned)i; break; } /* end if */ skip_slab = slab[skip_dim]; /* Check for being able to use fast algorithm for 1-D */ - if(0 == skip_dim) { + if (0 == skip_dim) { /* Create sequences until an entire row can't be used */ blk_count = tot_blk_count; - while(blk_count > 0) { + while (blk_count > 0) { /* Store the sequence information */ *off++ = loc; *len++ = actual_bytes; @@ -2461,21 +2457,21 @@ H5S__hyper_iter_get_seq_list_single(H5S_sel_iter_t *iter, size_t maxseq, size_t offset[skip_dim] += tot_blk_count; } /* end if */ else { - hsize_t tmp_block[H5S_MAX_RANK]; /* Temporary block offset */ - hsize_t skip[H5S_MAX_RANK]; /* Bytes to skip between blocks */ - int temp_dim; /* Temporary rank holder */ + hsize_t tmp_block[H5S_MAX_RANK]; /* Temporary block offset */ + hsize_t skip[H5S_MAX_RANK]; /* Bytes to skip between blocks */ + int temp_dim; /* Temporary rank holder */ /* Set the starting block location */ - for(u = 0; u < ndims; u++) + for (u = 0; u < ndims; u++) tmp_block[u] = iter->u.hyp.off[u] - tdiminfo[u].start; /* Compute the amount to skip between sequences */ - for(u = 0; u < ndims; u++) + for (u = 0; u < ndims; u++) skip[u] = (mem_size[u] - tdiminfo[u].block) * slab[u]; /* Create sequences until an entire row can't be used */ blk_count = tot_blk_count; - while(blk_count > 0) { + while (blk_count > 0) { /* Store the sequence information */ *off++ = loc; *len++ = actual_bytes; @@ -2487,13 +2483,14 @@ H5S__hyper_iter_get_seq_list_single(H5S_sel_iter_t *iter, size_t maxseq, size_t loc += skip_slab; /* Increment the offset and count for the other dimensions */ - while(temp_dim >= 0) { + while (temp_dim >= 0) { /* Move to the next row in the curent dimension */ offset[temp_dim]++; tmp_block[temp_dim]++; - /* If this block is still in the range of blocks to output for the dimension, break out of loop */ - if(tmp_block[temp_dim] < tdiminfo[temp_dim].block) + /* If this block is still in the range of blocks to output for the dimension, break + * out of loop */ + if (tmp_block[temp_dim] < tdiminfo[temp_dim].block) break; else { offset[temp_dim] = base_offset[temp_dim]; @@ -2508,8 +2505,8 @@ H5S__hyper_iter_get_seq_list_single(H5S_sel_iter_t *iter, size_t maxseq, size_t /* Decrement block count */ blk_count--; } /* end while */ - } /* end else */ - } /* end else */ + } /* end else */ + } /* end else */ /* Update the iterator, if there were any blocks used */ @@ -2517,10 +2514,10 @@ H5S__hyper_iter_get_seq_list_single(H5S_sel_iter_t *iter, size_t maxseq, size_t iter->elmt_left -= tot_blk_count * actual_elem; /* Check if there are elements left in iterator */ - if(iter->elmt_left > 0) { + if (iter->elmt_left > 0) { /* Update the iterator with the location we stopped */ /* (Subtract out the selection offset) */ - for(u = 0; u < ndims; u++) + for (u = 0; u < ndims; u++) iter->u.hyp.off[u] = (hsize_t)((hssize_t)offset[u] - sel_off[u]); } /* end if */ @@ -2532,8 +2529,8 @@ H5S__hyper_iter_get_seq_list_single(H5S_sel_iter_t *iter, size_t maxseq, size_t } /* end if */ /* Check for partial block, with room for another sequence */ - if(io_left > (tot_blk_count * actual_elem) && tot_blk_count < maxseq) { - size_t elmt_remainder; /* Elements remaining */ + if (io_left > (tot_blk_count * actual_elem) && tot_blk_count < maxseq) { + size_t elmt_remainder; /* Elements remaining */ /* Compute elements left */ elmt_remainder = io_left - (tot_blk_count * actual_elem); @@ -2564,7 +2561,6 @@ H5S__hyper_iter_get_seq_list_single(H5S_sel_iter_t *iter, size_t maxseq, size_t FUNC_LEAVE_NOAPI(SUCCEED) } /* end H5S__hyper_iter_get_seq_list_single() */ - /*-------------------------------------------------------------------------- NAME H5S__hyper_iter_get_seq_list @@ -2596,10 +2592,10 @@ H5S__hyper_iter_get_seq_list_single(H5S_sel_iter_t *iter, size_t maxseq, size_t REVISION LOG --------------------------------------------------------------------------*/ static herr_t -H5S__hyper_iter_get_seq_list(H5S_sel_iter_t *iter, size_t maxseq, - size_t maxelem, size_t *nseq, size_t *nelem, hsize_t *off, size_t *len) +H5S__hyper_iter_get_seq_list(H5S_sel_iter_t *iter, size_t maxseq, size_t maxelem, size_t *nseq, size_t *nelem, + hsize_t *off, size_t *len) { - herr_t ret_value = FAIL; /* return value */ + herr_t ret_value = FAIL; /* return value */ FUNC_ENTER_STATIC_NOERR @@ -2614,19 +2610,19 @@ H5S__hyper_iter_get_seq_list(H5S_sel_iter_t *iter, size_t maxseq, HDassert(len); /* Check for the special case of just one H5Sselect_hyperslab call made */ - if(iter->u.hyp.diminfo_valid) { - const H5S_hyper_dim_t *tdiminfo; /* Temporary pointer to diminfo information */ - const hssize_t *sel_off; /* Selection offset in dataspace */ - unsigned ndims; /* Number of dimensions of dataset */ - unsigned fast_dim; /* Rank of the fastest changing dimension for the dataspace */ - hbool_t single_block; /* Whether the selection is a single block */ - unsigned u; /* Local index variable */ + if (iter->u.hyp.diminfo_valid) { + const H5S_hyper_dim_t *tdiminfo; /* Temporary pointer to diminfo information */ + const hssize_t * sel_off; /* Selection offset in dataspace */ + unsigned ndims; /* Number of dimensions of dataset */ + unsigned fast_dim; /* Rank of the fastest changing dimension for the dataspace */ + hbool_t single_block; /* Whether the selection is a single block */ + unsigned u; /* Local index variable */ /* Set a local copy of the diminfo pointer */ tdiminfo = iter->u.hyp.diminfo; /* Check if this is a "flattened" regular hyperslab selection */ - if(iter->u.hyp.iter_rank != 0 && iter->u.hyp.iter_rank < iter->rank) { + if (iter->u.hyp.iter_rank != 0 && iter->u.hyp.iter_rank < iter->rank) { /* Set the aliases for a few important dimension ranks */ ndims = iter->u.hyp.iter_rank; @@ -2643,20 +2639,27 @@ H5S__hyper_iter_get_seq_list(H5S_sel_iter_t *iter, size_t maxseq, fast_dim = ndims - 1; /* Check if we stopped in the middle of a sequence of elements */ - if((iter->u.hyp.off[fast_dim] - tdiminfo[fast_dim].start) % tdiminfo[fast_dim].stride != 0 || - ((iter->u.hyp.off[fast_dim] != tdiminfo[fast_dim].start) && tdiminfo[fast_dim].count == 1)) { - hsize_t *slab; /* Hyperslab size */ - hsize_t loc; /* Coordinate offset */ - size_t leftover; /* The number of elements left over from the last sequence */ - size_t actual_elem; /* The actual number of elements to count */ - size_t elem_size; /* Size of each element iterating over */ + if ((iter->u.hyp.off[fast_dim] - tdiminfo[fast_dim].start) % tdiminfo[fast_dim].stride != 0 || + ((iter->u.hyp.off[fast_dim] != tdiminfo[fast_dim].start) && tdiminfo[fast_dim].count == 1)) { + hsize_t *slab; /* Hyperslab size */ + hsize_t loc; /* Coordinate offset */ + size_t leftover; /* The number of elements left over from the last sequence */ + size_t actual_elem; /* The actual number of elements to count */ + size_t elem_size; /* Size of each element iterating over */ /* Calculate the number of elements left in the sequence */ - if(tdiminfo[fast_dim].count == 1) { - H5_CHECKED_ASSIGN(leftover, size_t, tdiminfo[fast_dim].block - (iter->u.hyp.off[fast_dim] - tdiminfo[fast_dim].start), hsize_t); + if (tdiminfo[fast_dim].count == 1) { + H5_CHECKED_ASSIGN(leftover, size_t, + tdiminfo[fast_dim].block - + (iter->u.hyp.off[fast_dim] - tdiminfo[fast_dim].start), + hsize_t); } /* end if */ else { - H5_CHECKED_ASSIGN(leftover, size_t, tdiminfo[fast_dim].block - ((iter->u.hyp.off[fast_dim] - tdiminfo[fast_dim].start) % tdiminfo[fast_dim].stride), hsize_t); + H5_CHECKED_ASSIGN( + leftover, size_t, + tdiminfo[fast_dim].block - + ((iter->u.hyp.off[fast_dim] - tdiminfo[fast_dim].start) % tdiminfo[fast_dim].stride), + hsize_t); } /* end else */ /* Make certain that we don't write too many */ @@ -2664,10 +2667,10 @@ H5S__hyper_iter_get_seq_list(H5S_sel_iter_t *iter, size_t maxseq, /* Set up some local variables */ elem_size = iter->elmt_size; - slab = iter->u.hyp.slab; + slab = iter->u.hyp.slab; /* Compute the initial buffer offset */ - for(u = 0, loc = 0; u < ndims; u++) + for (u = 0, loc = 0; u < ndims; u++) loc += ((hsize_t)((hssize_t)iter->u.hyp.off[u] + sel_off[u])) * slab[u]; /* Add a new sequence */ @@ -2689,29 +2692,29 @@ H5S__hyper_iter_get_seq_list(H5S_sel_iter_t *iter, size_t maxseq, maxseq--; /* Set the number of sequences generated and elements used */ - *nseq = 1; + *nseq = 1; *nelem = actual_elem; /* Check for using up all the sequences/elements */ - if(0 == iter->elmt_left || 0 == maxelem || 0 == maxseq) - return(SUCCEED); + if (0 == iter->elmt_left || 0 == maxelem || 0 == maxseq) + return (SUCCEED); } /* end if */ else { /* Reset the number of sequences generated and elements used */ - *nseq = 0; + *nseq = 0; *nelem = 0; } /* end else */ /* Check for a single block selected */ single_block = TRUE; - for(u = 0; u < ndims; u++) - if(1 != tdiminfo[u].count) { + for (u = 0; u < ndims; u++) + if (1 != tdiminfo[u].count) { single_block = FALSE; break; } /* end if */ /* Check for single block selection */ - if(single_block) + if (single_block) /* Use single-block optimized call to generate sequence list */ ret_value = H5S__hyper_iter_get_seq_list_single(iter, maxseq, maxelem, nseq, nelem, off, len); else @@ -2725,7 +2728,6 @@ H5S__hyper_iter_get_seq_list(H5S_sel_iter_t *iter, size_t maxseq, FUNC_LEAVE_NOAPI(ret_value) } /* end H5S__hyper_iter_get_seq_list() */ - /*-------------------------------------------------------------------------- NAME H5S__hyper_iter_release @@ -2752,13 +2754,12 @@ H5S__hyper_iter_release(H5S_sel_iter_t *iter) HDassert(iter); /* Free the copy of the hyperslab selection span tree */ - if(iter->u.hyp.spans != NULL) + if (iter->u.hyp.spans != NULL) H5S__hyper_free_span_info(iter->u.hyp.spans); FUNC_LEAVE_NOAPI(SUCCEED) } /* end H5S__hyper_iter_release() */ - /*-------------------------------------------------------------------------- NAME H5S__hyper_new_span @@ -2781,32 +2782,30 @@ H5S__hyper_iter_release(H5S_sel_iter_t *iter) REVISION LOG --------------------------------------------------------------------------*/ static H5S_hyper_span_t * -H5S__hyper_new_span(hsize_t low, hsize_t high, H5S_hyper_span_info_t *down, - H5S_hyper_span_t *next) +H5S__hyper_new_span(hsize_t low, hsize_t high, H5S_hyper_span_info_t *down, H5S_hyper_span_t *next) { - H5S_hyper_span_t *ret_value = NULL; /* Return value */ + H5S_hyper_span_t *ret_value = NULL; /* Return value */ FUNC_ENTER_STATIC /* Allocate a new span node */ - if(NULL == (ret_value = H5FL_MALLOC(H5S_hyper_span_t))) + if (NULL == (ret_value = H5FL_MALLOC(H5S_hyper_span_t))) HGOTO_ERROR(H5E_DATASPACE, H5E_CANTALLOC, NULL, "can't allocate hyperslab span") /* Copy the span's basic information */ - ret_value->low = low; + ret_value->low = low; ret_value->high = high; ret_value->down = down; ret_value->next = next; /* Increment the reference count of the 'down span' if there is one */ - if(ret_value->down) + if (ret_value->down) ret_value->down->count++; done: FUNC_LEAVE_NOAPI(ret_value) } /* end H5S__hyper_new_span() */ - /*-------------------------------------------------------------------------- NAME H5S__hyper_new_span_info @@ -2829,7 +2828,7 @@ done: static H5S_hyper_span_info_t * H5S__hyper_new_span_info(unsigned rank) { - H5S_hyper_span_info_t *ret_value = NULL; /* Return value */ + H5S_hyper_span_info_t *ret_value = NULL; /* Return value */ FUNC_ENTER_STATIC @@ -2838,18 +2837,17 @@ H5S__hyper_new_span_info(unsigned rank) HDassert(rank <= H5S_MAX_RANK); /* Allocate a new span info node */ - if(NULL == (ret_value = (H5S_hyper_span_info_t *)H5FL_ARR_CALLOC(hbounds_t, rank * 2))) + if (NULL == (ret_value = (H5S_hyper_span_info_t *)H5FL_ARR_CALLOC(hbounds_t, rank * 2))) HGOTO_ERROR(H5E_DATASPACE, H5E_CANTALLOC, NULL, "can't allocate hyperslab span info") /* Set low & high bound pointers into the 'bounds' array */ - ret_value->low_bounds = ret_value->bounds; + ret_value->low_bounds = ret_value->bounds; ret_value->high_bounds = &ret_value->bounds[rank]; done: FUNC_LEAVE_NOAPI(ret_value) } /* end H5S__hyper_new_span_info() */ - /*-------------------------------------------------------------------------- NAME H5S__hyper_copy_span_helper @@ -2871,14 +2869,13 @@ done: REVISION LOG --------------------------------------------------------------------------*/ static H5S_hyper_span_info_t * -H5S__hyper_copy_span_helper(H5S_hyper_span_info_t *spans, unsigned rank, - unsigned op_info_i, uint64_t op_gen) +H5S__hyper_copy_span_helper(H5S_hyper_span_info_t *spans, unsigned rank, unsigned op_info_i, uint64_t op_gen) { - H5S_hyper_span_t *span; /* Hyperslab span */ - H5S_hyper_span_t *new_span; /* Temporary hyperslab span */ - H5S_hyper_span_t *prev_span; /* Previous hyperslab span */ - H5S_hyper_span_info_t *new_down; /* New down span tree */ - H5S_hyper_span_info_t *ret_value = NULL; /* Return value */ + H5S_hyper_span_t * span; /* Hyperslab span */ + H5S_hyper_span_t * new_span; /* Temporary hyperslab span */ + H5S_hyper_span_t * prev_span; /* Previous hyperslab span */ + H5S_hyper_span_info_t *new_down; /* New down span tree */ + H5S_hyper_span_info_t *ret_value = NULL; /* Return value */ FUNC_ENTER_STATIC @@ -2886,7 +2883,7 @@ H5S__hyper_copy_span_helper(H5S_hyper_span_info_t *spans, unsigned rank, HDassert(spans); /* Check if the span tree was already copied */ - if(spans->op_info[op_info_i].op_gen == op_gen) { + if (spans->op_info[op_info_i].op_gen == op_gen) { /* Just return the value of the already copied span tree */ ret_value = spans->op_info[op_info_i].u.copied; @@ -2895,7 +2892,7 @@ H5S__hyper_copy_span_helper(H5S_hyper_span_info_t *spans, unsigned rank, } /* end if */ else { /* Allocate a new span_info node */ - if(NULL == (ret_value = H5S__hyper_new_span_info(rank))) + if (NULL == (ret_value = H5S__hyper_new_span_info(rank))) HGOTO_ERROR(H5E_DATASPACE, H5E_CANTALLOC, NULL, "can't allocate hyperslab span info") /* Set the non-zero span_info information */ @@ -2910,22 +2907,22 @@ H5S__hyper_copy_span_helper(H5S_hyper_span_info_t *spans, unsigned rank, spans->op_info[op_info_i].u.copied = ret_value; /* Copy over the nodes in the span list */ - span = spans->head; + span = spans->head; prev_span = NULL; - while(span != NULL) { + while (span != NULL) { /* Allocate a new node */ - if(NULL == (new_span = H5S__hyper_new_span(span->low, span->high, NULL, NULL))) + if (NULL == (new_span = H5S__hyper_new_span(span->low, span->high, NULL, NULL))) HGOTO_ERROR(H5E_DATASPACE, H5E_CANTALLOC, NULL, "can't allocate hyperslab span") /* Append to list of spans */ - if(NULL == prev_span) + if (NULL == prev_span) ret_value->head = new_span; else prev_span->next = new_span; /* Recurse to copy the 'down' spans, if there are any */ - if(span->down != NULL) { - if(NULL == (new_down = H5S__hyper_copy_span_helper(span->down, rank - 1, op_info_i, op_gen))) + if (span->down != NULL) { + if (NULL == (new_down = H5S__hyper_copy_span_helper(span->down, rank - 1, op_info_i, op_gen))) HGOTO_ERROR(H5E_DATASPACE, H5E_CANTCOPY, NULL, "can't copy hyperslab spans") new_span->down = new_down; } /* end if */ @@ -2945,7 +2942,6 @@ done: FUNC_LEAVE_NOAPI(ret_value) } /* end H5S__hyper_copy_span_helper() */ - /*-------------------------------------------------------------------------- NAME H5S__hyper_copy_span @@ -2969,8 +2965,8 @@ done: static H5S_hyper_span_info_t * H5S__hyper_copy_span(H5S_hyper_span_info_t *spans, unsigned rank) { - uint64_t op_gen; /* Operation generation value */ - H5S_hyper_span_info_t *ret_value = NULL; /* Return value */ + uint64_t op_gen; /* Operation generation value */ + H5S_hyper_span_info_t *ret_value = NULL; /* Return value */ FUNC_ENTER_STATIC @@ -2983,14 +2979,13 @@ H5S__hyper_copy_span(H5S_hyper_span_info_t *spans, unsigned rank) /* Copy the hyperslab span tree */ /* Always use op_info[0] since we own this op_info, so there can be no * simultaneous operations */ - if(NULL == (ret_value = H5S__hyper_copy_span_helper(spans, rank, 0, op_gen))) + if (NULL == (ret_value = H5S__hyper_copy_span_helper(spans, rank, 0, op_gen))) HGOTO_ERROR(H5E_DATASPACE, H5E_CANTCOPY, NULL, "can't copy hyperslab span tree") done: FUNC_LEAVE_NOAPI(ret_value) } /* end H5S__hyper_copy_span() */ - /*-------------------------------------------------------------------------- NAME H5S__hyper_cmp_spans @@ -3013,23 +3008,23 @@ done: static H5_ATTR_PURE hbool_t H5S__hyper_cmp_spans(const H5S_hyper_span_info_t *span_info1, const H5S_hyper_span_info_t *span_info2) { - hbool_t ret_value = TRUE; /* Return value */ + hbool_t ret_value = TRUE; /* Return value */ FUNC_ENTER_STATIC_NOERR /* Check for redundant comparison (or both spans being NULL) */ - if(span_info1 != span_info2) { + if (span_info1 != span_info2) { /* Check for one span being NULL */ - if(span_info1 == NULL || span_info2 == NULL) + if (span_info1 == NULL || span_info2 == NULL) 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]) + if (span_info1->low_bounds[0] != span_info2->low_bounds[0]) HGOTO_DONE(FALSE) - else if(span_info1->high_bounds[0] != span_info2->high_bounds[0]) + else if (span_info1->high_bounds[0] != span_info2->high_bounds[0]) HGOTO_DONE(FALSE) else { const H5S_hyper_span_t *span1; @@ -3044,40 +3039,40 @@ H5S__hyper_cmp_spans(const H5S_hyper_span_info_t *span_info1, const H5S_hyper_sp HDassert(span2); /* infinite loop which must be broken out of */ - while(1) { + while (1) { /* Check for both spans being NULL */ - if(span1 == NULL && span2 == NULL) + if (span1 == NULL && span2 == NULL) HGOTO_DONE(TRUE) else { /* Check for one span being NULL */ - if(span1 == NULL || span2 == NULL) + if (span1 == NULL || span2 == NULL) HGOTO_DONE(FALSE) else { /* Check if the actual low & high span information is the same */ - if(span1->low != span2->low || span1->high != span2->high) + if (span1->low != span2->low || span1->high != span2->high) HGOTO_DONE(FALSE) else { - if(span1->down != NULL || span2->down != NULL) { - if(!H5S__hyper_cmp_spans(span1->down, span2->down)) + if (span1->down != NULL || span2->down != NULL) { + if (!H5S__hyper_cmp_spans(span1->down, span2->down)) HGOTO_DONE(FALSE) else { /* Keep going... */ } /* end else */ - } /* end if */ + } /* end if */ else { /* Keep going... */ } /* end else */ - } /* end else */ - } /* end else */ - } /* end else */ + } /* end else */ + } /* end else */ + } /* end else */ /* Advance to the next nodes in the span list */ span1 = span1->next; span2 = span2->next; } /* end while */ - } /* end else */ - } /* end else */ - } /* end if */ + } /* end else */ + } /* end else */ + } /* end if */ /* Fall through, with default return value of 'TRUE' if spans were already visited */ @@ -3085,7 +3080,6 @@ done: FUNC_LEAVE_NOAPI(ret_value) } /* end H5S__hyper_cmp_spans() */ - /*-------------------------------------------------------------------------- NAME H5S__hyper_free_span_info @@ -3117,13 +3111,13 @@ H5S__hyper_free_span_info(H5S_hyper_span_info_t *span_info) span_info->count--; /* Free the span tree if the reference count drops to zero */ - if(span_info->count == 0) { - H5S_hyper_span_t *span; /* Pointer to spans to iterate over */ + if (span_info->count == 0) { + H5S_hyper_span_t *span; /* Pointer to spans to iterate over */ /* Work through the list of spans pointed to by this 'info' node */ span = span_info->head; - while(span != NULL) { - H5S_hyper_span_t *next_span; /* Pointer to next span to iterate over */ + while (span != NULL) { + H5S_hyper_span_t *next_span; /* Pointer to next span to iterate over */ /* Keep a pointer to the next span */ next_span = span->next; @@ -3142,7 +3136,6 @@ H5S__hyper_free_span_info(H5S_hyper_span_info_t *span_info) FUNC_LEAVE_NOAPI_VOID } /* end H5S__hyper_free_span_info() */ - /*-------------------------------------------------------------------------- NAME H5S__hyper_free_span @@ -3171,7 +3164,7 @@ H5S__hyper_free_span(H5S_hyper_span_t *span) HDassert(span); /* Decrement the reference count of the 'down spans', freeing them if appropriate */ - if(span->down != NULL) + if (span->down != NULL) H5S__hyper_free_span_info(span->down); /* Free this span */ @@ -3180,7 +3173,6 @@ H5S__hyper_free_span(H5S_hyper_span_t *span) FUNC_LEAVE_NOAPI_VOID } /* end H5S__hyper_free_span() */ - /*-------------------------------------------------------------------------- NAME H5S__hyper_copy @@ -3209,9 +3201,9 @@ H5S__hyper_free_span(H5S_hyper_span_t *span) static herr_t H5S__hyper_copy(H5S_t *dst, const H5S_t *src, hbool_t share_selection) { - H5S_hyper_sel_t *dst_hslab; /* Pointer to destination hyperslab info */ - const H5S_hyper_sel_t *src_hslab; /* Pointer to source hyperslab info */ - herr_t ret_value = SUCCEED; /* Return value */ + H5S_hyper_sel_t * dst_hslab; /* Pointer to destination hyperslab info */ + const H5S_hyper_sel_t *src_hslab; /* Pointer to source hyperslab info */ + herr_t ret_value = SUCCEED; /* Return value */ FUNC_ENTER_STATIC @@ -3220,7 +3212,7 @@ H5S__hyper_copy(H5S_t *dst, const H5S_t *src, hbool_t share_selection) HDassert(dst); /* Allocate space for the hyperslab selection information */ - if(NULL == (dst->select.sel_info.hslab = H5FL_MALLOC(H5S_hyper_sel_t))) + if (NULL == (dst->select.sel_info.hslab = H5FL_MALLOC(H5S_hyper_sel_t))) HGOTO_ERROR(H5E_DATASPACE, H5E_CANTALLOC, FAIL, "can't allocate hyperslab info") /* Set temporary pointers */ @@ -3229,33 +3221,33 @@ H5S__hyper_copy(H5S_t *dst, const H5S_t *src, hbool_t share_selection) /* Copy the hyperslab information */ dst_hslab->diminfo_valid = src_hslab->diminfo_valid; - if(src_hslab->diminfo_valid == H5S_DIMINFO_VALID_YES) + if (src_hslab->diminfo_valid == H5S_DIMINFO_VALID_YES) H5MM_memcpy(&dst_hslab->diminfo, &src_hslab->diminfo, sizeof(H5S_hyper_diminfo_t)); /* Check if there is hyperslab span information to copy */ /* (Regular hyperslab information is copied with the selection structure) */ - if(src->select.sel_info.hslab->span_lst != NULL) { - if(share_selection) { + if (src->select.sel_info.hslab->span_lst != NULL) { + if (share_selection) { /* Share the source's span tree by incrementing the reference count on it */ dst->select.sel_info.hslab->span_lst = src->select.sel_info.hslab->span_lst; dst->select.sel_info.hslab->span_lst->count++; } /* end if */ else /* Copy the hyperslab span information */ - dst->select.sel_info.hslab->span_lst = H5S__hyper_copy_span(src->select.sel_info.hslab->span_lst, src->extent.rank); + dst->select.sel_info.hslab->span_lst = + H5S__hyper_copy_span(src->select.sel_info.hslab->span_lst, src->extent.rank); } /* end if */ else dst->select.sel_info.hslab->span_lst = NULL; /* Copy the unlimited dimension info */ - dst_hslab->unlim_dim = src_hslab->unlim_dim; + dst_hslab->unlim_dim = src_hslab->unlim_dim; dst_hslab->num_elem_non_unlim = src_hslab->num_elem_non_unlim; done: FUNC_LEAVE_NOAPI(ret_value) } /* end H5S__hyper_copy() */ - /*-------------------------------------------------------------------------- NAME H5S__hyper_is_valid @@ -3279,34 +3271,34 @@ done: static htri_t H5S__hyper_is_valid(const H5S_t *space) { - const hsize_t *low_bounds, *high_bounds; /* Pointers to the correct pair of low & high bounds */ - unsigned u; /* Counter */ - htri_t ret_value = TRUE; /* return value */ + const hsize_t *low_bounds, *high_bounds; /* Pointers to the correct pair of low & high bounds */ + unsigned u; /* Counter */ + htri_t ret_value = TRUE; /* return value */ FUNC_ENTER_STATIC_NOERR HDassert(space); /* Check for unlimited selection */ - if(space->select.sel_info.hslab->unlim_dim >= 0) + if (space->select.sel_info.hslab->unlim_dim >= 0) 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) { - low_bounds = space->select.sel_info.hslab->diminfo.low_bounds; + if (space->select.sel_info.hslab->diminfo_valid == H5S_DIMINFO_VALID_YES) { + low_bounds = space->select.sel_info.hslab->diminfo.low_bounds; high_bounds = space->select.sel_info.hslab->diminfo.high_bounds; } /* end if */ else { - low_bounds = space->select.sel_info.hslab->span_lst->low_bounds; + low_bounds = space->select.sel_info.hslab->span_lst->low_bounds; high_bounds = space->select.sel_info.hslab->span_lst->high_bounds; } /* end else */ /* Check each dimension */ - for(u = 0; u < space->extent.rank; u++) { + 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) + if (((hssize_t)low_bounds[u] + space->select.offset[u]) < 0) HGOTO_DONE(FALSE) - if((high_bounds[u] + (hsize_t)space->select.offset[u]) >= space->extent.size[u]) + if ((high_bounds[u] + (hsize_t)space->select.offset[u]) >= space->extent.size[u]) HGOTO_DONE(FALSE) } /* end for */ @@ -3314,7 +3306,6 @@ done: FUNC_LEAVE_NOAPI(ret_value) } /* end H5S__hyper_is_valid() */ - /*-------------------------------------------------------------------------- NAME H5S__hyper_span_nblocks_helper @@ -3335,10 +3326,9 @@ done: REVISION LOG --------------------------------------------------------------------------*/ static hsize_t -H5S__hyper_span_nblocks_helper(H5S_hyper_span_info_t *spans, unsigned op_info_i, - uint64_t op_gen) +H5S__hyper_span_nblocks_helper(H5S_hyper_span_info_t *spans, unsigned op_info_i, uint64_t op_gen) { - hsize_t ret_value = 0; /* Return value */ + hsize_t ret_value = 0; /* Return value */ FUNC_ENTER_STATIC_NOERR @@ -3346,31 +3336,31 @@ H5S__hyper_span_nblocks_helper(H5S_hyper_span_info_t *spans, unsigned op_info_i, HDassert(spans); /* Check if the span tree was already counted */ - if(spans->op_info[op_info_i].op_gen == op_gen) + if (spans->op_info[op_info_i].op_gen == op_gen) /* Just return the # of blocks in the already counted span tree */ ret_value = spans->op_info[op_info_i].u.nblocks; - else { /* Count the number of elements in the span tree */ - H5S_hyper_span_t *span; /* Hyperslab span */ + else { /* Count the number of elements in the span tree */ + H5S_hyper_span_t *span; /* Hyperslab span */ span = spans->head; - if(span->down) { - while(span) { + if (span->down) { + while (span) { /* If there are down spans, add the total down span blocks */ ret_value += H5S__hyper_span_nblocks_helper(span->down, op_info_i, op_gen); /* Advance to next span */ span = span->next; } /* end while */ - } /* end if */ + } /* end if */ else { - while(span) { + while (span) { /* If there are no down spans, just count the block in this span */ ret_value++; /* Advance to next span */ span = span->next; } /* end while */ - } /* end else */ + } /* end else */ /* Set the operation generation for this span tree, to avoid re-computing */ spans->op_info[op_info_i].op_gen = op_gen; @@ -3382,7 +3372,6 @@ H5S__hyper_span_nblocks_helper(H5S_hyper_span_info_t *spans, unsigned op_info_i, FUNC_LEAVE_NOAPI(ret_value) } /* end H5S__hyper_span_nblocks_helper() */ - /*-------------------------------------------------------------------------- NAME H5S__hyper_span_nblocks @@ -3403,13 +3392,13 @@ H5S__hyper_span_nblocks_helper(H5S_hyper_span_info_t *spans, unsigned op_info_i, static hsize_t H5S__hyper_span_nblocks(H5S_hyper_span_info_t *spans) { - hsize_t ret_value = 0; /* Return value */ + hsize_t ret_value = 0; /* Return value */ FUNC_ENTER_STATIC_NOERR /* Count the number of elements in the span tree */ - if(spans != NULL) { - uint64_t op_gen; /* Operation generation value */ + if (spans != NULL) { + uint64_t op_gen; /* Operation generation value */ /* Acquire an operation generation value for this operation */ op_gen = H5S__hyper_get_op_gen(); @@ -3423,7 +3412,6 @@ H5S__hyper_span_nblocks(H5S_hyper_span_info_t *spans) FUNC_LEAVE_NOAPI(ret_value) } /* end H5S__hyper_span_nblocks() */ - /*-------------------------------------------------------------------------- NAME H5S__get_select_hyper_nblocks @@ -3445,7 +3433,7 @@ H5S__hyper_span_nblocks(H5S_hyper_span_info_t *spans) static hsize_t H5S__get_select_hyper_nblocks(const H5S_t *space, hbool_t app_ref) { - hsize_t ret_value = 0; /* Return value */ + hsize_t ret_value = 0; /* Return value */ FUNC_ENTER_STATIC_NOERR @@ -3454,13 +3442,13 @@ H5S__get_select_hyper_nblocks(const H5S_t *space, hbool_t app_ref) /* Check for a "regular" hyperslab selection */ /* (No need to rebuild the dimension info yet -QAK) */ - if(space->select.sel_info.hslab->diminfo_valid == H5S_DIMINFO_VALID_YES) { - unsigned u; /* Local index variable */ + if (space->select.sel_info.hslab->diminfo_valid == H5S_DIMINFO_VALID_YES) { + unsigned u; /* Local index variable */ /* Check each dimension */ - for(ret_value = 1, u = 0; u < space->extent.rank; u++) - ret_value *= (app_ref ? space->select.sel_info.hslab->diminfo.app[u].count : - space->select.sel_info.hslab->diminfo.opt[u].count); + for (ret_value = 1, u = 0; u < space->extent.rank; u++) + ret_value *= (app_ref ? space->select.sel_info.hslab->diminfo.app[u].count + : space->select.sel_info.hslab->diminfo.opt[u].count); } /* end if */ else ret_value = H5S__hyper_span_nblocks(space->select.sel_info.hslab->span_lst); @@ -3468,7 +3456,6 @@ H5S__get_select_hyper_nblocks(const H5S_t *space, hbool_t app_ref) FUNC_LEAVE_NOAPI(ret_value) } /* end H5S__get_select_hyper_nblocks() */ - /*-------------------------------------------------------------------------- NAME H5Sget_select_hyper_nblocks @@ -3489,19 +3476,20 @@ H5S__get_select_hyper_nblocks(const H5S_t *space, hbool_t app_ref) hssize_t H5Sget_select_hyper_nblocks(hid_t spaceid) { - H5S_t *space; /* Dataspace to modify selection of */ - hssize_t ret_value; /* return value */ + H5S_t * space; /* Dataspace to modify selection of */ + hssize_t ret_value; /* return value */ FUNC_ENTER_API(FAIL) H5TRACE1("Hs", "i", spaceid); /* Check args */ - if(NULL == (space = (H5S_t *)H5I_object_verify(spaceid, H5I_DATASPACE))) + if (NULL == (space = (H5S_t *)H5I_object_verify(spaceid, H5I_DATASPACE))) HGOTO_ERROR(H5E_ARGS, H5E_BADTYPE, FAIL, "not a dataspace") - if(H5S_GET_SELECT_TYPE(space) != H5S_SEL_HYPERSLABS) + if (H5S_GET_SELECT_TYPE(space) != H5S_SEL_HYPERSLABS) HGOTO_ERROR(H5E_ARGS, H5E_BADTYPE, FAIL, "not a hyperslab selection") - if(space->select.sel_info.hslab->unlim_dim >= 0) - HGOTO_ERROR(H5E_DATASPACE, H5E_UNSUPPORTED, FAIL, "cannot get number of blocks for unlimited selection") + if (space->select.sel_info.hslab->unlim_dim >= 0) + HGOTO_ERROR(H5E_DATASPACE, H5E_UNSUPPORTED, FAIL, + "cannot get number of blocks for unlimited selection") ret_value = (hssize_t)H5S__get_select_hyper_nblocks(space, TRUE); @@ -3509,7 +3497,6 @@ done: FUNC_LEAVE_API(ret_value) } /* end H5Sget_select_hyper_nblocks() */ - /*-------------------------------------------------------------------------- NAME H5S__hyper_get_enc_size_real @@ -3535,9 +3522,9 @@ H5S__hyper_get_enc_size_real(hsize_t max_size) FUNC_ENTER_STATIC_NOERR - if(max_size > H5S_UINT32_MAX) + if (max_size > H5S_UINT32_MAX) ret_value = H5S_SELECT_INFO_ENC_SIZE_8; - else if(max_size > H5S_UINT16_MAX) + else if (max_size > H5S_UINT16_MAX) ret_value = H5S_SELECT_INFO_ENC_SIZE_4; else ret_value = H5S_SELECT_INFO_ENC_SIZE_2; @@ -3545,7 +3532,6 @@ H5S__hyper_get_enc_size_real(hsize_t max_size) FUNC_LEAVE_NOAPI(ret_value) } /* H5S__hyper_get_enc_size_real() */ - /*-------------------------------------------------------------------------- NAME H5S__hyper_get_version_enc_size @@ -3583,70 +3569,74 @@ H5S__hyper_get_enc_size_real(hsize_t max_size) static herr_t H5S__hyper_get_version_enc_size(const H5S_t *space, hsize_t block_count, uint32_t *version, uint8_t *enc_size) { - hsize_t bounds_start[H5S_MAX_RANK]; /* Starting coordinate of bounding box */ - hsize_t bounds_end[H5S_MAX_RANK]; /* Opposite coordinate of bounding box */ - hbool_t count_up_version = FALSE; /* Whether number of blocks exceed H5S_UINT32_MAX */ - hbool_t bound_up_version = FALSE; /* Whether high bounds exceed H5S_UINT32_MAX */ - H5F_libver_t low_bound; /* The 'low' bound of library format versions */ - H5F_libver_t high_bound; /* The 'high' bound of library format versions */ - htri_t is_regular; /* A regular hyperslab or not */ - uint32_t tmp_version; /* Local temporay version */ - unsigned u; /* Local index variable */ - herr_t ret_value = SUCCEED; /* Return value */ + hsize_t bounds_start[H5S_MAX_RANK]; /* Starting coordinate of bounding box */ + hsize_t bounds_end[H5S_MAX_RANK]; /* Opposite coordinate of bounding box */ + hbool_t count_up_version = FALSE; /* Whether number of blocks exceed H5S_UINT32_MAX */ + hbool_t bound_up_version = FALSE; /* Whether high bounds exceed H5S_UINT32_MAX */ + H5F_libver_t low_bound; /* The 'low' bound of library format versions */ + H5F_libver_t high_bound; /* The 'high' bound of library format versions */ + htri_t is_regular; /* A regular hyperslab or not */ + uint32_t tmp_version; /* Local temporay version */ + unsigned u; /* Local index variable */ + herr_t ret_value = SUCCEED; /* Return value */ FUNC_ENTER_STATIC /* Get bounding box for the selection */ HDmemset(bounds_end, 0, sizeof(bounds_end)); - if(space->select.sel_info.hslab->unlim_dim < 0) /* ! H5S_UNLIMITED */ + if (space->select.sel_info.hslab->unlim_dim < 0) /* ! H5S_UNLIMITED */ /* Get bounding box for the selection */ - if(H5S__hyper_bounds(space, bounds_start, bounds_end) < 0) + if (H5S__hyper_bounds(space, bounds_start, bounds_end) < 0) HGOTO_ERROR(H5E_DATASPACE, H5E_CANTGET, FAIL, "can't get selection bounds") /* Determine whether the number of blocks or the high bounds in the selection exceed (2^32 - 1) */ - if(block_count > H5S_UINT32_MAX) + if (block_count > H5S_UINT32_MAX) count_up_version = TRUE; else { - for(u = 0; u < space->extent.rank; u++) - if(bounds_end[u] > H5S_UINT32_MAX) { + for (u = 0; u < space->extent.rank; u++) + if (bounds_end[u] > H5S_UINT32_MAX) { bound_up_version = TRUE; break; } /* end if */ - } /* end else */ + } /* end else */ /* Get the file's low_bound and high_bound */ - if(H5CX_get_libver_bounds(&low_bound, &high_bound) < 0) + if (H5CX_get_libver_bounds(&low_bound, &high_bound) < 0) HGOTO_ERROR(H5E_DATASET, H5E_CANTGET, FAIL, "can't get low/high bounds from API context") /* Determine regular hyperslab */ is_regular = H5S__hyper_is_regular(space); - if(low_bound >= H5F_LIBVER_V112 || space->select.sel_info.hslab->unlim_dim >= 0) + if (low_bound >= H5F_LIBVER_V112 || space->select.sel_info.hslab->unlim_dim >= 0) tmp_version = MAX(H5S_HYPER_VERSION_2, H5O_sds_hyper_ver_bounds[low_bound]); else { - if(count_up_version || bound_up_version) + if (count_up_version || bound_up_version) tmp_version = is_regular ? H5S_HYPER_VERSION_2 : H5S_HYPER_VERSION_3; else - tmp_version = (is_regular && block_count >= 4) ? H5O_sds_hyper_ver_bounds[low_bound] : H5S_HYPER_VERSION_1; + tmp_version = + (is_regular && block_count >= 4) ? H5O_sds_hyper_ver_bounds[low_bound] : H5S_HYPER_VERSION_1; } /* end else */ /* Version bounds check */ - if(tmp_version > H5O_sds_hyper_ver_bounds[high_bound]) { - /* Fail for irregular hyperslab if exceeds 32 bits */ - if(count_up_version) - HGOTO_ERROR(H5E_DATASPACE, H5E_BADVALUE, FAIL, "The number of blocks in hyperslab selection exceeds 2^32") - else if(bound_up_version) - HGOTO_ERROR(H5E_DATASPACE, H5E_BADVALUE, FAIL, "The end of bounding box in hyperslab selection exceeds 2^32") + if (tmp_version > H5O_sds_hyper_ver_bounds[high_bound]) { + /* Fail for irregular hyperslab if exceeds 32 bits */ + if (count_up_version) + HGOTO_ERROR(H5E_DATASPACE, H5E_BADVALUE, FAIL, + "The number of blocks in hyperslab selection exceeds 2^32") + else if (bound_up_version) + HGOTO_ERROR(H5E_DATASPACE, H5E_BADVALUE, FAIL, + "The end of bounding box in hyperslab selection exceeds 2^32") else - HGOTO_ERROR(H5E_DATASPACE, H5E_BADRANGE, FAIL, "Dataspace hyperslab selection version out of bounds") + HGOTO_ERROR(H5E_DATASPACE, H5E_BADRANGE, FAIL, + "Dataspace hyperslab selection version out of bounds") } /* end if */ /* Set the message version */ *version = tmp_version; /* Determine the encoded size based on version */ - switch(tmp_version) { + switch (tmp_version) { case H5S_HYPER_VERSION_1: *enc_size = H5S_SELECT_INFO_ENC_SIZE_4; break; @@ -3656,18 +3646,18 @@ H5S__hyper_get_version_enc_size(const H5S_t *space, hsize_t block_count, uint32_ break; case H5S_HYPER_VERSION_3: - if(is_regular) { + if (is_regular) { uint8_t enc1, enc2; hsize_t max1 = 0; hsize_t max2 = 0; /* Find max for count[] and block[] */ - for(u = 0; u < space->extent.rank; u++) { - if(space->select.sel_info.hslab->diminfo.opt[u].count != H5S_UNLIMITED && - space->select.sel_info.hslab->diminfo.opt[u].count > max1) + for (u = 0; u < space->extent.rank; u++) { + if (space->select.sel_info.hslab->diminfo.opt[u].count != H5S_UNLIMITED && + space->select.sel_info.hslab->diminfo.opt[u].count > max1) max1 = space->select.sel_info.hslab->diminfo.opt[u].count; - if(space->select.sel_info.hslab->diminfo.opt[u].block != H5S_UNLIMITED && - space->select.sel_info.hslab->diminfo.opt[u].block > max1) + if (space->select.sel_info.hslab->diminfo.opt[u].block != H5S_UNLIMITED && + space->select.sel_info.hslab->diminfo.opt[u].block > max1) max1 = space->select.sel_info.hslab->diminfo.opt[u].block; } /* end for */ @@ -3675,10 +3665,10 @@ H5S__hyper_get_version_enc_size(const H5S_t *space, hsize_t block_count, uint32_ enc1 = H5S__hyper_get_enc_size_real(++max1); /* Find max for start[] and stride[] */ - for(u = 0; u < space->extent.rank; u++) { - if(space->select.sel_info.hslab->diminfo.opt[u].start > max2) + for (u = 0; u < space->extent.rank; u++) { + if (space->select.sel_info.hslab->diminfo.opt[u].start > max2) max2 = space->select.sel_info.hslab->diminfo.opt[u].start; - if(space->select.sel_info.hslab->diminfo.opt[u].stride > max2) + if (space->select.sel_info.hslab->diminfo.opt[u].stride > max2) max2 = space->select.sel_info.hslab->diminfo.opt[u].stride; } /* end for */ @@ -3692,12 +3682,12 @@ H5S__hyper_get_version_enc_size(const H5S_t *space, hsize_t block_count, uint32_ HDassert(space->select.sel_info.hslab->unlim_dim < 0); /* Find max for block_count and bounds_end[] */ - for(u = 0; u < space->extent.rank; u++) - if(bounds_end[u] > max_size) + for (u = 0; u < space->extent.rank; u++) + if (bounds_end[u] > max_size) max_size = bounds_end[u]; /* Determine the encoding size */ - *enc_size = H5S__hyper_get_enc_size_real(max_size); + *enc_size = H5S__hyper_get_enc_size_real(max_size); } /* end else */ break; @@ -3710,7 +3700,6 @@ done: FUNC_LEAVE_NOAPI(ret_value) } /* H5S__hyper_get_version_enc_size() */ - /*-------------------------------------------------------------------------- NAME H5S__hyper_serial_size @@ -3733,24 +3722,24 @@ done: static hssize_t H5S__hyper_serial_size(const H5S_t *space) { - hsize_t block_count = 0; /* block counter for regular hyperslabs */ - uint32_t version; /* Version number */ - uint8_t enc_size; /* Encoded size of hyperslab selection info */ - hssize_t ret_value = -1; /* return value */ + hsize_t block_count = 0; /* block counter for regular hyperslabs */ + uint32_t version; /* Version number */ + uint8_t enc_size; /* Encoded size of hyperslab selection info */ + hssize_t ret_value = -1; /* return value */ FUNC_ENTER_STATIC HDassert(space); /* Determine the number of blocks */ - if(space->select.sel_info.hslab->unlim_dim < 0) /* ! H5S_UNLIMITED */ + if (space->select.sel_info.hslab->unlim_dim < 0) /* ! H5S_UNLIMITED */ block_count = H5S__get_select_hyper_nblocks(space, FALSE); /* Determine the version and the encoded size */ - if(H5S__hyper_get_version_enc_size(space, block_count, &version, &enc_size) < 0) + if (H5S__hyper_get_version_enc_size(space, block_count, &version, &enc_size) < 0) HGOTO_ERROR(H5E_DATASPACE, H5E_CANTGET, FAIL, "can't determine hyper version & enc_size") - if(version == H5S_HYPER_VERSION_3) { + if (version == H5S_HYPER_VERSION_3) { /* Version 3: regular */ /* Size required is always: * <type (4 bytes)> + <version (4 bytes)> + <flags (1 byte)> + @@ -3758,9 +3747,8 @@ H5S__hyper_serial_size(const H5S_t *space) * (4 (start/stride/count/block) * <enc_size> * <rank>) = * 14 + (4 * enc_size * rank) bytes */ - if(H5S__hyper_is_regular(space)) - ret_value = (hssize_t)14 + - ((hssize_t)4 * (hssize_t)enc_size * (hssize_t)space->extent.rank); + if (H5S__hyper_is_regular(space)) + ret_value = (hssize_t)14 + ((hssize_t)4 * (hssize_t)enc_size * (hssize_t)space->extent.rank); else { /* Version 3: irregular */ /* Size required is always: @@ -3774,8 +3762,8 @@ H5S__hyper_serial_size(const H5S_t *space) H5_CHECK_OVERFLOW(((unsigned)2 * enc_size * space->extent.rank * block_count), hsize_t, hssize_t); ret_value += (hssize_t)((unsigned)2 * enc_size * space->extent.rank * block_count); } /* end else */ - } /* end if */ - else if(version == H5S_HYPER_VERSION_2) { + } /* end if */ + else if (version == H5S_HYPER_VERSION_2) { /* Version 2 */ /* Size required is always: * <type (4 bytes)> + <version (4 bytes)> + <flags (1 byte)> + @@ -3805,7 +3793,6 @@ done: FUNC_LEAVE_NOAPI(ret_value) } /* end H5S__hyper_serial_size() */ - /*-------------------------------------------------------------------------- NAME H5S__hyper_serialize_helper @@ -3830,11 +3817,11 @@ done: REVISION LOG --------------------------------------------------------------------------*/ static void -H5S__hyper_serialize_helper(const H5S_hyper_span_info_t *spans, - hsize_t *start, hsize_t *end, hsize_t rank, uint8_t enc_size, uint8_t **p) +H5S__hyper_serialize_helper(const H5S_hyper_span_info_t *spans, hsize_t *start, hsize_t *end, hsize_t rank, + uint8_t enc_size, uint8_t **p) { - H5S_hyper_span_t *curr; /* Pointer to current hyperslab span */ - uint8_t *pp = (*p); /* Local pointer for decoding */ + H5S_hyper_span_t *curr; /* Pointer to current hyperslab span */ + uint8_t * pp = (*p); /* Local pointer for decoding */ FUNC_ENTER_STATIC_NOERR @@ -3847,31 +3834,31 @@ H5S__hyper_serialize_helper(const H5S_hyper_span_info_t *spans, /* Walk through the list of spans, recursing or outputting them */ curr = spans->head; - while(curr != NULL) { + while (curr != NULL) { /* Recurse if this node has down spans */ - if(curr->down != NULL) { + if (curr->down != NULL) { /* Add the starting and ending points for this span to the list */ start[rank] = curr->low; - end[rank] = curr->high; + end[rank] = curr->high; /* Recurse down to the next dimension */ H5S__hyper_serialize_helper(curr->down, start, end, rank + 1, enc_size, &pp); } /* end if */ else { - hsize_t u; /* Index variable */ + hsize_t u; /* Index variable */ /* Encode all the previous dimensions starting & ending points */ - switch(enc_size) { + switch (enc_size) { case H5S_SELECT_INFO_ENC_SIZE_2: /* Encode previous starting points */ - for(u=0; u<rank; u++) + for (u = 0; u < rank; u++) UINT16ENCODE(pp, (uint16_t)start[u]); /* Encode starting point for this span */ UINT16ENCODE(pp, (uint16_t)curr->low); /* Encode previous ending points */ - for(u=0; u<rank; u++) + for (u = 0; u < rank; u++) UINT16ENCODE(pp, (uint16_t)end[u]); /* Encode starting point for this span */ @@ -3880,14 +3867,14 @@ H5S__hyper_serialize_helper(const H5S_hyper_span_info_t *spans, case H5S_SELECT_INFO_ENC_SIZE_4: /* Encode previous starting points */ - for(u=0; u<rank; u++) + for (u = 0; u < rank; u++) UINT32ENCODE(pp, (uint32_t)start[u]); /* Encode starting point for this span */ UINT32ENCODE(pp, (uint32_t)curr->low); - /* Encode previous ending points */ - for(u=0; u<rank; u++) + /* Encode previous ending points */ + for (u = 0; u < rank; u++) UINT32ENCODE(pp, (uint32_t)end[u]); /* Encode starting point for this span */ @@ -3896,14 +3883,14 @@ H5S__hyper_serialize_helper(const H5S_hyper_span_info_t *spans, case H5S_SELECT_INFO_ENC_SIZE_8: /* Encode previous starting points */ - for(u=0; u<rank; u++) + for (u = 0; u < rank; u++) UINT64ENCODE(pp, (uint64_t)start[u]); /* Encode starting point for this span */ UINT64ENCODE(pp, (uint64_t)curr->low); /* Encode previous ending points */ - for(u=0; u<rank; u++) + for (u = 0; u < rank; u++) UINT64ENCODE(pp, (uint64_t)end[u]); /* Encode starting point for this span */ @@ -3914,7 +3901,7 @@ H5S__hyper_serialize_helper(const H5S_hyper_span_info_t *spans, HDassert(0 && "Unknown enc size?!?"); } /* end switch */ - } /* end else */ + } /* end else */ /* Advance to next node */ curr = curr->next; @@ -3926,7 +3913,6 @@ H5S__hyper_serialize_helper(const H5S_hyper_span_info_t *spans, FUNC_LEAVE_NOAPI_VOID } /* end H5S__hyper_serialize_helper() */ - /*-------------------------------------------------------------------------- NAME H5S__hyper_serialize @@ -3951,24 +3937,24 @@ H5S__hyper_serialize_helper(const H5S_hyper_span_info_t *spans, static herr_t H5S__hyper_serialize(const H5S_t *space, uint8_t **p) { - const H5S_hyper_dim_t *diminfo; /* Alias for dataspace's diminfo information */ - hsize_t tmp_count[H5S_MAX_RANK]; /* Temporary hyperslab counts */ - hsize_t offset[H5S_MAX_RANK]; /* Offset of element in dataspace */ - hsize_t start[H5S_MAX_RANK]; /* Location of start of hyperslab */ - hsize_t end[H5S_MAX_RANK]; /* Location of end of hyperslab */ - uint8_t *pp; /* Local pointer for encoding */ - uint8_t *lenp = NULL; /* pointer to length location for later storage */ - uint32_t len = 0; /* number of bytes used */ - uint32_t version; /* Version number */ - uint8_t flags = 0; /* Flags for message */ - hsize_t block_count = 0; /* block counter for regular hyperslabs */ - unsigned fast_dim; /* Rank of the fastest changing dimension for the dataspace */ - unsigned ndims; /* Rank of the dataspace */ - unsigned u; /* Local counting variable */ - hbool_t complete = FALSE; /* Whether we are done with the iteration */ - hbool_t is_regular; /* Whether selection is regular */ - uint8_t enc_size; /* Encoded size */ - herr_t ret_value = SUCCEED; /* return value */ + const H5S_hyper_dim_t *diminfo; /* Alias for dataspace's diminfo information */ + hsize_t tmp_count[H5S_MAX_RANK]; /* Temporary hyperslab counts */ + hsize_t offset[H5S_MAX_RANK]; /* Offset of element in dataspace */ + hsize_t start[H5S_MAX_RANK]; /* Location of start of hyperslab */ + hsize_t end[H5S_MAX_RANK]; /* Location of end of hyperslab */ + uint8_t * pp; /* Local pointer for encoding */ + uint8_t * lenp = NULL; /* pointer to length location for later storage */ + uint32_t len = 0; /* number of bytes used */ + uint32_t version; /* Version number */ + uint8_t flags = 0; /* Flags for message */ + hsize_t block_count = 0; /* block counter for regular hyperslabs */ + unsigned fast_dim; /* Rank of the fastest changing dimension for the dataspace */ + unsigned ndims; /* Rank of the dataspace */ + unsigned u; /* Local counting variable */ + hbool_t complete = FALSE; /* Whether we are done with the iteration */ + hbool_t is_regular; /* Whether selection is regular */ + uint8_t enc_size; /* Encoded size */ + herr_t ret_value = SUCCEED; /* return value */ FUNC_ENTER_STATIC @@ -3979,61 +3965,60 @@ H5S__hyper_serialize(const H5S_t *space, uint8_t **p) HDassert(pp); /* Set some convienence values */ - ndims = space->extent.rank; + ndims = space->extent.rank; diminfo = space->select.sel_info.hslab->diminfo.opt; /* Calculate the # of blocks */ - if(space->select.sel_info.hslab->unlim_dim < 0) /* ! H5S_UNLIMITED */ + if (space->select.sel_info.hslab->unlim_dim < 0) /* ! H5S_UNLIMITED */ block_count = H5S__get_select_hyper_nblocks(space, FALSE); /* Determine the version and the encoded size */ - if(H5S__hyper_get_version_enc_size(space, block_count, &version, &enc_size) < 0) + if (H5S__hyper_get_version_enc_size(space, block_count, &version, &enc_size) < 0) HGOTO_ERROR(H5E_DATASPACE, H5E_CANTGET, FAIL, "can't determine hyper version & enc_size") - is_regular = H5S__hyper_is_regular(space); - if(is_regular && - (version == H5S_HYPER_VERSION_2 || version == H5S_HYPER_VERSION_3)) + is_regular = H5S__hyper_is_regular(space); + if (is_regular && (version == H5S_HYPER_VERSION_2 || version == H5S_HYPER_VERSION_3)) flags |= H5S_HYPER_REGULAR; /* Store the preamble information */ UINT32ENCODE(pp, (uint32_t)H5S_GET_SELECT_TYPE(space)); /* Store the type of selection */ - UINT32ENCODE(pp, version); /* Store the version number */ + UINT32ENCODE(pp, version); /* Store the version number */ - if(version >= 3) { + if (version >= 3) { *(pp)++ = flags; /* Store the flags */ *(pp)++ = enc_size; /* Store size of offset info */ - } /* end if */ + } /* end if */ else { - if(version == 2) + if (version == 2) *(pp)++ = flags; /* Store the flags */ else UINT32ENCODE(pp, (uint32_t)0); /* Store the un-used padding */ - lenp = pp; /* keep the pointer to the length location for later */ - pp += 4; /* skip over space for length */ + lenp = pp; /* keep the pointer to the length location for later */ + pp += 4; /* skip over space for length */ - len += 4; /* ndims */ - } /* end else */ + len += 4; /* ndims */ + } /* end else */ /* Encode number of dimensions */ UINT32ENCODE(pp, (uint32_t)ndims); - if(is_regular) { - if(version >= H5S_HYPER_VERSION_2) { + if (is_regular) { + if (version >= H5S_HYPER_VERSION_2) { HDassert(H5S_UNLIMITED == HSIZE_UNDEF); /* Iterate over dimensions */ /* Encode start/stride/block/count */ - switch(enc_size) { + switch (enc_size) { case H5S_SELECT_INFO_ENC_SIZE_2: HDassert(version == H5S_HYPER_VERSION_3); - for(u = 0; u < space->extent.rank; u++) { + for (u = 0; u < space->extent.rank; u++) { UINT16ENCODE(pp, diminfo[u].start); UINT16ENCODE(pp, diminfo[u].stride); - if(diminfo[u].count == H5S_UNLIMITED) + if (diminfo[u].count == H5S_UNLIMITED) UINT16ENCODE(pp, H5S_UINT16_MAX) else UINT16ENCODE(pp, diminfo[u].count) - if(diminfo[u].block == H5S_UNLIMITED) + if (diminfo[u].block == H5S_UNLIMITED) UINT16ENCODE(pp, H5S_UINT16_MAX) else UINT16ENCODE(pp, diminfo[u].block) @@ -4042,14 +4027,14 @@ H5S__hyper_serialize(const H5S_t *space, uint8_t **p) case H5S_SELECT_INFO_ENC_SIZE_4: HDassert(version == H5S_HYPER_VERSION_3); - for(u = 0; u < space->extent.rank; u++) { + for (u = 0; u < space->extent.rank; u++) { UINT32ENCODE(pp, diminfo[u].start); UINT32ENCODE(pp, diminfo[u].stride); - if(diminfo[u].count == H5S_UNLIMITED) + if (diminfo[u].count == H5S_UNLIMITED) UINT32ENCODE(pp, H5S_UINT32_MAX) else UINT32ENCODE(pp, diminfo[u].count) - if(diminfo[u].block == H5S_UNLIMITED) + if (diminfo[u].block == H5S_UNLIMITED) UINT32ENCODE(pp, H5S_UINT32_MAX) else UINT32ENCODE(pp, diminfo[u].block) @@ -4058,26 +4043,27 @@ H5S__hyper_serialize(const H5S_t *space, uint8_t **p) case H5S_SELECT_INFO_ENC_SIZE_8: HDassert(version == H5S_HYPER_VERSION_2 || version == H5S_HYPER_VERSION_3); - for(u = 0; u < space->extent.rank; u++) { + for (u = 0; u < space->extent.rank; u++) { UINT64ENCODE(pp, diminfo[u].start); UINT64ENCODE(pp, diminfo[u].stride); - if(diminfo[u].count == H5S_UNLIMITED) + if (diminfo[u].count == H5S_UNLIMITED) UINT64ENCODE(pp, H5S_UINT64_MAX) else UINT64ENCODE(pp, diminfo[u].count) - if(diminfo[u].block == H5S_UNLIMITED) + if (diminfo[u].block == H5S_UNLIMITED) UINT64ENCODE(pp, H5S_UINT64_MAX) else UINT64ENCODE(pp, diminfo[u].block) } /* end for */ - if(version == H5S_HYPER_VERSION_2) + if (version == H5S_HYPER_VERSION_2) len += (4 * space->extent.rank * 8); break; default: - HGOTO_ERROR(H5E_DATASPACE, H5E_UNSUPPORTED, FAIL, "unknown offset info size for hyperslab") + HGOTO_ERROR(H5E_DATASPACE, H5E_UNSUPPORTED, FAIL, + "unknown offset info size for hyperslab") break; } /* end switch */ - } /* end if */ + } /* end if */ else { HDassert(version == H5S_HYPER_VERSION_1); @@ -4092,52 +4078,52 @@ H5S__hyper_serialize(const H5S_t *space, uint8_t **p) /* Now serialize the information for the regular hyperslab */ /* Build the tables of count sizes as well as the initial offset */ - for(u = 0; u < ndims; u++) { + for (u = 0; u < ndims; u++) { tmp_count[u] = diminfo[u].count; - offset[u] = diminfo[u].start; + offset[u] = diminfo[u].start; } /* end for */ /* Go iterate over the hyperslabs */ - while(complete == FALSE) { + while (complete == FALSE) { /* Iterate over the blocks in the fastest dimension */ - while(tmp_count[fast_dim] > 0) { + while (tmp_count[fast_dim] > 0) { /* Add 8 bytes times the rank for each hyperslab selected */ len += 8 * ndims; /* Encode hyperslab starting location */ - for(u = 0; u < ndims; u++) + for (u = 0; u < ndims; u++) UINT32ENCODE(pp, (uint32_t)offset[u]); /* Encode hyperslab ending location */ - for(u = 0; u < ndims; u++) + for (u = 0; u < ndims; u++) UINT32ENCODE(pp, (uint32_t)(offset[u] + (diminfo[u].block - 1))); /* Move the offset to the next sequence to start */ - offset[fast_dim]+=diminfo[fast_dim].stride; + offset[fast_dim] += diminfo[fast_dim].stride; /* Decrement the block count */ tmp_count[fast_dim]--; } /* end while */ /* Work on other dimensions if necessary */ - if(fast_dim > 0) { - int temp_dim; /* Temporary rank holder */ + if (fast_dim > 0) { + int temp_dim; /* Temporary rank holder */ /* Reset the block counts */ tmp_count[fast_dim] = diminfo[fast_dim].count; /* Bubble up the decrement to the slower changing dimensions */ temp_dim = (int)fast_dim - 1; - while(temp_dim >= 0 && complete == FALSE) { + while (temp_dim >= 0 && complete == FALSE) { /* Decrement the block count */ tmp_count[temp_dim]--; /* Check if we have more blocks left */ - if(tmp_count[temp_dim] > 0) + if (tmp_count[temp_dim] > 0) break; /* Check for getting out of iterator */ - if(temp_dim == 0) + if (temp_dim == 0) complete = TRUE; /* Reset the block count in this dimension */ @@ -4146,19 +4132,19 @@ H5S__hyper_serialize(const H5S_t *space, uint8_t **p) /* Wrapped a dimension, go up to next dimension */ temp_dim--; } /* end while */ - } /* end if */ + } /* end if */ else - break; /* Break out now, for 1-D selections */ + break; /* Break out now, for 1-D selections */ /* Re-compute offset array */ - for(u = 0; u < ndims; u++) + for (u = 0; u < ndims; u++) offset[u] = diminfo[u].start + diminfo[u].stride * (diminfo[u].count - tmp_count[u]); } /* end while */ - } /* end else */ - } /* end if */ - else { /* irregular */ + } /* end else */ + } /* end if */ + else { /* irregular */ /* Encode number of hyperslabs */ - switch(enc_size) { + switch (enc_size) { case H5S_SELECT_INFO_ENC_SIZE_2: HDassert(version == H5S_HYPER_VERSION_3); H5_CHECK_OVERFLOW(block_count, hsize_t, uint16_t); @@ -4181,7 +4167,7 @@ H5S__hyper_serialize(const H5S_t *space, uint8_t **p) break; } /* end switch */ - if(version == H5S_HYPER_VERSION_1) { + if (version == H5S_HYPER_VERSION_1) { len += 4; /* block_count */ /* Add 8 bytes times the rank for each hyperslab selected */ @@ -4189,12 +4175,13 @@ H5S__hyper_serialize(const H5S_t *space, uint8_t **p) len += (uint32_t)(8 * ndims * block_count); } /* end if */ - H5S__hyper_serialize_helper(space->select.sel_info.hslab->span_lst, start, end, (hsize_t)0, enc_size, &pp); + H5S__hyper_serialize_helper(space->select.sel_info.hslab->span_lst, start, end, (hsize_t)0, enc_size, + &pp); } /* end else */ /* Encode length */ - if(version <= H5S_HYPER_VERSION_2) - UINT32ENCODE(lenp, (uint32_t)len); /* Store the length of the extra information */ + if (version <= H5S_HYPER_VERSION_2) + UINT32ENCODE(lenp, (uint32_t)len); /* Store the length of the extra information */ /* Update encoding pointer */ *p = pp; @@ -4203,7 +4190,6 @@ done: FUNC_LEAVE_NOAPI(ret_value) } /* end H5S__hyper_serialize() */ - /*-------------------------------------------------------------------------- NAME H5S__hyper_deserialize @@ -4229,18 +4215,18 @@ done: static herr_t H5S__hyper_deserialize(H5S_t **space, const uint8_t **p) { - H5S_t *tmp_space = NULL; /* Pointer to actual dataspace to use, - either *space or a newly allocated one */ - hsize_t dims[H5S_MAX_RANK]; /* Dimenion sizes */ - hsize_t start[H5S_MAX_RANK]; /* hyperslab start information */ - hsize_t block[H5S_MAX_RANK]; /* hyperslab block information */ - uint32_t version; /* Version number */ - uint8_t flags = 0; /* Flags */ - uint8_t enc_size = 0; /* Encoded size of selection info */ - unsigned rank; /* rank of points */ - const uint8_t *pp; /* Local pointer for decoding */ - unsigned u; /* Local counting variable */ - herr_t ret_value=FAIL; /* return value */ + H5S_t *tmp_space = NULL; /* Pointer to actual dataspace to use, + either *space or a newly allocated one */ + hsize_t dims[H5S_MAX_RANK]; /* Dimenion sizes */ + hsize_t start[H5S_MAX_RANK]; /* hyperslab start information */ + hsize_t block[H5S_MAX_RANK]; /* hyperslab block information */ + uint32_t version; /* Version number */ + uint8_t flags = 0; /* Flags */ + uint8_t enc_size = 0; /* Encoded size of selection info */ + unsigned rank; /* rank of points */ + const uint8_t *pp; /* Local pointer for decoding */ + unsigned u; /* Local counting variable */ + herr_t ret_value = FAIL; /* return value */ FUNC_ENTER_STATIC @@ -4254,8 +4240,8 @@ H5S__hyper_deserialize(H5S_t **space, const uint8_t **p) is moved from H5S_select_deserialize() in H5Sselect.c to here. This is needed for decoding virtual layout in H5O__layout_decode() */ /* Allocate space if not provided */ - if(!*space) { - if(NULL == (tmp_space = H5S_create(H5S_SIMPLE))) + if (!*space) { + if (NULL == (tmp_space = H5S_create(H5S_SIMPLE))) HGOTO_ERROR(H5E_DATASPACE, H5E_CANTCREATE, FAIL, "can't create dataspace") } /* end if */ else @@ -4264,14 +4250,14 @@ H5S__hyper_deserialize(H5S_t **space, const uint8_t **p) /* Decode version */ UINT32DECODE(pp, version); - if(version < H5S_HYPER_VERSION_1 || version > H5S_HYPER_VERSION_LATEST) + if (version < H5S_HYPER_VERSION_1 || version > H5S_HYPER_VERSION_LATEST) HGOTO_ERROR(H5E_DATASPACE, H5E_BADVALUE, FAIL, "bad version number for hyperslab selection") - if(version >= (uint32_t)H5S_HYPER_VERSION_2) { + if (version >= (uint32_t)H5S_HYPER_VERSION_2) { /* Decode flags */ flags = *(pp)++; - if(version >= (uint32_t)H5S_HYPER_VERSION_3) + if (version >= (uint32_t)H5S_HYPER_VERSION_3) /* decode size of offset info */ enc_size = *(pp)++; else { @@ -4280,85 +4266,86 @@ H5S__hyper_deserialize(H5S_t **space, const uint8_t **p) enc_size = H5S_SELECT_INFO_ENC_SIZE_8; } /* end else */ - /* Check for unknown flags */ - if(flags & ~H5S_SELECT_FLAG_BITS) + /* Check for unknown flags */ + if (flags & ~H5S_SELECT_FLAG_BITS) HGOTO_ERROR(H5E_DATASPACE, H5E_CANTLOAD, FAIL, "unknown flag for selection") - } - else { + } + else { /* Skip over the remainder of the header */ pp += 8; enc_size = H5S_SELECT_INFO_ENC_SIZE_4; - } /* end else */ + } /* end else */ - /* Check encoded */ - if(enc_size & ~H5S_SELECT_INFO_ENC_SIZE_BITS) + /* Check encoded */ + if (enc_size & ~H5S_SELECT_INFO_ENC_SIZE_BITS) HGOTO_ERROR(H5E_DATASPACE, H5E_CANTLOAD, FAIL, "unknown size of point/offset info for selection") /* Decode the rank of the point selection */ - UINT32DECODE(pp,rank); + UINT32DECODE(pp, rank); - if(!*space) { + if (!*space) { /* Patch the rank of the allocated dataspace */ HDmemset(dims, 0, (size_t)rank * sizeof(dims[0])); - if(H5S_set_extent_simple(tmp_space, rank, dims, NULL) < 0) + if (H5S_set_extent_simple(tmp_space, rank, dims, NULL) < 0) HGOTO_ERROR(H5E_DATASPACE, H5E_CANTINIT, FAIL, "can't set dimensions") } /* end if */ else /* Verify the rank of the provided dataspace */ - if(rank != tmp_space->extent.rank) - HGOTO_ERROR(H5E_DATASPACE, H5E_BADRANGE, FAIL, "rank of serialized selection does not match dataspace") + if (rank != tmp_space->extent.rank) + HGOTO_ERROR(H5E_DATASPACE, H5E_BADRANGE, FAIL, + "rank of serialized selection does not match dataspace") - if(flags & H5S_HYPER_REGULAR) { - hsize_t stride[H5S_MAX_RANK]; /* Hyperslab stride information */ - hsize_t count[H5S_MAX_RANK]; /* Hyperslab count information */ + if (flags & H5S_HYPER_REGULAR) { + hsize_t stride[H5S_MAX_RANK]; /* Hyperslab stride information */ + hsize_t count[H5S_MAX_RANK]; /* Hyperslab count information */ /* Sanity checks */ HDassert(H5S_UNLIMITED == HSIZE_UNDEF); HDassert(version >= H5S_HYPER_VERSION_2); - /* Decode start/stride/block/count */ - switch(enc_size) { + /* Decode start/stride/block/count */ + switch (enc_size) { case H5S_SELECT_INFO_ENC_SIZE_2: - for(u = 0; u < tmp_space->extent.rank; u++) { + for (u = 0; u < tmp_space->extent.rank; u++) { UINT16DECODE(pp, start[u]); UINT16DECODE(pp, stride[u]); UINT16DECODE(pp, count[u]); - if((uint16_t)count[u] == H5S_UINT16_MAX) + if ((uint16_t)count[u] == H5S_UINT16_MAX) count[u] = H5S_UNLIMITED; UINT16DECODE(pp, block[u]); - if((uint16_t)block[u] == H5S_UINT16_MAX) + if ((uint16_t)block[u] == H5S_UINT16_MAX) block[u] = H5S_UNLIMITED; } /* end for */ break; case H5S_SELECT_INFO_ENC_SIZE_4: - for(u = 0; u < tmp_space->extent.rank; u++) { + for (u = 0; u < tmp_space->extent.rank; u++) { UINT32DECODE(pp, start[u]); UINT32DECODE(pp, stride[u]); UINT32DECODE(pp, count[u]); - if((uint32_t)count[u] == H5S_UINT32_MAX) + if ((uint32_t)count[u] == H5S_UINT32_MAX) count[u] = H5S_UNLIMITED; UINT32DECODE(pp, block[u]); - if((uint32_t)block[u] == H5S_UINT32_MAX) + if ((uint32_t)block[u] == H5S_UINT32_MAX) block[u] = H5S_UNLIMITED; } /* end for */ break; case H5S_SELECT_INFO_ENC_SIZE_8: - for(u = 0; u < tmp_space->extent.rank; u++) { + for (u = 0; u < tmp_space->extent.rank; u++) { UINT64DECODE(pp, start[u]); UINT64DECODE(pp, stride[u]); UINT64DECODE(pp, count[u]); - if((uint64_t)count[u] == H5S_UINT64_MAX) + if ((uint64_t)count[u] == H5S_UINT64_MAX) count[u] = H5S_UNLIMITED; UINT64DECODE(pp, block[u]); - if((uint64_t)block[u] == H5S_UINT64_MAX) + if ((uint64_t)block[u] == H5S_UINT64_MAX) block[u] = H5S_UNLIMITED; } /* end for */ break; @@ -4369,21 +4356,21 @@ H5S__hyper_deserialize(H5S_t **space, const uint8_t **p) } /* end switch */ /* Select the hyperslab to the current selection */ - if((ret_value = H5S_select_hyperslab(tmp_space, H5S_SELECT_SET, start, stride, count, block)) < 0) + if ((ret_value = H5S_select_hyperslab(tmp_space, H5S_SELECT_SET, start, stride, count, block)) < 0) HGOTO_ERROR(H5E_DATASPACE, H5E_CANTSET, FAIL, "can't change selection") } /* end if */ else { - const hsize_t *stride; /* Hyperslab stride information */ - const hsize_t *count; /* Hyperslab count information */ - hsize_t end[H5S_MAX_RANK]; /* Hyperslab end information */ - hsize_t *tstart; /* Temporary hyperslab pointers */ - hsize_t *tend; /* Temporary hyperslab pointers */ - hsize_t *tblock; /* Temporary hyperslab pointers */ - size_t num_elem; /* Number of elements in selection */ - unsigned v; /* Local counting variable */ + const hsize_t *stride; /* Hyperslab stride information */ + const hsize_t *count; /* Hyperslab count information */ + hsize_t end[H5S_MAX_RANK]; /* Hyperslab end information */ + hsize_t * tstart; /* Temporary hyperslab pointers */ + hsize_t * tend; /* Temporary hyperslab pointers */ + hsize_t * tblock; /* Temporary hyperslab pointers */ + size_t num_elem; /* Number of elements in selection */ + unsigned v; /* Local counting variable */ /* Decode the number of blocks */ - switch(enc_size) { + switch (enc_size) { case H5S_SELECT_INFO_ENC_SIZE_2: UINT16DECODE(pp, num_elem); break; @@ -4405,62 +4392,63 @@ H5S__hyper_deserialize(H5S_t **space, const uint8_t **p) stride = count = H5S_hyper_ones_g; /* Retrieve the coordinates from the buffer */ - for(u = 0; u < num_elem; u++) { + for (u = 0; u < num_elem; u++) { /* Decode the starting and ending points */ - switch(enc_size) { + switch (enc_size) { case H5S_SELECT_INFO_ENC_SIZE_2: - for(tstart = start, v = 0; v < rank; v++, tstart++) + for (tstart = start, v = 0; v < rank; v++, tstart++) UINT16DECODE(pp, *tstart); - for(tend = end, v = 0; v < rank; v++, tend++) + for (tend = end, v = 0; v < rank; v++, tend++) UINT16DECODE(pp, *tend); break; case H5S_SELECT_INFO_ENC_SIZE_4: - for(tstart = start,v = 0; v < rank; v++, tstart++) + for (tstart = start, v = 0; v < rank; v++, tstart++) UINT32DECODE(pp, *tstart); - for(tend = end, v = 0; v < rank; v++, tend++) + for (tend = end, v = 0; v < rank; v++, tend++) UINT32DECODE(pp, *tend); break; case H5S_SELECT_INFO_ENC_SIZE_8: - for(tstart = start, v = 0; v < rank; v++, tstart++) + for (tstart = start, v = 0; v < rank; v++, tstart++) UINT64DECODE(pp, *tstart); - for(tend = end, v = 0; v < rank; v++, tend++) + for (tend = end, v = 0; v < rank; v++, tend++) UINT64DECODE(pp, *tend); break; default: - HGOTO_ERROR(H5E_DATASPACE, H5E_UNSUPPORTED, FAIL, "unknown offset info size for hyperslab") + HGOTO_ERROR(H5E_DATASPACE, H5E_UNSUPPORTED, FAIL, + "unknown offset info size for hyperslab") break; } /* end switch */ /* Change the ending points into blocks */ - for(tblock = block, tstart = start, tend = end, v = 0; v < rank; v++, tstart++, tend++, tblock++) + for (tblock = block, tstart = start, tend = end, v = 0; v < rank; v++, tstart++, tend++, tblock++) *tblock = (*tend - *tstart) + 1; /* Select or add the hyperslab to the current selection */ - if((ret_value = H5S_select_hyperslab(tmp_space, (u == 0 ? H5S_SELECT_SET : H5S_SELECT_OR), start, stride, count, block)) < 0) + if ((ret_value = H5S_select_hyperslab(tmp_space, (u == 0 ? H5S_SELECT_SET : H5S_SELECT_OR), start, + stride, count, block)) < 0) HGOTO_ERROR(H5E_DATASPACE, H5E_CANTSET, FAIL, "can't change selection") } /* end for */ - } /* end else */ + } /* end else */ /* Update decoding pointer */ *p = pp; /* Return space to the caller if allocated */ - if(!*space) + if (!*space) *space = tmp_space; done: /* Free temporary space if not passed to caller (only happens on error) */ - if(!*space && tmp_space) - if(H5S_close(tmp_space) < 0) + if (!*space && tmp_space) + if (H5S_close(tmp_space) < 0) HDONE_ERROR(H5E_DATASPACE, H5E_CANTFREE, FAIL, "can't close dataspace") FUNC_LEAVE_NOAPI(ret_value) } /* end H5S__hyper_deserialize() */ - /*-------------------------------------------------------------------------- NAME H5S__hyper_span_blocklist @@ -4495,12 +4483,11 @@ done: REVISION LOG --------------------------------------------------------------------------*/ static herr_t -H5S__hyper_span_blocklist(const H5S_hyper_span_info_t *spans, hsize_t start[], - hsize_t end[], hsize_t rank, hsize_t *startblock, hsize_t *numblocks, - hsize_t **buf) +H5S__hyper_span_blocklist(const H5S_hyper_span_info_t *spans, hsize_t start[], hsize_t end[], hsize_t rank, + hsize_t *startblock, hsize_t *numblocks, hsize_t **buf) { - const H5S_hyper_span_t *curr; /* Pointer to current hyperslab span */ - herr_t ret_value = SUCCEED; /* return value */ + const H5S_hyper_span_t *curr; /* Pointer to current hyperslab span */ + herr_t ret_value = SUCCEED; /* return value */ FUNC_ENTER_STATIC @@ -4515,20 +4502,20 @@ H5S__hyper_span_blocklist(const H5S_hyper_span_info_t *spans, hsize_t start[], /* Walk through the list of spans, recursing or outputting them */ curr = spans->head; - while(curr != NULL && *numblocks > 0) { + while (curr != NULL && *numblocks > 0) { /* Recurse if this node has down spans */ - if(curr->down != NULL) { + if (curr->down != NULL) { /* Add the starting and ending points for this span to the list */ start[rank] = curr->low; - end[rank] = curr->high; + end[rank] = curr->high; /* Recurse down to the next dimension */ - if(H5S__hyper_span_blocklist(curr->down, start, end, (rank + 1), startblock, numblocks, buf) < 0) + if (H5S__hyper_span_blocklist(curr->down, start, end, (rank + 1), startblock, numblocks, buf) < 0) HGOTO_ERROR(H5E_INTERNAL, H5E_CANTFREE, FAIL, "failed to release hyperslab spans") } /* end if */ else { /* Skip this block if we haven't skipped all the startblocks yet */ - if(*startblock > 0) { + if (*startblock > 0) { /* Decrement the starting block */ (*startblock)--; } /* end if */ @@ -4555,7 +4542,7 @@ H5S__hyper_span_blocklist(const H5S_hyper_span_info_t *spans, hsize_t start[], /* Decrement the number of blocks processed */ (*numblocks)--; } /* end else */ - } /* end else */ + } /* end else */ /* Advance to next node */ curr = curr->next; @@ -4565,7 +4552,6 @@ done: FUNC_LEAVE_NOAPI(ret_value) } /* end H5S__hyper_span_blocklist() */ - /*-------------------------------------------------------------------------- NAME H5S__get_select_hyper_blocklist @@ -4597,8 +4583,7 @@ done: REVISION LOG --------------------------------------------------------------------------*/ static herr_t -H5S__get_select_hyper_blocklist(H5S_t *space, hsize_t startblock, - hsize_t numblocks, hsize_t *buf) +H5S__get_select_hyper_blocklist(H5S_t *space, hsize_t startblock, hsize_t numblocks, hsize_t *buf) { herr_t ret_value = SUCCEED; /* Return value */ @@ -4611,26 +4596,26 @@ H5S__get_select_hyper_blocklist(H5S_t *space, hsize_t startblock, /* Attempt to rebuild diminfo if it is invalid and has not been confirmed * to be impossible. */ - if(space->select.sel_info.hslab->diminfo_valid == H5S_DIMINFO_VALID_NO) + if (space->select.sel_info.hslab->diminfo_valid == H5S_DIMINFO_VALID_NO) H5S__hyper_rebuild(space); /* Check for a "regular" hyperslab selection */ - if(space->select.sel_info.hslab->diminfo_valid == H5S_DIMINFO_VALID_YES) { - const H5S_hyper_dim_t *diminfo; /* Alias for dataspace's diminfo information */ - hsize_t tmp_count[H5S_MAX_RANK]; /* Temporary hyperslab counts */ - hsize_t offset[H5S_MAX_RANK]; /* Offset of element in dataspace */ - hsize_t end[H5S_MAX_RANK]; /* End of elements in dataspace */ - unsigned fast_dim; /* Rank of the fastest changing dimension for the dataspace */ - unsigned ndims; /* Rank of the dataspace */ - hbool_t done; /* Whether we are done with the iteration */ - unsigned u; /* Counter */ + if (space->select.sel_info.hslab->diminfo_valid == H5S_DIMINFO_VALID_YES) { + const H5S_hyper_dim_t *diminfo; /* Alias for dataspace's diminfo information */ + hsize_t tmp_count[H5S_MAX_RANK]; /* Temporary hyperslab counts */ + hsize_t offset[H5S_MAX_RANK]; /* Offset of element in dataspace */ + hsize_t end[H5S_MAX_RANK]; /* End of elements in dataspace */ + unsigned fast_dim; /* Rank of the fastest changing dimension for the dataspace */ + unsigned ndims; /* Rank of the dataspace */ + hbool_t done; /* Whether we are done with the iteration */ + unsigned u; /* Counter */ /* Set some convienence values */ - ndims = space->extent.rank; + ndims = space->extent.rank; fast_dim = ndims - 1; /* Check which set of dimension information to use */ - if(space->select.sel_info.hslab->unlim_dim >= 0) + if (space->select.sel_info.hslab->unlim_dim >= 0) /* * There is an unlimited dimension so we must use diminfo.opt as * it has been "clipped" to the current extent. @@ -4645,21 +4630,21 @@ H5S__get_select_hyper_blocklist(H5S_t *space, hsize_t startblock, diminfo = space->select.sel_info.hslab->diminfo.app; /* Build the tables of count sizes as well as the initial offset */ - for(u = 0; u < ndims; u++) { + for (u = 0; u < ndims; u++) { tmp_count[u] = diminfo[u].count; - offset[u] = diminfo[u].start; - end[u] = diminfo[u].start + (diminfo[u].block - 1); + offset[u] = diminfo[u].start; + end[u] = diminfo[u].start + (diminfo[u].block - 1); } /* end for */ /* We're not done with the iteration */ done = FALSE; /* Go iterate over the hyperslabs */ - while(!done && numblocks > 0) { + while (!done && numblocks > 0) { /* Skip over initial blocks */ - if(startblock > 0) { + if (startblock > 0) { /* Skip all blocks in row */ - if(startblock >= tmp_count[fast_dim]) { + if (startblock >= tmp_count[fast_dim]) { startblock -= tmp_count[fast_dim]; tmp_count[fast_dim] = 0; } /* end if */ @@ -4674,10 +4659,10 @@ H5S__get_select_hyper_blocklist(H5S_t *space, hsize_t startblock, /* Done with starting blocks */ startblock = 0; } /* end else */ - } /* end if */ + } /* end if */ /* Iterate over the blocks in the fastest dimension */ - while(tmp_count[fast_dim] > 0 && numblocks > 0) { + while (tmp_count[fast_dim] > 0 && numblocks > 0) { /* Sanity check */ HDassert(startblock == 0); @@ -4701,53 +4686,53 @@ H5S__get_select_hyper_blocklist(H5S_t *space, hsize_t startblock, } /* end while */ /* Work on other dimensions if necessary */ - if(fast_dim > 0 && numblocks > 0) { - int temp_dim; /* Temporary rank holder */ + if (fast_dim > 0 && numblocks > 0) { + int temp_dim; /* Temporary rank holder */ /* Reset the block counts */ tmp_count[fast_dim] = diminfo[fast_dim].count; /* Bubble up the decrement to the slower changing dimensions */ temp_dim = (int)(fast_dim - 1); - while(temp_dim >= 0 && !done) { + while (temp_dim >= 0 && !done) { /* Decrement the block count */ tmp_count[temp_dim]--; /* Check if we have more blocks left */ - if(tmp_count[temp_dim] > 0) + if (tmp_count[temp_dim] > 0) break; /* Reset the block count in this dimension */ tmp_count[temp_dim] = diminfo[temp_dim].count; /* Check for getting out of iterator */ - if(temp_dim == 0) + if (temp_dim == 0) done = TRUE; /* Wrapped a dimension, go up to next dimension */ temp_dim--; } /* end while */ - } /* end if */ + } /* end if */ /* Re-compute offset & end arrays */ - if(!done) - for(u = 0; u < ndims; u++) { + if (!done) + for (u = 0; u < ndims; u++) { offset[u] = diminfo[u].start + diminfo[u].stride * (diminfo[u].count - tmp_count[u]); - end[u] = offset[u] + (diminfo[u].block - 1); + end[u] = offset[u] + (diminfo[u].block - 1); } /* end for */ - } /* end while */ - } /* end if */ + } /* end while */ + } /* end if */ else { - hsize_t start[H5S_MAX_RANK]; /* Location of start of hyperslab */ - hsize_t end[H5S_MAX_RANK]; /* Location of end of hyperslab */ + hsize_t start[H5S_MAX_RANK]; /* Location of start of hyperslab */ + hsize_t end[H5S_MAX_RANK]; /* Location of end of hyperslab */ - ret_value = H5S__hyper_span_blocklist(space->select.sel_info.hslab->span_lst, start, end, (hsize_t)0, &startblock, &numblocks, &buf); + ret_value = H5S__hyper_span_blocklist(space->select.sel_info.hslab->span_lst, start, end, (hsize_t)0, + &startblock, &numblocks, &buf); } /* end else */ FUNC_LEAVE_NOAPI(ret_value) } /* end H5S__get_select_hyper_blocklist() */ - /*-------------------------------------------------------------------------- NAME H5Sget_select_hyper_blocklist @@ -4779,36 +4764,35 @@ H5S__get_select_hyper_blocklist(H5S_t *space, hsize_t startblock, REVISION LOG --------------------------------------------------------------------------*/ herr_t -H5Sget_select_hyper_blocklist(hid_t spaceid, hsize_t startblock, - hsize_t numblocks, hsize_t buf[/*numblocks*/]) +H5Sget_select_hyper_blocklist(hid_t spaceid, hsize_t startblock, hsize_t numblocks, + hsize_t buf[/*numblocks*/]) { - H5S_t *space; /* Dataspace to modify selection of */ - herr_t ret_value; /* return value */ + H5S_t *space; /* Dataspace to modify selection of */ + herr_t ret_value; /* return value */ FUNC_ENTER_API(FAIL) H5TRACE4("e", "ihh*[a2]h", spaceid, startblock, numblocks, buf); /* Check args */ - if(buf == NULL) + if (buf == NULL) HGOTO_ERROR(H5E_ARGS, H5E_BADVALUE, FAIL, "invalid pointer") - if(NULL == (space = (H5S_t *)H5I_object_verify(spaceid, H5I_DATASPACE))) + if (NULL == (space = (H5S_t *)H5I_object_verify(spaceid, H5I_DATASPACE))) HGOTO_ERROR(H5E_ARGS, H5E_BADTYPE, FAIL, "not a dataspace") - if(H5S_GET_SELECT_TYPE(space)!=H5S_SEL_HYPERSLABS) + if (H5S_GET_SELECT_TYPE(space) != H5S_SEL_HYPERSLABS) HGOTO_ERROR(H5E_ARGS, H5E_BADTYPE, FAIL, "not a hyperslab selection") - if(space->select.sel_info.hslab->unlim_dim >= 0) + if (space->select.sel_info.hslab->unlim_dim >= 0) HGOTO_ERROR(H5E_DATASPACE, H5E_UNSUPPORTED, FAIL, "cannot get blocklist for unlimited selection") /* Go get the correct number of blocks */ - if(numblocks > 0) + if (numblocks > 0) ret_value = H5S__get_select_hyper_blocklist(space, startblock, numblocks, buf); else - ret_value = SUCCEED; /* Successfully got 0 blocks... */ + ret_value = SUCCEED; /* Successfully got 0 blocks... */ done: FUNC_LEAVE_API(ret_value) } /* end H5Sget_select_hyper_blocklist() */ - /*-------------------------------------------------------------------------- NAME H5S__hyper_bounds @@ -4838,8 +4822,8 @@ done: static herr_t H5S__hyper_bounds(const H5S_t *space, hsize_t *start, hsize_t *end) { - const hsize_t *low_bounds, *high_bounds; /* Pointers to the correct pair of low & high bounds */ - herr_t ret_value = SUCCEED; /* Return value */ + const hsize_t *low_bounds, *high_bounds; /* Pointers to the correct pair of low & high bounds */ + herr_t ret_value = SUCCEED; /* Return value */ FUNC_ENTER_STATIC @@ -4849,36 +4833,36 @@ H5S__hyper_bounds(const H5S_t *space, hsize_t *start, hsize_t *end) HDassert(end); /* Check which set of low & high bounds we should be using */ - if(space->select.sel_info.hslab->diminfo_valid == H5S_DIMINFO_VALID_YES) { - low_bounds = space->select.sel_info.hslab->diminfo.low_bounds; + if (space->select.sel_info.hslab->diminfo_valid == H5S_DIMINFO_VALID_YES) { + low_bounds = space->select.sel_info.hslab->diminfo.low_bounds; high_bounds = space->select.sel_info.hslab->diminfo.high_bounds; } /* end if */ else { - low_bounds = space->select.sel_info.hslab->span_lst->low_bounds; + low_bounds = space->select.sel_info.hslab->span_lst->low_bounds; high_bounds = space->select.sel_info.hslab->span_lst->high_bounds; } /* end else */ /* Check for offset set */ - if(space->select.offset_changed) { - unsigned u; /* Local index variable */ + if (space->select.offset_changed) { + unsigned u; /* Local index variable */ /* Loop over dimensions */ - for(u = 0; u < space->extent.rank; u++) { + for (u = 0; u < space->extent.rank; u++) { /* Sanity check */ HDassert(low_bounds[u] <= high_bounds[u]); /* Check for offset moving selection negative */ - if(((hssize_t)low_bounds[u] + space->select.offset[u]) < 0) + if (((hssize_t)low_bounds[u] + space->select.offset[u]) < 0) HGOTO_ERROR(H5E_DATASPACE, H5E_BADRANGE, FAIL, "offset moves selection out of bounds") /* Set the low & high bounds in this dimension */ start[u] = (hsize_t)((hssize_t)low_bounds[u] + space->select.offset[u]); - if((int)u == space->select.sel_info.hslab->unlim_dim) + if ((int)u == space->select.sel_info.hslab->unlim_dim) end[u] = H5S_UNLIMITED; else end[u] = (hsize_t)((hssize_t)high_bounds[u] + space->select.offset[u]); } /* end for */ - } /* end if */ + } /* end if */ else { /* Offset vector is still zeros, just copy low & high bounds */ H5MM_memcpy(start, low_bounds, sizeof(hsize_t) * space->extent.rank); @@ -4889,7 +4873,6 @@ done: FUNC_LEAVE_NOAPI(ret_value) } /* end H5S__hyper_bounds() */ - /*-------------------------------------------------------------------------- NAME H5S__hyper_offset @@ -4913,38 +4896,40 @@ done: static herr_t H5S__hyper_offset(const H5S_t *space, hsize_t *offset) { - const hssize_t *sel_offset; /* Pointer to the selection's offset */ - const hsize_t *dim_size; /* Pointer to a dataspace's extent */ - hsize_t accum; /* Accumulator for dimension sizes */ - unsigned rank; /* Dataspace rank */ - int i; /* index variable */ - herr_t ret_value = SUCCEED; /* Return value */ + const hssize_t *sel_offset; /* Pointer to the selection's offset */ + const hsize_t * dim_size; /* Pointer to a dataspace's extent */ + hsize_t accum; /* Accumulator for dimension sizes */ + unsigned rank; /* Dataspace rank */ + int i; /* index variable */ + herr_t ret_value = SUCCEED; /* Return value */ FUNC_ENTER_STATIC - HDassert(space && space->extent.rank>0); + HDassert(space && space->extent.rank > 0); HDassert(offset); /* Start at linear offset 0 */ *offset = 0; /* Set up pointers to arrays of values */ - rank = space->extent.rank; + rank = space->extent.rank; sel_offset = space->select.offset; - dim_size = space->extent.size; + dim_size = space->extent.size; /* Check for a "regular" hyperslab selection */ /* (No need to rebuild the dimension info yet -QAK) */ - if(space->select.sel_info.hslab->diminfo_valid == H5S_DIMINFO_VALID_YES) { - const H5S_hyper_dim_t *diminfo = space->select.sel_info.hslab->diminfo.opt; /* Local alias for diminfo */ + if (space->select.sel_info.hslab->diminfo_valid == H5S_DIMINFO_VALID_YES) { + const H5S_hyper_dim_t *diminfo = + space->select.sel_info.hslab->diminfo.opt; /* Local alias for diminfo */ /* Loop through starting coordinates, calculating the linear offset */ accum = 1; - for(i = (int)(rank - 1); i >= 0; i--) { - hssize_t hyp_offset = (hssize_t)diminfo[i].start + sel_offset[i]; /* Hyperslab's offset in this dimension */ + for (i = (int)(rank - 1); i >= 0; i--) { + hssize_t hyp_offset = + (hssize_t)diminfo[i].start + sel_offset[i]; /* Hyperslab's offset in this dimension */ /* Check for offset moving selection out of the dataspace */ - if(hyp_offset < 0 || (hsize_t)hyp_offset >= dim_size[i]) + if (hyp_offset < 0 || (hsize_t)hyp_offset >= dim_size[i]) HGOTO_ERROR(H5E_DATASPACE, H5E_BADRANGE, FAIL, "offset moves selection out of bounds") /* Add the hyperslab's offset in this dimension to the total linear offset */ @@ -4953,14 +4938,14 @@ H5S__hyper_offset(const H5S_t *space, hsize_t *offset) /* Increase the accumulator */ accum *= dim_size[i]; } /* end for */ - } /* end if */ + } /* end if */ else { - const H5S_hyper_span_t *span; /* Hyperslab span node */ - hsize_t dim_accum[H5S_MAX_RANK]; /* Accumulators, for each dimension */ + const H5S_hyper_span_t *span; /* Hyperslab span node */ + hsize_t dim_accum[H5S_MAX_RANK]; /* Accumulators, for each dimension */ /* Calculate the accumulator for each dimension */ accum = 1; - for(i = (int)(rank - 1); i >= 0; i--) { + for (i = (int)(rank - 1); i >= 0; i--) { /* Set the accumulator for this dimension */ dim_accum[i] = accum; @@ -4973,18 +4958,19 @@ H5S__hyper_offset(const H5S_t *space, hsize_t *offset) /* Work down the spans, computing the linear offset */ i = 0; - while(span) { - hssize_t hyp_offset = (hssize_t)span->low + sel_offset[i]; /* Hyperslab's offset in this dimension */ + while (span) { + hssize_t hyp_offset = + (hssize_t)span->low + sel_offset[i]; /* Hyperslab's offset in this dimension */ /* Check for offset moving selection out of the dataspace */ - if(hyp_offset < 0 || (hsize_t)hyp_offset >= dim_size[i]) + if (hyp_offset < 0 || (hsize_t)hyp_offset >= dim_size[i]) HGOTO_ERROR(H5E_DATASPACE, H5E_BADRANGE, FAIL, "offset moves selection out of bounds") /* Add the hyperslab's offset in this dimension to the total linear offset */ *offset += (hsize_t)(hyp_offset * (hssize_t)dim_accum[i]); /* Advance to first span in "down" dimension */ - if(span->down) { + if (span->down) { HDassert(span->down->head); span = span->down->head; } /* end if */ @@ -4992,13 +4978,12 @@ H5S__hyper_offset(const H5S_t *space, hsize_t *offset) span = NULL; i++; } /* end while */ - } /* end else */ + } /* end else */ done: FUNC_LEAVE_NOAPI(ret_value) } /* end H5S__hyper_offset() */ - /*-------------------------------------------------------------------------- NAME H5S__hyper_unlim_dim @@ -5025,7 +5010,6 @@ H5S__hyper_unlim_dim(const H5S_t *space) FUNC_LEAVE_NOAPI(space->select.sel_info.hslab->unlim_dim); } /* end H5S__hyper_unlim_dim() */ - /*-------------------------------------------------------------------------- NAME H5S__hyper_num_elem_non_unlim @@ -5058,7 +5042,7 @@ H5S__hyper_num_elem_non_unlim(const H5S_t *space, hsize_t *num_elem_non_unlim) HDassert(num_elem_non_unlim); /* Get number of elements in the non-unlimited dimensions */ - if(space->select.sel_info.hslab->unlim_dim >= 0) + if (space->select.sel_info.hslab->unlim_dim >= 0) *num_elem_non_unlim = space->select.sel_info.hslab->num_elem_non_unlim; else HGOTO_ERROR(H5E_DATASPACE, H5E_BADVALUE, FAIL, "selection has no unlimited dimension") @@ -5067,7 +5051,6 @@ done: FUNC_LEAVE_NOAPI(ret_value) } /* end H5S__hyper_num_elem_non_unlim() */ - /*-------------------------------------------------------------------------- NAME H5S__hyper_is_contiguous @@ -5089,10 +5072,10 @@ done: static H5_ATTR_PURE htri_t H5S__hyper_is_contiguous(const H5S_t *space) { - hbool_t small_contiguous, /* Flag for small contiguous block */ - large_contiguous; /* Flag for large contiguous block */ - unsigned u; /* index variable */ - htri_t ret_value = FALSE; /* Return value */ + hbool_t small_contiguous, /* Flag for small contiguous block */ + large_contiguous; /* Flag for large contiguous block */ + unsigned u; /* index variable */ + htri_t ret_value = FALSE; /* Return value */ FUNC_ENTER_STATIC_NOERR @@ -5100,8 +5083,9 @@ H5S__hyper_is_contiguous(const H5S_t *space) /* Check for a "regular" hyperslab selection */ /* (No need to rebuild the dimension info yet -QAK) */ - if(space->select.sel_info.hslab->diminfo_valid == H5S_DIMINFO_VALID_YES) { - const H5S_hyper_dim_t *diminfo=space->select.sel_info.hslab->diminfo.opt; /* local alias for diminfo */ + if (space->select.sel_info.hslab->diminfo_valid == H5S_DIMINFO_VALID_YES) { + const H5S_hyper_dim_t *diminfo = + space->select.sel_info.hslab->diminfo.opt; /* local alias for diminfo */ /* * For a regular hyperslab to be contiguous, it must have only one @@ -5117,43 +5101,43 @@ H5S__hyper_is_contiguous(const H5S_t *space) */ /* Initialize flags */ - large_contiguous = TRUE; /* assume true and reset if the dimensions don't match */ - small_contiguous = FALSE; /* assume false initially */ + large_contiguous = TRUE; /* assume true and reset if the dimensions don't match */ + small_contiguous = FALSE; /* assume false initially */ /* Check for a "large contigous" block */ - for(u = 0; u < space->extent.rank; u++) { - if(diminfo[u].count > 1) { + for (u = 0; u < space->extent.rank; u++) { + if (diminfo[u].count > 1) { large_contiguous = FALSE; break; } /* end if */ - if(u > 0 && diminfo[u].block != space->extent.size[u]) { + if (u > 0 && diminfo[u].block != space->extent.size[u]) { large_contiguous = FALSE; break; } /* end if */ - } /* end for */ + } /* end for */ /* If we didn't find a large contiguous block, check for a small one */ - if(!large_contiguous) { + if (!large_contiguous) { small_contiguous = TRUE; - for(u = 0; u < space->extent.rank; u++) { - if(diminfo[u].count > 1) { + for (u = 0; u < space->extent.rank; u++) { + if (diminfo[u].count > 1) { small_contiguous = FALSE; break; } /* end if */ - if(u < (space->extent.rank - 1) && diminfo[u].block != 1) { + if (u < (space->extent.rank - 1) && diminfo[u].block != 1) { small_contiguous = FALSE; break; } /* end if */ - } /* end for */ - } /* end if */ + } /* end for */ + } /* end if */ /* Indicate true if it's either a large or small contiguous block */ - if(large_contiguous || small_contiguous) + if (large_contiguous || small_contiguous) ret_value = TRUE; } /* end if */ else { - H5S_hyper_span_info_t *spans; /* Hyperslab span info node */ - H5S_hyper_span_t *span; /* Hyperslab span node */ + H5S_hyper_span_info_t *spans; /* Hyperslab span info node */ + H5S_hyper_span_t * span; /* Hyperslab span node */ /* * For a hyperslab to be contiguous, it must have only one block and @@ -5163,36 +5147,37 @@ H5S__hyper_is_contiguous(const H5S_t *space) * block size must be 1 in all but the fastest changing dimension. */ /* Initialize flags */ - large_contiguous = TRUE; /* assume true and reset if the dimensions don't match */ - small_contiguous = FALSE; /* assume false initially */ + large_contiguous = TRUE; /* assume true and reset if the dimensions don't match */ + small_contiguous = FALSE; /* assume false initially */ /* Get information for slowest changing information */ spans = space->select.sel_info.hslab->span_lst; - span = spans->head; + span = spans->head; /* If there are multiple spans in the slowest changing dimension, the selection isn't contiguous */ - if(span->next != NULL) + if (span->next != NULL) large_contiguous = FALSE; else { /* Now check the rest of the dimensions */ - if(span->down != NULL) { - u = 1; /* Current dimension working on */ + if (span->down != NULL) { + u = 1; /* Current dimension working on */ /* Get the span information for the next fastest dimension */ spans = span->down; /* Cycle down the spans until we run out of down spans or find a non-contiguous span */ - while(spans != NULL) { + while (spans != NULL) { span = spans->head; /* Check that this is the only span and it spans the entire dimension */ - if(span->next != NULL) { + if (span->next != NULL) { large_contiguous = FALSE; break; } /* end if */ else { - /* If this span doesn't cover the entire dimension, then this selection isn't contiguous */ - if(((span->high - span->low) + 1) != space->extent.size[u]) { + /* If this span doesn't cover the entire dimension, then this selection isn't + * contiguous */ + if (((span->high - span->low) + 1) != space->extent.size[u]) { large_contiguous = FALSE; break; } /* end if */ @@ -5203,34 +5188,35 @@ H5S__hyper_is_contiguous(const H5S_t *space) /* Increment dimension */ u++; } /* end else */ - } /* end else */ - } /* end while */ - } /* end if */ - } /* end else */ + } /* end else */ + } /* end while */ + } /* end if */ + } /* end else */ /* If we didn't find a large contiguous block, check for a small one */ - if(!large_contiguous) { + if (!large_contiguous) { small_contiguous = TRUE; /* Get information for slowest changing information */ spans = space->select.sel_info.hslab->span_lst; - span = spans->head; + span = spans->head; /* Current dimension working on */ u = 0; /* Cycle down the spans until we run out of down spans or find a non-contiguous span */ - while(spans != NULL) { + while (spans != NULL) { span = spans->head; /* Check that this is the only span and it spans the entire dimension */ - if(span->next != NULL) { + if (span->next != NULL) { small_contiguous = FALSE; break; } /* end if */ else { - /* If this span doesn't cover the entire dimension, then this selection isn't contiguous */ - if(u < (space->extent.rank - 1) && ((span->high-span->low) + 1) != 1) { + /* If this span doesn't cover the entire dimension, then this selection isn't contiguous + */ + if (u < (space->extent.rank - 1) && ((span->high - span->low) + 1) != 1) { small_contiguous = FALSE; break; } /* end if */ @@ -5241,19 +5227,18 @@ H5S__hyper_is_contiguous(const H5S_t *space) /* Increment dimension */ u++; } /* end else */ - } /* end else */ - } /* end while */ - } /* end if */ + } /* end else */ + } /* end while */ + } /* end if */ /* Indicate true if it's either a large or small contiguous block */ - if(large_contiguous || small_contiguous) + if (large_contiguous || small_contiguous) ret_value = TRUE; } /* end else */ FUNC_LEAVE_NOAPI(ret_value) } /* end H5S__hyper_is_contiguous() */ - /*-------------------------------------------------------------------------- NAME H5S__hyper_is_single @@ -5275,7 +5260,7 @@ H5S__hyper_is_contiguous(const H5S_t *space) static H5_ATTR_PURE htri_t H5S__hyper_is_single(const H5S_t *space) { - htri_t ret_value = TRUE; /* return value */ + htri_t ret_value = TRUE; /* return value */ FUNC_ENTER_STATIC_NOERR @@ -5285,8 +5270,8 @@ H5S__hyper_is_single(const H5S_t *space) /* (No need to rebuild the dimension info yet, since the span-tree * algorithm is fast -QAK) */ - if(space->select.sel_info.hslab->diminfo_valid == H5S_DIMINFO_VALID_YES) { - unsigned u; /* index variable */ + if (space->select.sel_info.hslab->diminfo_valid == H5S_DIMINFO_VALID_YES) { + unsigned u; /* index variable */ /* * For a regular hyperslab to be single, it must have only one @@ -5294,12 +5279,12 @@ 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) + for (u = 0; u < space->extent.rank; u++) + if (space->select.sel_info.hslab->diminfo.opt[u].count > 1) HGOTO_DONE(FALSE) } /* end if */ else { - H5S_hyper_span_info_t *spans; /* Hyperslab span info node */ + H5S_hyper_span_info_t *spans; /* Hyperslab span info node */ /* * For a region to be single, it must have only one block @@ -5308,25 +5293,24 @@ H5S__hyper_is_single(const H5S_t *space) spans = space->select.sel_info.hslab->span_lst; /* Cycle down the spans until we run out of down spans or find a non-contiguous span */ - while(spans != NULL) { - H5S_hyper_span_t *span; /* Hyperslab span node */ + while (spans != NULL) { + H5S_hyper_span_t *span; /* Hyperslab span node */ span = spans->head; /* Check that this is the only span and it spans the entire dimension */ - if(span->next != NULL) + if (span->next != NULL) HGOTO_DONE(FALSE) else /* Walk down to the next span */ spans = span->down; } /* end while */ - } /* end else */ + } /* end else */ done: FUNC_LEAVE_NOAPI(ret_value) } /* end H5S__hyper_is_single() */ - /*-------------------------------------------------------------------------- NAME H5S__hyper_is_regular @@ -5349,7 +5333,7 @@ done: static htri_t H5S__hyper_is_regular(const H5S_t *space) { - htri_t ret_value = FAIL; /* return value */ + htri_t ret_value = FAIL; /* return value */ FUNC_ENTER_STATIC_NOERR @@ -5359,11 +5343,11 @@ H5S__hyper_is_regular(const H5S_t *space) /* Attempt to rebuild diminfo if it is invalid and has not been confirmed * to be impossible. */ - if(space->select.sel_info.hslab->diminfo_valid == H5S_DIMINFO_VALID_NO) - H5S__hyper_rebuild((H5S_t *)space); /* Casting away const OK -NAF */ + if (space->select.sel_info.hslab->diminfo_valid == H5S_DIMINFO_VALID_NO) + H5S__hyper_rebuild((H5S_t *)space); /* Casting away const OK -NAF */ /* Only simple check for regular hyperslabs for now... */ - if(space->select.sel_info.hslab->diminfo_valid == H5S_DIMINFO_VALID_YES) + if (space->select.sel_info.hslab->diminfo_valid == H5S_DIMINFO_VALID_YES) ret_value = TRUE; else ret_value = FALSE; @@ -5371,7 +5355,6 @@ H5S__hyper_is_regular(const H5S_t *space) FUNC_LEAVE_NOAPI(ret_value) } /* end H5S__hyper_is_regular() */ - /*-------------------------------------------------------------------------- NAME H5S__hyper_spans_shape_same_helper @@ -5399,10 +5382,10 @@ H5S__hyper_is_regular(const H5S_t *space) --------------------------------------------------------------------------*/ static H5_ATTR_PURE hbool_t H5S__hyper_spans_shape_same_helper(const H5S_hyper_span_info_t *span_info1, - const H5S_hyper_span_info_t *span_info2, hssize_t offset[], - hbool_t rest_zeros[]) + const H5S_hyper_span_info_t *span_info2, hssize_t offset[], + hbool_t rest_zeros[]) { - hbool_t ret_value = TRUE; /* Return value */ + hbool_t ret_value = TRUE; /* Return value */ FUNC_ENTER_STATIC_NOERR @@ -5416,9 +5399,9 @@ H5S__hyper_spans_shape_same_helper(const H5S_hyper_span_info_t *span_info1, /* (Could compare lower dimensions also, but not certain if * 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]) + if ((hsize_t)((hssize_t)span_info1->low_bounds[0] + offset[0]) != span_info2->low_bounds[0]) HGOTO_DONE(FALSE) - else if((hsize_t)((hssize_t)span_info1->high_bounds[0] + offset[0]) != span_info2->high_bounds[0]) + else if ((hsize_t)((hssize_t)span_info1->high_bounds[0] + offset[0]) != span_info2->high_bounds[0]) HGOTO_DONE(FALSE) else { const H5S_hyper_span_t *span1; @@ -5433,37 +5416,39 @@ H5S__hyper_spans_shape_same_helper(const H5S_hyper_span_info_t *span_info1, HDassert(span2); /* infinite loop which must be broken out of */ - while(1) { + while (1) { /* Check for both spans being NULL */ - if(span1 == NULL && span2 == NULL) + if (span1 == NULL && span2 == NULL) HGOTO_DONE(TRUE) /* Check for one span being NULL */ - if(span1 == NULL || span2 == NULL) + if (span1 == NULL || span2 == NULL) 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) + if ((hsize_t)((hssize_t)span1->low + offset[0]) != span2->low || + (hsize_t)((hssize_t)span1->high + offset[0]) != span2->high) HGOTO_DONE(FALSE) /* Check for down tree for this span */ - if(span1->down != NULL || span2->down != NULL) { + 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)) + if (rest_zeros[0]) { + if (!H5S__hyper_cmp_spans(span1->down, span2->down)) HGOTO_DONE(FALSE) else { /* Keep going... */ } /* end else */ - } /* end if */ + } /* end if */ else { - if(!H5S__hyper_spans_shape_same_helper(span1->down, span2->down, &offset[1], &rest_zeros[1])) + if (!H5S__hyper_spans_shape_same_helper(span1->down, span2->down, &offset[1], + &rest_zeros[1])) HGOTO_DONE(FALSE) else { /* Keep going... */ } /* end else */ - } /* end else */ - } /* end if */ + } /* end else */ + } /* end if */ else { /* Keep going... */ } /* end else */ @@ -5472,7 +5457,7 @@ H5S__hyper_spans_shape_same_helper(const H5S_hyper_span_info_t *span_info1, span1 = span1->next; span2 = span2->next; } /* end while */ - } /* end else */ + } /* end else */ /* Fall through, with default return value of 'TRUE' if spans were already visited */ @@ -5480,7 +5465,6 @@ done: FUNC_LEAVE_NOAPI(ret_value) } /* end H5S__hyper_spans_shape_same_helper() */ - /*-------------------------------------------------------------------------- NAME H5S__hyper_spans_shape_same @@ -5502,16 +5486,16 @@ done: REVISION LOG --------------------------------------------------------------------------*/ static H5_ATTR_PURE hbool_t -H5S__hyper_spans_shape_same(const H5S_hyper_span_info_t *span_info1, - const H5S_hyper_span_info_t *span_info2, unsigned ndims) +H5S__hyper_spans_shape_same(const H5S_hyper_span_info_t *span_info1, const H5S_hyper_span_info_t *span_info2, + unsigned ndims) { - const H5S_hyper_span_t *span1; /* Pointer to spans in first span tree */ - const H5S_hyper_span_t *span2; /* Pointer to spans in second span tree */ - hssize_t offset[H5S_MAX_RANK]; /* Offset vector for selections */ - hbool_t rest_zeros[H5S_MAX_RANK]; /* Vector of flags to indicate when remaining offset is all zero */ - hbool_t zero_offset; /* Whether the two selections have a non-zero offset */ - unsigned u; /* Local index variable */ - hbool_t ret_value = TRUE; /* Return value */ + const H5S_hyper_span_t *span1; /* Pointer to spans in first span tree */ + const H5S_hyper_span_t *span2; /* Pointer to spans in second span tree */ + hssize_t offset[H5S_MAX_RANK]; /* Offset vector for selections */ + hbool_t rest_zeros[H5S_MAX_RANK]; /* Vector of flags to indicate when remaining offset is all zero */ + hbool_t zero_offset; /* Whether the two selections have a non-zero offset */ + unsigned u; /* Local index variable */ + hbool_t ret_value = TRUE; /* Return value */ FUNC_ENTER_STATIC_NOERR @@ -5525,16 +5509,16 @@ H5S__hyper_spans_shape_same(const H5S_hyper_span_info_t *span_info1, HDmemset(rest_zeros, 0, sizeof(rest_zeros)); /* Check for an offset between the two selections */ - span1 = span_info1->head; - span2 = span_info2->head; + span1 = span_info1->head; + span2 = span_info2->head; zero_offset = TRUE; - for(u = 0; u < ndims; u++) { + for (u = 0; u < ndims; u++) { /* Check for offset in this dimension */ - if(span1->low != span2->low) { + if (span1->low != span2->low) { offset[u] = (hssize_t)span2->low - (hssize_t)span1->low; /* Indicate that the offset vector is not all zeros */ - if(zero_offset) + if (zero_offset) zero_offset = FALSE; } /* end if */ @@ -5543,19 +5527,19 @@ H5S__hyper_spans_shape_same(const H5S_hyper_span_info_t *span_info1, HDassert((span1->down && span2->down) || (NULL == span1->down && NULL == span2->down)); /* Advance to next dimension */ - if(span1->down) { + if (span1->down) { span1 = span1->down->head; span2 = span2->down->head; } /* end if */ - } /* end for */ + } /* end for */ /* Check if there's a "tail" of all zeros in a non-zero offset vector */ - if(!zero_offset) { - int i; /* Local index variable */ + if (!zero_offset) { + int i; /* Local index variable */ /* Find first non-zero offset, from the fastest dimension up */ - for(i = (int)(ndims - 1); i >= 0; i--) - if(offset[i]) { + for (i = (int)(ndims - 1); i >= 0; i--) + if (offset[i]) { rest_zeros[i] = TRUE; break; } /* end if */ @@ -5569,7 +5553,7 @@ H5S__hyper_spans_shape_same(const H5S_hyper_span_info_t *span_info1, * comparison routine. Otherwise, use a generalized version of that * routine. */ - if(zero_offset) + if (zero_offset) ret_value = H5S__hyper_cmp_spans(span_info1, span_info2); else ret_value = H5S__hyper_spans_shape_same_helper(span_info1, span_info2, offset, rest_zeros); @@ -5577,7 +5561,6 @@ H5S__hyper_spans_shape_same(const H5S_hyper_span_info_t *span_info1, FUNC_LEAVE_NOAPI(ret_value) } /* end H5S__hyper_spans_shape_same() */ - /*-------------------------------------------------------------------------- NAME H5S__hyper_shape_same @@ -5605,9 +5588,9 @@ H5S__hyper_spans_shape_same(const H5S_hyper_span_info_t *span_info1, static htri_t H5S__hyper_shape_same(const H5S_t *space1, const H5S_t *space2) { - unsigned space1_rank; /* Number of dimensions of first dataspace */ - unsigned space2_rank; /* Number of dimensions of second dataspace */ - htri_t ret_value = TRUE; /* Return value */ + unsigned space1_rank; /* Number of dimensions of first dataspace */ + unsigned space2_rank; /* Number of dimensions of second dataspace */ + htri_t ret_value = TRUE; /* Return value */ FUNC_ENTER_STATIC @@ -5625,16 +5608,16 @@ H5S__hyper_shape_same(const H5S_t *space1, const H5S_t *space2) /* Rebuild diminfo if it is invalid and has not been confirmed to be * impossible */ - if(space1->select.sel_info.hslab->diminfo_valid == H5S_DIMINFO_VALID_NO) - H5S__hyper_rebuild((H5S_t *)space1); /* Casting away const OK -QAK */ - if(space2->select.sel_info.hslab->diminfo_valid == H5S_DIMINFO_VALID_NO) - H5S__hyper_rebuild((H5S_t *)space2); /* Casting away const OK -QAK */ + if (space1->select.sel_info.hslab->diminfo_valid == H5S_DIMINFO_VALID_NO) + H5S__hyper_rebuild((H5S_t *)space1); /* Casting away const OK -QAK */ + if (space2->select.sel_info.hslab->diminfo_valid == H5S_DIMINFO_VALID_NO) + H5S__hyper_rebuild((H5S_t *)space2); /* Casting away const OK -QAK */ /* If both are regular hyperslabs, compare their diminfo values */ - if(space1->select.sel_info.hslab->diminfo_valid == H5S_DIMINFO_VALID_YES - && space2->select.sel_info.hslab->diminfo_valid == H5S_DIMINFO_VALID_YES) { - int space1_dim; /* Current dimension in first dataspace */ - int space2_dim; /* Current dimension in second dataspace */ + if (space1->select.sel_info.hslab->diminfo_valid == H5S_DIMINFO_VALID_YES && + space2->select.sel_info.hslab->diminfo_valid == H5S_DIMINFO_VALID_YES) { + int space1_dim; /* Current dimension in first dataspace */ + int space2_dim; /* Current dimension in second dataspace */ /* Initialize dimensions */ space1_dim = (int)space1_rank - 1; @@ -5643,63 +5626,65 @@ H5S__hyper_shape_same(const H5S_t *space1, const H5S_t *space2) /* Check that the shapes are the same in the common dimensions, and that * block == 1 in all dimensions that appear only in space1. */ - 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) + 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) - if(space1->select.sel_info.hslab->diminfo.opt[space1_dim].count != - space2->select.sel_info.hslab->diminfo.opt[space2_dim].count) + if (space1->select.sel_info.hslab->diminfo.opt[space1_dim].count != + space2->select.sel_info.hslab->diminfo.opt[space2_dim].count) HGOTO_DONE(FALSE) - if(space1->select.sel_info.hslab->diminfo.opt[space1_dim].block != - space2->select.sel_info.hslab->diminfo.opt[space2_dim].block) + if (space1->select.sel_info.hslab->diminfo.opt[space1_dim].block != + space2->select.sel_info.hslab->diminfo.opt[space2_dim].block) HGOTO_DONE(FALSE) space1_dim--; space2_dim--; } /* end while */ - while(space1_dim >= 0) { - if(space1->select.sel_info.hslab->diminfo.opt[space1_dim].block != 1) + while (space1_dim >= 0) { + if (space1->select.sel_info.hslab->diminfo.opt[space1_dim].block != 1) HGOTO_DONE(FALSE) space1_dim--; } /* end while */ - } /* end if */ + } /* end if */ /* If both aren't regular, use fast irregular comparison */ else { - H5S_hyper_span_info_t *spans1; /* Hyperslab spans for first dataspace */ + H5S_hyper_span_info_t *spans1; /* Hyperslab spans for first dataspace */ /* Make certain that both selections have span trees */ - if(NULL == space1->select.sel_info.hslab->span_lst) - if(H5S__hyper_generate_spans((H5S_t *)space1) < 0) /* Casting away const OK -QAK */ - HGOTO_ERROR(H5E_DATASPACE, H5E_UNINITIALIZED, FAIL, "can't construct span tree for hyperslab selection") - if(NULL == space2->select.sel_info.hslab->span_lst) - if(H5S__hyper_generate_spans((H5S_t *)space2) < 0) /* Casting away const OK -QAK */ - HGOTO_ERROR(H5E_DATASPACE, H5E_UNINITIALIZED, FAIL, "can't construct span tree for hyperslab selection") + if (NULL == space1->select.sel_info.hslab->span_lst) + if (H5S__hyper_generate_spans((H5S_t *)space1) < 0) /* Casting away const OK -QAK */ + HGOTO_ERROR(H5E_DATASPACE, H5E_UNINITIALIZED, FAIL, + "can't construct span tree for hyperslab selection") + if (NULL == space2->select.sel_info.hslab->span_lst) + if (H5S__hyper_generate_spans((H5S_t *)space2) < 0) /* Casting away const OK -QAK */ + HGOTO_ERROR(H5E_DATASPACE, H5E_UNINITIALIZED, FAIL, + "can't construct span tree for hyperslab selection") /* If rank of space A is different (guaranteed greater) than * rank of space B, walk down the span tree, verifying * that the block size is 1 on the way down. */ - if(space1_rank > space2_rank) { - unsigned diff_rank = space1_rank - space2_rank; /* Difference in ranks */ + if (space1_rank > space2_rank) { + unsigned diff_rank = space1_rank - space2_rank; /* Difference in ranks */ /* Walk down the dimensions */ spans1 = space1->select.sel_info.hslab->span_lst; - while(diff_rank > 0) { - H5S_hyper_span_t *span; /* Span for this dimension */ + while (diff_rank > 0) { + H5S_hyper_span_t *span; /* Span for this dimension */ /* Get pointer to first span in tree */ span = spans1->head; /* Check for more spans in this dimension */ - if(span->next) + if (span->next) HGOTO_DONE(FALSE) /* Check for span size > 1 element */ - if(span->low != span->high) + if (span->low != span->high) HGOTO_DONE(FALSE) /* Walk down to the next dimension */ @@ -5723,7 +5708,6 @@ done: FUNC_LEAVE_NOAPI(ret_value) } /* end H5S__hyper_shape_same() */ - /*-------------------------------------------------------------------------- NAME H5S__hyper_release @@ -5753,8 +5737,8 @@ H5S__hyper_release(H5S_t *space) space->select.num_elem = 0; /* Release irregular hyperslab information */ - if(space->select.sel_info.hslab) { - if(space->select.sel_info.hslab->span_lst != NULL) + if (space->select.sel_info.hslab) { + if (space->select.sel_info.hslab->span_lst != NULL) H5S__hyper_free_span_info(space->select.sel_info.hslab->span_lst); /* Release space for the hyperslab selection information */ @@ -5764,7 +5748,6 @@ H5S__hyper_release(H5S_t *space) FUNC_LEAVE_NOAPI(SUCCEED) } /* end H5S__hyper_release() */ - /*-------------------------------------------------------------------------- NAME H5S__hyper_coord_to_span @@ -5786,9 +5769,9 @@ H5S__hyper_release(H5S_t *space) static H5S_hyper_span_t * H5S__hyper_coord_to_span(unsigned rank, const hsize_t *coords) { - H5S_hyper_span_t *new_span; /* Pointer to new span tree for coordinate */ - H5S_hyper_span_info_t *down = NULL; /* Pointer to new span tree for next level down */ - H5S_hyper_span_t *ret_value = NULL; /* Return value */ + H5S_hyper_span_t * new_span; /* Pointer to new span tree for coordinate */ + H5S_hyper_span_info_t *down = NULL; /* Pointer to new span tree for next level down */ + H5S_hyper_span_t * ret_value = NULL; /* Return value */ FUNC_ENTER_STATIC @@ -5796,9 +5779,9 @@ H5S__hyper_coord_to_span(unsigned rank, const hsize_t *coords) HDassert(coords); /* Search for location to insert new element in tree */ - if(rank > 1) { + if (rank > 1) { /* Allocate a span info node for coordinates below this one */ - if(NULL == (down = H5S__hyper_new_span_info(rank - 1))) + if (NULL == (down = H5S__hyper_new_span_info(rank - 1))) HGOTO_ERROR(H5E_DATASPACE, H5E_CANTALLOC, NULL, "can't allocate hyperslab span") /* Set the low & high bounds for this span info node */ @@ -5806,28 +5789,27 @@ H5S__hyper_coord_to_span(unsigned rank, const hsize_t *coords) H5MM_memcpy(down->high_bounds, &coords[1], (rank - 1) * sizeof(hsize_t)); /* Build span tree for coordinates below this one */ - if(NULL == (down->head = H5S__hyper_coord_to_span(rank - 1, &coords[1]))) + if (NULL == (down->head = H5S__hyper_coord_to_span(rank - 1, &coords[1]))) HGOTO_ERROR(H5E_DATASPACE, H5E_CANTALLOC, NULL, "can't allocate hyperslab span") - /* Update the tail pointer of the down dimension, and it's a single span element */ - down->tail = down->head; + /* Update the tail pointer of the down dimension, and it's a single span element */ + down->tail = down->head; } /* end if */ /* Build span for this coordinate */ - if(NULL == (new_span = H5S__hyper_new_span(coords[0], coords[0], down, NULL))) + if (NULL == (new_span = H5S__hyper_new_span(coords[0], coords[0], down, NULL))) HGOTO_ERROR(H5E_DATASPACE, H5E_CANTALLOC, NULL, "can't allocate hyperslab span") /* Set return value */ ret_value = new_span; done: - if(ret_value == NULL && down != NULL) + if (ret_value == NULL && down != NULL) H5S__hyper_free_span_info(down); FUNC_LEAVE_NOAPI(ret_value) } /* end H5S__hyper_coord_to_span() */ - /*-------------------------------------------------------------------------- NAME H5S__hyper_add_span_element_helper @@ -5850,11 +5832,11 @@ done: REVISION LOG --------------------------------------------------------------------------*/ static herr_t -H5S__hyper_add_span_element_helper(H5S_hyper_span_info_t *span_tree, - unsigned rank, const hsize_t *coords, int *first_dim_modified) +H5S__hyper_add_span_element_helper(H5S_hyper_span_info_t *span_tree, unsigned rank, const hsize_t *coords, + int *first_dim_modified) { - H5S_hyper_span_t *tail_span; /* Pointer to the tail span of one dimension */ - herr_t ret_value = SUCCEED; /* Return value */ + H5S_hyper_span_t *tail_span; /* Pointer to the tail span of one dimension */ + herr_t ret_value = SUCCEED; /* Return value */ FUNC_ENTER_STATIC @@ -5869,24 +5851,24 @@ H5S__hyper_add_span_element_helper(H5S_hyper_span_info_t *span_tree, /* Determine if tail span includes a portion of the coordinate */ /* (Should never happen with the lowest level in the span tree) */ - if(coords[0] >= tail_span->low && coords[0] <= tail_span->high) { - H5S_hyper_span_t *prev_down_tail_span; /* Pointer to previous down spans' tail pointer */ - hsize_t prev_down_tail_span_high; /* Value of previous down spans' tail's high value */ + if (coords[0] >= tail_span->low && coords[0] <= tail_span->high) { + H5S_hyper_span_t *prev_down_tail_span; /* Pointer to previous down spans' tail pointer */ + hsize_t prev_down_tail_span_high; /* Value of previous down spans' tail's high value */ /* Retain into about down spans' tail */ - prev_down_tail_span = tail_span->down->tail; + prev_down_tail_span = tail_span->down->tail; prev_down_tail_span_high = tail_span->down->tail->high; /* Drop down a dimension */ HDassert(rank > 1); - if(H5S__hyper_add_span_element_helper(tail_span->down, rank - 1, &coords[1], first_dim_modified) < 0) + if (H5S__hyper_add_span_element_helper(tail_span->down, rank - 1, &coords[1], first_dim_modified) < 0) HGOTO_ERROR(H5E_DATASET, H5E_CANTINSERT, FAIL, "can't insert coordinate into span tree") /* Check & update high bounds for lower dimensions */ - if(*first_dim_modified >= 0) { - unsigned first_dim; /* First dimension modified, relative to this span tree */ - hbool_t first_dim_set = FALSE; /* Whether first dimension modified is set */ - unsigned u; /* Local index variable */ + if (*first_dim_modified >= 0) { + unsigned first_dim; /* First dimension modified, relative to this span tree */ + hbool_t first_dim_set = FALSE; /* Whether first dimension modified is set */ + unsigned u; /* Local index variable */ /* Adjust first dimension modified to be relative to this span tree */ first_dim = (unsigned)(*first_dim_modified + 1); @@ -5895,33 +5877,33 @@ H5S__hyper_add_span_element_helper(H5S_hyper_span_info_t *span_tree, *first_dim_modified = -1; /* Iterate through coordinates */ - for(u = first_dim; u < rank; u++) { + for (u = first_dim; u < rank; u++) { /* Check if coordinate is outside the bounds for this span tree */ - if(coords[u] > span_tree->high_bounds[u]) { + if (coords[u] > span_tree->high_bounds[u]) { /* Update high bounds for this tree */ span_tree->high_bounds[u] = coords[u]; /* Need to signal to higher dimensions if high bounds changed */ - if(!first_dim_set) { + if (!first_dim_set) { *first_dim_modified = (int)u; - first_dim_set = TRUE; + first_dim_set = TRUE; } /* end if */ - } /* end if */ - } /* end for */ - } /* end if */ + } /* end if */ + } /* end for */ + } /* end if */ /* Check if previous tail span in down spans is different than current * tail span, or if its high value changed, in which case we should * check if the updated node can share down spans with other nodes. */ - if(tail_span->down->tail != prev_down_tail_span || - prev_down_tail_span_high != tail_span->down->tail->high) { + if (tail_span->down->tail != prev_down_tail_span || + prev_down_tail_span_high != tail_span->down->tail->high) { H5S_hyper_span_t *stop_span; /* Pointer to span to stop at */ - H5S_hyper_span_t *tmp_span; /* Temporary pointer to a span */ - uint64_t op_gen; /* Operation generation value */ + H5S_hyper_span_t *tmp_span; /* Temporary pointer to a span */ + uint64_t op_gen; /* Operation generation value */ /* Determine which span to stop at */ - if(tail_span->down->tail != prev_down_tail_span) { + if (tail_span->down->tail != prev_down_tail_span) { /* Sanity check */ HDassert(prev_down_tail_span->next == tail_span->down->tail); @@ -5947,23 +5929,23 @@ H5S__hyper_add_span_element_helper(H5S_hyper_span_info_t *span_tree, * information. */ tmp_span = tail_span->down->head; - while(tmp_span != stop_span) { - hbool_t attempt_merge_spans = FALSE; /* Whether to merge spans */ + while (tmp_span != stop_span) { + hbool_t attempt_merge_spans = FALSE; /* Whether to merge spans */ /* Different tests for when to run the 'merge' algorithm, * depending whether there's "down trees" or not. */ - if(NULL == tmp_span->down) { + if (NULL == tmp_span->down) { /* Spin through spans until we find the one before the 'stop' span */ - if(tmp_span->next == stop_span) + if (tmp_span->next == stop_span) attempt_merge_spans = TRUE; } /* end if */ else { /* Check if we've compared the 'stop' span's "down tree" to * this span's "down tree" already. */ - if(tmp_span->down->op_info[0].op_gen != op_gen) { - if(H5S__hyper_cmp_spans(tmp_span->down, stop_span->down)) + if (tmp_span->down->op_info[0].op_gen != op_gen) { + if (H5S__hyper_cmp_spans(tmp_span->down, stop_span->down)) attempt_merge_spans = TRUE; /* Remember that we visited this span's "down tree" already */ @@ -5972,16 +5954,16 @@ H5S__hyper_add_span_element_helper(H5S_hyper_span_info_t *span_tree, */ tmp_span->down->op_info[0].op_gen = op_gen; } /* end if */ - } /* end else */ + } /* end else */ /* Check for merging into previous span */ - if(attempt_merge_spans) { - if(tmp_span->high + 1 == stop_span->low) { + if (attempt_merge_spans) { + if (tmp_span->high + 1 == stop_span->low) { /* Increase size of previous span */ tmp_span->high++; /* Update pointers appropriately */ - if(stop_span == prev_down_tail_span) { + if (stop_span == prev_down_tail_span) { /* Sanity check */ HDassert(stop_span->next == tail_span->down->tail); @@ -5991,7 +5973,7 @@ H5S__hyper_add_span_element_helper(H5S_hyper_span_info_t *span_tree, /* Sanity check */ HDassert(tmp_span->next == tail_span->down->tail); - tmp_span->next = NULL; + tmp_span->next = NULL; tail_span->down->tail = tmp_span; } /* end else */ @@ -6000,7 +5982,7 @@ H5S__hyper_add_span_element_helper(H5S_hyper_span_info_t *span_tree, } /* end if */ /* Span is disjoint, but has the same "down tree" selection */ /* (If it has a "down tree") */ - else if(stop_span->down) { + else if (stop_span->down) { /* Release "down tree" information */ H5S__hyper_free_span_info(stop_span->down); @@ -6018,23 +6000,24 @@ H5S__hyper_add_span_element_helper(H5S_hyper_span_info_t *span_tree, /* Advance to next span to check */ tmp_span = tmp_span->next; } /* end while */ - } /* end if */ - } /* end if */ + } /* end if */ + } /* end if */ else { - unsigned u; /* Local index variable */ + unsigned u; /* Local index variable */ /* Check if we made it all the way to the bottom span list in the tree * and the new coordinate adjoins the current tail span. */ - if(rank == 1 && (tail_span->high + 1) == coords[0]) + if (rank == 1 && (tail_span->high + 1) == coords[0]) /* Append element to current tail span */ tail_span->high++; else { - H5S_hyper_span_t *new_span; /* New span created for element */ + H5S_hyper_span_t *new_span; /* New span created for element */ /* Make span tree for current coordinate(s) */ - if(NULL == (new_span = H5S__hyper_coord_to_span(rank, coords))) - HGOTO_ERROR(H5E_DATASPACE, H5E_CANTALLOC, FAIL, "can't allocate hyperslab spans for coordinate") + if (NULL == (new_span = H5S__hyper_coord_to_span(rank, coords))) + HGOTO_ERROR(H5E_DATASPACE, H5E_CANTALLOC, FAIL, + "can't allocate hyperslab spans for coordinate") /* Add new span to span tree list */ tail_span->next = new_span; @@ -6046,8 +6029,8 @@ H5S__hyper_add_span_element_helper(H5S_hyper_span_info_t *span_tree, span_tree->high_bounds[0] = coords[0]; /* Update high bounds for dimensions below this one */ - for(u = 1; u < rank; u++) - if(coords[u] > span_tree->high_bounds[u]) + for (u = 1; u < rank; u++) + if (coords[u] > span_tree->high_bounds[u]) span_tree->high_bounds[u] = coords[u]; /* Need to signal to higher dimensions that high bounds changed */ @@ -6058,7 +6041,6 @@ done: FUNC_LEAVE_NOAPI(ret_value) } /* end H5S__hyper_add_span_element_helper() */ - /*-------------------------------------------------------------------------- NAME H5S_hyper_add_span_element @@ -6100,8 +6082,8 @@ done: herr_t H5S_hyper_add_span_element(H5S_t *space, unsigned rank, const hsize_t *coords) { - H5S_hyper_span_info_t *head = NULL; /* Pointer to new head of span tree */ - herr_t ret_value = SUCCEED; /* Return value */ + H5S_hyper_span_info_t *head = NULL; /* Pointer to new head of span tree */ + herr_t ret_value = SUCCEED; /* Return value */ FUNC_ENTER_NOAPI(FAIL) @@ -6111,9 +6093,9 @@ H5S_hyper_add_span_element(H5S_t *space, unsigned rank, const hsize_t *coords) HDassert(space->extent.rank == rank); /* Check if this is the first element in the selection */ - if(NULL == space->select.sel_info.hslab) { + if (NULL == space->select.sel_info.hslab) { /* Allocate a span info node */ - if(NULL == (head = H5S__hyper_new_span_info(rank))) + if (NULL == (head = H5S__hyper_new_span_info(rank))) HGOTO_ERROR(H5E_DATASPACE, H5E_CANTALLOC, FAIL, "can't allocate hyperslab span info") /* Set the low & high bounds for this span info node */ @@ -6124,14 +6106,14 @@ H5S_hyper_add_span_element(H5S_t *space, unsigned rank, const hsize_t *coords) head->count = 1; /* Build span tree for this coordinate */ - if(NULL == (head->head = H5S__hyper_coord_to_span(rank, coords))) + if (NULL == (head->head = H5S__hyper_coord_to_span(rank, coords))) HGOTO_ERROR(H5E_DATASPACE, H5E_CANTALLOC, FAIL, "can't allocate hyperslab spans for coordinate") /* Update the tail pointer of this newly created span in dimension "rank" */ head->tail = head->head; /* Allocate selection info */ - if(NULL == (space->select.sel_info.hslab = H5FL_MALLOC(H5S_hyper_sel_t))) + if (NULL == (space->select.sel_info.hslab = H5FL_MALLOC(H5S_hyper_sel_t))) HGOTO_ERROR(H5E_DATASPACE, H5E_CANTALLOC, FAIL, "can't allocate hyperslab selection") /* Set the selection to the new span tree */ @@ -6150,10 +6132,11 @@ H5S_hyper_add_span_element(H5S_t *space, unsigned rank, const hsize_t *coords) space->select.num_elem = 1; } /* end if */ else { - int first_dim_modified = -1; /* Index of first dimension modified */ + int first_dim_modified = -1; /* Index of first dimension modified */ /* Add the element to the current set of spans */ - if(H5S__hyper_add_span_element_helper(space->select.sel_info.hslab->span_lst, rank, coords, &first_dim_modified) < 0) + if (H5S__hyper_add_span_element_helper(space->select.sel_info.hslab->span_lst, rank, coords, + &first_dim_modified) < 0) HGOTO_ERROR(H5E_DATASPACE, H5E_CANTINSERT, FAIL, "can't insert coordinate into span tree") /* Increment # of elements in selection */ @@ -6161,14 +6144,13 @@ H5S_hyper_add_span_element(H5S_t *space, unsigned rank, const hsize_t *coords) } /* end else */ done: - if(ret_value < 0) - if(head) + if (ret_value < 0) + if (head) H5S__hyper_free_span_info(head); FUNC_LEAVE_NOAPI(ret_value) } /* end H5S_hyper_add_span_element() */ - /*-------------------------------------------------------------------------- NAME H5S__hyper_intersect_block_helper @@ -6192,11 +6174,10 @@ done: REVISION LOG --------------------------------------------------------------------------*/ static hbool_t -H5S__hyper_intersect_block_helper(H5S_hyper_span_info_t *spans, - unsigned rank, const hsize_t *start, const hsize_t *end, unsigned op_info_i, - uint64_t op_gen) +H5S__hyper_intersect_block_helper(H5S_hyper_span_info_t *spans, unsigned rank, const hsize_t *start, + const hsize_t *end, unsigned op_info_i, uint64_t op_gen) { - hbool_t ret_value = FALSE; /* Return value */ + hbool_t ret_value = FALSE; /* Return value */ FUNC_ENTER_STATIC_NOERR @@ -6206,47 +6187,48 @@ H5S__hyper_intersect_block_helper(H5S_hyper_span_info_t *spans, HDassert(end); /* Check if we've already visited this span tree */ - if(spans->op_info[op_info_i].op_gen != op_gen) { - H5S_hyper_span_t *curr; /* Pointer to current span in 1st span tree */ - unsigned u; /* Local index variable */ + if (spans->op_info[op_info_i].op_gen != op_gen) { + H5S_hyper_span_t *curr; /* Pointer to current span in 1st span tree */ + unsigned u; /* Local index variable */ /* Verify that there is a possibility of an overlap by checking the block * against the low & high bounds for the span tree. */ - for(u = 0; u < rank; u++) - if(start[u] > spans->high_bounds[u] || end[u] < spans->low_bounds[u]) + for (u = 0; u < rank; u++) + if (start[u] > spans->high_bounds[u] || end[u] < spans->low_bounds[u]) HGOTO_DONE(FALSE) /* Get the span list for spans in this tree */ curr = spans->head; /* Iterate over the spans in the tree */ - while(curr != NULL) { + while (curr != NULL) { /* Check for span entirely before block */ - if(curr->high < *start) + if (curr->high < *start) /* Advance to next span in this dimension */ 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) + else if (curr->low > *end) HGOTO_DONE(FALSE) /* block & span overlap */ else { /* If this is the bottom dimension, then the span tree overlaps the block */ - if(curr->down == NULL) + if (curr->down == NULL) HGOTO_DONE(TRUE) /* Recursively check spans in next dimension down */ else { /* If there is an intersection in the "down" dimensions, * the span trees overlap. */ - if(H5S__hyper_intersect_block_helper(curr->down, rank - 1, start + 1, end + 1, op_info_i, op_gen)) + if (H5S__hyper_intersect_block_helper(curr->down, rank - 1, start + 1, end + 1, op_info_i, + op_gen)) HGOTO_DONE(TRUE) /* No intersection in down dimensions, advance to next span */ curr = curr->next; } /* end else */ - } /* end else */ - } /* end while */ + } /* end else */ + } /* end while */ /* Set the tree's operation generation */ spans->op_info[op_info_i].op_gen = op_gen; @@ -6258,7 +6240,6 @@ done: FUNC_LEAVE_NOAPI(ret_value) } /* end H5S__hyper_intersect_block_helper() */ - /*-------------------------------------------------------------------------- NAME H5S__hyper_intersect_block @@ -6283,7 +6264,7 @@ done: static htri_t H5S__hyper_intersect_block(const H5S_t *space, const hsize_t *start, const hsize_t *end) { - htri_t ret_value = FAIL; /* Return value */ + htri_t ret_value = FAIL; /* Return value */ FUNC_ENTER_STATIC_NOERR @@ -6296,43 +6277,43 @@ H5S__hyper_intersect_block(const H5S_t *space, const hsize_t *start, const hsize /* Attempt to rebuild diminfo if it is invalid and has not been confirmed * to be impossible. */ - if(space->select.sel_info.hslab->diminfo_valid == H5S_DIMINFO_VALID_NO) - H5S__hyper_rebuild((H5S_t *)space); /* Casting away const OK -QAK */ + if (space->select.sel_info.hslab->diminfo_valid == H5S_DIMINFO_VALID_NO) + H5S__hyper_rebuild((H5S_t *)space); /* Casting away const OK -QAK */ /* Check for regular hyperslab intersection */ - if(space->select.sel_info.hslab->diminfo_valid == H5S_DIMINFO_VALID_YES) { - hbool_t single_block; /* Whether the regular selection is a single block */ - unsigned u; /* Local index variable */ + if (space->select.sel_info.hslab->diminfo_valid == H5S_DIMINFO_VALID_YES) { + hbool_t single_block; /* Whether the regular selection is a single block */ + unsigned u; /* Local index variable */ /* Check for a single block */ /* For a regular hyperslab to be single, it must have only one block * (i.e. count == 1 in all dimensions). */ single_block = TRUE; - for(u = 0; u < space->extent.rank; u++) - if(space->select.sel_info.hslab->diminfo.opt[u].count > 1) + for (u = 0; u < space->extent.rank; u++) + if (space->select.sel_info.hslab->diminfo.opt[u].count > 1) single_block = FALSE; /* Single blocks have already been "compared" above, in the low / high * bound checking, so just return TRUE if we've reached here - they * would have been rejected earlier, if they didn't intersect. */ - if(single_block) + if (single_block) HGOTO_DONE(TRUE) else { /* Loop over the dimensions, checking for an intersection */ - for(u = 0; u < space->extent.rank; u++) { + for (u = 0; u < space->extent.rank; u++) { /* If the block's start is <= the hyperslab start, they intersect */ /* (So, if the start is > the hyperslab start, check more conditions) */ - if(start[u] > space->select.sel_info.hslab->diminfo.opt[u].start) { - hsize_t adj_start; /* Start coord, adjusted for hyperslab selection parameters */ - hsize_t nstride; /* Number of strides into the selection */ + if (start[u] > space->select.sel_info.hslab->diminfo.opt[u].start) { + hsize_t adj_start; /* Start coord, adjusted for hyperslab selection parameters */ + hsize_t nstride; /* Number of strides into the selection */ /* Adjust start coord for selection's 'start' offset */ adj_start = start[u] - space->select.sel_info.hslab->diminfo.opt[u].start; /* Compute # of strides into the selection */ - if(space->select.sel_info.hslab->diminfo.opt[u].count > 1) + if (space->select.sel_info.hslab->diminfo.opt[u].count > 1) nstride = adj_start / space->select.sel_info.hslab->diminfo.opt[u].stride; else nstride = 0; @@ -6348,8 +6329,8 @@ H5S__hyper_intersect_block(const H5S_t *space, const hsize_t *start, const hsize /* If the adjusted start doesn't fall within the first hyperslab * span, check for the block overlapping with the next one. */ - if(adj_start >= space->select.sel_info.hslab->diminfo.opt[u].block) { - hsize_t adj_end; /* End coord, adjusted for hyperslab selection parameters */ + if (adj_start >= space->select.sel_info.hslab->diminfo.opt[u].block) { + hsize_t adj_end; /* End coord, adjusted for hyperslab selection parameters */ /* Adjust end coord for selection's 'start' offset */ adj_end = end[u] - space->select.sel_info.hslab->diminfo.opt[u].start; @@ -6362,20 +6343,20 @@ H5S__hyper_intersect_block(const H5S_t *space, const hsize_t *start, const hsize /* If block doesn't extend over beginning of next span, * it doesn't intersect. */ - if(adj_end < space->select.sel_info.hslab->diminfo.opt[u].stride) + if (adj_end < space->select.sel_info.hslab->diminfo.opt[u].stride) HGOTO_DONE(FALSE) } /* end if */ - } /* end if */ - } /* end for */ + } /* end if */ + } /* end for */ /* 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) } /* end else */ - } /* end if */ + } /* end if */ else { - uint64_t op_gen; /* Operation generation value */ + uint64_t op_gen; /* Operation generation value */ /* Acquire an operation generation value for this operation */ op_gen = H5S__hyper_get_op_gen(); @@ -6383,14 +6364,14 @@ H5S__hyper_intersect_block(const H5S_t *space, const hsize_t *start, const hsize /* Perform the span-by-span intersection check */ /* Always use op_info[0] since we own this op_info, so there can be no * simultaneous operations */ - ret_value = H5S__hyper_intersect_block_helper(space->select.sel_info.hslab->span_lst, space->extent.rank, start, end, 0, op_gen); + ret_value = H5S__hyper_intersect_block_helper(space->select.sel_info.hslab->span_lst, + space->extent.rank, start, end, 0, op_gen); } /* end else */ done: FUNC_LEAVE_NOAPI(ret_value) } /* end H5S__hyper_intersect_block() */ - /*-------------------------------------------------------------------------- NAME H5S__hyper_adjust_u_helper @@ -6413,8 +6394,8 @@ done: REVISION LOG --------------------------------------------------------------------------*/ static void -H5S__hyper_adjust_u_helper(H5S_hyper_span_info_t *spans, unsigned rank, - const hsize_t *offset, unsigned op_info_i, uint64_t op_gen) +H5S__hyper_adjust_u_helper(H5S_hyper_span_info_t *spans, unsigned rank, const hsize_t *offset, + unsigned op_info_i, uint64_t op_gen) { FUNC_ENTER_STATIC_NOERR @@ -6423,12 +6404,12 @@ H5S__hyper_adjust_u_helper(H5S_hyper_span_info_t *spans, unsigned rank, HDassert(offset); /* Check if we've already set this span tree */ - if(spans->op_info[op_info_i].op_gen != op_gen) { - H5S_hyper_span_t *span; /* Pointer to current span in span tree */ - unsigned u; /* Local index variable */ + if (spans->op_info[op_info_i].op_gen != op_gen) { + H5S_hyper_span_t *span; /* Pointer to current span in span tree */ + unsigned u; /* Local index variable */ /* Adjust the span tree's low & high bounds */ - for(u = 0; u < rank; u++) { + for (u = 0; u < rank; u++) { HDassert(spans->low_bounds[u] >= offset[u]); spans->low_bounds[u] -= offset[u]; spans->high_bounds[u] -= offset[u]; @@ -6436,14 +6417,14 @@ H5S__hyper_adjust_u_helper(H5S_hyper_span_info_t *spans, unsigned rank, /* Iterate over the spans in tree */ span = spans->head; - while(span != NULL) { + while (span != NULL) { /* Adjust span offset */ HDassert(span->low >= *offset); span->low -= *offset; span->high -= *offset; /* Recursively adjust spans in next dimension down */ - if(span->down != NULL) + if (span->down != NULL) H5S__hyper_adjust_u_helper(span->down, rank - 1, offset + 1, op_info_i, op_gen); /* Advance to next span in this dimension */ @@ -6457,7 +6438,6 @@ H5S__hyper_adjust_u_helper(H5S_hyper_span_info_t *spans, unsigned rank, FUNC_LEAVE_NOAPI_VOID } /* end H5S__hyper_adjust_u_helper() */ - /*-------------------------------------------------------------------------- NAME H5S__hyper_adjust_u @@ -6479,8 +6459,8 @@ H5S__hyper_adjust_u_helper(H5S_hyper_span_info_t *spans, unsigned rank, static herr_t H5S__hyper_adjust_u(H5S_t *space, const hsize_t *offset) { - hbool_t non_zero_offset = FALSE; /* Whether any offset is non-zero */ - unsigned u; /* Local index variable */ + hbool_t non_zero_offset = FALSE; /* Whether any offset is non-zero */ + unsigned u; /* Local index variable */ FUNC_ENTER_STATIC_NOERR @@ -6489,18 +6469,18 @@ H5S__hyper_adjust_u(H5S_t *space, const hsize_t *offset) HDassert(offset); /* Check for an all-zero offset vector */ - for(u = 0; u < space->extent.rank; u++) - if(0 != offset[u]) { + for (u = 0; u < space->extent.rank; u++) + if (0 != offset[u]) { non_zero_offset = TRUE; break; } /* Only perform operation if the offset is non-zero */ - if(non_zero_offset) { + if (non_zero_offset) { /* Subtract the offset from the "regular" coordinates, if they exist */ /* (No need to rebuild the dimension info yet -QAK) */ - if(space->select.sel_info.hslab->diminfo_valid == H5S_DIMINFO_VALID_YES) { - for(u = 0; u < space->extent.rank; u++) { + if (space->select.sel_info.hslab->diminfo_valid == H5S_DIMINFO_VALID_YES) { + for (u = 0; u < space->extent.rank; u++) { HDassert(space->select.sel_info.hslab->diminfo.opt[u].start >= offset[u]); space->select.sel_info.hslab->diminfo.opt[u].start -= offset[u]; @@ -6509,11 +6489,11 @@ H5S__hyper_adjust_u(H5S_t *space, const hsize_t *offset) space->select.sel_info.hslab->diminfo.low_bounds[u] -= offset[u]; space->select.sel_info.hslab->diminfo.high_bounds[u] -= offset[u]; } /* end for */ - } /* end if */ + } /* end if */ /* Subtract the offset from the span tree coordinates, if they exist */ - if(space->select.sel_info.hslab->span_lst) { - uint64_t op_gen; /* Operation generation value */ + if (space->select.sel_info.hslab->span_lst) { + uint64_t op_gen; /* Operation generation value */ /* Acquire an operation generation value for this operation */ op_gen = H5S__hyper_get_op_gen(); @@ -6521,14 +6501,14 @@ H5S__hyper_adjust_u(H5S_t *space, const hsize_t *offset) /* Perform adjustment */ /* Always use op_info[0] since we own this op_info, so there can be no * simultaneous operations */ - H5S__hyper_adjust_u_helper(space->select.sel_info.hslab->span_lst, space->extent.rank, offset, 0, op_gen); + H5S__hyper_adjust_u_helper(space->select.sel_info.hslab->span_lst, space->extent.rank, offset, 0, + op_gen); } /* end if */ - } /* end if */ + } /* end if */ FUNC_LEAVE_NOAPI(SUCCEED) } /* end H5S__hyper_adjust_u() */ - /*------------------------------------------------------------------------- * Function: H5S__hyper_project_scalar * @@ -6545,7 +6525,7 @@ H5S__hyper_adjust_u(H5S_t *space, const hsize_t *offset) static herr_t H5S__hyper_project_scalar(const H5S_t *space, hsize_t *offset) { - hsize_t block[H5S_MAX_RANK]; /* Block selected in base dataspace */ + hsize_t block[H5S_MAX_RANK]; /* Block selected in base dataspace */ FUNC_ENTER_STATIC_NOERR @@ -6555,12 +6535,13 @@ H5S__hyper_project_scalar(const H5S_t *space, hsize_t *offset) /* Check for a "regular" hyperslab selection */ /* (No need to rebuild the dimension info yet -QAK) */ - if(space->select.sel_info.hslab->diminfo_valid == H5S_DIMINFO_VALID_YES) { - const H5S_hyper_dim_t *diminfo = space->select.sel_info.hslab->diminfo.opt; /* Alias for dataspace's diminfo information */ - unsigned u; /* Counter */ + if (space->select.sel_info.hslab->diminfo_valid == H5S_DIMINFO_VALID_YES) { + const H5S_hyper_dim_t *diminfo = + space->select.sel_info.hslab->diminfo.opt; /* Alias for dataspace's diminfo information */ + unsigned u; /* Counter */ /* Build the table of the initial offset */ - for(u = 0; u < space->extent.rank; u++) { + for (u = 0; u < space->extent.rank; u++) { /* Sanity check diminfo */ HDassert(1 == diminfo[u].count); HDassert(1 == diminfo[u].block); @@ -6571,15 +6552,15 @@ H5S__hyper_project_scalar(const H5S_t *space, hsize_t *offset) /* Keep the offset for later */ block[u] = diminfo[u].start; } /* end for */ - } /* end if */ + } /* end if */ else { - const H5S_hyper_span_t *curr; /* Pointer to current hyperslab span */ - unsigned curr_dim; /* Current dimension being operated on */ + const H5S_hyper_span_t *curr; /* Pointer to current hyperslab span */ + unsigned curr_dim; /* Current dimension being operated on */ /* Advance down selected spans */ - curr = space->select.sel_info.hslab->span_lst->head; + curr = space->select.sel_info.hslab->span_lst->head; curr_dim = 0; - while(1) { + while (1) { /* Sanity checks */ HDassert(NULL == curr->next); HDassert(curr->low == curr->high); @@ -6589,14 +6570,14 @@ H5S__hyper_project_scalar(const H5S_t *space, hsize_t *offset) block[curr_dim] = curr->low; /* Advance down to next dimension */ - if(curr->down) { + if (curr->down) { curr = curr->down->head; curr_dim++; } /* end if */ else break; } /* end while */ - } /* end else */ + } /* end else */ /* Calculate offset of selection in projected buffer */ *offset = H5VM_array_offset(space->extent.rank, space->extent.size, block); @@ -6604,7 +6585,6 @@ H5S__hyper_project_scalar(const H5S_t *space, hsize_t *offset) FUNC_LEAVE_NOAPI(SUCCEED) } /* end H5S__hyper_project_scalar() */ - /*------------------------------------------------------------------------- * Function: H5S__hyper_project_simple_lower * @@ -6621,8 +6601,8 @@ H5S__hyper_project_scalar(const H5S_t *space, hsize_t *offset) static herr_t H5S__hyper_project_simple_lower(const H5S_t *base_space, H5S_t *new_space) { - H5S_hyper_span_info_t *down; /* Pointer to list of spans */ - unsigned curr_dim; /* Current dimension being operated on */ + H5S_hyper_span_info_t *down; /* Pointer to list of spans */ + unsigned curr_dim; /* Current dimension being operated on */ FUNC_ENTER_STATIC_NOERR @@ -6632,9 +6612,9 @@ H5S__hyper_project_simple_lower(const H5S_t *base_space, H5S_t *new_space) HDassert(new_space->extent.rank < base_space->extent.rank); /* Walk down the span tree until we reach the selection to project */ - down = base_space->select.sel_info.hslab->span_lst; + down = base_space->select.sel_info.hslab->span_lst; curr_dim = 0; - while(down && curr_dim < (base_space->extent.rank - new_space->extent.rank)) { + while (down && curr_dim < (base_space->extent.rank - new_space->extent.rank)) { /* Sanity check */ HDassert(NULL == down->head->next); @@ -6651,7 +6631,6 @@ H5S__hyper_project_simple_lower(const H5S_t *base_space, H5S_t *new_space) FUNC_LEAVE_NOAPI(SUCCEED) } /* end H5S__hyper_project_simple_lower() */ - /*------------------------------------------------------------------------- * Function: H5S__hyper_project_simple_higher * @@ -6668,11 +6647,11 @@ H5S__hyper_project_simple_lower(const H5S_t *base_space, H5S_t *new_space) static herr_t H5S__hyper_project_simple_higher(const H5S_t *base_space, H5S_t *new_space) { - H5S_hyper_span_t *prev_span = NULL; /* Pointer to previous list of spans */ - unsigned delta_rank; /* Difference in dataspace ranks */ - unsigned curr_dim; /* Current dimension being operated on */ - unsigned u; /* Local index variable */ - herr_t ret_value = SUCCEED; /* Return value */ + H5S_hyper_span_t *prev_span = NULL; /* Pointer to previous list of spans */ + unsigned delta_rank; /* Difference in dataspace ranks */ + unsigned curr_dim; /* Current dimension being operated on */ + unsigned u; /* Local index variable */ + herr_t ret_value = SUCCEED; /* Return value */ FUNC_ENTER_STATIC @@ -6683,48 +6662,50 @@ H5S__hyper_project_simple_higher(const H5S_t *base_space, H5S_t *new_space) /* Create nodes until reaching the correct # of dimensions */ new_space->select.sel_info.hslab->span_lst = NULL; - curr_dim = 0; - delta_rank = (new_space->extent.rank - base_space->extent.rank); - while(curr_dim < delta_rank) { - H5S_hyper_span_info_t *new_span_info; /* Pointer to list of spans */ - H5S_hyper_span_t *new_span; /* Temporary hyperslab span */ + curr_dim = 0; + delta_rank = (new_space->extent.rank - base_space->extent.rank); + while (curr_dim < delta_rank) { + H5S_hyper_span_info_t *new_span_info; /* Pointer to list of spans */ + H5S_hyper_span_t * new_span; /* Temporary hyperslab span */ /* Allocate a new span_info node */ - if(NULL == (new_span_info = H5S__hyper_new_span_info(new_space->extent.rank))) { - if(prev_span) + if (NULL == (new_span_info = H5S__hyper_new_span_info(new_space->extent.rank))) { + if (prev_span) H5S__hyper_free_span(prev_span); HGOTO_ERROR(H5E_DATASPACE, H5E_CANTALLOC, FAIL, "can't allocate hyperslab span info") } /* end if */ /* Check for linking into higher span */ - if(prev_span) + if (prev_span) prev_span->down = new_span_info; /* Allocate a new node */ - if(NULL == (new_span = H5S__hyper_new_span((hsize_t)0, (hsize_t)0, NULL, NULL))) { + if (NULL == (new_span = H5S__hyper_new_span((hsize_t)0, (hsize_t)0, NULL, NULL))) { HDassert(new_span_info); - if(!prev_span) + if (!prev_span) (void)H5FL_ARR_FREE(hbounds_t, new_span_info); HGOTO_ERROR(H5E_DATASPACE, H5E_CANTALLOC, FAIL, "can't allocate hyperslab span") } /* end if */ /* Set the span_info information */ new_span_info->count = 1; - new_span_info->head = new_span; - new_span_info->tail = new_span; + new_span_info->head = new_span; + new_span_info->tail = new_span; /* Set the bounding box */ - for(u = 0; u < delta_rank; u++) { - new_span_info->low_bounds[u] = 0; + for (u = 0; u < delta_rank; u++) { + new_span_info->low_bounds[u] = 0; new_span_info->high_bounds[u] = 0; } /* end for */ - for(; u < new_space->extent.rank; u++) { - new_span_info->low_bounds[u] = base_space->select.sel_info.hslab->span_lst->low_bounds[u - delta_rank]; - new_span_info->high_bounds[u] = base_space->select.sel_info.hslab->span_lst->high_bounds[u - delta_rank]; + for (; u < new_space->extent.rank; u++) { + new_span_info->low_bounds[u] = + base_space->select.sel_info.hslab->span_lst->low_bounds[u - delta_rank]; + new_span_info->high_bounds[u] = + base_space->select.sel_info.hslab->span_lst->high_bounds[u - delta_rank]; } /* end for */ /* Attach to new space, if top span info */ - if(NULL == new_space->select.sel_info.hslab->span_lst) + if (NULL == new_space->select.sel_info.hslab->span_lst) new_space->select.sel_info.hslab->span_lst = new_span_info; /* Remember previous span info */ @@ -6741,17 +6722,17 @@ H5S__hyper_project_simple_higher(const H5S_t *base_space, H5S_t *new_space) prev_span->down->count++; done: - if(ret_value < 0 && new_space->select.sel_info.hslab->span_lst) { - if(new_space->select.sel_info.hslab->span_lst->head) + if (ret_value < 0 && new_space->select.sel_info.hslab->span_lst) { + if (new_space->select.sel_info.hslab->span_lst->head) H5S__hyper_free_span(new_space->select.sel_info.hslab->span_lst->head); - new_space->select.sel_info.hslab->span_lst = (H5S_hyper_span_info_t *)H5FL_ARR_FREE(hbounds_t, new_space->select.sel_info.hslab->span_lst); + new_space->select.sel_info.hslab->span_lst = + (H5S_hyper_span_info_t *)H5FL_ARR_FREE(hbounds_t, new_space->select.sel_info.hslab->span_lst); } /* end if */ FUNC_LEAVE_NOAPI(ret_value) } /* end H5S__hyper_project_simple_higher() */ - /*------------------------------------------------------------------------- * Function: H5S__hyper_project_simple * @@ -6766,10 +6747,9 @@ done: *------------------------------------------------------------------------- */ static herr_t -H5S__hyper_project_simple(const H5S_t *base_space, H5S_t *new_space, - hsize_t *offset) +H5S__hyper_project_simple(const H5S_t *base_space, H5S_t *new_space, hsize_t *offset) { - herr_t ret_value = SUCCEED; /* Return value */ + herr_t ret_value = SUCCEED; /* Return value */ FUNC_ENTER_STATIC @@ -6779,11 +6759,11 @@ H5S__hyper_project_simple(const H5S_t *base_space, H5S_t *new_space, HDassert(offset); /* We are setting a new selection, remove any current selection in new dataspace */ - if(H5S_SELECT_RELEASE(new_space) < 0) + if (H5S_SELECT_RELEASE(new_space) < 0) HGOTO_ERROR(H5E_DATASPACE, H5E_CANTDELETE, FAIL, "can't release selection") /* Allocate space for the hyperslab selection information */ - if(NULL == (new_space->select.sel_info.hslab = H5FL_MALLOC(H5S_hyper_sel_t))) + if (NULL == (new_space->select.sel_info.hslab = H5FL_MALLOC(H5S_hyper_sel_t))) HGOTO_ERROR(H5E_DATASPACE, H5E_CANTALLOC, FAIL, "can't allocate hyperslab info") /* Set unlim_dim */ @@ -6791,25 +6771,26 @@ H5S__hyper_project_simple(const H5S_t *base_space, H5S_t *new_space, /* Check for a "regular" hyperslab selection */ /* (No need to rebuild the dimension info yet -QAK) */ - if(base_space->select.sel_info.hslab->diminfo_valid == H5S_DIMINFO_VALID_YES) { - unsigned base_space_dim; /* Current dimension in the base dataspace */ - unsigned new_space_dim; /* Current dimension in the new dataspace */ - unsigned u; /* Local index variable */ + if (base_space->select.sel_info.hslab->diminfo_valid == H5S_DIMINFO_VALID_YES) { + unsigned base_space_dim; /* Current dimension in the base dataspace */ + unsigned new_space_dim; /* Current dimension in the new dataspace */ + unsigned u; /* Local index variable */ /* Check if the new space's rank is < or > base space's rank */ - if(new_space->extent.rank < base_space->extent.rank) { - const H5S_hyper_dim_t *opt_diminfo = base_space->select.sel_info.hslab->diminfo.opt; /* Alias for dataspace's diminfo information */ - hsize_t block[H5S_MAX_RANK]; /* Block selected in base dataspace */ + if (new_space->extent.rank < base_space->extent.rank) { + const H5S_hyper_dim_t *opt_diminfo = base_space->select.sel_info.hslab->diminfo + .opt; /* Alias for dataspace's diminfo information */ + hsize_t block[H5S_MAX_RANK]; /* Block selected in base dataspace */ /* Compute the offset for the down-projection */ HDmemset(block, 0, sizeof(block)); - for(u = 0; u < (base_space->extent.rank - new_space->extent.rank); u++) + for (u = 0; u < (base_space->extent.rank - new_space->extent.rank); u++) block[u] = opt_diminfo[u].start; *offset = H5VM_array_offset(base_space->extent.rank, base_space->extent.size, block); /* Set the correct dimensions for the base & new spaces */ base_space_dim = base_space->extent.rank - new_space->extent.rank; - new_space_dim = 0; + new_space_dim = 0; } /* end if */ else { HDassert(new_space->extent.rank > base_space->extent.rank); @@ -6818,16 +6799,17 @@ H5S__hyper_project_simple(const H5S_t *base_space, H5S_t *new_space, *offset = 0; /* Set the diminfo information for the higher dimensions */ - for(new_space_dim = 0; new_space_dim < (new_space->extent.rank - base_space->extent.rank); new_space_dim++) { - new_space->select.sel_info.hslab->diminfo.app[new_space_dim].start = 0; + for (new_space_dim = 0; new_space_dim < (new_space->extent.rank - base_space->extent.rank); + new_space_dim++) { + new_space->select.sel_info.hslab->diminfo.app[new_space_dim].start = 0; new_space->select.sel_info.hslab->diminfo.app[new_space_dim].stride = 1; - new_space->select.sel_info.hslab->diminfo.app[new_space_dim].count = 1; - new_space->select.sel_info.hslab->diminfo.app[new_space_dim].block = 1; + new_space->select.sel_info.hslab->diminfo.app[new_space_dim].count = 1; + new_space->select.sel_info.hslab->diminfo.app[new_space_dim].block = 1; - new_space->select.sel_info.hslab->diminfo.opt[new_space_dim].start = 0; + new_space->select.sel_info.hslab->diminfo.opt[new_space_dim].start = 0; new_space->select.sel_info.hslab->diminfo.opt[new_space_dim].stride = 1; - new_space->select.sel_info.hslab->diminfo.opt[new_space_dim].count = 1; - new_space->select.sel_info.hslab->diminfo.opt[new_space_dim].block = 1; + new_space->select.sel_info.hslab->diminfo.opt[new_space_dim].count = 1; + new_space->select.sel_info.hslab->diminfo.opt[new_space_dim].block = 1; } /* end for */ /* Start at beginning of base space's dimension info */ @@ -6835,24 +6817,24 @@ H5S__hyper_project_simple(const H5S_t *base_space, H5S_t *new_space, } /* end else */ /* Copy the diminfo */ - while(base_space_dim < base_space->extent.rank) { + while (base_space_dim < base_space->extent.rank) { new_space->select.sel_info.hslab->diminfo.app[new_space_dim].start = - base_space->select.sel_info.hslab->diminfo.app[base_space_dim].start; + base_space->select.sel_info.hslab->diminfo.app[base_space_dim].start; new_space->select.sel_info.hslab->diminfo.app[new_space_dim].stride = - base_space->select.sel_info.hslab->diminfo.app[base_space_dim].stride; + base_space->select.sel_info.hslab->diminfo.app[base_space_dim].stride; new_space->select.sel_info.hslab->diminfo.app[new_space_dim].count = - base_space->select.sel_info.hslab->diminfo.app[base_space_dim].count; + base_space->select.sel_info.hslab->diminfo.app[base_space_dim].count; new_space->select.sel_info.hslab->diminfo.app[new_space_dim].block = - base_space->select.sel_info.hslab->diminfo.app[base_space_dim].block; + base_space->select.sel_info.hslab->diminfo.app[base_space_dim].block; new_space->select.sel_info.hslab->diminfo.opt[new_space_dim].start = - base_space->select.sel_info.hslab->diminfo.opt[base_space_dim].start; + base_space->select.sel_info.hslab->diminfo.opt[base_space_dim].start; new_space->select.sel_info.hslab->diminfo.opt[new_space_dim].stride = - base_space->select.sel_info.hslab->diminfo.opt[base_space_dim].stride; + base_space->select.sel_info.hslab->diminfo.opt[base_space_dim].stride; new_space->select.sel_info.hslab->diminfo.opt[new_space_dim].count = - base_space->select.sel_info.hslab->diminfo.opt[base_space_dim].count; + base_space->select.sel_info.hslab->diminfo.opt[base_space_dim].count; new_space->select.sel_info.hslab->diminfo.opt[new_space_dim].block = - base_space->select.sel_info.hslab->diminfo.opt[base_space_dim].block; + base_space->select.sel_info.hslab->diminfo.opt[base_space_dim].block; /* Advance to next dimensions */ base_space_dim++; @@ -6860,9 +6842,14 @@ H5S__hyper_project_simple(const H5S_t *base_space, H5S_t *new_space, } /* end for */ /* Update the bounding box */ - for(u = 0; u < new_space->extent.rank; u++) { - new_space->select.sel_info.hslab->diminfo.low_bounds[u] = new_space->select.sel_info.hslab->diminfo.opt[u].start; - new_space->select.sel_info.hslab->diminfo.high_bounds[u] = new_space->select.sel_info.hslab->diminfo.low_bounds[u] + new_space->select.sel_info.hslab->diminfo.opt[u].stride * (new_space->select.sel_info.hslab->diminfo.opt[u].count - 1) + (new_space->select.sel_info.hslab->diminfo.opt[u].block - 1); + for (u = 0; u < new_space->extent.rank; u++) { + new_space->select.sel_info.hslab->diminfo.low_bounds[u] = + new_space->select.sel_info.hslab->diminfo.opt[u].start; + new_space->select.sel_info.hslab->diminfo.high_bounds[u] = + new_space->select.sel_info.hslab->diminfo.low_bounds[u] + + new_space->select.sel_info.hslab->diminfo.opt[u].stride * + (new_space->select.sel_info.hslab->diminfo.opt[u].count - 1) + + (new_space->select.sel_info.hslab->diminfo.opt[u].block - 1); } /* end for */ /* Indicate that the dimension information is valid */ @@ -6873,18 +6860,18 @@ H5S__hyper_project_simple(const H5S_t *base_space, H5S_t *new_space, } /* end if */ else { /* Check if the new space's rank is < or > base space's rank */ - if(new_space->extent.rank < base_space->extent.rank) { - const H5S_hyper_span_t *curr; /* Pointer to current hyperslab span */ - hsize_t block[H5S_MAX_RANK]; /* Block selected in base dataspace */ - unsigned curr_dim; /* Current dimension being operated on */ + if (new_space->extent.rank < base_space->extent.rank) { + const H5S_hyper_span_t *curr; /* Pointer to current hyperslab span */ + hsize_t block[H5S_MAX_RANK]; /* Block selected in base dataspace */ + unsigned curr_dim; /* Current dimension being operated on */ /* Clear the block buffer */ HDmemset(block, 0, sizeof(block)); /* Advance down selected spans */ - curr = base_space->select.sel_info.hslab->span_lst->head; + curr = base_space->select.sel_info.hslab->span_lst->head; curr_dim = 0; - while(curr && curr_dim < (base_space->extent.rank - new_space->extent.rank)) { + while (curr && curr_dim < (base_space->extent.rank - new_space->extent.rank)) { /* Save the location of the selection in current dimension */ block[curr_dim] = curr->low; @@ -6897,8 +6884,9 @@ H5S__hyper_project_simple(const H5S_t *base_space, H5S_t *new_space, *offset = H5VM_array_offset(base_space->extent.rank, base_space->extent.size, block); /* Project the base space's selection down in less dimensions */ - if(H5S__hyper_project_simple_lower(base_space, new_space) < 0) - HGOTO_ERROR(H5E_DATASPACE, H5E_CANTSELECT, FAIL, "can't project hyperslab selection into less dimensions") + if (H5S__hyper_project_simple_lower(base_space, new_space) < 0) + HGOTO_ERROR(H5E_DATASPACE, H5E_CANTSELECT, FAIL, + "can't project hyperslab selection into less dimensions") } /* end if */ else { HDassert(new_space->extent.rank > base_space->extent.rank); @@ -6907,8 +6895,9 @@ H5S__hyper_project_simple(const H5S_t *base_space, H5S_t *new_space, *offset = 0; /* Project the base space's selection down in more dimensions */ - if(H5S__hyper_project_simple_higher(base_space, new_space) < 0) - HGOTO_ERROR(H5E_DATASPACE, H5E_CANTSELECT, FAIL, "can't project hyperslab selection into less dimensions") + if (H5S__hyper_project_simple_higher(base_space, new_space) < 0) + HGOTO_ERROR(H5E_DATASPACE, H5E_CANTSELECT, FAIL, + "can't project hyperslab selection into less dimensions") } /* end else */ /* Copy the status of the dimension information */ @@ -6925,7 +6914,6 @@ done: FUNC_LEAVE_NOAPI(ret_value) } /* end H5S__hyper_project_simple() */ - /*-------------------------------------------------------------------------- NAME H5S__hyper_adjust_s_helper @@ -6948,8 +6936,8 @@ done: REVISION LOG --------------------------------------------------------------------------*/ static void -H5S__hyper_adjust_s_helper(H5S_hyper_span_info_t *spans, unsigned rank, - const hssize_t *offset, unsigned op_info_i, uint64_t op_gen) +H5S__hyper_adjust_s_helper(H5S_hyper_span_info_t *spans, unsigned rank, const hssize_t *offset, + unsigned op_info_i, uint64_t op_gen) { FUNC_ENTER_STATIC_NOERR @@ -6958,27 +6946,27 @@ H5S__hyper_adjust_s_helper(H5S_hyper_span_info_t *spans, unsigned rank, HDassert(offset); /* Check if we've already set this span tree */ - if(spans->op_info[op_info_i].op_gen != op_gen) { - H5S_hyper_span_t *span; /* Pointer to current span in span tree */ - unsigned u; /* Local index variable */ + if (spans->op_info[op_info_i].op_gen != op_gen) { + H5S_hyper_span_t *span; /* Pointer to current span in span tree */ + unsigned u; /* Local index variable */ /* Adjust the span tree's low & high bounds */ - for(u = 0; u < rank; u++) { + for (u = 0; u < rank; u++) { HDassert((hssize_t)spans->low_bounds[u] >= offset[u]); - spans->low_bounds[u] = (hsize_t)((hssize_t)spans->low_bounds[u] - offset[u]); + spans->low_bounds[u] = (hsize_t)((hssize_t)spans->low_bounds[u] - offset[u]); spans->high_bounds[u] = (hsize_t)((hssize_t)spans->high_bounds[u] - offset[u]); } /* end for */ /* Iterate over the spans in tree */ span = spans->head; - while(span != NULL) { + while (span != NULL) { /* Adjust span offset */ HDassert((hssize_t)span->low >= *offset); - span->low = (hsize_t)((hssize_t)span->low - *offset); + span->low = (hsize_t)((hssize_t)span->low - *offset); span->high = (hsize_t)((hssize_t)span->high - *offset); /* Recursively adjust spans in next dimension down */ - if(span->down != NULL) + if (span->down != NULL) H5S__hyper_adjust_s_helper(span->down, rank - 1, offset + 1, op_info_i, op_gen); /* Advance to next span in this dimension */ @@ -6992,7 +6980,6 @@ H5S__hyper_adjust_s_helper(H5S_hyper_span_info_t *spans, unsigned rank, FUNC_LEAVE_NOAPI_VOID } /* end H5S__hyper_adjust_s_helper() */ - /*-------------------------------------------------------------------------- NAME H5S__hyper_adjust_s @@ -7014,8 +7001,8 @@ H5S__hyper_adjust_s_helper(H5S_hyper_span_info_t *spans, unsigned rank, static herr_t H5S__hyper_adjust_s(H5S_t *space, const hssize_t *offset) { - hbool_t non_zero_offset = FALSE; /* Whether any offset is non-zero */ - unsigned u; /* Local index variable */ + hbool_t non_zero_offset = FALSE; /* Whether any offset is non-zero */ + unsigned u; /* Local index variable */ FUNC_ENTER_STATIC_NOERR @@ -7024,31 +7011,34 @@ H5S__hyper_adjust_s(H5S_t *space, const hssize_t *offset) HDassert(offset); /* Check for an all-zero offset vector */ - for(u = 0; u < space->extent.rank; u++) - if(0 != offset[u]) { + for (u = 0; u < space->extent.rank; u++) + if (0 != offset[u]) { non_zero_offset = TRUE; break; } /* end if */ /* Only perform operation if the offset is non-zero */ - if(non_zero_offset) { + if (non_zero_offset) { /* Subtract the offset from the "regular" coordinates, if they exist */ /* (No need to rebuild the dimension info yet -QAK) */ - if(space->select.sel_info.hslab->diminfo_valid == H5S_DIMINFO_VALID_YES) { - for(u = 0; u < space->extent.rank; u++) { + if (space->select.sel_info.hslab->diminfo_valid == H5S_DIMINFO_VALID_YES) { + for (u = 0; u < space->extent.rank; u++) { HDassert((hssize_t)space->select.sel_info.hslab->diminfo.opt[u].start >= offset[u]); - space->select.sel_info.hslab->diminfo.opt[u].start = (hsize_t)((hssize_t)space->select.sel_info.hslab->diminfo.opt[u].start - offset[u]); + space->select.sel_info.hslab->diminfo.opt[u].start = + (hsize_t)((hssize_t)space->select.sel_info.hslab->diminfo.opt[u].start - offset[u]); /* Adjust the low & high bounds */ HDassert((hssize_t)space->select.sel_info.hslab->diminfo.low_bounds[u] >= offset[u]); - space->select.sel_info.hslab->diminfo.low_bounds[u] = (hsize_t)((hssize_t)space->select.sel_info.hslab->diminfo.low_bounds[u] - offset[u]); - space->select.sel_info.hslab->diminfo.high_bounds[u] = (hsize_t)((hssize_t)space->select.sel_info.hslab->diminfo.high_bounds[u] - offset[u]); + space->select.sel_info.hslab->diminfo.low_bounds[u] = + (hsize_t)((hssize_t)space->select.sel_info.hslab->diminfo.low_bounds[u] - offset[u]); + space->select.sel_info.hslab->diminfo.high_bounds[u] = + (hsize_t)((hssize_t)space->select.sel_info.hslab->diminfo.high_bounds[u] - offset[u]); } /* end for */ - } /* end if */ + } /* end if */ /* Subtract the offset from the span tree coordinates, if they exist */ - if(space->select.sel_info.hslab->span_lst) { - uint64_t op_gen; /* Operation generation value */ + if (space->select.sel_info.hslab->span_lst) { + uint64_t op_gen; /* Operation generation value */ /* Acquire an operation generation value for this operation */ op_gen = H5S__hyper_get_op_gen(); @@ -7056,14 +7046,14 @@ H5S__hyper_adjust_s(H5S_t *space, const hssize_t *offset) /* Perform the adjustment */ /* Always use op_info[0] since we own this op_info, so there can be no * simultaneous operations */ - H5S__hyper_adjust_s_helper(space->select.sel_info.hslab->span_lst, space->extent.rank, offset, 0, op_gen); + H5S__hyper_adjust_s_helper(space->select.sel_info.hslab->span_lst, space->extent.rank, offset, 0, + op_gen); } /* end if */ } FUNC_LEAVE_NOAPI(SUCCEED) } /* end H5S__hyper_adjust_s() */ - /*-------------------------------------------------------------------------- NAME H5S_hyper_normalize_offset @@ -7088,7 +7078,7 @@ H5S__hyper_adjust_s(H5S_t *space, const hssize_t *offset) htri_t H5S_hyper_normalize_offset(H5S_t *space, hssize_t *old_offset) { - htri_t ret_value = FALSE; /* Return value */ + htri_t ret_value = FALSE; /* Return value */ FUNC_ENTER_NOAPI(FAIL) @@ -7097,17 +7087,17 @@ H5S_hyper_normalize_offset(H5S_t *space, hssize_t *old_offset) HDassert(old_offset); /* Check for hyperslab selection & offset changed */ - if(H5S_GET_SELECT_TYPE(space) == H5S_SEL_HYPERSLABS && space->select.offset_changed) { - unsigned u; /* Local index variable */ + if (H5S_GET_SELECT_TYPE(space) == H5S_SEL_HYPERSLABS && space->select.offset_changed) { + unsigned u; /* Local index variable */ /* Copy & invert the selection offset */ - for(u = 0; u < space->extent.rank; u++) { - old_offset[u] = space->select.offset[u]; + for (u = 0; u < space->extent.rank; u++) { + old_offset[u] = space->select.offset[u]; space->select.offset[u] = -space->select.offset[u]; } /* end for */ /* Call the 'adjust' routine */ - if(H5S__hyper_adjust_s(space, space->select.offset) < 0) + if (H5S__hyper_adjust_s(space, space->select.offset) < 0) HGOTO_ERROR(H5E_DATASPACE, H5E_CANTSET, FAIL, "can't adjust selection") /* Zero out the selection offset */ @@ -7121,7 +7111,6 @@ done: FUNC_LEAVE_NOAPI(ret_value) } /* end H5S_hyper_normalize_offset() */ - /*-------------------------------------------------------------------------- NAME H5S_hyper_denormalize_offset @@ -7146,7 +7135,7 @@ done: herr_t H5S_hyper_denormalize_offset(H5S_t *space, const hssize_t *old_offset) { - herr_t ret_value = SUCCEED; /* Return value */ + herr_t ret_value = SUCCEED; /* Return value */ FUNC_ENTER_NOAPI(FAIL) @@ -7155,7 +7144,7 @@ H5S_hyper_denormalize_offset(H5S_t *space, const hssize_t *old_offset) HDassert(H5S_GET_SELECT_TYPE(space) == H5S_SEL_HYPERSLABS); /* Call the 'adjust' routine */ - if(H5S__hyper_adjust_s(space, old_offset) < 0) + if (H5S__hyper_adjust_s(space, old_offset) < 0) HGOTO_ERROR(H5E_DATASPACE, H5E_CANTSET, FAIL, "can't adjust selection") /* Copy the selection offset over */ @@ -7165,7 +7154,6 @@ done: FUNC_LEAVE_NOAPI(ret_value) } /* end H5S_hyper_denormalize_offset() */ - /*-------------------------------------------------------------------------- NAME H5S__hyper_append_span @@ -7188,11 +7176,11 @@ done: REVISION LOG --------------------------------------------------------------------------*/ static herr_t -H5S__hyper_append_span(H5S_hyper_span_info_t **span_tree, unsigned ndims, - hsize_t low, hsize_t high, H5S_hyper_span_info_t *down) +H5S__hyper_append_span(H5S_hyper_span_info_t **span_tree, unsigned ndims, hsize_t low, hsize_t high, + H5S_hyper_span_info_t *down) { - H5S_hyper_span_t *new_span = NULL; - herr_t ret_value = SUCCEED; /* Return value */ + H5S_hyper_span_t *new_span = NULL; + herr_t ret_value = SUCCEED; /* Return value */ FUNC_ENTER_STATIC @@ -7200,40 +7188,40 @@ H5S__hyper_append_span(H5S_hyper_span_info_t **span_tree, unsigned ndims, HDassert(span_tree); /* Check for adding first node to merged spans */ - if(*span_tree == NULL) { + if (*span_tree == NULL) { /* Allocate new span node to append to list */ - if(NULL == (new_span = H5S__hyper_new_span(low, high, down, NULL))) + if (NULL == (new_span = H5S__hyper_new_span(low, high, down, NULL))) HGOTO_ERROR(H5E_DATASPACE, H5E_CANTALLOC, FAIL, "can't allocate hyperslab span") /* Make new span the first node in span list */ /* Allocate a new span_info node */ - if(NULL == (*span_tree = H5S__hyper_new_span_info(ndims))) + if (NULL == (*span_tree = H5S__hyper_new_span_info(ndims))) HGOTO_ERROR(H5E_DATASPACE, H5E_CANTALLOC, FAIL, "can't allocate hyperslab span") /* Set the span tree's basic information */ (*span_tree)->count = 1; - (*span_tree)->head = new_span; - (*span_tree)->tail = new_span; + (*span_tree)->head = new_span; + (*span_tree)->tail = new_span; /* Set low & high bounds for new span tree */ - (*span_tree)->low_bounds[0] = low; + (*span_tree)->low_bounds[0] = low; (*span_tree)->high_bounds[0] = high; - if(down) { + if (down) { /* Sanity check */ HDassert(ndims > 1); H5MM_memcpy(&((*span_tree)->low_bounds[1]), down->low_bounds, sizeof(hsize_t) * (ndims - 1)); H5MM_memcpy(&((*span_tree)->high_bounds[1]), down->high_bounds, sizeof(hsize_t) * (ndims - 1)); } /* end if */ - } /* end if */ + } /* end if */ /* Merge or append to existing merged spans list */ else { - htri_t down_cmp = (-1); /* Comparison value for down spans */ + htri_t down_cmp = (-1); /* Comparison value for down spans */ /* Check if span can just extend the previous merged span */ - if((((*span_tree)->tail->high + 1) == low) && - (down_cmp = H5S__hyper_cmp_spans(down, (*span_tree)->tail->down))) { + if ((((*span_tree)->tail->high + 1) == low) && + (down_cmp = H5S__hyper_cmp_spans(down, (*span_tree)->tail->down))) { /* Extend previous merged span to include new high bound */ (*span_tree)->tail->high = high; @@ -7242,17 +7230,17 @@ H5S__hyper_append_span(H5S_hyper_span_info_t **span_tree, unsigned ndims, (*span_tree)->high_bounds[0] = high; } /* end if */ else { - H5S_hyper_span_info_t *new_down; /* Down pointer for new span node */ + H5S_hyper_span_info_t *new_down; /* Down pointer for new span node */ /* Sanity check */ /* (If down_cmp was set to TRUE above, we won't be in this branch) */ HDassert(down_cmp != TRUE); /* Check if there is actually a down span */ - if(down) { + if (down) { /* Check if the down spans for the new span node are the same as the previous span node */ /* (Uses the 'down span comparison' from earlier, if already computed) */ - if(down_cmp < 0 && (down_cmp = H5S__hyper_cmp_spans(down, (*span_tree)->tail->down))) + if (down_cmp < 0 && (down_cmp = H5S__hyper_cmp_spans(down, (*span_tree)->tail->down))) /* Share the previous span's down span tree */ new_down = (*span_tree)->tail->down; else @@ -7262,48 +7250,47 @@ H5S__hyper_append_span(H5S_hyper_span_info_t **span_tree, unsigned ndims, new_down = NULL; /* Allocate new span node to append to list */ - if(NULL == (new_span = H5S__hyper_new_span(low, high, new_down, NULL))) + if (NULL == (new_span = H5S__hyper_new_span(low, high, new_down, NULL))) HGOTO_ERROR(H5E_DATASPACE, H5E_CANTALLOC, FAIL, "can't allocate hyperslab span") /* Update the high bounds for current dimension */ (*span_tree)->high_bounds[0] = high; /* Update low & high bounds in lower dimensions, if there are any */ - if(down) { + if (down) { /* Sanity checks */ HDassert(ndims > 1); HDassert(down_cmp >= 0); /* Check if we are sharing down spans with a previous node */ /* (Only need to check for bounds changing if down spans aren't shared) */ - if(down_cmp == FALSE) { - unsigned u; /* Local index variable */ + if (down_cmp == FALSE) { + unsigned u; /* Local index variable */ /* Loop over lower dimensions, checking & updating low & high bounds */ - for(u = 0; u < (ndims - 1); u++) { - if(down->low_bounds[u] < (*span_tree)->low_bounds[u + 1]) + for (u = 0; u < (ndims - 1); u++) { + if (down->low_bounds[u] < (*span_tree)->low_bounds[u + 1]) (*span_tree)->low_bounds[u + 1] = down->low_bounds[u]; - if(down->high_bounds[u] > (*span_tree)->high_bounds[u + 1]) + if (down->high_bounds[u] > (*span_tree)->high_bounds[u + 1]) (*span_tree)->high_bounds[u + 1] = down->high_bounds[u]; } /* end for */ - } /* end if */ - } /* end if */ + } /* end if */ + } /* end if */ /* Append to end of merged spans list */ (*span_tree)->tail->next = new_span; - (*span_tree)->tail = new_span; + (*span_tree)->tail = new_span; } /* end else */ - } /* end else */ + } /* end else */ done: - if(ret_value < 0) - if(new_span) + if (ret_value < 0) + if (new_span) H5S__hyper_free_span(new_span); FUNC_LEAVE_NOAPI(ret_value) } /* end H5S__hyper_append_span() */ - /*-------------------------------------------------------------------------- NAME H5S__hyper_clip_spans @@ -7345,15 +7332,14 @@ done: REVISION LOG --------------------------------------------------------------------------*/ static herr_t -H5S__hyper_clip_spans(H5S_hyper_span_info_t *a_spans, H5S_hyper_span_info_t *b_spans, - unsigned selector, unsigned ndims, - H5S_hyper_span_info_t **a_not_b, H5S_hyper_span_info_t **a_and_b, - H5S_hyper_span_info_t **b_not_a) +H5S__hyper_clip_spans(H5S_hyper_span_info_t *a_spans, H5S_hyper_span_info_t *b_spans, unsigned selector, + unsigned ndims, H5S_hyper_span_info_t **a_not_b, H5S_hyper_span_info_t **a_and_b, + H5S_hyper_span_info_t **b_not_a) { - hbool_t need_a_not_b; /* Whether to generate a_not_b list */ - hbool_t need_a_and_b; /* Whether to generate a_and_b list */ - hbool_t need_b_not_a; /* Whether to generate b_not_a list */ - herr_t ret_value = SUCCEED; /* Return value */ + hbool_t need_a_not_b; /* Whether to generate a_not_b list */ + hbool_t need_a_and_b; /* Whether to generate a_and_b list */ + hbool_t need_b_not_a; /* Whether to generate b_not_a list */ + herr_t ret_value = SUCCEED; /* Return value */ FUNC_ENTER_STATIC @@ -7370,28 +7356,28 @@ H5S__hyper_clip_spans(H5S_hyper_span_info_t *a_spans, H5S_hyper_span_info_t *b_s need_b_not_a = ((selector & H5S_HYPER_COMPUTE_B_NOT_A) != 0); /* Check if both span trees are not defined */ - if(a_spans == NULL && b_spans == NULL) { + if (a_spans == NULL && b_spans == NULL) { *a_not_b = NULL; *a_and_b = NULL; *b_not_a = NULL; } /* end if */ /* If span 'a' is not defined, but 'b' is, copy 'b' and set the other return span trees to empty */ - else if(a_spans == NULL) { + else if (a_spans == NULL) { *a_not_b = NULL; *a_and_b = NULL; - if(need_b_not_a) { - if(NULL == (*b_not_a = H5S__hyper_copy_span(b_spans, ndims))) + if (need_b_not_a) { + if (NULL == (*b_not_a = H5S__hyper_copy_span(b_spans, ndims))) HGOTO_ERROR(H5E_INTERNAL, H5E_CANTCOPY, FAIL, "can't copy hyperslab span tree") } /* end if */ else *b_not_a = NULL; } /* end if */ /* If span 'b' is not defined, but 'a' is, copy 'a' and set the other return span trees to empty */ - else if(b_spans == NULL) { + else if (b_spans == NULL) { *a_and_b = NULL; *b_not_a = NULL; - if(need_a_not_b) { - if(NULL == (*a_not_b = H5S__hyper_copy_span(a_spans, ndims))) + if (need_a_not_b) { + if (NULL == (*a_not_b = H5S__hyper_copy_span(a_spans, ndims))) HGOTO_ERROR(H5E_INTERNAL, H5E_CANTCOPY, FAIL, "can't copy hyperslab span tree") } /* end if */ else @@ -7400,20 +7386,20 @@ H5S__hyper_clip_spans(H5S_hyper_span_info_t *a_spans, H5S_hyper_span_info_t *b_s /* If span 'a' and 'b' are both defined, calculate the proper span trees */ else { /* Check if both span trees completely overlap */ - if(H5S__hyper_cmp_spans(a_spans, b_spans)) { + if (H5S__hyper_cmp_spans(a_spans, b_spans)) { *a_not_b = NULL; *b_not_a = NULL; - if(need_a_and_b) { - if(NULL == (*a_and_b = H5S__hyper_copy_span(a_spans, ndims))) + if (need_a_and_b) { + if (NULL == (*a_and_b = H5S__hyper_copy_span(a_spans, ndims))) HGOTO_ERROR(H5E_INTERNAL, H5E_CANTCOPY, FAIL, "can't copy hyperslab span tree") } /* end if */ else *a_and_b = NULL; } /* end if */ else { - H5S_hyper_span_t *span_a; /* Pointer to a node in span tree 'a' */ - H5S_hyper_span_t *span_b; /* Pointer to a node in span tree 'b' */ - hbool_t recover_a, recover_b; /* Flags to indicate when to recover temporary spans */ + H5S_hyper_span_t *span_a; /* Pointer to a node in span tree 'a' */ + H5S_hyper_span_t *span_b; /* Pointer to a node in span tree 'b' */ + hbool_t recover_a, recover_b; /* Flags to indicate when to recover temporary spans */ /* Get the pointers to the new and old span lists */ span_a = a_spans->head; @@ -7423,22 +7409,26 @@ H5S__hyper_clip_spans(H5S_hyper_span_info_t *a_spans, H5S_hyper_span_info_t *b_s recover_a = recover_b = FALSE; /* Work through the list of spans in the new list */ - while(span_a != NULL && span_b != NULL) { - H5S_hyper_span_info_t *down_a_not_b; /* Temporary pointer to a_not_b span tree of down spans for overlapping nodes */ - H5S_hyper_span_info_t *down_a_and_b; /* Temporary pointer to a_and_b span tree of down spans for overlapping nodes */ - H5S_hyper_span_info_t *down_b_not_a; /* Temporary pointer to b_and_a span tree of down spans for overlapping nodes */ - H5S_hyper_span_t *tmp_span; /* Temporary pointer to new span */ + while (span_a != NULL && span_b != NULL) { + H5S_hyper_span_info_t *down_a_not_b; /* Temporary pointer to a_not_b span tree of down spans + for overlapping nodes */ + H5S_hyper_span_info_t *down_a_and_b; /* Temporary pointer to a_and_b span tree of down spans + for overlapping nodes */ + H5S_hyper_span_info_t *down_b_not_a; /* Temporary pointer to b_and_a span tree of down spans + for overlapping nodes */ + H5S_hyper_span_t *tmp_span; /* Temporary pointer to new span */ /* Check if span 'a' is completely before span 'b' */ /* AAAAAAA */ /* <-----------------------------------> */ /* BBBBBBBBBB */ - if(span_a->high < span_b->low) { + if (span_a->high < span_b->low) { /* Copy span 'a' and add to a_not_b list */ /* Merge/add span 'a' with/to a_not_b list */ - if(need_a_not_b) - if(H5S__hyper_append_span(a_not_b, ndims, span_a->low, span_a->high, span_a->down) < 0) + if (need_a_not_b) + if (H5S__hyper_append_span(a_not_b, ndims, span_a->low, span_a->high, span_a->down) < + 0) HGOTO_ERROR(H5E_DATASPACE, H5E_CANTAPPEND, FAIL, "can't allocate hyperslab span") /* Advance span 'a', leave span 'b' */ @@ -7449,27 +7439,32 @@ H5S__hyper_clip_spans(H5S_hyper_span_info_t *a_spans, H5S_hyper_span_info_t *b_s /* AAAAAAAAAAAA */ /* <-----------------------------------> */ /* BBBBBBBBBB */ - else if(span_a->low < span_b->low && (span_a->high >= span_b->low && span_a->high <= span_b->high)) { + else if (span_a->low < span_b->low && + (span_a->high >= span_b->low && span_a->high <= span_b->high)) { /* Split span 'a' into two parts at the low bound of span 'b' */ /* Merge/add lower part of span 'a' with/to a_not_b list */ - if(need_a_not_b) - if(H5S__hyper_append_span(a_not_b, ndims, span_a->low, span_b->low - 1, span_a->down) < 0) + if (need_a_not_b) + if (H5S__hyper_append_span(a_not_b, ndims, span_a->low, span_b->low - 1, + span_a->down) < 0) HGOTO_ERROR(H5E_DATASPACE, H5E_CANTAPPEND, FAIL, "can't allocate hyperslab span") /* Check for overlaps between upper part of span 'a' and lower part of span 'b' */ /* Make certain both spans either have a down span or both don't have one */ - HDassert((span_a->down != NULL && span_b->down != NULL) || (span_a->down == NULL && span_b->down == NULL)); + HDassert((span_a->down != NULL && span_b->down != NULL) || + (span_a->down == NULL && span_b->down == NULL)); /* If there are no down spans, just add the overlapping area to the a_and_b list */ - if(span_a->down == NULL) { + if (span_a->down == NULL) { /* Merge/add overlapped part with/to a_and_b list */ - if(need_a_and_b) - if(H5S__hyper_append_span(a_and_b, ndims, span_b->low, span_a->high, NULL) < 0) - HGOTO_ERROR(H5E_DATASPACE, H5E_CANTAPPEND, FAIL, "can't allocate hyperslab span") + if (need_a_and_b) + if (H5S__hyper_append_span(a_and_b, ndims, span_b->low, span_a->high, NULL) < 0) + HGOTO_ERROR(H5E_DATASPACE, H5E_CANTAPPEND, FAIL, + "can't allocate hyperslab span") } /* end if */ - /* If there are down spans, check for the overlap in them and add to each appropriate list */ + /* If there are down spans, check for the overlap in them and add to each appropriate list + */ else { /* NULL out the temporary pointers to clipped areas in down spans */ down_a_not_b = NULL; @@ -7481,52 +7476,60 @@ H5S__hyper_clip_spans(H5S_hyper_span_info_t *a_spans, H5S_hyper_span_info_t *b_s * has been updated in the following clip function (via * all_clips_bounds), there's no need updating the bound box * after each append call in the following codes */ - if(H5S__hyper_clip_spans(span_a->down, span_b->down, selector, ndims - 1, &down_a_not_b, &down_a_and_b, &down_b_not_a) < 0) + if (H5S__hyper_clip_spans(span_a->down, span_b->down, selector, ndims - 1, + &down_a_not_b, &down_a_and_b, &down_b_not_a) < 0) HGOTO_ERROR(H5E_DATASPACE, H5E_CANTCLIP, FAIL, "can't clip hyperslab information") /* Check for additions to the a_not_b list */ - if(down_a_not_b) { + if (down_a_not_b) { HDassert(need_a_not_b == TRUE); /* Merge/add overlapped part with/to a_not_b list */ - if(H5S__hyper_append_span(a_not_b, ndims, span_b->low, span_a->high, down_a_not_b) < 0) - HGOTO_ERROR(H5E_DATASPACE, H5E_CANTAPPEND, FAIL, "can't allocate hyperslab span") + if (H5S__hyper_append_span(a_not_b, ndims, span_b->low, span_a->high, + down_a_not_b) < 0) + HGOTO_ERROR(H5E_DATASPACE, H5E_CANTAPPEND, FAIL, + "can't allocate hyperslab span") /* Release the down span tree generated */ H5S__hyper_free_span_info(down_a_not_b); } /* end if */ /* Check for additions to the a_and_b list */ - if(down_a_and_b) { + if (down_a_and_b) { HDassert(need_a_and_b == TRUE); /* Merge/add overlapped part with/to a_and_b list */ - if(H5S__hyper_append_span(a_and_b, ndims, span_b->low, span_a->high, down_a_and_b) < 0) - HGOTO_ERROR(H5E_DATASPACE, H5E_CANTAPPEND, FAIL, "can't allocate hyperslab span") + if (H5S__hyper_append_span(a_and_b, ndims, span_b->low, span_a->high, + down_a_and_b) < 0) + HGOTO_ERROR(H5E_DATASPACE, H5E_CANTAPPEND, FAIL, + "can't allocate hyperslab span") /* Release the down span tree generated */ H5S__hyper_free_span_info(down_a_and_b); } /* end if */ /* Check for additions to the b_not_a list */ - if(down_b_not_a) { + if (down_b_not_a) { HDassert(need_b_not_a == TRUE); /* Merge/add overlapped part with/to b_not_a list */ - if(H5S__hyper_append_span(b_not_a, ndims, span_b->low, span_a->high, down_b_not_a) < 0) - HGOTO_ERROR(H5E_DATASPACE, H5E_CANTAPPEND, FAIL, "can't allocate hyperslab span") + if (H5S__hyper_append_span(b_not_a, ndims, span_b->low, span_a->high, + down_b_not_a) < 0) + HGOTO_ERROR(H5E_DATASPACE, H5E_CANTAPPEND, FAIL, + "can't allocate hyperslab span") /* Release the down span tree generated */ H5S__hyper_free_span_info(down_b_not_a); } /* end if */ - } /* end else */ + } /* end else */ /* Split off upper part of span 'b' at upper span of span 'a' */ /* Check if there is actually an upper part of span 'b' to split off */ - if(span_a->high < span_b->high) { + if (span_a->high < span_b->high) { /* Allocate new span node for upper part of span 'b' */ - if(NULL == (tmp_span = H5S__hyper_new_span(span_a->high + 1, span_b->high, span_b->down, span_b->next))) + if (NULL == (tmp_span = H5S__hyper_new_span(span_a->high + 1, span_b->high, + span_b->down, span_b->next))) HGOTO_ERROR(H5E_DATASPACE, H5E_NOSPACE, FAIL, "can't allocate hyperslab span") /* Advance span 'a' */ @@ -7542,33 +7545,37 @@ H5S__hyper_clip_spans(H5S_hyper_span_info_t *a_spans, H5S_hyper_span_info_t *b_s H5S_HYPER_ADVANCE_SPAN(recover_a, span_a, span_a->next); H5S_HYPER_ADVANCE_SPAN(recover_b, span_b, span_b->next); } /* end else */ - } /* end if */ + } /* end if */ /* Check if span 'a' overlaps the lower & upper bound */ /* of span 'b' */ /* AAAAAAAAAAAAAAAAAAAAA */ /* <-----------------------------------> */ /* BBBBBBBBBB */ - else if(span_a->low < span_b->low && span_a->high > span_b->high) { + else if (span_a->low < span_b->low && span_a->high > span_b->high) { /* Split off lower part of span 'a' at lower span of span 'b' */ /* Merge/add lower part of span 'a' with/to a_not_b list */ - if(need_a_not_b) - if(H5S__hyper_append_span(a_not_b, ndims, span_a->low, span_b->low - 1, span_a->down) < 0) + if (need_a_not_b) + if (H5S__hyper_append_span(a_not_b, ndims, span_a->low, span_b->low - 1, + span_a->down) < 0) HGOTO_ERROR(H5E_DATASPACE, H5E_CANTAPPEND, FAIL, "can't allocate hyperslab span") /* Check for overlaps between middle part of span 'a' and span 'b' */ /* Make certain both spans either have a down span or both don't have one */ - HDassert((span_a->down != NULL && span_b->down != NULL) || (span_a->down == NULL && span_b->down == NULL)); + HDassert((span_a->down != NULL && span_b->down != NULL) || + (span_a->down == NULL && span_b->down == NULL)); /* If there are no down spans, just add the overlapping area to the a_and_b list */ - if(span_a->down == NULL) { + if (span_a->down == NULL) { /* Merge/add overlapped part with/to a_and_b list */ - if(need_a_and_b) - if(H5S__hyper_append_span(a_and_b, ndims, span_b->low, span_b->high, NULL) < 0) - HGOTO_ERROR(H5E_DATASPACE, H5E_CANTAPPEND, FAIL, "can't allocate hyperslab span") + if (need_a_and_b) + if (H5S__hyper_append_span(a_and_b, ndims, span_b->low, span_b->high, NULL) < 0) + HGOTO_ERROR(H5E_DATASPACE, H5E_CANTAPPEND, FAIL, + "can't allocate hyperslab span") } /* end if */ - /* If there are down spans, check for the overlap in them and add to each appropriate list */ + /* If there are down spans, check for the overlap in them and add to each appropriate list + */ else { /* NULL out the temporary pointers to clipped areas in down spans */ down_a_not_b = NULL; @@ -7576,50 +7583,58 @@ H5S__hyper_clip_spans(H5S_hyper_span_info_t *a_spans, H5S_hyper_span_info_t *b_s down_b_not_a = NULL; /* Check for overlaps in the 'down spans' of span 'a' & 'b' */ - if(H5S__hyper_clip_spans(span_a->down, span_b->down, selector, ndims - 1, &down_a_not_b, &down_a_and_b, &down_b_not_a) < 0) + if (H5S__hyper_clip_spans(span_a->down, span_b->down, selector, ndims - 1, + &down_a_not_b, &down_a_and_b, &down_b_not_a) < 0) HGOTO_ERROR(H5E_DATASPACE, H5E_CANTCLIP, FAIL, "can't clip hyperslab information") /* Check for additions to the a_not_b list */ - if(down_a_not_b) { + if (down_a_not_b) { HDassert(need_a_not_b == TRUE); /* Merge/add overlapped part with/to a_not_b list */ - if(H5S__hyper_append_span(a_not_b, ndims, span_b->low, span_b->high, down_a_not_b) < 0) - HGOTO_ERROR(H5E_DATASPACE, H5E_CANTAPPEND, FAIL, "can't allocate hyperslab span") + if (H5S__hyper_append_span(a_not_b, ndims, span_b->low, span_b->high, + down_a_not_b) < 0) + HGOTO_ERROR(H5E_DATASPACE, H5E_CANTAPPEND, FAIL, + "can't allocate hyperslab span") /* Release the down span tree generated */ H5S__hyper_free_span_info(down_a_not_b); } /* end if */ /* Check for additions to the a_and_b list */ - if(down_a_and_b) { + if (down_a_and_b) { HDassert(need_a_and_b == TRUE); /* Merge/add overlapped part with/to a_and_b list */ - if(H5S__hyper_append_span(a_and_b, ndims, span_b->low, span_b->high, down_a_and_b) < 0) - HGOTO_ERROR(H5E_DATASPACE, H5E_CANTAPPEND, FAIL, "can't allocate hyperslab span") + if (H5S__hyper_append_span(a_and_b, ndims, span_b->low, span_b->high, + down_a_and_b) < 0) + HGOTO_ERROR(H5E_DATASPACE, H5E_CANTAPPEND, FAIL, + "can't allocate hyperslab span") /* Release the down span tree generated */ H5S__hyper_free_span_info(down_a_and_b); } /* end if */ /* Check for additions to the b_not_a list */ - if(down_b_not_a) { + if (down_b_not_a) { HDassert(need_b_not_a == TRUE); /* Merge/add overlapped part with/to b_not_a list */ - if(H5S__hyper_append_span(b_not_a, ndims, span_b->low, span_b->high, down_b_not_a) < 0) - HGOTO_ERROR(H5E_DATASPACE, H5E_CANTAPPEND, FAIL, "can't allocate hyperslab span") + if (H5S__hyper_append_span(b_not_a, ndims, span_b->low, span_b->high, + down_b_not_a) < 0) + HGOTO_ERROR(H5E_DATASPACE, H5E_CANTAPPEND, FAIL, + "can't allocate hyperslab span") /* Release the down span tree generated */ H5S__hyper_free_span_info(down_b_not_a); } /* end if */ - } /* end else */ + } /* end else */ /* Split off upper part of span 'a' at upper span of span 'b' */ /* Allocate new span node for upper part of span 'a' */ - if(NULL == (tmp_span = H5S__hyper_new_span(span_b->high + 1, span_a->high, span_a->down, span_a->next))) + if (NULL == (tmp_span = H5S__hyper_new_span(span_b->high + 1, span_a->high, span_a->down, + span_a->next))) HGOTO_ERROR(H5E_DATASPACE, H5E_NOSPACE, FAIL, "can't allocate hyperslab span") /* Make upper part of span 'a' the new span 'a' */ @@ -7633,15 +7648,17 @@ H5S__hyper_clip_spans(H5S_hyper_span_info_t *a_spans, H5S_hyper_span_info_t *b_s /* AAAAA */ /* <-----------------------------------> */ /* BBBBBBBBBB */ - else if(span_a->low >= span_b->low && span_a->high <= span_b->high) { + else if (span_a->low >= span_b->low && span_a->high <= span_b->high) { /* Split off lower part of span 'b' at lower span of span 'a' */ /* Check if there is actually a lower part of span 'b' to split off */ - if(span_a->low > span_b->low) { + if (span_a->low > span_b->low) { /* Merge/add lower part of span 'b' with/to b_not_a list */ - if(need_b_not_a) - if(H5S__hyper_append_span(b_not_a, ndims, span_b->low, span_a->low - 1, span_b->down) < 0) - HGOTO_ERROR(H5E_DATASPACE, H5E_CANTAPPEND, FAIL, "can't allocate hyperslab span") + if (need_b_not_a) + if (H5S__hyper_append_span(b_not_a, ndims, span_b->low, span_a->low - 1, + span_b->down) < 0) + HGOTO_ERROR(H5E_DATASPACE, H5E_CANTAPPEND, FAIL, + "can't allocate hyperslab span") } /* end if */ else { /* Keep going, nothing to split off */ @@ -7650,16 +7667,19 @@ H5S__hyper_clip_spans(H5S_hyper_span_info_t *a_spans, H5S_hyper_span_info_t *b_s /* Check for overlaps between span 'a' and midle of span 'b' */ /* Make certain both spans either have a down span or both don't have one */ - HDassert((span_a->down != NULL && span_b->down != NULL) || (span_a->down == NULL && span_b->down == NULL)); + HDassert((span_a->down != NULL && span_b->down != NULL) || + (span_a->down == NULL && span_b->down == NULL)); /* If there are no down spans, just add the overlapping area to the a_and_b list */ - if(span_a->down == NULL) { + if (span_a->down == NULL) { /* Merge/add overlapped part with/to a_and_b list */ - if(need_a_and_b) - if(H5S__hyper_append_span(a_and_b, ndims, span_a->low, span_a->high, NULL) < 0) - HGOTO_ERROR(H5E_DATASPACE, H5E_CANTAPPEND, FAIL, "can't allocate hyperslab span") + if (need_a_and_b) + if (H5S__hyper_append_span(a_and_b, ndims, span_a->low, span_a->high, NULL) < 0) + HGOTO_ERROR(H5E_DATASPACE, H5E_CANTAPPEND, FAIL, + "can't allocate hyperslab span") } /* end if */ - /* If there are down spans, check for the overlap in them and add to each appropriate list */ + /* If there are down spans, check for the overlap in them and add to each appropriate list + */ else { /* NULL out the temporary pointers to clipped areas in down spans */ down_a_not_b = NULL; @@ -7667,52 +7687,60 @@ H5S__hyper_clip_spans(H5S_hyper_span_info_t *a_spans, H5S_hyper_span_info_t *b_s down_b_not_a = NULL; /* Check for overlaps in the 'down spans' of span 'a' & 'b' */ - if(H5S__hyper_clip_spans(span_a->down, span_b->down, selector, ndims - 1, &down_a_not_b, &down_a_and_b, &down_b_not_a) < 0) + if (H5S__hyper_clip_spans(span_a->down, span_b->down, selector, ndims - 1, + &down_a_not_b, &down_a_and_b, &down_b_not_a) < 0) HGOTO_ERROR(H5E_DATASPACE, H5E_CANTCLIP, FAIL, "can't clip hyperslab information") /* Check for additions to the a_not_b list */ - if(down_a_not_b) { + if (down_a_not_b) { HDassert(need_a_not_b == TRUE); /* Merge/add overlapped part with/to a_not_b list */ - if(H5S__hyper_append_span(a_not_b, ndims, span_a->low, span_a->high, down_a_not_b) < 0) - HGOTO_ERROR(H5E_DATASPACE, H5E_CANTAPPEND, FAIL, "can't allocate hyperslab span") + if (H5S__hyper_append_span(a_not_b, ndims, span_a->low, span_a->high, + down_a_not_b) < 0) + HGOTO_ERROR(H5E_DATASPACE, H5E_CANTAPPEND, FAIL, + "can't allocate hyperslab span") /* Release the down span tree generated */ H5S__hyper_free_span_info(down_a_not_b); } /* end if */ /* Check for additions to the a_and_b list */ - if(down_a_and_b) { + if (down_a_and_b) { HDassert(need_a_and_b == TRUE); /* Merge/add overlapped part with/to a_and_b list */ - if(H5S__hyper_append_span(a_and_b, ndims, span_a->low, span_a->high, down_a_and_b) < 0) - HGOTO_ERROR(H5E_DATASPACE, H5E_CANTAPPEND, FAIL, "can't allocate hyperslab span") + if (H5S__hyper_append_span(a_and_b, ndims, span_a->low, span_a->high, + down_a_and_b) < 0) + HGOTO_ERROR(H5E_DATASPACE, H5E_CANTAPPEND, FAIL, + "can't allocate hyperslab span") /* Release the down span tree generated */ H5S__hyper_free_span_info(down_a_and_b); } /* end if */ /* Check for additions to the b_not_a list */ - if(down_b_not_a) { + if (down_b_not_a) { HDassert(need_b_not_a == TRUE); /* Merge/add overlapped part with/to b_not_a list */ - if(H5S__hyper_append_span(b_not_a, ndims, span_a->low, span_a->high, down_b_not_a) < 0) - HGOTO_ERROR(H5E_DATASPACE, H5E_CANTAPPEND, FAIL, "can't allocate hyperslab span") + if (H5S__hyper_append_span(b_not_a, ndims, span_a->low, span_a->high, + down_b_not_a) < 0) + HGOTO_ERROR(H5E_DATASPACE, H5E_CANTAPPEND, FAIL, + "can't allocate hyperslab span") /* Release the down span tree generated */ H5S__hyper_free_span_info(down_b_not_a); } /* end if */ - } /* end else */ + } /* end else */ /* Check if there is actually an upper part of span 'b' to split off */ - if(span_a->high < span_b->high) { + if (span_a->high < span_b->high) { /* Split off upper part of span 'b' at upper span of span 'a' */ /* Allocate new span node for upper part of spans 'a' */ - if(NULL == (tmp_span = H5S__hyper_new_span(span_a->high + 1, span_b->high, span_b->down, span_b->next))) + if (NULL == (tmp_span = H5S__hyper_new_span(span_a->high + 1, span_b->high, + span_b->down, span_b->next))) HGOTO_ERROR(H5E_DATASPACE, H5E_CANTALLOC, FAIL, "can't allocate hyperslab span") /* And advance span 'a' */ @@ -7727,21 +7755,24 @@ H5S__hyper_clip_spans(H5S_hyper_span_info_t *a_spans, H5S_hyper_span_info_t *b_s H5S_HYPER_ADVANCE_SPAN(recover_a, span_a, span_a->next); H5S_HYPER_ADVANCE_SPAN(recover_b, span_b, span_b->next); } /* end else */ - } /* end if */ + } /* end if */ /* Check if span 'a' overlaps only the upper bound */ /* of span 'b' */ /* AAAAAAAAAA */ /* <-----------------------------------> */ /* BBBBBBBBBB */ - else if((span_a->low >= span_b->low && span_a->low <= span_b->high) && span_a->high > span_b->high) { + else if ((span_a->low >= span_b->low && span_a->low <= span_b->high) && + span_a->high > span_b->high) { /* Check if there is actually a lower part of span 'b' to split off */ - if(span_a->low > span_b->low) { + if (span_a->low > span_b->low) { /* Split off lower part of span 'b' at lower span of span 'a' */ /* Merge/add lower part of span 'b' with/to b_not_a list */ - if(need_b_not_a) - if(H5S__hyper_append_span(b_not_a, ndims, span_b->low, span_a->low - 1, span_b->down) < 0) - HGOTO_ERROR(H5E_DATASPACE, H5E_CANTAPPEND, FAIL, "can't allocate hyperslab span") + if (need_b_not_a) + if (H5S__hyper_append_span(b_not_a, ndims, span_b->low, span_a->low - 1, + span_b->down) < 0) + HGOTO_ERROR(H5E_DATASPACE, H5E_CANTAPPEND, FAIL, + "can't allocate hyperslab span") } /* end if */ else { /* Keep going, nothing to split off */ @@ -7750,16 +7781,19 @@ H5S__hyper_clip_spans(H5S_hyper_span_info_t *a_spans, H5S_hyper_span_info_t *b_s /* Check for overlaps between lower part of span 'a' and upper part of span 'b' */ /* Make certain both spans either have a down span or both don't have one */ - HDassert((span_a->down != NULL && span_b->down != NULL) || (span_a->down == NULL && span_b->down == NULL)); + HDassert((span_a->down != NULL && span_b->down != NULL) || + (span_a->down == NULL && span_b->down == NULL)); /* If there are no down spans, just add the overlapping area to the a_and_b list */ - if(span_a->down == NULL) { + if (span_a->down == NULL) { /* Merge/add overlapped part with/to a_and_b list */ - if(need_a_and_b) - if(H5S__hyper_append_span(a_and_b, ndims, span_a->low, span_b->high, NULL) < 0) - HGOTO_ERROR(H5E_DATASPACE, H5E_CANTAPPEND, FAIL, "can't allocate hyperslab span") + if (need_a_and_b) + if (H5S__hyper_append_span(a_and_b, ndims, span_a->low, span_b->high, NULL) < 0) + HGOTO_ERROR(H5E_DATASPACE, H5E_CANTAPPEND, FAIL, + "can't allocate hyperslab span") } /* end if */ - /* If there are down spans, check for the overlap in them and add to each appropriate list */ + /* If there are down spans, check for the overlap in them and add to each appropriate list + */ else { /* NULL out the temporary pointers to clipped areas in down spans */ down_a_not_b = NULL; @@ -7767,50 +7801,58 @@ H5S__hyper_clip_spans(H5S_hyper_span_info_t *a_spans, H5S_hyper_span_info_t *b_s down_b_not_a = NULL; /* Check for overlaps in the 'down spans' of span 'a' & 'b' */ - if(H5S__hyper_clip_spans(span_a->down, span_b->down, selector, ndims - 1, &down_a_not_b, &down_a_and_b, &down_b_not_a) < 0) + if (H5S__hyper_clip_spans(span_a->down, span_b->down, selector, ndims - 1, + &down_a_not_b, &down_a_and_b, &down_b_not_a) < 0) HGOTO_ERROR(H5E_DATASPACE, H5E_CANTCLIP, FAIL, "can't clip hyperslab information") /* Check for additions to the a_not_b list */ - if(down_a_not_b) { + if (down_a_not_b) { HDassert(need_a_not_b == TRUE); /* Merge/add overlapped part with/to a_not_b list */ - if(H5S__hyper_append_span(a_not_b, ndims, span_a->low, span_b->high, down_a_not_b) < 0) - HGOTO_ERROR(H5E_DATASPACE, H5E_CANTAPPEND, FAIL, "can't allocate hyperslab span") + if (H5S__hyper_append_span(a_not_b, ndims, span_a->low, span_b->high, + down_a_not_b) < 0) + HGOTO_ERROR(H5E_DATASPACE, H5E_CANTAPPEND, FAIL, + "can't allocate hyperslab span") /* Release the down span tree generated */ H5S__hyper_free_span_info(down_a_not_b); } /* end if */ /* Check for additions to the a_and_b list */ - if(down_a_and_b) { + if (down_a_and_b) { HDassert(need_a_and_b == TRUE); /* Merge/add overlapped part with/to a_and_b list */ - if(H5S__hyper_append_span(a_and_b, ndims, span_a->low, span_b->high, down_a_and_b) < 0) - HGOTO_ERROR(H5E_DATASPACE, H5E_CANTAPPEND, FAIL, "can't allocate hyperslab span") + if (H5S__hyper_append_span(a_and_b, ndims, span_a->low, span_b->high, + down_a_and_b) < 0) + HGOTO_ERROR(H5E_DATASPACE, H5E_CANTAPPEND, FAIL, + "can't allocate hyperslab span") /* Release the down span tree generated */ H5S__hyper_free_span_info(down_a_and_b); } /* end if */ /* Check for additions to the b_not_a list */ - if(down_b_not_a) { + if (down_b_not_a) { HDassert(need_b_not_a == TRUE); /* Merge/add overlapped part with/to b_not_a list */ - if(H5S__hyper_append_span(b_not_a, ndims, span_a->low, span_b->high, down_b_not_a) < 0) - HGOTO_ERROR(H5E_DATASPACE, H5E_CANTAPPEND, FAIL, "can't allocate hyperslab span") + if (H5S__hyper_append_span(b_not_a, ndims, span_a->low, span_b->high, + down_b_not_a) < 0) + HGOTO_ERROR(H5E_DATASPACE, H5E_CANTAPPEND, FAIL, + "can't allocate hyperslab span") /* Release the down span tree generated */ H5S__hyper_free_span_info(down_b_not_a); } /* end if */ - } /* end else */ + } /* end else */ /* Split off upper part of span 'a' at upper span of span 'b' */ /* Allocate new span node for upper part of span 'a' */ - if(NULL == (tmp_span = H5S__hyper_new_span(span_b->high + 1, span_a->high, span_a->down, span_a->next))) + if (NULL == (tmp_span = H5S__hyper_new_span(span_b->high + 1, span_a->high, span_a->down, + span_a->next))) HGOTO_ERROR(H5E_DATASPACE, H5E_CANTALLOC, FAIL, "can't allocate hyperslab span") /* Make upper part of span 'a' into new span 'a' */ @@ -7828,19 +7870,20 @@ H5S__hyper_clip_spans(H5S_hyper_span_info_t *a_spans, H5S_hyper_span_info_t *b_s /* Copy span 'b' and add to b_not_a list */ /* Merge/add span 'b' with/to b_not_a list */ - if(need_b_not_a) - if(H5S__hyper_append_span(b_not_a, ndims, span_b->low, span_b->high, span_b->down) < 0) + if (need_b_not_a) + if (H5S__hyper_append_span(b_not_a, ndims, span_b->low, span_b->high, span_b->down) < + 0) HGOTO_ERROR(H5E_DATASPACE, H5E_CANTAPPEND, FAIL, "can't allocate hyperslab span") /* Advance span 'b', leave span 'a' */ H5S_HYPER_ADVANCE_SPAN(recover_b, span_b, span_b->next); } /* end else */ - } /* end while */ + } /* end while */ /* Clean up 'a' spans which haven't been covered yet */ - if(span_a != NULL && span_b == NULL) { + if (span_a != NULL && span_b == NULL) { /* Check if need to merge/add 'a' spans with/to a_not_b list */ - if(need_a_not_b) { + if (need_a_not_b) { /* (This loop, and the similar one below for 'b' spans, * could be replaced with an optimized routine that quickly * appended the remaining spans to the 'not' list, but @@ -7848,25 +7891,26 @@ H5S__hyper_clip_spans(H5S_hyper_span_info_t *a_spans, H5S_hyper_span_info_t *b_s * important use case, it's been left generic, and similar * to other code above. -QAK, 2019/02/01) */ - while(span_a != NULL) { + while (span_a != NULL) { /* Copy span 'a' and add to a_not_b list */ - if(H5S__hyper_append_span(a_not_b, ndims, span_a->low, span_a->high, span_a->down) < 0) + if (H5S__hyper_append_span(a_not_b, ndims, span_a->low, span_a->high, span_a->down) < + 0) HGOTO_ERROR(H5E_DATASPACE, H5E_CANTAPPEND, FAIL, "can't allocate hyperslab span") /* Advance to the next 'a' span */ H5S_HYPER_ADVANCE_SPAN(recover_a, span_a, span_a->next); } /* end while */ - } /* end if */ + } /* end if */ else { /* Free the span, if it's generated */ - if(recover_a) + if (recover_a) H5S__hyper_free_span(span_a); } /* end else */ - } /* end if */ + } /* end if */ /* Clean up 'b' spans which haven't been covered yet */ - else if(span_a == NULL && span_b != NULL) { + else if (span_a == NULL && span_b != NULL) { /* Check if need to merge/add 'b' spans with/to b_not_a list */ - if(need_b_not_a) { + if (need_b_not_a) { /* (This loop, and the similar one above for 'a' spans, * could be replaced with an optimized routine that quickly * appended the remaining spans to the 'not' list, but @@ -7874,32 +7918,32 @@ H5S__hyper_clip_spans(H5S_hyper_span_info_t *a_spans, H5S_hyper_span_info_t *b_s * important use case, it's been left generic, and similar * to other code above. -QAK, 2019/02/01) */ - while(span_b != NULL) { + while (span_b != NULL) { /* Copy span 'b' and add to b_not_a list */ - if(H5S__hyper_append_span(b_not_a, ndims, span_b->low, span_b->high, span_b->down) < 0) + if (H5S__hyper_append_span(b_not_a, ndims, span_b->low, span_b->high, span_b->down) < + 0) HGOTO_ERROR(H5E_DATASPACE, H5E_CANTAPPEND, FAIL, "can't allocate hyperslab span") /* Advance to the next 'b' span */ H5S_HYPER_ADVANCE_SPAN(recover_b, span_b, span_b->next); } /* end while */ - } /* end if */ + } /* end if */ else { /* Free the span, if it's generated */ - if(recover_b) + if (recover_b) H5S__hyper_free_span(span_b); } /* end else */ - } /* end if */ + } /* end if */ else /* Sanity check */ HDassert(span_a == NULL && span_b == NULL); } /* end else */ - } /* end else */ + } /* end else */ done: FUNC_LEAVE_NOAPI(ret_value) } /* end H5S__hyper_clip_spans() */ - /*-------------------------------------------------------------------------- NAME H5S__hyper_merge_spans_helper @@ -7924,11 +7968,10 @@ done: REVISION LOG --------------------------------------------------------------------------*/ static H5S_hyper_span_info_t * -H5S__hyper_merge_spans_helper(H5S_hyper_span_info_t *a_spans, H5S_hyper_span_info_t *b_spans, - unsigned ndims) +H5S__hyper_merge_spans_helper(H5S_hyper_span_info_t *a_spans, H5S_hyper_span_info_t *b_spans, unsigned ndims) { H5S_hyper_span_info_t *merged_spans = NULL; /* Pointer to the merged span tree */ - H5S_hyper_span_info_t *ret_value = NULL; /* Return value */ + H5S_hyper_span_info_t *ret_value = NULL; /* Return value */ FUNC_ENTER_STATIC @@ -7936,19 +7979,19 @@ H5S__hyper_merge_spans_helper(H5S_hyper_span_info_t *a_spans, H5S_hyper_span_inf HDassert((a_spans != NULL && b_spans != NULL) || (a_spans == NULL && b_spans == NULL)); /* Check if the span trees for the 'a' span and the 'b' span are the same */ - if(H5S__hyper_cmp_spans(a_spans, b_spans)) { - if(a_spans == NULL) + if (H5S__hyper_cmp_spans(a_spans, b_spans)) { + if (a_spans == NULL) merged_spans = NULL; else { /* Copy one of the span trees to return */ - if(NULL == (merged_spans = H5S__hyper_copy_span(a_spans, ndims))) + if (NULL == (merged_spans = H5S__hyper_copy_span(a_spans, ndims))) HGOTO_ERROR(H5E_INTERNAL, H5E_CANTCOPY, NULL, "can't copy hyperslab span tree") } /* end else */ - } /* end if */ + } /* end if */ else { - H5S_hyper_span_t *span_a; /* Pointer to current span 'a' working on */ - H5S_hyper_span_t *span_b; /* Pointer to current span 'b' working on */ - hbool_t recover_a, recover_b; /* Flags to indicate when to recover temporary spans */ + H5S_hyper_span_t *span_a; /* Pointer to current span 'a' working on */ + H5S_hyper_span_t *span_b; /* Pointer to current span 'b' working on */ + hbool_t recover_a, recover_b; /* Flags to indicate when to recover temporary spans */ /* Get the pointers to the 'a' and 'b' span lists */ span_a = a_spans->head; @@ -7958,17 +8001,17 @@ H5S__hyper_merge_spans_helper(H5S_hyper_span_info_t *a_spans, H5S_hyper_span_inf recover_a = recover_b = FALSE; /* Work through the list of spans in the new list */ - while(span_a != NULL && span_b != NULL) { - H5S_hyper_span_info_t *tmp_spans; /* Pointer to temporary new span tree */ - H5S_hyper_span_t *tmp_span; /* Pointer to temporary new span */ + while (span_a != NULL && span_b != NULL) { + H5S_hyper_span_info_t *tmp_spans; /* Pointer to temporary new span tree */ + H5S_hyper_span_t * tmp_span; /* Pointer to temporary new span */ /* Check if the 'a' span is completely before 'b' span */ /* AAAAAAA */ /* <-----------------------------------> */ /* BBBBBBBBBB */ - if(span_a->high < span_b->low) { + if (span_a->high < span_b->low) { /* Merge/add span 'a' with/to the merged spans */ - if(H5S__hyper_append_span(&merged_spans, ndims, span_a->low, span_a->high, span_a->down) < 0) + if (H5S__hyper_append_span(&merged_spans, ndims, span_a->low, span_a->high, span_a->down) < 0) HGOTO_ERROR(H5E_DATASPACE, H5E_CANTAPPEND, NULL, "can't allocate hyperslab span") /* Advance span 'a' */ @@ -7979,23 +8022,27 @@ H5S__hyper_merge_spans_helper(H5S_hyper_span_info_t *a_spans, H5S_hyper_span_inf /* AAAAAAAAAAAA */ /* <-----------------------------------> */ /* BBBBBBBBBB */ - else if(span_a->low < span_b->low && (span_a->high >= span_b->low && span_a->high <= span_b->high)) { + else if (span_a->low < span_b->low && + (span_a->high >= span_b->low && span_a->high <= span_b->high)) { /* Check if span 'a' and span 'b' down spans are equal */ - if(H5S__hyper_cmp_spans(span_a->down, span_b->down)) { + if (H5S__hyper_cmp_spans(span_a->down, span_b->down)) { /* Merge/add copy of span 'a' with/to merged spans */ - if(H5S__hyper_append_span(&merged_spans, ndims, span_a->low, span_a->high, span_a->down) < 0) + if (H5S__hyper_append_span(&merged_spans, ndims, span_a->low, span_a->high, + span_a->down) < 0) HGOTO_ERROR(H5E_DATASPACE, H5E_CANTAPPEND, NULL, "can't allocate hyperslab span") } /* end if */ else { /* Merge/add lower part of span 'a' with/to merged spans */ - if(H5S__hyper_append_span(&merged_spans, ndims, span_a->low, span_b->low - 1, span_a->down) < 0) + if (H5S__hyper_append_span(&merged_spans, ndims, span_a->low, span_b->low - 1, + span_a->down) < 0) HGOTO_ERROR(H5E_DATASPACE, H5E_CANTAPPEND, NULL, "can't allocate hyperslab span") /* Get merged span tree for overlapped section */ tmp_spans = H5S__hyper_merge_spans_helper(span_a->down, span_b->down, ndims - 1); /* Merge/add overlapped section to merged spans */ - if(H5S__hyper_append_span(&merged_spans, ndims, span_b->low, span_a->high, tmp_spans) < 0) + if (H5S__hyper_append_span(&merged_spans, ndims, span_b->low, span_a->high, tmp_spans) < + 0) HGOTO_ERROR(H5E_DATASPACE, H5E_CANTAPPEND, NULL, "can't allocate hyperslab span") /* Release merged span tree for overlapped section */ @@ -8003,11 +8050,12 @@ H5S__hyper_merge_spans_helper(H5S_hyper_span_info_t *a_spans, H5S_hyper_span_inf } /* end else */ /* Check if there is an upper part of span 'b' */ - if(span_a->high < span_b->high) { + if (span_a->high < span_b->high) { /* Copy upper part of span 'b' as new span 'b' */ /* Allocate new span node to append to list */ - if(NULL == (tmp_span = H5S__hyper_new_span(span_a->high + 1, span_b->high, span_b->down, span_b->next))) + if (NULL == (tmp_span = H5S__hyper_new_span(span_a->high + 1, span_b->high, span_b->down, + span_b->next))) HGOTO_ERROR(H5E_DATASPACE, H5E_CANTALLOC, NULL, "can't allocate hyperslab span") /* Advance span 'a' */ @@ -8022,29 +8070,32 @@ H5S__hyper_merge_spans_helper(H5S_hyper_span_info_t *a_spans, H5S_hyper_span_inf H5S_HYPER_ADVANCE_SPAN(recover_a, span_a, span_a->next); H5S_HYPER_ADVANCE_SPAN(recover_b, span_b, span_b->next); } /* end else */ - } /* end if */ + } /* end if */ /* Check if span 'a' overlaps the lower & upper bound */ /* of span 'b' */ /* AAAAAAAAAAAAAAAAAAAAA */ /* <-----------------------------------> */ /* BBBBBBBBBB */ - else if(span_a->low < span_b->low && span_a->high > span_b->high) { + else if (span_a->low < span_b->low && span_a->high > span_b->high) { /* Check if span 'a' and span 'b' down spans are equal */ - if(H5S__hyper_cmp_spans(span_a->down, span_b->down)) { + if (H5S__hyper_cmp_spans(span_a->down, span_b->down)) { /* Merge/add copy of lower & middle parts of span 'a' to merged spans */ - if(H5S__hyper_append_span(&merged_spans, ndims, span_a->low, span_b->high, span_a->down) < 0) + if (H5S__hyper_append_span(&merged_spans, ndims, span_a->low, span_b->high, + span_a->down) < 0) HGOTO_ERROR(H5E_DATASPACE, H5E_CANTAPPEND, NULL, "can't allocate hyperslab span") } /* end if */ else { /* Merge/add lower part of span 'a' to merged spans */ - if(H5S__hyper_append_span(&merged_spans, ndims, span_a->low, span_b->low - 1, span_a->down) < 0) + if (H5S__hyper_append_span(&merged_spans, ndims, span_a->low, span_b->low - 1, + span_a->down) < 0) HGOTO_ERROR(H5E_DATASPACE, H5E_CANTAPPEND, NULL, "can't allocate hyperslab span") /* Get merged span tree for overlapped section */ tmp_spans = H5S__hyper_merge_spans_helper(span_a->down, span_b->down, ndims - 1); /* Merge/add overlapped section to merged spans */ - if(H5S__hyper_append_span(&merged_spans, ndims, span_b->low, span_b->high, tmp_spans) < 0) + if (H5S__hyper_append_span(&merged_spans, ndims, span_b->low, span_b->high, tmp_spans) < + 0) HGOTO_ERROR(H5E_DATASPACE, H5E_CANTAPPEND, NULL, "can't allocate hyperslab span") /* Release merged span tree for overlapped section */ @@ -8054,7 +8105,8 @@ H5S__hyper_merge_spans_helper(H5S_hyper_span_info_t *a_spans, H5S_hyper_span_inf /* Copy upper part of span 'a' as new span 'a' (remember to free) */ /* Allocate new span node to append to list */ - if(NULL == (tmp_span = H5S__hyper_new_span(span_b->high + 1, span_a->high, span_a->down, span_a->next))) + if (NULL == (tmp_span = H5S__hyper_new_span(span_b->high + 1, span_a->high, span_a->down, + span_a->next))) HGOTO_ERROR(H5E_DATASPACE, H5E_CANTALLOC, NULL, "can't allocate hyperslab span") /* Set new span 'a' to tmp_span */ @@ -8068,18 +8120,20 @@ H5S__hyper_merge_spans_helper(H5S_hyper_span_info_t *a_spans, H5S_hyper_span_inf /* AAAAA */ /* <-----------------------------------> */ /* BBBBBBBBBB */ - else if(span_a->low >= span_b->low && span_a->high <= span_b->high) { + else if (span_a->low >= span_b->low && span_a->high <= span_b->high) { /* Check if span 'a' and span 'b' down spans are equal */ - if(H5S__hyper_cmp_spans(span_a->down, span_b->down)) { + if (H5S__hyper_cmp_spans(span_a->down, span_b->down)) { /* Merge/add copy of lower & middle parts of span 'b' to merged spans */ - if(H5S__hyper_append_span(&merged_spans, ndims, span_b->low, span_a->high, span_a->down) < 0) + if (H5S__hyper_append_span(&merged_spans, ndims, span_b->low, span_a->high, + span_a->down) < 0) HGOTO_ERROR(H5E_DATASPACE, H5E_CANTAPPEND, NULL, "can't allocate hyperslab span") } /* end if */ else { /* Check if there is a lower part of span 'b' */ - if(span_a->low > span_b->low) { + if (span_a->low > span_b->low) { /* Merge/add lower part of span 'b' to merged spans */ - if(H5S__hyper_append_span(&merged_spans, ndims, span_b->low, span_a->low - 1, span_b->down) < 0) + if (H5S__hyper_append_span(&merged_spans, ndims, span_b->low, span_a->low - 1, + span_b->down) < 0) HGOTO_ERROR(H5E_DATASPACE, H5E_CANTAPPEND, NULL, "can't allocate hyperslab span") } /* end if */ else { @@ -8090,7 +8144,8 @@ H5S__hyper_merge_spans_helper(H5S_hyper_span_info_t *a_spans, H5S_hyper_span_inf tmp_spans = H5S__hyper_merge_spans_helper(span_a->down, span_b->down, ndims - 1); /* Merge/add overlapped section to merged spans */ - if(H5S__hyper_append_span(&merged_spans, ndims, span_a->low, span_a->high, tmp_spans) < 0) + if (H5S__hyper_append_span(&merged_spans, ndims, span_a->low, span_a->high, tmp_spans) < + 0) HGOTO_ERROR(H5E_DATASPACE, H5E_CANTAPPEND, NULL, "can't allocate hyperslab span") /* Release merged span tree for overlapped section */ @@ -8098,11 +8153,12 @@ H5S__hyper_merge_spans_helper(H5S_hyper_span_info_t *a_spans, H5S_hyper_span_inf } /* end else */ /* Check if there is an upper part of span 'b' */ - if(span_a->high < span_b->high) { + if (span_a->high < span_b->high) { /* Copy upper part of span 'b' as new span 'b' (remember to free) */ /* Allocate new span node to append to list */ - if(NULL == (tmp_span = H5S__hyper_new_span(span_a->high + 1, span_b->high, span_b->down, span_b->next))) + if (NULL == (tmp_span = H5S__hyper_new_span(span_a->high + 1, span_b->high, span_b->down, + span_b->next))) HGOTO_ERROR(H5E_DATASPACE, H5E_CANTALLOC, NULL, "can't allocate hyperslab span") /* Advance span 'a' */ @@ -8117,24 +8173,27 @@ H5S__hyper_merge_spans_helper(H5S_hyper_span_info_t *a_spans, H5S_hyper_span_inf H5S_HYPER_ADVANCE_SPAN(recover_a, span_a, span_a->next); H5S_HYPER_ADVANCE_SPAN(recover_b, span_b, span_b->next); } /* end else */ - } /* end if */ + } /* end if */ /* Check if span 'a' overlaps only the upper bound */ /* of span 'b' */ /* AAAAAAAAAA */ /* <-----------------------------------> */ /* BBBBBBBBBB */ - else if((span_a->low >= span_b->low && span_a->low <= span_b->high) && span_a->high > span_b->high) { + else if ((span_a->low >= span_b->low && span_a->low <= span_b->high) && + span_a->high > span_b->high) { /* Check if span 'a' and span 'b' down spans are equal */ - if(H5S__hyper_cmp_spans(span_a->down, span_b->down)) { + if (H5S__hyper_cmp_spans(span_a->down, span_b->down)) { /* Merge/add copy of span 'b' to merged spans if so */ - if(H5S__hyper_append_span(&merged_spans, ndims, span_b->low, span_b->high, span_b->down) < 0) + if (H5S__hyper_append_span(&merged_spans, ndims, span_b->low, span_b->high, + span_b->down) < 0) HGOTO_ERROR(H5E_DATASPACE, H5E_CANTAPPEND, NULL, "can't allocate hyperslab span") } /* end if */ else { /* Check if there is a lower part of span 'b' */ - if(span_a->low > span_b->low) { + if (span_a->low > span_b->low) { /* Merge/add lower part of span 'b' to merged spans */ - if(H5S__hyper_append_span(&merged_spans, ndims, span_b->low, span_a->low - 1, span_b->down) < 0) + if (H5S__hyper_append_span(&merged_spans, ndims, span_b->low, span_a->low - 1, + span_b->down) < 0) HGOTO_ERROR(H5E_DATASPACE, H5E_CANTAPPEND, NULL, "can't allocate hyperslab span") } /* end if */ else { @@ -8145,7 +8204,8 @@ H5S__hyper_merge_spans_helper(H5S_hyper_span_info_t *a_spans, H5S_hyper_span_inf tmp_spans = H5S__hyper_merge_spans_helper(span_a->down, span_b->down, ndims - 1); /* Merge/add overlapped section to merged spans */ - if(H5S__hyper_append_span(&merged_spans, ndims, span_a->low, span_b->high, tmp_spans) < 0) + if (H5S__hyper_append_span(&merged_spans, ndims, span_a->low, span_b->high, tmp_spans) < + 0) HGOTO_ERROR(H5E_DATASPACE, H5E_CANTAPPEND, NULL, "can't allocate hyperslab span") /* Release merged span tree for overlapped section */ @@ -8155,7 +8215,8 @@ H5S__hyper_merge_spans_helper(H5S_hyper_span_info_t *a_spans, H5S_hyper_span_inf /* Copy upper part of span 'a' as new span 'a' */ /* Allocate new span node to append to list */ - if(NULL == (tmp_span = H5S__hyper_new_span(span_b->high + 1, span_a->high, span_a->down, span_a->next))) + if (NULL == (tmp_span = H5S__hyper_new_span(span_b->high + 1, span_a->high, span_a->down, + span_a->next))) HGOTO_ERROR(H5E_DATASPACE, H5E_CANTALLOC, NULL, "can't allocate hyperslab span") /* Set new span 'a' to tmp_span */ @@ -8171,51 +8232,50 @@ H5S__hyper_merge_spans_helper(H5S_hyper_span_info_t *a_spans, H5S_hyper_span_inf /* BBBBBBBBBB */ else { /* Merge/add span 'b' with the merged spans */ - if(H5S__hyper_append_span(&merged_spans, ndims, span_b->low, span_b->high, span_b->down) < 0) + if (H5S__hyper_append_span(&merged_spans, ndims, span_b->low, span_b->high, span_b->down) < 0) HGOTO_ERROR(H5E_DATASPACE, H5E_CANTAPPEND, NULL, "can't allocate hyperslab span") /* Advance span 'b' */ H5S_HYPER_ADVANCE_SPAN(recover_b, span_b, span_b->next); } /* end else */ - } /* end while */ + } /* end while */ /* Clean up 'a' spans which haven't been added to the list of merged spans */ - if(span_a != NULL && span_b == NULL) { - while(span_a != NULL) { + if (span_a != NULL && span_b == NULL) { + while (span_a != NULL) { /* Merge/add all 'a' spans into the merged spans */ - if(H5S__hyper_append_span(&merged_spans, ndims, span_a->low, span_a->high, span_a->down) < 0) + if (H5S__hyper_append_span(&merged_spans, ndims, span_a->low, span_a->high, span_a->down) < 0) HGOTO_ERROR(H5E_DATASPACE, H5E_CANTAPPEND, NULL, "can't allocate hyperslab span") /* Advance to next 'a' span, until all processed */ H5S_HYPER_ADVANCE_SPAN(recover_a, span_a, span_a->next); } /* end while */ - } /* end if */ + } /* end if */ /* Clean up 'b' spans which haven't been added to the list of merged spans */ - if(span_a == NULL && span_b != NULL) { - while(span_b != NULL) { + if (span_a == NULL && span_b != NULL) { + while (span_b != NULL) { /* Merge/add all 'b' spans into the merged spans */ - if(H5S__hyper_append_span(&merged_spans, ndims, span_b->low, span_b->high, span_b->down) < 0) + if (H5S__hyper_append_span(&merged_spans, ndims, span_b->low, span_b->high, span_b->down) < 0) HGOTO_ERROR(H5E_DATASPACE, H5E_CANTAPPEND, NULL, "can't allocate hyperslab span") /* Advance to next 'b' span, until all processed */ H5S_HYPER_ADVANCE_SPAN(recover_b, span_b, span_b->next); } /* end while */ - } /* end if */ - } /* end else */ + } /* end if */ + } /* end else */ /* Set return value */ ret_value = merged_spans; done: - if(ret_value == NULL) - if(merged_spans) + if (ret_value == NULL) + if (merged_spans) H5S__hyper_free_span_info(merged_spans); FUNC_LEAVE_NOAPI(ret_value) } /* end H5S__hyper_merge_spans_helper() */ - /*-------------------------------------------------------------------------- NAME H5S__hyper_merge_spans @@ -8239,7 +8299,7 @@ done: static herr_t H5S__hyper_merge_spans(H5S_t *space, H5S_hyper_span_info_t *new_spans) { - herr_t ret_value = SUCCEED; /* Return value */ + herr_t ret_value = SUCCEED; /* Return value */ FUNC_ENTER_STATIC @@ -8248,7 +8308,7 @@ H5S__hyper_merge_spans(H5S_t *space, H5S_hyper_span_info_t *new_spans) HDassert(new_spans); /* If this is the first span tree in the hyperslab selection, just use it */ - if(space->select.sel_info.hslab->span_lst == NULL) { + if (space->select.sel_info.hslab->span_lst == NULL) { space->select.sel_info.hslab->span_lst = new_spans; space->select.sel_info.hslab->span_lst->count++; } /* end if */ @@ -8256,7 +8316,8 @@ H5S__hyper_merge_spans(H5S_t *space, H5S_hyper_span_info_t *new_spans) H5S_hyper_span_info_t *merged_spans; /* Get the merged spans */ - if(NULL == (merged_spans = H5S__hyper_merge_spans_helper(space->select.sel_info.hslab->span_lst, new_spans, space->extent.rank))) + if (NULL == (merged_spans = H5S__hyper_merge_spans_helper(space->select.sel_info.hslab->span_lst, + new_spans, space->extent.rank))) HGOTO_ERROR(H5E_DATASPACE, H5E_CANTMERGE, FAIL, "can't merge hyperslab spans") /* Free the previous spans */ @@ -8270,7 +8331,6 @@ done: FUNC_LEAVE_NOAPI(ret_value) } /* end H5S__hyper_merge_spans() */ - /*-------------------------------------------------------------------------- NAME H5S__hyper_spans_nelem_helper @@ -8291,10 +8351,9 @@ done: REVISION LOG --------------------------------------------------------------------------*/ static hsize_t -H5S__hyper_spans_nelem_helper(H5S_hyper_span_info_t *spans, unsigned op_info_i, - uint64_t op_gen) +H5S__hyper_spans_nelem_helper(H5S_hyper_span_info_t *spans, unsigned op_info_i, uint64_t op_gen) { - hsize_t ret_value = 0; /* Return value */ + hsize_t ret_value = 0; /* Return value */ FUNC_ENTER_STATIC_NOERR @@ -8302,25 +8361,25 @@ H5S__hyper_spans_nelem_helper(H5S_hyper_span_info_t *spans, unsigned op_info_i, HDassert(spans); /* Check if the span tree was already counted */ - if(spans->op_info[op_info_i].op_gen == op_gen) + if (spans->op_info[op_info_i].op_gen == op_gen) /* Just return the # of elements in the already counted span tree */ ret_value = spans->op_info[op_info_i].u.nelmts; - else { /* Count the number of elements in the span tree */ - const H5S_hyper_span_t *span; /* Hyperslab span */ + else { /* Count the number of elements in the span tree */ + const H5S_hyper_span_t *span; /* Hyperslab span */ span = spans->head; - if(NULL == span->down) { - while(span != NULL) { + if (NULL == span->down) { + while (span != NULL) { /* Compute # of elements covered */ ret_value += (span->high - span->low) + 1; /* Advance to next span */ span = span->next; } /* end while */ - } /* end if */ + } /* end if */ else { - while(span != NULL) { - hsize_t nelmts; /* # of elements covered by current span */ + while (span != NULL) { + hsize_t nelmts; /* # of elements covered by current span */ /* Compute # of elements covered */ nelmts = (span->high - span->low) + 1; @@ -8331,7 +8390,7 @@ H5S__hyper_spans_nelem_helper(H5S_hyper_span_info_t *spans, unsigned op_info_i, /* Advance to next span */ span = span->next; } /* end while */ - } /* end else */ + } /* end else */ /* Set the operation generation for this span tree, to avoid re-computing */ spans->op_info[op_info_i].op_gen = op_gen; @@ -8343,7 +8402,6 @@ H5S__hyper_spans_nelem_helper(H5S_hyper_span_info_t *spans, unsigned op_info_i, FUNC_LEAVE_NOAPI(ret_value) } /* end H5S__hyper_spans_nelem_helper() */ - /*-------------------------------------------------------------------------- NAME H5S__hyper_spans_nelem @@ -8364,8 +8422,8 @@ H5S__hyper_spans_nelem_helper(H5S_hyper_span_info_t *spans, unsigned op_info_i, static hsize_t H5S__hyper_spans_nelem(H5S_hyper_span_info_t *spans) { - uint64_t op_gen; /* Operation generation value */ - hsize_t ret_value = 0; /* Return value */ + uint64_t op_gen; /* Operation generation value */ + hsize_t ret_value = 0; /* Return value */ FUNC_ENTER_STATIC_NOERR @@ -8383,7 +8441,6 @@ H5S__hyper_spans_nelem(H5S_hyper_span_info_t *spans) FUNC_LEAVE_NOAPI(ret_value) } /* end H5S__hyper_spans_nelem() */ - /*-------------------------------------------------------------------------- NAME H5S__hyper_add_disjoint_spans @@ -8410,7 +8467,7 @@ H5S__hyper_spans_nelem(H5S_hyper_span_info_t *spans) static herr_t H5S__hyper_add_disjoint_spans(H5S_t *space, H5S_hyper_span_info_t *new_spans) { - herr_t ret_value = SUCCEED; /* Return value */ + herr_t ret_value = SUCCEED; /* Return value */ FUNC_ENTER_STATIC @@ -8422,7 +8479,7 @@ H5S__hyper_add_disjoint_spans(H5S_t *space, H5S_hyper_span_info_t *new_spans) space->select.num_elem += H5S__hyper_spans_nelem(new_spans); /* Add the new spans to the existing selection in the dataspace */ - if(H5S__hyper_merge_spans(space, new_spans) < 0) + if (H5S__hyper_merge_spans(space, new_spans) < 0) HGOTO_ERROR(H5E_DATASPACE, H5E_CANTINSERT, FAIL, "can't merge hyperslabs") /* Free the memory space for new spans */ @@ -8432,7 +8489,6 @@ done: FUNC_LEAVE_NOAPI(ret_value) } /* end H5S__hyper_add_disjoint_spans */ - /*-------------------------------------------------------------------------- NAME H5S__hyper_make_spans @@ -8459,14 +8515,14 @@ done: REVISION LOG --------------------------------------------------------------------------*/ static H5S_hyper_span_info_t * -H5S__hyper_make_spans(unsigned rank, const hsize_t *start, const hsize_t *stride, - const hsize_t *count, const hsize_t *block) +H5S__hyper_make_spans(unsigned rank, const hsize_t *start, const hsize_t *stride, const hsize_t *count, + const hsize_t *block) { - H5S_hyper_span_info_t *down = NULL; /* Pointer to spans in next dimension down */ - H5S_hyper_span_t *last_span; /* Current position in hyperslab span list */ - H5S_hyper_span_t *head = NULL; /* Head of new hyperslab span list */ - int i; /* Counters */ - H5S_hyper_span_info_t *ret_value = NULL; /* Return value */ + H5S_hyper_span_info_t *down = NULL; /* Pointer to spans in next dimension down */ + H5S_hyper_span_t * last_span; /* Current position in hyperslab span list */ + H5S_hyper_span_t * head = NULL; /* Head of new hyperslab span list */ + int i; /* Counters */ + H5S_hyper_span_info_t *ret_value = NULL; /* Return value */ FUNC_ENTER_STATIC @@ -8478,32 +8534,32 @@ H5S__hyper_make_spans(unsigned rank, const hsize_t *start, const hsize_t *stride HDassert(block); /* Start creating spans in fastest changing dimension */ - for(i = (int)(rank - 1); i >= 0; i--) { - hsize_t curr_low, curr_high; /* Current low & high values */ - hsize_t dim_stride; /* Current dim's stride */ - unsigned u; /* Local index variable */ + for (i = (int)(rank - 1); i >= 0; i--) { + hsize_t curr_low, curr_high; /* Current low & high values */ + hsize_t dim_stride; /* Current dim's stride */ + unsigned u; /* Local index variable */ /* Sanity check */ - if(0 == count[i]) + if (0 == count[i]) HGOTO_ERROR(H5E_DATASPACE, H5E_BADVALUE, NULL, "count == 0 is invalid") /* Start a new list in this dimension */ - head = NULL; + head = NULL; last_span = NULL; /* Generate all the span segments for this dimension */ - curr_low = start[i]; - curr_high = start[i] + (block[i] - 1); + curr_low = start[i]; + curr_high = start[i] + (block[i] - 1); dim_stride = stride[i]; - for(u = 0; u < count[i]; u++, curr_low += dim_stride, curr_high += dim_stride) { - H5S_hyper_span_t *span; /* New hyperslab span */ + for (u = 0; u < count[i]; u++, curr_low += dim_stride, curr_high += dim_stride) { + H5S_hyper_span_t *span; /* New hyperslab span */ /* Allocate a span node */ - if(NULL == (span = H5FL_MALLOC(H5S_hyper_span_t))) + if (NULL == (span = H5FL_MALLOC(H5S_hyper_span_t))) HGOTO_ERROR(H5E_DATASPACE, H5E_CANTALLOC, NULL, "can't allocate hyperslab span") /* Set the span's basic information */ - span->low = curr_low; + span->low = curr_low; span->high = curr_high; span->next = NULL; @@ -8512,7 +8568,7 @@ H5S__hyper_make_spans(unsigned rank, const hsize_t *start, const hsize_t *stride span->down = down; /* Append to the list of spans in this dimension */ - if(head == NULL) + if (head == NULL) head = span; else last_span->next = span; @@ -8522,11 +8578,11 @@ H5S__hyper_make_spans(unsigned rank, const hsize_t *start, const hsize_t *stride } /* end for */ /* Increment ref. count of shared span */ - if(down != NULL) + if (down != NULL) down->count = (unsigned)count[i]; /* Allocate a span info node */ - if(NULL == (down = H5S__hyper_new_span_info(rank))) + if (NULL == (down = H5S__hyper_new_span_info(rank))) HGOTO_ERROR(H5E_DATASPACE, H5E_CANTALLOC, NULL, "can't allocate hyperslab span") /* Keep the pointer to the next dimension down's completed list */ @@ -8536,19 +8592,21 @@ H5S__hyper_make_spans(unsigned rank, const hsize_t *start, const hsize_t *stride down->tail = last_span; /* Set the low & high bounds for this dimension */ - down->low_bounds[0] = down->head->low; + down->low_bounds[0] = down->head->low; down->high_bounds[0] = down->tail->high; /* Copy bounds from lower dimensions */ /* (head & tail pointers share lower dimensions, so using either is OK) */ - if(head->down) { - H5MM_memcpy(&down->low_bounds[1], &head->down->low_bounds[0], sizeof(hsize_t) * ((rank - 1) - (unsigned)i)); - H5MM_memcpy(&down->high_bounds[1], &head->down->high_bounds[0], sizeof(hsize_t) * ((rank - 1) - (unsigned)i)); + if (head->down) { + H5MM_memcpy(&down->low_bounds[1], &head->down->low_bounds[0], + sizeof(hsize_t) * ((rank - 1) - (unsigned)i)); + H5MM_memcpy(&down->high_bounds[1], &head->down->high_bounds[0], + sizeof(hsize_t) * ((rank - 1) - (unsigned)i)); } /* end if */ - } /* end for */ + } /* end for */ /* Indicate that there is a pointer to this tree */ - if(down) + if (down) down->count = 1; /* Success! Return the head of the list in the slowest changing dimension */ @@ -8556,32 +8614,31 @@ H5S__hyper_make_spans(unsigned rank, const hsize_t *start, const hsize_t *stride done: /* cleanup if error (ret_value will be NULL) */ - if(!ret_value) { - if(head || down) { - if(head && down) - if(down->head != head) + if (!ret_value) { + if (head || down) { + if (head && down) + if (down->head != head) down = NULL; do { - if(down) { + if (down) { head = down->head; down = (H5S_hyper_span_info_t *)H5FL_ARR_FREE(hbounds_t, down); } /* end if */ down = head->down; - while(head) { + while (head) { last_span = head->next; - head = H5FL_FREE(H5S_hyper_span_t, head); - head = last_span; + head = H5FL_FREE(H5S_hyper_span_t, head); + head = last_span; } /* end while */ - } while(down); + } while (down); } /* end if */ - } /* end if */ + } /* end if */ FUNC_LEAVE_NOAPI(ret_value) } /* end H5S__hyper_make_spans() */ - /*-------------------------------------------------------------------------- NAME H5S__hyper_update_diminfo @@ -8611,10 +8668,9 @@ done: REVISION LOG --------------------------------------------------------------------------*/ static herr_t -H5S__hyper_update_diminfo(H5S_t *space, H5S_seloper_t op, - const H5S_hyper_dim_t *new_hyper_diminfo) +H5S__hyper_update_diminfo(H5S_t *space, H5S_seloper_t op, const H5S_hyper_dim_t *new_hyper_diminfo) { - herr_t ret_value = SUCCEED; /* Return value */ + herr_t ret_value = SUCCEED; /* Return value */ FUNC_ENTER_STATIC_NOERR @@ -8624,182 +8680,180 @@ H5S__hyper_update_diminfo(H5S_t *space, H5S_seloper_t op, /* Check for conditions that prevent us from using the fast algorithm here */ /* (and instead require H5S__hyper_rebuild) */ - if(!((op == H5S_SELECT_OR) || (op == H5S_SELECT_XOR)) - || space->select.sel_info.hslab->diminfo_valid != H5S_DIMINFO_VALID_YES - || !space->select.sel_info.hslab->span_lst->head) + if (!((op == H5S_SELECT_OR) || (op == H5S_SELECT_XOR)) || + space->select.sel_info.hslab->diminfo_valid != H5S_DIMINFO_VALID_YES || + !space->select.sel_info.hslab->span_lst->head) space->select.sel_info.hslab->diminfo_valid = H5S_DIMINFO_VALID_NO; else { - H5S_hyper_dim_t tmp_diminfo[H5S_MAX_RANK]; /* Temporary dimension info */ - hbool_t found_nonidentical_dim = FALSE; - unsigned curr_dim; + H5S_hyper_dim_t tmp_diminfo[H5S_MAX_RANK]; /* Temporary dimension info */ + hbool_t found_nonidentical_dim = FALSE; + unsigned curr_dim; /* Copy current diminfo.opt values */ H5MM_memcpy(tmp_diminfo, space->select.sel_info.hslab->diminfo.opt, sizeof(tmp_diminfo)); /* Loop over dimensions */ - for(curr_dim = 0; curr_dim < space->extent.rank; curr_dim++) { + for (curr_dim = 0; curr_dim < space->extent.rank; curr_dim++) { /* Check for this being identical */ - if((tmp_diminfo[curr_dim].start != new_hyper_diminfo[curr_dim].start) - || (tmp_diminfo[curr_dim].stride != new_hyper_diminfo[curr_dim].stride) - || (tmp_diminfo[curr_dim].count != new_hyper_diminfo[curr_dim].count) - || (tmp_diminfo[curr_dim].block != new_hyper_diminfo[curr_dim].block)) { - hsize_t high_start, high_count, high_block; /* The start, count & block values for the higher block */ + if ((tmp_diminfo[curr_dim].start != new_hyper_diminfo[curr_dim].start) || + (tmp_diminfo[curr_dim].stride != new_hyper_diminfo[curr_dim].stride) || + (tmp_diminfo[curr_dim].count != new_hyper_diminfo[curr_dim].count) || + (tmp_diminfo[curr_dim].block != new_hyper_diminfo[curr_dim].block)) { + hsize_t high_start, high_count, + high_block; /* The start, count & block values for the higher block */ /* Dimension is not identical */ /* Check if we already found a nonidentical dim - only one is * allowed */ - if(found_nonidentical_dim) { + if (found_nonidentical_dim) { space->select.sel_info.hslab->diminfo_valid = H5S_DIMINFO_VALID_NO; break; } /* end if */ /* Check that strides are the same, or count is 1 for one of the * slabs */ - if((tmp_diminfo[curr_dim].stride != new_hyper_diminfo[curr_dim].stride) - && (tmp_diminfo[curr_dim].count > 1) - && (new_hyper_diminfo[curr_dim].count > 1)) { + if ((tmp_diminfo[curr_dim].stride != new_hyper_diminfo[curr_dim].stride) && + (tmp_diminfo[curr_dim].count > 1) && (new_hyper_diminfo[curr_dim].count > 1)) { space->select.sel_info.hslab->diminfo_valid = H5S_DIMINFO_VALID_NO; break; } /* end if */ /* Patch tmp_diminfo.stride if its count is 1 */ - if((tmp_diminfo[curr_dim].count == 1) - && (new_hyper_diminfo[curr_dim].count > 1)) + if ((tmp_diminfo[curr_dim].count == 1) && (new_hyper_diminfo[curr_dim].count > 1)) tmp_diminfo[curr_dim].stride = new_hyper_diminfo[curr_dim].stride; /* Determine lowest start, and set tmp_diminfo.start, count and * block to use the lowest, and high_start, high_count and * high_block to use the highest */ - if(tmp_diminfo[curr_dim].start < new_hyper_diminfo[curr_dim].start) { + if (tmp_diminfo[curr_dim].start < new_hyper_diminfo[curr_dim].start) { high_start = new_hyper_diminfo[curr_dim].start; high_count = new_hyper_diminfo[curr_dim].count; high_block = new_hyper_diminfo[curr_dim].block; } /* end if */ else { - high_start = tmp_diminfo[curr_dim].start; + high_start = tmp_diminfo[curr_dim].start; tmp_diminfo[curr_dim].start = new_hyper_diminfo[curr_dim].start; - high_count = tmp_diminfo[curr_dim].count; + high_count = tmp_diminfo[curr_dim].count; tmp_diminfo[curr_dim].count = new_hyper_diminfo[curr_dim].count; - high_block = tmp_diminfo[curr_dim].block; + high_block = tmp_diminfo[curr_dim].block; tmp_diminfo[curr_dim].block = new_hyper_diminfo[curr_dim].block; } /* end else */ /* If count is 1 for both slabs, take different actions */ - if((tmp_diminfo[curr_dim].count == 1) && (high_count == 1)) { + if ((tmp_diminfo[curr_dim].count == 1) && (high_count == 1)) { /* Check for overlap */ - if((tmp_diminfo[curr_dim].start + tmp_diminfo[curr_dim].block) - > high_start) { + if ((tmp_diminfo[curr_dim].start + tmp_diminfo[curr_dim].block) > high_start) { /* Check operation type */ - if(op == H5S_SELECT_OR) + if (op == H5S_SELECT_OR) /* Merge blocks */ - tmp_diminfo[curr_dim].block = ((high_start + high_block) - >= (tmp_diminfo[curr_dim].start + tmp_diminfo[curr_dim].block)) + tmp_diminfo[curr_dim].block = + ((high_start + high_block) >= + (tmp_diminfo[curr_dim].start + tmp_diminfo[curr_dim].block)) ? (high_start + high_block - tmp_diminfo[curr_dim].start) : tmp_diminfo[curr_dim].block; else { /* Block values must be the same */ - if(tmp_diminfo[curr_dim].block != high_block) { + if (tmp_diminfo[curr_dim].block != high_block) { space->select.sel_info.hslab->diminfo_valid = H5S_DIMINFO_VALID_NO; break; } /* end if */ /* XOR - overlap creates 2 blocks */ tmp_diminfo[curr_dim].stride = high_block; - tmp_diminfo[curr_dim].count = 2; - tmp_diminfo[curr_dim].block = high_start - tmp_diminfo[curr_dim].start; + tmp_diminfo[curr_dim].count = 2; + tmp_diminfo[curr_dim].block = high_start - tmp_diminfo[curr_dim].start; } /* end else */ - } /* end if */ - else if((tmp_diminfo[curr_dim].start + tmp_diminfo[curr_dim].block) - == high_start) + } /* end if */ + else if ((tmp_diminfo[curr_dim].start + tmp_diminfo[curr_dim].block) == high_start) /* Blocks border, merge them */ tmp_diminfo[curr_dim].block += high_block; else { /* Distinct blocks */ /* Block values must be the same */ - if(tmp_diminfo[curr_dim].block != high_block) { + if (tmp_diminfo[curr_dim].block != high_block) { space->select.sel_info.hslab->diminfo_valid = H5S_DIMINFO_VALID_NO; break; } /* end if */ /* Create strided selection */ tmp_diminfo[curr_dim].stride = high_start - tmp_diminfo[curr_dim].start; - tmp_diminfo[curr_dim].count = 2; + tmp_diminfo[curr_dim].count = 2; } /* end else */ - } /* end if */ + } /* end if */ else { /* Check if block values are the same */ - if(tmp_diminfo[curr_dim].block != new_hyper_diminfo[curr_dim].block) { + if (tmp_diminfo[curr_dim].block != new_hyper_diminfo[curr_dim].block) { space->select.sel_info.hslab->diminfo_valid = H5S_DIMINFO_VALID_NO; break; } /* end if */ /* Check phase of strides */ - if((tmp_diminfo[curr_dim].start % tmp_diminfo[curr_dim].stride) - != (new_hyper_diminfo[curr_dim].start % tmp_diminfo[curr_dim].stride)) { + if ((tmp_diminfo[curr_dim].start % tmp_diminfo[curr_dim].stride) != + (new_hyper_diminfo[curr_dim].start % tmp_diminfo[curr_dim].stride)) { space->select.sel_info.hslab->diminfo_valid = H5S_DIMINFO_VALID_NO; break; } /* end if */ /* Check operation type */ - if(op == H5S_SELECT_OR) { + if (op == H5S_SELECT_OR) { /* Make sure the slabs border or overlap */ - if(high_start > (tmp_diminfo[curr_dim].start - + (tmp_diminfo[curr_dim].count - * tmp_diminfo[curr_dim].stride))) { + if (high_start > (tmp_diminfo[curr_dim].start + + (tmp_diminfo[curr_dim].count * tmp_diminfo[curr_dim].stride))) { space->select.sel_info.hslab->diminfo_valid = H5S_DIMINFO_VALID_NO; break; } /* end if */ - } /* end if */ + } /* end if */ else /* XOR: Make sure the slabs border */ - if(high_start != (tmp_diminfo[curr_dim].start - + (tmp_diminfo[curr_dim].count - * tmp_diminfo[curr_dim].stride))) { - space->select.sel_info.hslab->diminfo_valid = H5S_DIMINFO_VALID_NO; - break; - } /* end if */ + if (high_start != (tmp_diminfo[curr_dim].start + + (tmp_diminfo[curr_dim].count * tmp_diminfo[curr_dim].stride))) { + space->select.sel_info.hslab->diminfo_valid = H5S_DIMINFO_VALID_NO; + break; + } /* end if */ /* Set count for combined selection */ - tmp_diminfo[curr_dim].count = ((high_start - - tmp_diminfo[curr_dim].start) - / tmp_diminfo[curr_dim].stride) + high_count; + tmp_diminfo[curr_dim].count = + ((high_start - tmp_diminfo[curr_dim].start) / tmp_diminfo[curr_dim].stride) + + high_count; } /* end else */ /* Indicate that we found a nonidentical dim */ found_nonidentical_dim = TRUE; } /* end if */ - } /* end for */ + } /* end for */ /* Check if we succeeded, if so, set the new diminfo values */ - if(space->select.sel_info.hslab->diminfo_valid == H5S_DIMINFO_VALID_YES) - for(curr_dim = 0; curr_dim < space->extent.rank; curr_dim++) { + if (space->select.sel_info.hslab->diminfo_valid == H5S_DIMINFO_VALID_YES) + for (curr_dim = 0; curr_dim < space->extent.rank; curr_dim++) { hsize_t tmp_high_bound; /* Set the new diminfo values */ - space->select.sel_info.hslab->diminfo.app[curr_dim].start = space->select.sel_info.hslab->diminfo.opt[curr_dim].start = tmp_diminfo[curr_dim].start; + space->select.sel_info.hslab->diminfo.app[curr_dim].start = + space->select.sel_info.hslab->diminfo.opt[curr_dim].start = tmp_diminfo[curr_dim].start; HDassert(tmp_diminfo[curr_dim].stride > 0); - space->select.sel_info.hslab->diminfo.app[curr_dim].stride = space->select.sel_info.hslab->diminfo.opt[curr_dim].stride = tmp_diminfo[curr_dim].stride; + space->select.sel_info.hslab->diminfo.app[curr_dim].stride = + space->select.sel_info.hslab->diminfo.opt[curr_dim].stride = tmp_diminfo[curr_dim].stride; HDassert(tmp_diminfo[curr_dim].count > 0); - space->select.sel_info.hslab->diminfo.app[curr_dim].count = space->select.sel_info.hslab->diminfo.opt[curr_dim].count = tmp_diminfo[curr_dim].count; + space->select.sel_info.hslab->diminfo.app[curr_dim].count = + space->select.sel_info.hslab->diminfo.opt[curr_dim].count = tmp_diminfo[curr_dim].count; HDassert(tmp_diminfo[curr_dim].block > 0); - space->select.sel_info.hslab->diminfo.app[curr_dim].block = space->select.sel_info.hslab->diminfo.opt[curr_dim].block = tmp_diminfo[curr_dim].block; + space->select.sel_info.hslab->diminfo.app[curr_dim].block = + space->select.sel_info.hslab->diminfo.opt[curr_dim].block = tmp_diminfo[curr_dim].block; /* Check for updating the low & high bounds */ - if(tmp_diminfo[curr_dim].start < space->select.sel_info.hslab->diminfo.low_bounds[curr_dim]) + if (tmp_diminfo[curr_dim].start < space->select.sel_info.hslab->diminfo.low_bounds[curr_dim]) space->select.sel_info.hslab->diminfo.low_bounds[curr_dim] = tmp_diminfo[curr_dim].start; - tmp_high_bound = tmp_diminfo[curr_dim].start + - (tmp_diminfo[curr_dim].block - 1) + - (tmp_diminfo[curr_dim].stride * (tmp_diminfo[curr_dim].count - 1)); - if(tmp_high_bound > space->select.sel_info.hslab->diminfo.low_bounds[curr_dim]) + tmp_high_bound = tmp_diminfo[curr_dim].start + (tmp_diminfo[curr_dim].block - 1) + + (tmp_diminfo[curr_dim].stride * (tmp_diminfo[curr_dim].count - 1)); + if (tmp_high_bound > space->select.sel_info.hslab->diminfo.low_bounds[curr_dim]) space->select.sel_info.hslab->diminfo.high_bounds[curr_dim] = tmp_high_bound; } /* end for */ - } /* end else */ + } /* end else */ FUNC_LEAVE_NOAPI(ret_value) } /* end H5S__hyper_update_diminfo() */ - /*-------------------------------------------------------------------------- NAME H5S__hyper_rebuild_helper @@ -8826,14 +8880,14 @@ H5S__hyper_update_diminfo(H5S_t *space, H5S_seloper_t op, static hbool_t H5S__hyper_rebuild_helper(const H5S_hyper_span_info_t *spans, H5S_hyper_dim_t span_slab_info[]) { - const H5S_hyper_span_t *span; /* Hyperslab span */ - const H5S_hyper_span_t *prev_span; /* Previous span in list */ - hsize_t start; /* Starting element for this dimension */ - hsize_t stride; /* Stride for this dimension */ - hsize_t block; /* Block size for this dimension */ - hsize_t prev_low; /* Low bound for previous span */ - size_t spancount; /* Number of spans encountered in this dimension */ - hbool_t ret_value = TRUE; /* Return value */ + const H5S_hyper_span_t *span; /* Hyperslab span */ + const H5S_hyper_span_t *prev_span; /* Previous span in list */ + hsize_t start; /* Starting element for this dimension */ + hsize_t stride; /* Stride for this dimension */ + hsize_t block; /* Block size for this dimension */ + hsize_t prev_low; /* Low bound for previous span */ + size_t spancount; /* Number of spans encountered in this dimension */ + hbool_t ret_value = TRUE; /* Return value */ FUNC_ENTER_STATIC_NOERR @@ -8841,15 +8895,15 @@ H5S__hyper_rebuild_helper(const H5S_hyper_span_info_t *spans, H5S_hyper_dim_t sp HDassert(spans); /* Initialization */ - span = spans->head; - stride = 1; - prev_low = 0; + span = spans->head; + stride = 1; + prev_low = 0; spancount = 0; /* Get "canonical" down span information */ - if(span->down) + 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])) + if (!H5S__hyper_rebuild_helper(span->down, &span_slab_info[1])) HGOTO_DONE(FALSE) /* Assign the initial starting point & block size for this dimension */ @@ -8858,31 +8912,31 @@ H5S__hyper_rebuild_helper(const H5S_hyper_span_info_t *spans, H5S_hyper_dim_t sp /* Loop the spans */ prev_span = NULL; - while(span) { - if(spancount > 0) { - hsize_t curr_stride; /* Current stride from previous span */ - hsize_t curr_block; /* Block size of current span */ + while (span) { + if (spancount > 0) { + hsize_t curr_stride; /* Current stride from previous span */ + hsize_t curr_block; /* Block size of current span */ /* Sanity check */ HDassert(prev_span); /* Check that down spans match current slab info */ /* (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)) + if (span->down && prev_span->down != span->down) + if (!H5S__hyper_cmp_spans(span->down, prev_span->down)) HGOTO_DONE(FALSE) /* Obtain values for stride and block */ curr_stride = span->low - prev_low; - curr_block = (span->high - span->low) + 1; + curr_block = (span->high - span->low) + 1; /* Compare stride and block for this span. To compare stride, * three spans are needed. Account for the first two spans. */ - if(curr_block != block) + if (curr_block != block) HGOTO_DONE(FALSE) - if(spancount > 1) { - if(stride != curr_stride) + if (spancount > 1) { + if (stride != curr_stride) HGOTO_DONE(FALSE) } /* end if */ else @@ -8894,7 +8948,7 @@ H5S__hyper_rebuild_helper(const H5S_hyper_span_info_t *spans, H5S_hyper_dim_t sp /* Advance to next span */ prev_span = span; - span = span->next; + span = span->next; spancount++; } /* end while */ @@ -8908,7 +8962,6 @@ done: FUNC_LEAVE_NOAPI(ret_value) } /* end H5S__hyper_rebuild_helper() */ - /*-------------------------------------------------------------------------- NAME H5S__hyper_rebuild @@ -8943,14 +8996,17 @@ H5S__hyper_rebuild(H5S_t *space) /* Check whether the slab can be rebuilt */ /* (Only regular selection can be rebuilt. If yes, fill in correct values) */ - if(FALSE == H5S__hyper_rebuild_helper(space->select.sel_info.hslab->span_lst, rebuilt_slab_info)) + if (FALSE == H5S__hyper_rebuild_helper(space->select.sel_info.hslab->span_lst, rebuilt_slab_info)) space->select.sel_info.hslab->diminfo_valid = H5S_DIMINFO_VALID_IMPOSSIBLE; else { /* Set the dimension info & bounds for the dataspace, from the rebuilt info */ H5MM_memcpy(space->select.sel_info.hslab->diminfo.app, rebuilt_slab_info, sizeof(rebuilt_slab_info)); H5MM_memcpy(space->select.sel_info.hslab->diminfo.opt, rebuilt_slab_info, sizeof(rebuilt_slab_info)); - H5MM_memcpy(space->select.sel_info.hslab->diminfo.low_bounds, space->select.sel_info.hslab->span_lst->low_bounds, sizeof(hsize_t) * space->extent.rank); - H5MM_memcpy(space->select.sel_info.hslab->diminfo.high_bounds, space->select.sel_info.hslab->span_lst->high_bounds, sizeof(hsize_t) * space->extent.rank); + H5MM_memcpy(space->select.sel_info.hslab->diminfo.low_bounds, + space->select.sel_info.hslab->span_lst->low_bounds, sizeof(hsize_t) * space->extent.rank); + H5MM_memcpy(space->select.sel_info.hslab->diminfo.high_bounds, + space->select.sel_info.hslab->span_lst->high_bounds, + sizeof(hsize_t) * space->extent.rank); space->select.sel_info.hslab->diminfo_valid = H5S_DIMINFO_VALID_YES; } /* end else */ @@ -8958,7 +9014,6 @@ H5S__hyper_rebuild(H5S_t *space) FUNC_LEAVE_NOAPI_VOID } /* end H5S__hyper_rebuild() */ - /*-------------------------------------------------------------------------- NAME H5S__hyper_generate_spans @@ -8980,12 +9035,12 @@ H5S__hyper_rebuild(H5S_t *space) static herr_t H5S__hyper_generate_spans(H5S_t *space) { - hsize_t tmp_start[H5S_MAX_RANK]; /* Temporary start information */ - hsize_t tmp_stride[H5S_MAX_RANK]; /* Temporary stride information */ - hsize_t tmp_count[H5S_MAX_RANK]; /* Temporary count information */ - hsize_t tmp_block[H5S_MAX_RANK]; /* Temporary block information */ - unsigned u; /* Local index variable */ - herr_t ret_value = SUCCEED; /* Return value */ + hsize_t tmp_start[H5S_MAX_RANK]; /* Temporary start information */ + hsize_t tmp_stride[H5S_MAX_RANK]; /* Temporary stride information */ + hsize_t tmp_count[H5S_MAX_RANK]; /* Temporary count information */ + hsize_t tmp_block[H5S_MAX_RANK]; /* Temporary block information */ + unsigned u; /* Local index variable */ + herr_t ret_value = SUCCEED; /* Return value */ FUNC_ENTER_STATIC @@ -8993,31 +9048,30 @@ H5S__hyper_generate_spans(H5S_t *space) HDassert(H5S_GET_SELECT_TYPE(space) == H5S_SEL_HYPERSLABS); /* Get the diminfo */ - for(u = 0; u < space->extent.rank; u++) { + for (u = 0; u < space->extent.rank; u++) { /* Check for unlimited dimension and return error */ /* These should be able to be converted to assertions once everything * that calls this function checks for unlimited selections first * (especially the new hyperslab API) -NAF */ - if(space->select.sel_info.hslab->diminfo.opt[u].count == H5S_UNLIMITED) + if (space->select.sel_info.hslab->diminfo.opt[u].count == H5S_UNLIMITED) HGOTO_ERROR(H5E_DATASPACE, H5E_UNSUPPORTED, FAIL, "can't generate spans with unlimited count") - if(space->select.sel_info.hslab->diminfo.opt[u].block == H5S_UNLIMITED) + if (space->select.sel_info.hslab->diminfo.opt[u].block == H5S_UNLIMITED) HGOTO_ERROR(H5E_DATASPACE, H5E_UNSUPPORTED, FAIL, "can't generate spans with unlimited block") - tmp_start[u] = space->select.sel_info.hslab->diminfo.opt[u].start; + tmp_start[u] = space->select.sel_info.hslab->diminfo.opt[u].start; tmp_stride[u] = space->select.sel_info.hslab->diminfo.opt[u].stride; - tmp_count[u] = space->select.sel_info.hslab->diminfo.opt[u].count; - tmp_block[u] = space->select.sel_info.hslab->diminfo.opt[u].block; + tmp_count[u] = space->select.sel_info.hslab->diminfo.opt[u].count; + tmp_block[u] = space->select.sel_info.hslab->diminfo.opt[u].block; } /* end for */ /* Build the hyperslab information also */ - if(H5S__generate_hyperslab(space, H5S_SELECT_SET, tmp_start, tmp_stride, tmp_count, tmp_block) < 0) + if (H5S__generate_hyperslab(space, H5S_SELECT_SET, tmp_start, tmp_stride, tmp_count, tmp_block) < 0) HGOTO_ERROR(H5E_DATASPACE, H5E_CANTINSERT, FAIL, "can't generate hyperslabs") done: FUNC_LEAVE_NOAPI(ret_value) } /* end H5S__hyper_generate_spans() */ - /*-------------------------------------------------------------------------- NAME H5S__check_spans_overlap @@ -9037,10 +9091,9 @@ done: REVISION LOG --------------------------------------------------------------------------*/ static H5_ATTR_PURE hbool_t -H5S__check_spans_overlap(const H5S_hyper_span_info_t *spans1, - const H5S_hyper_span_info_t *spans2) +H5S__check_spans_overlap(const H5S_hyper_span_info_t *spans1, const H5S_hyper_span_info_t *spans2) { - hbool_t ret_value = FALSE; /* Return value */ + hbool_t ret_value = FALSE; /* Return value */ FUNC_ENTER_STATIC_NOERR @@ -9049,23 +9102,23 @@ H5S__check_spans_overlap(const H5S_hyper_span_info_t *spans1, HDassert(spans2); /* Use low & high bounds to try to avoid spinning through the span lists */ - if(H5S_RANGE_OVERLAP(spans1->low_bounds[0], spans1->high_bounds[0], - spans2->low_bounds[0], spans2->high_bounds[0])) { - H5S_hyper_span_t *span1, *span2; /* Hyperslab spans */ + if (H5S_RANGE_OVERLAP(spans1->low_bounds[0], spans1->high_bounds[0], spans2->low_bounds[0], + spans2->high_bounds[0])) { + H5S_hyper_span_t *span1, *span2; /* Hyperslab spans */ /* Walk over spans, comparing them for overlap */ span1 = spans1->head; span2 = spans2->head; - while(span1 && span2) { + while (span1 && span2) { /* Check current two spans for overlap */ - if(H5S_RANGE_OVERLAP(span1->low, span1->high, span2->low, span2->high)) { + if (H5S_RANGE_OVERLAP(span1->low, span1->high, span2->low, span2->high)) { /* Check for spans in lowest dimension already */ - if(span1->down) { + if (span1->down) { /* Sanity check */ HDassert(span2->down); /* Check lower dimensions for overlap */ - if(H5S__check_spans_overlap(span1->down, span2->down)) + if (H5S__check_spans_overlap(span1->down, span2->down)) HGOTO_DONE(TRUE); } /* end if */ else @@ -9073,32 +9126,31 @@ H5S__check_spans_overlap(const H5S_hyper_span_info_t *spans1, } /* end if */ /* Advance one of the spans */ - if(span1->high <= span2->high) { + if (span1->high <= span2->high) { /* Advance span1, unless it would be off the list and span2 has more nodes */ - if(NULL == span1->next && NULL != span2->next) + if (NULL == span1->next && NULL != span2->next) span2 = span2->next; else span1 = span1->next; } /* end if */ else { /* Advance span2, unless it would be off the list and span1 has more nodes */ - if(NULL == span2->next && NULL != span1->next) + if (NULL == span2->next && NULL != span1->next) span1 = span1->next; else span2 = span2->next; } /* end else */ - } /* end while */ + } /* end while */ /* Make certain we've exhausted our comparisons */ HDassert((NULL == span1 && (NULL != span2 && NULL == span2->next)) || - ((NULL != span1 && NULL == span1->next) && NULL == span2)); + ((NULL != span1 && NULL == span1->next) && NULL == span2)); } /* end of */ done: FUNC_LEAVE_NOAPI(ret_value) } /* end H5S__check_spans_overlap() */ - /*-------------------------------------------------------------------------- NAME H5S__fill_in_new_space @@ -9129,16 +9181,17 @@ done: REVISION LOG --------------------------------------------------------------------------*/ static herr_t -H5S__fill_in_new_space(H5S_t *space1, H5S_seloper_t op, - H5S_hyper_span_info_t *space2_span_lst, hbool_t can_own_span2, - hbool_t *span2_owned, hbool_t *updated_spans, H5S_t **result) +H5S__fill_in_new_space(H5S_t *space1, H5S_seloper_t op, H5S_hyper_span_info_t *space2_span_lst, + hbool_t can_own_span2, hbool_t *span2_owned, hbool_t *updated_spans, H5S_t **result) { - H5S_hyper_span_info_t *a_not_b = NULL; /* Span tree for hyperslab spans in old span tree and not in new span tree */ - H5S_hyper_span_info_t *a_and_b = NULL; /* Span tree for hyperslab spans in both old and new span trees */ - H5S_hyper_span_info_t *b_not_a = NULL; /* Span tree for hyperslab spans in new span tree and not in old span tree */ - hbool_t overlapped = FALSE; /* Whether selections overlap */ + H5S_hyper_span_info_t *a_not_b = + NULL; /* Span tree for hyperslab spans in old span tree and not in new span tree */ + H5S_hyper_span_info_t *a_and_b = NULL; /* Span tree for hyperslab spans in both old and new span trees */ + H5S_hyper_span_info_t *b_not_a = + NULL; /* Span tree for hyperslab spans in new span tree and not in old span tree */ + hbool_t overlapped = FALSE; /* Whether selections overlap */ hbool_t is_result_new = FALSE; - herr_t ret_value = SUCCEED; /* Return value */ + herr_t ret_value = SUCCEED; /* Return value */ FUNC_ENTER_STATIC @@ -9151,39 +9204,40 @@ H5S__fill_in_new_space(H5S_t *space1, H5S_seloper_t op, HDassert(span2_owned); /* Reset flags to return */ - *span2_owned = FALSE; + *span2_owned = FALSE; *updated_spans = FALSE; /* The result shares the same info from space1 */ - if(*result == NULL) { - if(NULL == ((*result) = H5S_copy(space1, TRUE, TRUE))) + if (*result == NULL) { + if (NULL == ((*result) = H5S_copy(space1, TRUE, TRUE))) HGOTO_ERROR(H5E_DATASPACE, H5E_CANTINIT, FAIL, "unable to copy dataspace") space1->select.sel_info.hslab->span_lst->count--; (*result)->select.sel_info.hslab->span_lst = NULL; - is_result_new = TRUE; + is_result_new = TRUE; } /* end if */ /* Check both spaces to see if they overlap */ overlapped = H5S__check_spans_overlap(space1->select.sel_info.hslab->span_lst, space2_span_lst); - if(!overlapped) { - switch(op) { + if (!overlapped) { + switch (op) { case H5S_SELECT_OR: case H5S_SELECT_XOR: /* Add the new disjoint spans to the space */ /* Copy of space1's spans to *result, and another copy of space2's spans */ - if(is_result_new) - (*result)->select.sel_info.hslab->span_lst = H5S__hyper_copy_span(space1->select.sel_info.hslab->span_lst, space1->extent.rank); - if(!can_own_span2) { + if (is_result_new) + (*result)->select.sel_info.hslab->span_lst = + H5S__hyper_copy_span(space1->select.sel_info.hslab->span_lst, space1->extent.rank); + if (!can_own_span2) { b_not_a = H5S__hyper_copy_span(space2_span_lst, space1->extent.rank); - if(H5S__hyper_add_disjoint_spans(*result, b_not_a) < 0) + if (H5S__hyper_add_disjoint_spans(*result, b_not_a) < 0) HGOTO_ERROR(H5E_DATASPACE, H5E_CANTINSERT, FAIL, "can't append hyperslabs") /* The new_spans are now owned by 'space', so they should not be released */ b_not_a = NULL; } /* end if */ else { - if(H5S__hyper_add_disjoint_spans(*result, space2_span_lst) < 0) + if (H5S__hyper_add_disjoint_spans(*result, space2_span_lst) < 0) HGOTO_ERROR(H5E_DATASPACE, H5E_CANTINSERT, FAIL, "can't append hyperslabs") *span2_owned = TRUE; } /* end else */ @@ -9194,21 +9248,22 @@ H5S__fill_in_new_space(H5S_t *space1, H5S_seloper_t op, case H5S_SELECT_AND: /* Convert *result to "none" selection */ - if(H5S_select_none(*result) < 0) + if (H5S_select_none(*result) < 0) HGOTO_ERROR(H5E_DATASPACE, H5E_CANTSELECT, FAIL, "can't convert selection") HGOTO_DONE(SUCCEED); case H5S_SELECT_NOTB: /* Copy space1's spans to *result */ - if(is_result_new) - (*result)->select.sel_info.hslab->span_lst = H5S__hyper_copy_span(space1->select.sel_info.hslab->span_lst, space1->extent.rank); + if (is_result_new) + (*result)->select.sel_info.hslab->span_lst = + H5S__hyper_copy_span(space1->select.sel_info.hslab->span_lst, space1->extent.rank); /* Indicate that the spans changed */ *updated_spans = TRUE; break; case H5S_SELECT_NOTA: - if(!is_result_new) { + if (!is_result_new) { HDassert(space1 == *result); /* Free the current selection */ @@ -9217,11 +9272,12 @@ H5S__fill_in_new_space(H5S_t *space1, H5S_seloper_t op, } /* end if */ /* Copy space2's spans to *result */ - if(!can_own_span2) - (*result)->select.sel_info.hslab->span_lst = H5S__hyper_copy_span(space2_span_lst, space1->extent.rank); + if (!can_own_span2) + (*result)->select.sel_info.hslab->span_lst = + H5S__hyper_copy_span(space2_span_lst, space1->extent.rank); else { (*result)->select.sel_info.hslab->span_lst = space2_span_lst; - *span2_owned = TRUE; + *span2_owned = TRUE; } /* end else */ /* Reset the number of items in selection */ @@ -9239,12 +9295,12 @@ H5S__fill_in_new_space(H5S_t *space1, H5S_seloper_t op, default: HGOTO_ERROR(H5E_ARGS, H5E_UNSUPPORTED, FAIL, "invalid selection operation") } /* end switch */ - } /* end if */ + } /* end if */ else { - unsigned selector = 0; /* Select which clipping spans to generate */ + unsigned selector = 0; /* Select which clipping spans to generate */ /* Generate mask for clip operation depending on the op */ - switch(op) { + switch (op) { case H5S_SELECT_OR: /* a + b_not_a */ selector = H5S_HYPER_COMPUTE_B_NOT_A; break; @@ -9275,21 +9331,21 @@ H5S__fill_in_new_space(H5S_t *space1, H5S_seloper_t op, } /* end switch */ /* Generate lists of spans which overlap and don't overlap */ - if(H5S__hyper_clip_spans(space1->select.sel_info.hslab->span_lst, - space2_span_lst, selector, space1->extent.rank, - &a_not_b, &a_and_b, &b_not_a) < 0) + if (H5S__hyper_clip_spans(space1->select.sel_info.hslab->span_lst, space2_span_lst, selector, + space1->extent.rank, &a_not_b, &a_and_b, &b_not_a) < 0) HGOTO_ERROR(H5E_DATASPACE, H5E_CANTCLIP, FAIL, "can't clip hyperslab information") - switch(op) { + switch (op) { case H5S_SELECT_OR: - if(is_result_new) - (*result)->select.sel_info.hslab->span_lst = H5S__hyper_copy_span(space1->select.sel_info.hslab->span_lst, space1->extent.rank); + if (is_result_new) + (*result)->select.sel_info.hslab->span_lst = + H5S__hyper_copy_span(space1->select.sel_info.hslab->span_lst, space1->extent.rank); break; case H5S_SELECT_AND: case H5S_SELECT_XOR: case H5S_SELECT_NOTB: case H5S_SELECT_NOTA: - if(!is_result_new) { + if (!is_result_new) { HDassert(space1 == *result); /* Free the current selection */ @@ -9312,7 +9368,7 @@ H5S__fill_in_new_space(H5S_t *space1, H5S_seloper_t op, } /* end switch */ /* Check if there are any non-overlapped selections */ - if(a_not_b) { + if (a_not_b) { /* Other than OR, the span_lst is set to NULL. And in OR, * a_not_b is not needed */ @@ -9332,7 +9388,7 @@ H5S__fill_in_new_space(H5S_t *space1, H5S_seloper_t op, a_not_b = NULL; } /* end if */ - if(a_and_b) { + if (a_and_b) { /** * 1. Other than OR, the span_lst is set to NULL. And in OR, * a_and_b is not needed @@ -9355,9 +9411,9 @@ H5S__fill_in_new_space(H5S_t *space1, H5S_seloper_t op, a_and_b = NULL; } /* end if */ - if(b_not_a) { + if (b_not_a) { /* Merge the b_not_a spans into the result dataspace */ - if(H5S__hyper_merge_spans(*result, b_not_a) < 0) + if (H5S__hyper_merge_spans(*result, b_not_a) < 0) HGOTO_ERROR(H5E_DATASPACE, H5E_CANTINSERT, FAIL, "can't insert hyperslabs") /* Update the number of elements in current selection */ @@ -9366,10 +9422,10 @@ H5S__fill_in_new_space(H5S_t *space1, H5S_seloper_t op, /* Indicate that the spans were updated */ *updated_spans = TRUE; } /* end if */ - } /* end else for the case the new span overlaps with the old (i.e. space) */ + } /* end else for the case the new span overlaps with the old (i.e. space) */ /* Check if the spans weren't updated, and reset selection if so */ - if(!*updated_spans) { + if (!*updated_spans) { /* If updated_spans remains FALSE as in this branch, it means the * result has been cleared in XOR / AND / NOTB / NOTA cases, and the * result is a copy of the dataspace in the OR case. @@ -9378,26 +9434,25 @@ H5S__fill_in_new_space(H5S_t *space1, H5S_seloper_t op, * span trees (i.e. a_not_b, a_and_b, and b_not_a), the * updated_spans must be TRUE. */ - if(H5S_SELECT_OR != op) { + if (H5S_SELECT_OR != op) { /* Convert *result to "none" selection */ - if(H5S_select_none(*result) < 0) + if (H5S_select_none(*result) < 0) HGOTO_ERROR(H5E_DATASPACE, H5E_CANTSELECT, FAIL, "can't convert selection") } /* end else */ - } /* end if */ + } /* end if */ done: /* Free resources */ - if(a_not_b) + if (a_not_b) H5S__hyper_free_span_info(a_not_b); - if(a_and_b) + if (a_and_b) H5S__hyper_free_span_info(a_and_b); - if(b_not_a) + if (b_not_a) H5S__hyper_free_span_info(b_not_a); FUNC_LEAVE_NOAPI(ret_value) } /* end H5S__fill_in_new_space() */ - /*------------------------------------------------------------------------- * Function: H5S__generate_hyperlab * @@ -9411,11 +9466,11 @@ done: *------------------------------------------------------------------------- */ static herr_t -H5S__generate_hyperslab(H5S_t *space, H5S_seloper_t op, const hsize_t start[], - const hsize_t stride[], const hsize_t count[], const hsize_t block[]) +H5S__generate_hyperslab(H5S_t *space, H5S_seloper_t op, const hsize_t start[], const hsize_t stride[], + const hsize_t count[], const hsize_t block[]) { H5S_hyper_span_info_t *new_spans = NULL; /* Span tree for new hyperslab */ - herr_t ret_value = SUCCEED; /* Return value */ + herr_t ret_value = SUCCEED; /* Return value */ FUNC_ENTER_STATIC @@ -9428,13 +9483,13 @@ H5S__generate_hyperslab(H5S_t *space, H5S_seloper_t op, const hsize_t start[], HDassert(block); /* Generate span tree for new hyperslab information */ - if(NULL == (new_spans = H5S__hyper_make_spans(space->extent.rank, start, stride, count, block))) + if (NULL == (new_spans = H5S__hyper_make_spans(space->extent.rank, start, stride, count, block))) HGOTO_ERROR(H5E_DATASPACE, H5E_CANTINSERT, FAIL, "can't create hyperslab information") /* Generate list of blocks to add/remove based on selection operation */ - if(op == H5S_SELECT_SET) { + if (op == H5S_SELECT_SET) { /* Free current selection */ - if(NULL != space->select.sel_info.hslab->span_lst) + if (NULL != space->select.sel_info.hslab->span_lst) H5S__hyper_free_span_info(space->select.sel_info.hslab->span_lst); /* Set the hyperslab selection to the new span tree */ @@ -9448,46 +9503,45 @@ H5S__generate_hyperslab(H5S_t *space, H5S_seloper_t op, const hsize_t start[], } /* end if */ else { hbool_t new_spans_owned = FALSE; - hbool_t updated_spans = FALSE; + hbool_t updated_spans = FALSE; /* Generate new spans for space */ - if(H5S__fill_in_new_space(space, op, new_spans, TRUE, &new_spans_owned, &updated_spans, &space) < 0) + if (H5S__fill_in_new_space(space, op, new_spans, TRUE, &new_spans_owned, &updated_spans, &space) < 0) HGOTO_ERROR(H5E_DATASPACE, H5E_CANTSELECT, FAIL, "can't generate the specified hyperslab") /* Check if the spans were updated by H5S__fill_in_new_space */ - if(updated_spans) { + if (updated_spans) { H5S_hyper_dim_t new_hyper_diminfo[H5S_MAX_RANK]; - unsigned u; /* Local index variable */ + unsigned u; /* Local index variable */ /* Sanity check */ HDassert(space->select.sel_info.hslab->span_lst->head); /* Build diminfo struct */ - for(u = 0; u <space->extent.rank; u++) { - new_hyper_diminfo[u].start = start[u]; + for (u = 0; u < space->extent.rank; u++) { + new_hyper_diminfo[u].start = start[u]; new_hyper_diminfo[u].stride = stride[u]; - new_hyper_diminfo[u].count = count[u]; - new_hyper_diminfo[u].block = block[u]; + new_hyper_diminfo[u].count = count[u]; + new_hyper_diminfo[u].block = block[u]; } /* end for */ /* Update space's dim info */ - if(H5S__hyper_update_diminfo(space, op, new_hyper_diminfo) < 0) + if (H5S__hyper_update_diminfo(space, op, new_hyper_diminfo) < 0) HGOTO_ERROR(H5E_DATASPACE, H5E_CANTCOUNT, FAIL, "can't update hyperslab info") } /* end if */ /* Indicate that the new_spans are owned, there's no need to free */ - if(new_spans_owned) + if (new_spans_owned) new_spans = NULL; } /* end else */ done: - if(new_spans) + if (new_spans) H5S__hyper_free_span_info(new_spans); FUNC_LEAVE_NOAPI(ret_value) } /* end H5S__generate_hyperslab() */ - /*------------------------------------------------------------------------- * Function: H5S__set_regular_hyperslab * @@ -9501,12 +9555,12 @@ done: *------------------------------------------------------------------------- */ herr_t -H5S__set_regular_hyperslab(H5S_t *space, const hsize_t start[], - const hsize_t *app_stride, const hsize_t app_count[], const hsize_t *app_block, - const hsize_t *opt_stride, const hsize_t opt_count[], const hsize_t *opt_block) +H5S__set_regular_hyperslab(H5S_t *space, const hsize_t start[], const hsize_t *app_stride, + const hsize_t app_count[], const hsize_t *app_block, const hsize_t *opt_stride, + const hsize_t opt_count[], const hsize_t *opt_block) { - unsigned u; /* Local index variable */ - herr_t ret_value = SUCCEED; /* Return value */ + unsigned u; /* Local index variable */ + herr_t ret_value = SUCCEED; /* Return value */ FUNC_ENTER_STATIC @@ -9521,27 +9575,27 @@ H5S__set_regular_hyperslab(H5S_t *space, const hsize_t start[], HDassert(opt_block); /* If we are setting a new selection, remove current selection first */ - if(H5S_SELECT_RELEASE(space) < 0) + if (H5S_SELECT_RELEASE(space) < 0) HGOTO_ERROR(H5E_DATASPACE, H5E_CANTDELETE, FAIL, "can't release selection") /* Allocate space for the hyperslab selection information */ - if(NULL == (space->select.sel_info.hslab = H5FL_MALLOC(H5S_hyper_sel_t))) + if (NULL == (space->select.sel_info.hslab = H5FL_MALLOC(H5S_hyper_sel_t))) HGOTO_ERROR(H5E_DATASPACE, H5E_CANTALLOC, FAIL, "can't allocate hyperslab info") /* Set the diminfo */ - space->select.num_elem = 1; + space->select.num_elem = 1; space->select.sel_info.hslab->unlim_dim = -1; - for(u = 0; u < space->extent.rank; u++) { + for (u = 0; u < space->extent.rank; u++) { /* Set application and optimized hyperslab info */ - space->select.sel_info.hslab->diminfo.app[u].start = start[u]; + space->select.sel_info.hslab->diminfo.app[u].start = start[u]; space->select.sel_info.hslab->diminfo.app[u].stride = app_stride[u]; - space->select.sel_info.hslab->diminfo.app[u].count = app_count[u]; - space->select.sel_info.hslab->diminfo.app[u].block = app_block[u]; + space->select.sel_info.hslab->diminfo.app[u].count = app_count[u]; + space->select.sel_info.hslab->diminfo.app[u].block = app_block[u]; - space->select.sel_info.hslab->diminfo.opt[u].start = start[u]; + space->select.sel_info.hslab->diminfo.opt[u].start = start[u]; space->select.sel_info.hslab->diminfo.opt[u].stride = opt_stride[u]; - space->select.sel_info.hslab->diminfo.opt[u].count = opt_count[u]; - space->select.sel_info.hslab->diminfo.opt[u].block = opt_block[u]; + space->select.sel_info.hslab->diminfo.opt[u].count = opt_count[u]; + space->select.sel_info.hslab->diminfo.opt[u].block = opt_block[u]; /* Update # of elements selected */ space->select.num_elem *= (opt_count[u] * opt_block[u]); @@ -9550,20 +9604,21 @@ H5S__set_regular_hyperslab(H5S_t *space, const hsize_t start[], space->select.sel_info.hslab->diminfo.low_bounds[u] = start[u]; /* Check for unlimited dimension & set high bound */ - if((app_count[u] == H5S_UNLIMITED) || (app_block[u] == H5S_UNLIMITED)) { - space->select.sel_info.hslab->unlim_dim = (int)u; + if ((app_count[u] == H5S_UNLIMITED) || (app_block[u] == H5S_UNLIMITED)) { + space->select.sel_info.hslab->unlim_dim = (int)u; space->select.sel_info.hslab->diminfo.high_bounds[u] = H5S_UNLIMITED; } /* end if */ else - space->select.sel_info.hslab->diminfo.high_bounds[u] = start[u] + opt_stride[u] * (opt_count[u] - 1) + (opt_block[u] - 1); + space->select.sel_info.hslab->diminfo.high_bounds[u] = + start[u] + opt_stride[u] * (opt_count[u] - 1) + (opt_block[u] - 1); } /* end for */ /* Handle unlimited selections */ - if(space->select.sel_info.hslab->unlim_dim >= 0) { + if (space->select.sel_info.hslab->unlim_dim >= 0) { /* Calculate num_elem_non_unlim */ space->select.sel_info.hslab->num_elem_non_unlim = (hsize_t)1; - for(u = 0; u < space->extent.rank; u++) - if((int)u != space->select.sel_info.hslab->unlim_dim) + for (u = 0; u < space->extent.rank; u++) + if ((int)u != space->select.sel_info.hslab->unlim_dim) space->select.sel_info.hslab->num_elem_non_unlim *= (opt_count[u] * opt_block[u]); /* Update num_elem */ @@ -9583,7 +9638,6 @@ done: FUNC_LEAVE_NOAPI(ret_value) } /* end H5S__set_regular_hyperslab() */ - /*------------------------------------------------------------------------- * Function: H5S__hyper_regular_and_single_block * @@ -9601,14 +9655,13 @@ done: *------------------------------------------------------------------------- */ static herr_t -H5S__hyper_regular_and_single_block(H5S_t *space, const hsize_t start[], - const hsize_t block[]) +H5S__hyper_regular_and_single_block(H5S_t *space, const hsize_t start[], const hsize_t block[]) { - hsize_t select_end, block_end; /* End of block & selection */ - hbool_t single_block; /* Whether the selection is a single block */ - hbool_t overlap; /* Whether block & selection overlap */ - unsigned u; /* Local index variable */ - herr_t ret_value = SUCCEED; /* Return value */ + hsize_t select_end, block_end; /* End of block & selection */ + hbool_t single_block; /* Whether the selection is a single block */ + hbool_t overlap; /* Whether block & selection overlap */ + unsigned u; /* Local index variable */ + herr_t ret_value = SUCCEED; /* Return value */ FUNC_ENTER_STATIC @@ -9619,26 +9672,27 @@ H5S__hyper_regular_and_single_block(H5S_t *space, const hsize_t start[], /* Check for single block selection in dataspace */ single_block = TRUE; - for(u = 0; u < space->extent.rank; u++) - if(1 != space->select.sel_info.hslab->diminfo.opt[u].count) { + for (u = 0; u < space->extent.rank; u++) + if (1 != space->select.sel_info.hslab->diminfo.opt[u].count) { single_block = FALSE; break; } /* end if */ /* Perform different optimizations, based on type of regular selection */ - if(single_block) { - hsize_t new_start[H5S_MAX_RANK]; /* New starting coordinate */ - hsize_t new_block[H5S_MAX_RANK]; /* New block size */ + if (single_block) { + hsize_t new_start[H5S_MAX_RANK]; /* New starting coordinate */ + hsize_t new_block[H5S_MAX_RANK]; /* New block size */ /* Check for overlap and compute new start offset & block sizes */ overlap = TRUE; - for(u = 0; u < space->extent.rank; u++) { + for (u = 0; u < space->extent.rank; u++) { /* Compute the end of the selection & block in this dimension */ select_end = space->select.sel_info.hslab->diminfo.high_bounds[u]; - block_end = (start[u] + block[u]) - 1; + block_end = (start[u] + block[u]) - 1; /* Check for overlap */ - if(!H5S_RANGE_OVERLAP(space->select.sel_info.hslab->diminfo.opt[u].start, select_end, start[u], block_end)) { + if (!H5S_RANGE_OVERLAP(space->select.sel_info.hslab->diminfo.opt[u].start, select_end, start[u], + block_end)) { overlap = FALSE; break; } /* end if */ @@ -9649,125 +9703,122 @@ H5S__hyper_regular_and_single_block(H5S_t *space, const hsize_t start[], } /* end for */ /* Check for overlap of selection & block */ - if(overlap) { + if (overlap) { /* Set selection to regular hyperslab */ - if(H5S__set_regular_hyperslab(space, new_start, H5S_hyper_ones_g, H5S_hyper_ones_g, new_block, - H5S_hyper_ones_g, H5S_hyper_ones_g, new_block) < 0) + if (H5S__set_regular_hyperslab(space, new_start, H5S_hyper_ones_g, H5S_hyper_ones_g, new_block, + H5S_hyper_ones_g, H5S_hyper_ones_g, new_block) < 0) HGOTO_ERROR(H5E_DATASPACE, H5E_CANTSET, FAIL, "can't set regular hyperslab selection") } /* end if */ else /* Selection & block don't overlap, set to "none" selection */ - if(H5S_select_none(space) < 0) - HGOTO_ERROR(H5E_DATASPACE, H5E_CANTSELECT, FAIL, "can't convert selection") + if (H5S_select_none(space) < 0) + HGOTO_ERROR(H5E_DATASPACE, H5E_CANTSELECT, FAIL, "can't convert selection") } /* end if */ else { hsize_t new_start[H5S_MAX_RANK]; /* New start for hyperslab selection */ hsize_t new_count[H5S_MAX_RANK]; /* New count for hyperslab selection */ - hsize_t stride[H5S_MAX_RANK]; /* Stride for hyperslab selection */ + hsize_t stride[H5S_MAX_RANK]; /* Stride for hyperslab selection */ hsize_t new_block[H5S_MAX_RANK]; /* New block for hyperslab selection */ - hbool_t partial_first_span; /* Whether first span in intersection is partial */ - hbool_t partial_last_span; /* Whether last span in intersection is partial */ + hbool_t partial_first_span; /* Whether first span in intersection is partial */ + hbool_t partial_last_span; /* Whether last span in intersection is partial */ /* Iterate over selection, checking for overlap and computing first / last * span that intersects with the block. */ - overlap = TRUE; + overlap = TRUE; partial_first_span = FALSE; - partial_last_span = FALSE; - for(u = 0; u < space->extent.rank; u++) { - hsize_t first_span_start, first_span_end; /* Start / end of first span */ + partial_last_span = FALSE; + for (u = 0; u < space->extent.rank; u++) { + hsize_t first_span_start, first_span_end; /* Start / end of first span */ hsize_t last_span_start, last_span_end; /* Start / end of last span */ - hsize_t nstride; /* Number of strides into the selection */ + hsize_t nstride; /* Number of strides into the selection */ /* Compute the end of the selection & block in this dimension */ select_end = space->select.sel_info.hslab->diminfo.high_bounds[u]; - block_end = (start[u] + block[u]) - 1; + block_end = (start[u] + block[u]) - 1; /* Check for overlap */ - if(!H5S_RANGE_OVERLAP(space->select.sel_info.hslab->diminfo.opt[u].start, select_end, start[u], block_end)) { + if (!H5S_RANGE_OVERLAP(space->select.sel_info.hslab->diminfo.opt[u].start, select_end, start[u], + block_end)) { overlap = FALSE; break; } /* end if */ /* Find first span that is before or overlaps with start of block */ - if(space->select.sel_info.hslab->diminfo.opt[u].start >= start[u]) { + if (space->select.sel_info.hslab->diminfo.opt[u].start >= start[u]) { /* Calculate start & end of first span */ first_span_start = space->select.sel_info.hslab->diminfo.opt[u].start; - first_span_end = (first_span_start + - space->select.sel_info.hslab->diminfo.opt[u].block) - 1; + first_span_end = (first_span_start + space->select.sel_info.hslab->diminfo.opt[u].block) - 1; /* Check if first span overlaps _end_ of block */ - if(block_end >= first_span_start && block_end <= first_span_end) + if (block_end >= first_span_start && block_end <= first_span_end) partial_first_span = TRUE; } /* end if */ else { - hsize_t adj_start; /* Start coord, adjusted for hyperslab selection parameters */ + hsize_t adj_start; /* Start coord, adjusted for hyperslab selection parameters */ /* Adjust start coord for selection's 'start' offset */ adj_start = start[u] - space->select.sel_info.hslab->diminfo.opt[u].start; /* Compute # of strides into the selection */ - if(space->select.sel_info.hslab->diminfo.opt[u].count > 1) + if (space->select.sel_info.hslab->diminfo.opt[u].count > 1) nstride = adj_start / space->select.sel_info.hslab->diminfo.opt[u].stride; else nstride = 0; /* Calculate start & end of first span */ first_span_start = space->select.sel_info.hslab->diminfo.opt[u].start + - (nstride * space->select.sel_info.hslab->diminfo.opt[u].stride); - first_span_end = (first_span_start + - space->select.sel_info.hslab->diminfo.opt[u].block) - 1; + (nstride * space->select.sel_info.hslab->diminfo.opt[u].stride); + first_span_end = (first_span_start + space->select.sel_info.hslab->diminfo.opt[u].block) - 1; /* Check if first span overlaps start of block */ - if(first_span_start < start[u] && first_span_end >= start[u]) + if (first_span_start < start[u] && first_span_end >= start[u]) partial_first_span = TRUE; /* Advance first span to start higher than block's start, * if it's not partial. */ - if(first_span_end < start[u]) { + if (first_span_end < start[u]) { first_span_start += space->select.sel_info.hslab->diminfo.opt[u].stride; first_span_end += space->select.sel_info.hslab->diminfo.opt[u].stride; } /* end if */ - } /* end else */ + } /* end else */ /* Find last span that is before or overlaps with end of block */ - if(select_end < block_end) { + if (select_end < block_end) { /* Calculate start & end of last span */ - last_span_start = (select_end - - space->select.sel_info.hslab->diminfo.opt[u].block) + 1; - last_span_end = select_end; + last_span_start = (select_end - space->select.sel_info.hslab->diminfo.opt[u].block) + 1; + last_span_end = select_end; /* Check if last span overlaps _start_ of block */ - if(start[u] >= last_span_start && start[u] <= last_span_end) + if (start[u] >= last_span_start && start[u] <= last_span_end) partial_last_span = TRUE; } /* end if */ else { - hsize_t adj_end; /* End coord, adjusted for hyperslab selection parameters */ + hsize_t adj_end; /* End coord, adjusted for hyperslab selection parameters */ /* Adjust end coord for selection's 'start' offset */ adj_end = block_end - space->select.sel_info.hslab->diminfo.opt[u].start; /* Compute # of strides into the selection */ - if(space->select.sel_info.hslab->diminfo.opt[u].count > 1) + if (space->select.sel_info.hslab->diminfo.opt[u].count > 1) nstride = adj_end / space->select.sel_info.hslab->diminfo.opt[u].stride; else nstride = 0; /* Calculate start & end of last span */ last_span_start = space->select.sel_info.hslab->diminfo.opt[u].start + - (nstride * space->select.sel_info.hslab->diminfo.opt[u].stride); - last_span_end = (last_span_start + - space->select.sel_info.hslab->diminfo.opt[u].block) - 1; + (nstride * space->select.sel_info.hslab->diminfo.opt[u].stride); + last_span_end = (last_span_start + space->select.sel_info.hslab->diminfo.opt[u].block) - 1; /* Check if last span overlaps end of block */ - if(block_end >= last_span_start && block_end <= last_span_end) + if (block_end >= last_span_start && block_end <= last_span_end) partial_last_span = TRUE; } /* end else */ /* Check if no spans are inside block */ /* (Can happen when block falls in "gap" between spans) */ - if(last_span_end < start[u]) { + if (last_span_end < start[u]) { overlap = FALSE; break; } /* end if */ @@ -9777,9 +9828,10 @@ H5S__hyper_regular_and_single_block(H5S_t *space, const hsize_t start[], /* Compute new start / count / block values */ new_start[u] = first_span_start; - if(last_span_start != first_span_start) + if (last_span_start != first_span_start) new_count[u] = ((last_span_start - first_span_start) / - space->select.sel_info.hslab->diminfo.opt[u].stride) + 1; + space->select.sel_info.hslab->diminfo.opt[u].stride) + + 1; else new_count[u] = 1; new_block[u] = space->select.sel_info.hslab->diminfo.opt[u].block; @@ -9789,35 +9841,35 @@ H5S__hyper_regular_and_single_block(H5S_t *space, const hsize_t start[], } /* end for */ /* Check for overlap of selection & block */ - if(overlap) { + if (overlap) { /* Set selection to regular hyperslab */ - if(H5S__set_regular_hyperslab(space, new_start, stride, new_count, new_block, - stride, new_count, new_block) < 0) + if (H5S__set_regular_hyperslab(space, new_start, stride, new_count, new_block, stride, new_count, + new_block) < 0) HGOTO_ERROR(H5E_DATASPACE, H5E_CANTSET, FAIL, "can't set regular hyperslab selection") /* If there's a partial first or last span, have to 'AND' against selection */ - if(partial_first_span || partial_last_span) { + if (partial_first_span || partial_last_span) { /* Generate span tree for regular selection */ - if(H5S__hyper_generate_spans(space) < 0) + if (H5S__hyper_generate_spans(space) < 0) HGOTO_ERROR(H5E_DATASPACE, H5E_UNINITIALIZED, FAIL, "dataspace does not have span tree") /* 'AND' against block */ - if(H5S__generate_hyperslab(space, H5S_SELECT_AND, start, H5S_hyper_ones_g, H5S_hyper_ones_g, block) < 0) + if (H5S__generate_hyperslab(space, H5S_SELECT_AND, start, H5S_hyper_ones_g, H5S_hyper_ones_g, + block) < 0) HGOTO_ERROR(H5E_DATASPACE, H5E_CANTINSERT, FAIL, "can't generate hyperslabs") } /* end if */ - } /* end if */ + } /* end if */ else { /* Selection & block don't overlap, set to "none" selection */ - if(H5S_select_none(space) < 0) + if (H5S_select_none(space) < 0) HGOTO_ERROR(H5E_DATASPACE, H5E_CANTSELECT, FAIL, "can't convert selection") } /* end else */ - } /* end else */ + } /* end else */ done: FUNC_LEAVE_NOAPI(ret_value) } /* end H5S__hyper_regular_and_single_block() */ - /*------------------------------------------------------------------------- * Function: H5S_select_hyperslab * @@ -9831,18 +9883,18 @@ done: *------------------------------------------------------------------------- */ herr_t -H5S_select_hyperslab(H5S_t *space, H5S_seloper_t op, const hsize_t start[], - const hsize_t *stride, const hsize_t count[], const hsize_t *block) +H5S_select_hyperslab(H5S_t *space, H5S_seloper_t op, const hsize_t start[], const hsize_t *stride, + const hsize_t count[], const hsize_t *block) { - hsize_t int_stride[H5S_MAX_RANK]; /* Internal storage for stride information */ - hsize_t int_count[H5S_MAX_RANK]; /* Internal storage for count information */ - hsize_t int_block[H5S_MAX_RANK]; /* Internal storage for block information */ - const hsize_t *opt_stride; /* Optimized stride information */ - const hsize_t *opt_count; /* Optimized count information */ - const hsize_t *opt_block; /* Optimized block information */ - int unlim_dim = -1; /* Unlimited dimension in selection, of -1 if none */ - unsigned u; /* Local index variable */ - herr_t ret_value = SUCCEED; /* Return value */ + hsize_t int_stride[H5S_MAX_RANK]; /* Internal storage for stride information */ + hsize_t int_count[H5S_MAX_RANK]; /* Internal storage for count information */ + hsize_t int_block[H5S_MAX_RANK]; /* Internal storage for block information */ + const hsize_t *opt_stride; /* Optimized stride information */ + const hsize_t *opt_count; /* Optimized count information */ + const hsize_t *opt_block; /* Optimized block information */ + int unlim_dim = -1; /* Unlimited dimension in selection, of -1 if none */ + unsigned u; /* Local index variable */ + herr_t ret_value = SUCCEED; /* Return value */ FUNC_ENTER_NOAPI(FAIL) @@ -9853,34 +9905,34 @@ H5S_select_hyperslab(H5S_t *space, H5S_seloper_t op, const hsize_t start[], HDassert(op > H5S_SELECT_NOOP && op < H5S_SELECT_INVALID); /* Point to the correct stride values */ - if(stride == NULL) + if (stride == NULL) stride = H5S_hyper_ones_g; /* Point to the correct block values */ - if(block == NULL) + if (block == NULL) block = H5S_hyper_ones_g; /* Check new selection */ - for(u = 0; u < space->extent.rank; u++) { + for (u = 0; u < space->extent.rank; u++) { /* Check for overlapping hyperslab blocks in new selection. */ - if(count[u] > 1 && stride[u] < block[u]) + if (count[u] > 1 && stride[u] < block[u]) HGOTO_ERROR(H5E_ARGS, H5E_BADVALUE, FAIL, "hyperslab blocks overlap") /* Detect zero-sized hyperslabs in new selection */ - if(count[u] == 0 || block[u] == 0) { - switch(op) { - case H5S_SELECT_SET: /* Select "set" operation */ - case H5S_SELECT_AND: /* Binary "and" operation for hyperslabs */ - case H5S_SELECT_NOTA: /* Binary "B not A" operation for hyperslabs */ + if (count[u] == 0 || block[u] == 0) { + switch (op) { + case H5S_SELECT_SET: /* Select "set" operation */ + case H5S_SELECT_AND: /* Binary "and" operation for hyperslabs */ + case H5S_SELECT_NOTA: /* Binary "B not A" operation for hyperslabs */ /* Convert to "none" selection */ - if(H5S_select_none(space) < 0) + if (H5S_select_none(space) < 0) HGOTO_ERROR(H5E_DATASPACE, H5E_CANTSELECT, FAIL, "can't convert selection") HGOTO_DONE(SUCCEED); - case H5S_SELECT_OR: /* Binary "or" operation for hyperslabs */ - case H5S_SELECT_XOR: /* Binary "xor" operation for hyperslabs */ - case H5S_SELECT_NOTB: /* Binary "A not B" operation for hyperslabs */ - HGOTO_DONE(SUCCEED); /* Selection stays same */ + case H5S_SELECT_OR: /* Binary "or" operation for hyperslabs */ + case H5S_SELECT_XOR: /* Binary "xor" operation for hyperslabs */ + case H5S_SELECT_NOTB: /* Binary "A not B" operation for hyperslabs */ + HGOTO_DONE(SUCCEED); /* Selection stays same */ case H5S_SELECT_NOOP: case H5S_SELECT_APPEND: @@ -9889,73 +9941,75 @@ H5S_select_hyperslab(H5S_t *space, H5S_seloper_t op, const hsize_t start[], default: HGOTO_ERROR(H5E_ARGS, H5E_UNSUPPORTED, FAIL, "invalid selection operation") } /* end switch */ - } /* end if */ + } /* end if */ /* Check for unlimited dimension */ - if((count[u] == H5S_UNLIMITED) || (block[u] == H5S_UNLIMITED)) { - if(unlim_dim >= 0) - HGOTO_ERROR(H5E_DATASPACE, H5E_UNSUPPORTED, FAIL, "cannot have more than one unlimited dimension in selection") + if ((count[u] == H5S_UNLIMITED) || (block[u] == H5S_UNLIMITED)) { + if (unlim_dim >= 0) + HGOTO_ERROR(H5E_DATASPACE, H5E_UNSUPPORTED, FAIL, + "cannot have more than one unlimited dimension in selection") else { - if(count[u] == block[u]) /* Both are H5S_UNLIMITED */ - HGOTO_ERROR(H5E_DATASPACE, H5E_UNSUPPORTED, FAIL, "count and block cannot both be unlimited") + if (count[u] == block[u]) /* Both are H5S_UNLIMITED */ + HGOTO_ERROR(H5E_DATASPACE, H5E_UNSUPPORTED, FAIL, + "count and block cannot both be unlimited") unlim_dim = (int)u; } /* end else */ - } /* end if */ - } /* end for */ + } /* end if */ + } /* end for */ /* Optimize hyperslab parameters to merge contiguous blocks, etc. */ - if(stride == H5S_hyper_ones_g && block == H5S_hyper_ones_g) { + if (stride == H5S_hyper_ones_g && block == H5S_hyper_ones_g) { /* Point to existing arrays */ opt_stride = H5S_hyper_ones_g; - opt_count = H5S_hyper_ones_g; - opt_block = count; + opt_count = H5S_hyper_ones_g; + opt_block = count; } /* end if */ else { /* Point to local arrays */ opt_stride = int_stride; - opt_count = int_count; - opt_block = int_block; - for(u = 0; u < space->extent.rank; u++) { + opt_count = int_count; + opt_block = int_block; + for (u = 0; u < space->extent.rank; u++) { /* contiguous hyperslabs have the block size equal to the stride */ - if((stride[u] == block[u]) && (count[u] != H5S_UNLIMITED)) { - int_count[u] = 1; + if ((stride[u] == block[u]) && (count[u] != H5S_UNLIMITED)) { + int_count[u] = 1; int_stride[u] = 1; - if(block[u] == 1) + if (block[u] == 1) int_block[u] = count[u]; else int_block[u] = block[u] * count[u]; } /* end if */ else { - if(count[u] == 1) + if (count[u] == 1) int_stride[u] = 1; else { HDassert((stride[u] > block[u]) || - ((stride[u] == block[u]) && (count[u] == H5S_UNLIMITED))); + ((stride[u] == block[u]) && (count[u] == H5S_UNLIMITED))); int_stride[u] = stride[u]; } /* end else */ int_count[u] = count[u]; int_block[u] = block[u]; } /* end else */ - } /* end for */ - } /* end else */ + } /* end for */ + } /* end else */ /* Check for operating on unlimited selection */ - if((H5S_GET_SELECT_TYPE(space) == H5S_SEL_HYPERSLABS) - && (space->select.sel_info.hslab->unlim_dim >= 0) - && (op != H5S_SELECT_SET)) { + if ((H5S_GET_SELECT_TYPE(space) == H5S_SEL_HYPERSLABS) && + (space->select.sel_info.hslab->unlim_dim >= 0) && (op != H5S_SELECT_SET)) { /* Check for invalid operation */ - if(unlim_dim >= 0) - HGOTO_ERROR(H5E_DATASPACE, H5E_UNSUPPORTED, FAIL, "cannot modify unlimited selection with another unlimited selection") - if(!((op == H5S_SELECT_AND) || (op == H5S_SELECT_NOTA))) + if (unlim_dim >= 0) + HGOTO_ERROR(H5E_DATASPACE, H5E_UNSUPPORTED, FAIL, + "cannot modify unlimited selection with another unlimited selection") + if (!((op == H5S_SELECT_AND) || (op == H5S_SELECT_NOTA))) HGOTO_ERROR(H5E_DATASPACE, H5E_UNSUPPORTED, FAIL, "unsupported operation on unlimited selection") HDassert(space->select.sel_info.hslab->diminfo_valid); /* Clip unlimited selection to include new selection */ - if(H5S_hyper_clip_unlim(space, - start[space->select.sel_info.hslab->unlim_dim] - + ((opt_count[space->select.sel_info.hslab->unlim_dim] - (hsize_t)1) - * opt_stride[space->select.sel_info.hslab->unlim_dim]) - + opt_block[space->select.sel_info.hslab->unlim_dim]) < 0) + if (H5S_hyper_clip_unlim(space, + start[space->select.sel_info.hslab->unlim_dim] + + ((opt_count[space->select.sel_info.hslab->unlim_dim] - (hsize_t)1) * + opt_stride[space->select.sel_info.hslab->unlim_dim]) + + opt_block[space->select.sel_info.hslab->unlim_dim]) < 0) HGOTO_ERROR(H5E_DATASPACE, H5E_CANTCLIP, FAIL, "failed to clip unlimited selection") /* If an empty space was returned it must be "none" */ @@ -9963,22 +10017,22 @@ H5S_select_hyperslab(H5S_t *space, H5S_seloper_t op, const hsize_t start[], } /* end if */ /* Fixup operation for non-hyperslab selections */ - switch(H5S_GET_SELECT_TYPE(space)) { - case H5S_SEL_NONE: /* No elements selected in dataspace */ - switch(op) { - case H5S_SELECT_SET: /* Select "set" operation */ + switch (H5S_GET_SELECT_TYPE(space)) { + case H5S_SEL_NONE: /* No elements selected in dataspace */ + switch (op) { + case H5S_SELECT_SET: /* Select "set" operation */ /* Change "none" selection to hyperslab selection */ break; - case H5S_SELECT_OR: /* Binary "or" operation for hyperslabs */ - case H5S_SELECT_XOR: /* Binary "xor" operation for hyperslabs */ - case H5S_SELECT_NOTA: /* Binary "B not A" operation for hyperslabs */ + case H5S_SELECT_OR: /* Binary "or" operation for hyperslabs */ + case H5S_SELECT_XOR: /* Binary "xor" operation for hyperslabs */ + case H5S_SELECT_NOTA: /* Binary "B not A" operation for hyperslabs */ op = H5S_SELECT_SET; /* Maps to "set" operation when applied to "none" selection */ break; - case H5S_SELECT_AND: /* Binary "and" operation for hyperslabs */ - case H5S_SELECT_NOTB: /* Binary "A not B" operation for hyperslabs */ - HGOTO_DONE(SUCCEED); /* Selection stays "none" */ + case H5S_SELECT_AND: /* Binary "and" operation for hyperslabs */ + case H5S_SELECT_NOTB: /* Binary "A not B" operation for hyperslabs */ + HGOTO_DONE(SUCCEED); /* Selection stays "none" */ case H5S_SELECT_NOOP: case H5S_SELECT_APPEND: @@ -9989,43 +10043,44 @@ H5S_select_hyperslab(H5S_t *space, H5S_seloper_t op, const hsize_t start[], } /* end switch */ break; - case H5S_SEL_ALL: /* All elements selected in dataspace */ - switch(op) { - case H5S_SELECT_SET: /* Select "set" operation */ + case H5S_SEL_ALL: /* All elements selected in dataspace */ + switch (op) { + case H5S_SELECT_SET: /* Select "set" operation */ /* Change "all" selection to hyperslab selection */ break; - case H5S_SELECT_OR: /* Binary "or" operation for hyperslabs */ - HGOTO_DONE(SUCCEED); /* Selection stays "all" */ + case H5S_SELECT_OR: /* Binary "or" operation for hyperslabs */ + HGOTO_DONE(SUCCEED); /* Selection stays "all" */ - case H5S_SELECT_AND: /* Binary "and" operation for hyperslabs */ + case H5S_SELECT_AND: /* Binary "and" operation for hyperslabs */ op = H5S_SELECT_SET; /* Maps to "set" operation when applied to "none" selection */ break; - case H5S_SELECT_XOR: /* Binary "xor" operation for hyperslabs */ - case H5S_SELECT_NOTB: /* Binary "A not B" operation for hyperslabs */ + case H5S_SELECT_XOR: /* Binary "xor" operation for hyperslabs */ + case H5S_SELECT_NOTB: /* Binary "A not B" operation for hyperslabs */ /* Convert current "all" selection to "real" hyperslab selection */ /* Then allow operation to proceed */ { - const hsize_t *tmp_start; /* Temporary start information */ - const hsize_t *tmp_stride; /* Temporary stride information */ - const hsize_t *tmp_count; /* Temporary count information */ - const hsize_t *tmp_block; /* Temporary block information */ + const hsize_t *tmp_start; /* Temporary start information */ + const hsize_t *tmp_stride; /* Temporary stride information */ + const hsize_t *tmp_count; /* Temporary count information */ + const hsize_t *tmp_block; /* Temporary block information */ /* Set up temporary information for the dimensions */ - tmp_start = H5S_hyper_zeros_g; + tmp_start = H5S_hyper_zeros_g; tmp_stride = tmp_count = H5S_hyper_ones_g; - tmp_block = space->extent.size; + tmp_block = space->extent.size; /* Convert to hyperslab selection */ - if(H5S_select_hyperslab(space, H5S_SELECT_SET, tmp_start, tmp_stride, tmp_count, tmp_block) < 0) + if (H5S_select_hyperslab(space, H5S_SELECT_SET, tmp_start, tmp_stride, tmp_count, + tmp_block) < 0) HGOTO_ERROR(H5E_DATASPACE, H5E_CANTDELETE, FAIL, "can't convert selection") } /* end case */ break; - case H5S_SELECT_NOTA: /* Binary "B not A" operation for hyperslabs */ + case H5S_SELECT_NOTA: /* Binary "B not A" operation for hyperslabs */ /* Convert to "none" selection */ - if(H5S_select_none(space) < 0) + if (H5S_select_none(space) < 0) HGOTO_ERROR(H5E_DATASPACE, H5E_CANTSELECT, FAIL, "can't convert selection") HGOTO_DONE(SUCCEED); @@ -10042,8 +10097,8 @@ H5S_select_hyperslab(H5S_t *space, H5S_seloper_t op, const hsize_t start[], /* Hyperslab operation on hyperslab selection, OK */ break; - case H5S_SEL_POINTS: /* Can't combine hyperslab operations and point selections currently */ - if(op == H5S_SELECT_SET) /* Allow only "set" operation to proceed */ + case H5S_SEL_POINTS: /* Can't combine hyperslab operations and point selections currently */ + if (op == H5S_SELECT_SET) /* Allow only "set" operation to proceed */ break; /* Else fall through to error */ H5_ATTR_FALLTHROUGH @@ -10054,54 +10109,58 @@ H5S_select_hyperslab(H5S_t *space, H5S_seloper_t op, const hsize_t start[], HGOTO_ERROR(H5E_ARGS, H5E_UNSUPPORTED, FAIL, "invalid selection operation") } /* end switch */ - if(op == H5S_SELECT_SET) { + if (op == H5S_SELECT_SET) { /* Set selection to regular hyperslab */ - if(H5S__set_regular_hyperslab(space, start, stride, count, block, opt_stride, opt_count, opt_block) < 0) + if (H5S__set_regular_hyperslab(space, start, stride, count, block, opt_stride, opt_count, opt_block) < + 0) HGOTO_ERROR(H5E_DATASPACE, H5E_CANTSET, FAIL, "can't set regular hyperslab selection") } /* end if */ - else if(op >= H5S_SELECT_OR && op <= H5S_SELECT_NOTA) { - hbool_t single_block; /* Whether the selection is a single block */ + else if (op >= H5S_SELECT_OR && op <= H5S_SELECT_NOTA) { + hbool_t single_block; /* Whether the selection is a single block */ /* Sanity check */ HDassert(H5S_GET_SELECT_TYPE(space) == H5S_SEL_HYPERSLABS); /* Handle unlimited selections */ - if(unlim_dim >= 0) { + if (unlim_dim >= 0) { hsize_t bounds_start[H5S_MAX_RANK]; hsize_t bounds_end[H5S_MAX_RANK]; hsize_t tmp_count = opt_count[unlim_dim]; hsize_t tmp_block = opt_block[unlim_dim]; /* Check for invalid operation */ - if(space->select.sel_info.hslab->unlim_dim >= 0) - HGOTO_ERROR(H5E_DATASPACE, H5E_UNSUPPORTED, FAIL, "cannot modify unlimited selection with another unlimited selection") - if(!((op == H5S_SELECT_AND) || (op == H5S_SELECT_NOTB))) - HGOTO_ERROR(H5E_DATASPACE, H5E_UNSUPPORTED, FAIL, "unsupported operation with unlimited selection") + if (space->select.sel_info.hslab->unlim_dim >= 0) + HGOTO_ERROR(H5E_DATASPACE, H5E_UNSUPPORTED, FAIL, + "cannot modify unlimited selection with another unlimited selection") + if (!((op == H5S_SELECT_AND) || (op == H5S_SELECT_NOTB))) + HGOTO_ERROR(H5E_DATASPACE, H5E_UNSUPPORTED, FAIL, + "unsupported operation with unlimited selection") /* Get bounds of existing selection */ - if(H5S__hyper_bounds(space, bounds_start, bounds_end) < 0) + if (H5S__hyper_bounds(space, bounds_start, bounds_end) < 0) HGOTO_ERROR(H5E_DATASPACE, H5E_CANTGET, FAIL, "can't get selection bounds") /* Patch count and block to remove unlimited and include the * existing selection. */ - H5S__hyper_get_clip_diminfo(start[unlim_dim], opt_stride[unlim_dim], &tmp_count, &tmp_block, bounds_end[unlim_dim] + (hsize_t)1); + H5S__hyper_get_clip_diminfo(start[unlim_dim], opt_stride[unlim_dim], &tmp_count, &tmp_block, + bounds_end[unlim_dim] + (hsize_t)1); HDassert((tmp_count == 1) || (opt_count != H5S_hyper_ones_g)); HDassert((tmp_block == 1) || (opt_block != H5S_hyper_ones_g)); - if(opt_count != H5S_hyper_ones_g) { + if (opt_count != H5S_hyper_ones_g) { HDassert(opt_count == int_count); int_count[unlim_dim] = tmp_count; } /* end if */ - if(opt_block != H5S_hyper_ones_g) { + if (opt_block != H5S_hyper_ones_g) { HDassert(opt_block == int_block); int_block[unlim_dim] = tmp_block; } /* end if */ - } /* end if */ + } /* end if */ /* Check for a single block selected */ single_block = TRUE; - for(u = 0; u < space->extent.rank; u++) - if(1 != opt_count[u]) { + for (u = 0; u < space->extent.rank; u++) + if (1 != opt_count[u]) { single_block = FALSE; break; } /* end if */ @@ -10109,25 +10168,26 @@ H5S_select_hyperslab(H5S_t *space, H5S_seloper_t op, const hsize_t start[], /* Check for single block "AND" operation on a regular hyperslab, which * is used for constructing chunk maps and can be optimized for. */ - if(H5S_SELECT_AND == op && single_block && - space->select.sel_info.hslab->diminfo_valid == H5S_DIMINFO_VALID_YES) { - if(H5S__hyper_regular_and_single_block(space, start, opt_block) < 0) - HGOTO_ERROR(H5E_DATASPACE, H5E_CANTOPERATE, FAIL, "can't 'AND' single block against regular hyperslab") + if (H5S_SELECT_AND == op && single_block && + space->select.sel_info.hslab->diminfo_valid == H5S_DIMINFO_VALID_YES) { + if (H5S__hyper_regular_and_single_block(space, start, opt_block) < 0) + HGOTO_ERROR(H5E_DATASPACE, H5E_CANTOPERATE, FAIL, + "can't 'AND' single block against regular hyperslab") } /* end if */ else { /* Check if there's no hyperslab span information currently */ - if(NULL == space->select.sel_info.hslab->span_lst) - if(H5S__hyper_generate_spans(space) < 0) + if (NULL == space->select.sel_info.hslab->span_lst) + if (H5S__hyper_generate_spans(space) < 0) HGOTO_ERROR(H5E_DATASPACE, H5E_UNINITIALIZED, FAIL, "dataspace does not have span tree") /* Set selection type */ space->select.type = H5S_sel_hyper; /* Add in the new hyperslab information */ - if(H5S__generate_hyperslab(space, op, start, opt_stride, opt_count, opt_block) < 0) + if (H5S__generate_hyperslab(space, op, start, opt_stride, opt_count, opt_block) < 0) HGOTO_ERROR(H5E_DATASPACE, H5E_CANTINSERT, FAIL, "can't generate hyperslabs") } /* end else */ - } /* end if */ + } /* end if */ else HGOTO_ERROR(H5E_ARGS, H5E_UNSUPPORTED, FAIL, "invalid selection operation") @@ -10135,7 +10195,6 @@ done: FUNC_LEAVE_NOAPI(ret_value) } /* end H5S_select_hyperslab() */ - /*-------------------------------------------------------------------------- NAME H5Sselect_hyperslab @@ -10163,8 +10222,8 @@ done: REVISION LOG --------------------------------------------------------------------------*/ herr_t -H5Sselect_hyperslab(hid_t space_id, H5S_seloper_t op, const hsize_t start[], - const hsize_t stride[], const hsize_t count[], const hsize_t block[]) +H5Sselect_hyperslab(hid_t space_id, H5S_seloper_t op, const hsize_t start[], const hsize_t stride[], + const hsize_t count[], const hsize_t block[]) { H5S_t *space; /* Dataspace to modify selection of */ herr_t ret_value = SUCCEED; /* Return value */ @@ -10173,33 +10232,32 @@ H5Sselect_hyperslab(hid_t space_id, H5S_seloper_t op, const hsize_t start[], H5TRACE6("e", "iSs*h*h*h*h", space_id, op, start, stride, count, block); /* Check args */ - if(NULL == (space = (H5S_t *)H5I_object_verify(space_id, H5I_DATASPACE))) + if (NULL == (space = (H5S_t *)H5I_object_verify(space_id, H5I_DATASPACE))) HGOTO_ERROR(H5E_ARGS, H5E_BADTYPE, FAIL, "not a dataspace") - if(H5S_SCALAR == H5S_GET_EXTENT_TYPE(space)) + if (H5S_SCALAR == H5S_GET_EXTENT_TYPE(space)) HGOTO_ERROR(H5E_ARGS, H5E_BADTYPE, FAIL, "hyperslab doesn't support H5S_SCALAR space") - if(H5S_NULL == H5S_GET_EXTENT_TYPE(space)) + if (H5S_NULL == H5S_GET_EXTENT_TYPE(space)) HGOTO_ERROR(H5E_ARGS, H5E_BADTYPE, FAIL, "hyperslab doesn't support H5S_NULL space") - if(start == NULL || count == NULL) + if (start == NULL || count == NULL) HGOTO_ERROR(H5E_ARGS, H5E_BADVALUE, FAIL, "hyperslab not specified") - if(!(op > H5S_SELECT_NOOP && op < H5S_SELECT_INVALID)) + if (!(op > H5S_SELECT_NOOP && op < H5S_SELECT_INVALID)) HGOTO_ERROR(H5E_ARGS, H5E_UNSUPPORTED, FAIL, "invalid selection operation") - if(stride != NULL) { - unsigned u; /* Local index variable */ + if (stride != NULL) { + unsigned u; /* Local index variable */ /* Check for 0-sized strides */ - for(u = 0; u < space->extent.rank; u++) - if(stride[u] == 0) + for (u = 0; u < space->extent.rank; u++) + if (stride[u] == 0) HGOTO_ERROR(H5E_ARGS, H5E_BADVALUE, FAIL, "invalid stride==0 value") } /* end if */ - if(H5S_select_hyperslab(space, op, start, stride, count, block) < 0) + if (H5S_select_hyperslab(space, op, start, stride, count, block) < 0) HGOTO_ERROR(H5E_DATASPACE, H5E_CANTINIT, FAIL, "unable to set hyperslab selection") done: FUNC_LEAVE_API(ret_value) } /* end H5Sselect_hyperslab() */ - /*-------------------------------------------------------------------------- NAME H5S_combine_hyperslab @@ -10231,12 +10289,11 @@ done: REVISION LOG --------------------------------------------------------------------------*/ herr_t -H5S_combine_hyperslab(H5S_t *old_space, H5S_seloper_t op, const hsize_t start[], - const hsize_t *stride, const hsize_t count[], const hsize_t *block, - H5S_t **new_space) +H5S_combine_hyperslab(H5S_t *old_space, H5S_seloper_t op, const hsize_t start[], const hsize_t *stride, + const hsize_t count[], const hsize_t *block, H5S_t **new_space) { - unsigned u; /* Local index variable */ - herr_t ret_value = SUCCEED; /* Return value */ + unsigned u; /* Local index variable */ + herr_t ret_value = SUCCEED; /* Return value */ FUNC_ENTER_NOAPI(FAIL) @@ -10249,39 +10306,39 @@ H5S_combine_hyperslab(H5S_t *old_space, H5S_seloper_t op, const hsize_t start[], HDassert(*new_space == NULL); /* Point to the correct stride values */ - if(stride == NULL) + if (stride == NULL) stride = H5S_hyper_ones_g; /* Point to the correct block values */ - if(block == NULL) + if (block == NULL) block = H5S_hyper_ones_g; /* Check new selection. */ - for(u = 0; u < old_space->extent.rank; u++) { + for (u = 0; u < old_space->extent.rank; u++) { /* Check for overlapping hyperslab blocks in new selection. */ - if(count[u] > 1 && stride[u] < block[u]) + if (count[u] > 1 && stride[u] < block[u]) HGOTO_ERROR(H5E_ARGS, H5E_BADVALUE, FAIL, "hyperslab blocks overlap") /* Detect zero-sized hyperslabs in new selection */ - if(count[u] == 0 || block[u] == 0) { - switch(op) { - case H5S_SELECT_AND: /* Binary "and" operation for hyperslabs */ - case H5S_SELECT_NOTA: /* Binary "B not A" operation for hyperslabs */ + if (count[u] == 0 || block[u] == 0) { + switch (op) { + case H5S_SELECT_AND: /* Binary "and" operation for hyperslabs */ + case H5S_SELECT_NOTA: /* Binary "B not A" operation for hyperslabs */ /* Convert to "none" selection */ /* Copy the first dataspace without sharing the list of spans */ - if(NULL == ((*new_space) = H5S_copy(old_space, TRUE, TRUE))) + if (NULL == ((*new_space) = H5S_copy(old_space, TRUE, TRUE))) HGOTO_ERROR(H5E_DATASPACE, H5E_CANTINIT, FAIL, "unable to copy dataspace") - if(H5S_select_none((*new_space)) < 0) + if (H5S_select_none((*new_space)) < 0) HGOTO_ERROR(H5E_DATASPACE, H5E_CANTSELECT, FAIL, "can't convert selection") HGOTO_DONE(SUCCEED); - case H5S_SELECT_OR: /* Binary "or" operation for hyperslabs */ - case H5S_SELECT_XOR: /* Binary "xor" operation for hyperslabs */ - case H5S_SELECT_NOTB: /* Binary "A not B" operation for hyperslabs */ + case H5S_SELECT_OR: /* Binary "or" operation for hyperslabs */ + case H5S_SELECT_XOR: /* Binary "xor" operation for hyperslabs */ + case H5S_SELECT_NOTB: /* Binary "A not B" operation for hyperslabs */ /* Copy the first dataspace with sharing the list of spans */ - if(NULL == ((*new_space) = H5S_copy(old_space, FALSE, TRUE))) + if (NULL == ((*new_space) = H5S_copy(old_space, FALSE, TRUE))) HGOTO_ERROR(H5E_DATASPACE, H5E_CANTINIT, FAIL, "unable to copy dataspace") - HGOTO_DONE(SUCCEED); /* Selection stays same */ + HGOTO_DONE(SUCCEED); /* Selection stays same */ case H5S_SELECT_NOOP: case H5S_SELECT_SET: @@ -10291,92 +10348,95 @@ H5S_combine_hyperslab(H5S_t *old_space, H5S_seloper_t op, const hsize_t start[], default: HGOTO_ERROR(H5E_ARGS, H5E_UNSUPPORTED, FAIL, "invalid selection operation") } /* end switch */ - } /* end if */ - } /* end for */ + } /* end if */ + } /* end for */ - if(H5S_GET_SELECT_TYPE(old_space) == H5S_SEL_HYPERSLABS) { - hsize_t *old_low_bounds; /* Pointer to old space's low & high bounds */ + if (H5S_GET_SELECT_TYPE(old_space) == H5S_SEL_HYPERSLABS) { + hsize_t *old_low_bounds; /* Pointer to old space's low & high bounds */ hsize_t *old_high_bounds; - hsize_t new_low_bounds[H5S_MAX_RANK]; /* New space's low & high bounds */ - hsize_t new_high_bounds[H5S_MAX_RANK]; - hbool_t overlapped = FALSE; + hsize_t new_low_bounds[H5S_MAX_RANK]; /* New space's low & high bounds */ + hsize_t new_high_bounds[H5S_MAX_RANK]; + hbool_t overlapped = FALSE; /* Set up old space's low & high bounds */ - if(old_space->select.sel_info.hslab->span_lst) { - old_low_bounds = old_space->select.sel_info.hslab->span_lst->low_bounds; + if (old_space->select.sel_info.hslab->span_lst) { + old_low_bounds = old_space->select.sel_info.hslab->span_lst->low_bounds; old_high_bounds = old_space->select.sel_info.hslab->span_lst->high_bounds; } /* end if */ else { - old_low_bounds = old_space->select.sel_info.hslab->diminfo.low_bounds; + old_low_bounds = old_space->select.sel_info.hslab->diminfo.low_bounds; old_high_bounds = old_space->select.sel_info.hslab->diminfo.high_bounds; } /* end else */ /* Generate bounding box for hyperslab parameters */ - for(u = 0; u < old_space->extent.rank; u++) { - new_low_bounds[u] = start[u]; + for (u = 0; u < old_space->extent.rank; u++) { + new_low_bounds[u] = start[u]; new_high_bounds[u] = start[u] + stride[u] * (count[u] - 1) + (block[u] - 1); } /* end for */ /* Check bound box of both spaces to see if they overlap */ - if(H5S_RANGE_OVERLAP(old_low_bounds[0], old_high_bounds[0], - new_low_bounds[0], new_high_bounds[0])) + if (H5S_RANGE_OVERLAP(old_low_bounds[0], old_high_bounds[0], new_low_bounds[0], new_high_bounds[0])) overlapped = TRUE; /* Non-overlapping situations can be handled in special ways */ - if(!overlapped) { + if (!overlapped) { H5S_hyper_span_info_t *new_spans = NULL; - H5S_hyper_dim_t new_hyper_diminfo[H5S_MAX_RANK]; + H5S_hyper_dim_t new_hyper_diminfo[H5S_MAX_RANK]; - if(NULL == ((*new_space) = H5S_copy(old_space, TRUE, TRUE))) + if (NULL == ((*new_space) = H5S_copy(old_space, TRUE, TRUE))) HGOTO_ERROR(H5E_DATASPACE, H5E_CANTCOPY, FAIL, "unable to copy dataspace") - if(NULL != (*new_space)->select.sel_info.hslab->span_lst) { + if (NULL != (*new_space)->select.sel_info.hslab->span_lst) { old_space->select.sel_info.hslab->span_lst->count--; (*new_space)->select.sel_info.hslab->span_lst = NULL; } /* end if */ /* Generate hyperslab info for new space */ - switch(op) { + switch (op) { case H5S_SELECT_OR: case H5S_SELECT_XOR: /* Add the new space to the space */ - if(NULL == (new_spans = H5S__hyper_make_spans(old_space->extent.rank, start, stride, count, block))) + if (NULL == (new_spans = H5S__hyper_make_spans(old_space->extent.rank, start, stride, + count, block))) HGOTO_ERROR(H5E_DATASPACE, H5E_CANTINSERT, FAIL, "can't create hyperslab information") - if(NULL != old_space->select.sel_info.hslab->span_lst) - (*new_space)->select.sel_info.hslab->span_lst = H5S__hyper_copy_span(old_space->select.sel_info.hslab->span_lst, old_space->extent.rank); - if(H5S__hyper_add_disjoint_spans(*new_space, new_spans) < 0) + if (NULL != old_space->select.sel_info.hslab->span_lst) + (*new_space)->select.sel_info.hslab->span_lst = H5S__hyper_copy_span( + old_space->select.sel_info.hslab->span_lst, old_space->extent.rank); + if (H5S__hyper_add_disjoint_spans(*new_space, new_spans) < 0) HGOTO_ERROR(H5E_DATASPACE, H5E_CANTINSERT, FAIL, "can't append hyperslabs") /* Build diminfo struct */ - for(u = 0; u < (*new_space)->extent.rank; u++) { - new_hyper_diminfo[u].start = start[u]; + for (u = 0; u < (*new_space)->extent.rank; u++) { + new_hyper_diminfo[u].start = start[u]; new_hyper_diminfo[u].stride = stride[u]; - new_hyper_diminfo[u].count = count[u]; - new_hyper_diminfo[u].block = block[u]; + new_hyper_diminfo[u].count = count[u]; + new_hyper_diminfo[u].block = block[u]; } /* end for */ /* Update space's dim info */ - if(H5S__hyper_update_diminfo(*new_space, op, new_hyper_diminfo) < 0) + if (H5S__hyper_update_diminfo(*new_space, op, new_hyper_diminfo) < 0) HGOTO_ERROR(H5E_DATASPACE, H5E_CANTCOUNT, FAIL, "can't update hyperslab info") break; case H5S_SELECT_AND: - if(H5S_select_none((*new_space)) < 0) + if (H5S_select_none((*new_space)) < 0) HGOTO_ERROR(H5E_DATASPACE, H5E_CANTSELECT, FAIL, "can't convert selection") break; case H5S_SELECT_NOTB: - if(NULL != old_space->select.sel_info.hslab->span_lst) { - if(NULL == ((*new_space)->select.sel_info.hslab->span_lst = H5S__hyper_copy_span(old_space->select.sel_info.hslab->span_lst, old_space->extent.rank))) + if (NULL != old_space->select.sel_info.hslab->span_lst) { + if (NULL == ((*new_space)->select.sel_info.hslab->span_lst = H5S__hyper_copy_span( + old_space->select.sel_info.hslab->span_lst, old_space->extent.rank))) HGOTO_ERROR(H5E_DATASPACE, H5E_CANTCOPY, FAIL, "unable to copy dataspace") } /* end if */ else { - if(H5S_select_none((*new_space)) < 0) + if (H5S_select_none((*new_space)) < 0) HGOTO_ERROR(H5E_DATASPACE, H5E_CANTSELECT, FAIL, "can't convert selection") } /* end else */ break; case H5S_SELECT_NOTA: - if(H5S__set_regular_hyperslab(*new_space, start, stride, count, block, stride, count, block) < 0) + if (H5S__set_regular_hyperslab(*new_space, start, stride, count, block, stride, count, + block) < 0) HGOTO_ERROR(H5E_DATASPACE, H5E_CANTSET, FAIL, "can't set regular selection") break; @@ -10391,21 +10451,20 @@ H5S_combine_hyperslab(H5S_t *old_space, H5S_seloper_t op, const hsize_t start[], HGOTO_DONE(SUCCEED); } /* end if(!overlapped) */ - } /* end if the selection of old space is H5S_SEL_HYPERSLABS */ + } /* end if the selection of old space is H5S_SEL_HYPERSLABS */ /* Copy the first dataspace with sharing the list of spans */ - if(NULL == ((*new_space) = H5S_copy(old_space, TRUE, TRUE))) + if (NULL == ((*new_space) = H5S_copy(old_space, TRUE, TRUE))) HGOTO_ERROR(H5E_DATASPACE, H5E_CANTINIT, FAIL, "unable to copy dataspace") /* Note: a little overhead in calling the function as some conditions are checked again */ - if(H5S_select_hyperslab(*new_space, op, start, stride, count, block) < 0) + if (H5S_select_hyperslab(*new_space, op, start, stride, count, block) < 0) HGOTO_ERROR(H5E_DATASPACE, H5E_CANTINIT, FAIL, "unable to set hyperslab selection") done: FUNC_LEAVE_NOAPI(ret_value) } /* end H5S_combine_hyperslab() */ - /*------------------------------------------------------------------------- * Function: H5S__fill_in_select * @@ -10424,7 +10483,7 @@ H5S__fill_in_select(H5S_t *space1, H5S_seloper_t op, H5S_t *space2, H5S_t **resu { hbool_t span2_owned; hbool_t updated_spans; - herr_t ret_value = SUCCEED; /* Return value */ + herr_t ret_value = SUCCEED; /* Return value */ FUNC_ENTER_STATIC @@ -10439,15 +10498,16 @@ H5S__fill_in_select(H5S_t *space1, H5S_seloper_t op, H5S_t *space2, H5S_t **resu HDassert(space2->select.sel_info.hslab->span_lst); /* Note: the offset of space2 is not considered here for bounding box */ - if(H5S__fill_in_new_space(space1, op, space2->select.sel_info.hslab->span_lst, FALSE, &span2_owned, &updated_spans, result) < 0) + if (H5S__fill_in_new_space(space1, op, space2->select.sel_info.hslab->span_lst, FALSE, &span2_owned, + &updated_spans, result) < 0) HGOTO_ERROR(H5E_DATASPACE, H5E_CANTSELECT, FAIL, "can't create the specified selection") /* Update diminfo if space2's diminfo was valid, otherwise just mark it as * invalid if the spans were updated */ HDassert(result); - if(updated_spans) { - if(space2->select.sel_info.hslab->diminfo_valid == H5S_DIMINFO_VALID_YES) { - if(H5S__hyper_update_diminfo(*result, op, space2->select.sel_info.hslab->diminfo.opt) < 0) + if (updated_spans) { + if (space2->select.sel_info.hslab->diminfo_valid == H5S_DIMINFO_VALID_YES) { + if (H5S__hyper_update_diminfo(*result, op, space2->select.sel_info.hslab->diminfo.opt) < 0) HGOTO_ERROR(H5E_DATASPACE, H5E_CANTCOUNT, FAIL, "can't update hyperslab info") } /* end if */ else @@ -10458,7 +10518,6 @@ done: FUNC_LEAVE_NOAPI(ret_value) } /* end H5S__fill_in_select() */ - /*-------------------------------------------------------------------------- NAME H5Scombine_hyperslab @@ -10489,40 +10548,39 @@ done: REVISION LOG --------------------------------------------------------------------------*/ hid_t -H5Scombine_hyperslab(hid_t space_id, H5S_seloper_t op, const hsize_t start[], - const hsize_t stride[], const hsize_t count[], const hsize_t block[]) +H5Scombine_hyperslab(hid_t space_id, H5S_seloper_t op, const hsize_t start[], const hsize_t stride[], + const hsize_t count[], const hsize_t block[]) { - H5S_t *space; /* Dataspace to modify selection of */ - H5S_t *new_space = NULL; /* New dataspace created */ - hid_t ret_value; /* Return value */ + H5S_t *space; /* Dataspace to modify selection of */ + H5S_t *new_space = NULL; /* New dataspace created */ + hid_t ret_value; /* Return value */ FUNC_ENTER_API(H5I_INVALID_HID) H5TRACE6("i", "iSs*h*h*h*h", space_id, op, start, stride, count, block); /* Check args */ - if(NULL == (space = (H5S_t *)H5I_object_verify(space_id, H5I_DATASPACE))) + if (NULL == (space = (H5S_t *)H5I_object_verify(space_id, H5I_DATASPACE))) HGOTO_ERROR(H5E_ARGS, H5E_BADTYPE, H5I_INVALID_HID, "not a dataspace") - if(start == NULL || count == NULL) + if (start == NULL || count == NULL) HGOTO_ERROR(H5E_ARGS, H5E_BADVALUE, H5I_INVALID_HID, "hyperslab not specified") - if(!(op >= H5S_SELECT_SET && op <= H5S_SELECT_NOTA)) + if (!(op >= H5S_SELECT_SET && op <= H5S_SELECT_NOTA)) HGOTO_ERROR(H5E_ARGS, H5E_UNSUPPORTED, H5I_INVALID_HID, "invalid selection operation") /* Generate new space, with combination of selections */ - if(H5S_combine_hyperslab(space, op, start, stride, count, block, &new_space) < 0) + if (H5S_combine_hyperslab(space, op, start, stride, count, block, &new_space) < 0) HGOTO_ERROR(H5E_DATASPACE, H5E_CANTINIT, H5I_INVALID_HID, "unable to set hyperslab selection") /* Atomize */ - if((ret_value = H5I_register(H5I_DATASPACE, new_space, TRUE)) < 0) + if ((ret_value = H5I_register(H5I_DATASPACE, new_space, TRUE)) < 0) HGOTO_ERROR(H5E_ATOM, H5E_CANTREGISTER, H5I_INVALID_HID, "unable to register dataspace atom") done: - if(ret_value < 0 && new_space) + if (ret_value < 0 && new_space) H5S_close(new_space); FUNC_LEAVE_API(ret_value) } /* end H5Scombine_hyperslab() */ - /*------------------------------------------------------------------------- * Function: H5S__combine_select * @@ -10538,8 +10596,8 @@ done: static H5S_t * H5S__combine_select(H5S_t *space1, H5S_seloper_t op, H5S_t *space2) { - H5S_t *new_space = NULL; /* New dataspace generated */ - H5S_t *ret_value = NULL; /* Return value */ + H5S_t *new_space = NULL; /* New dataspace generated */ + H5S_t *ret_value = NULL; /* Return value */ FUNC_ENTER_STATIC @@ -10549,31 +10607,31 @@ H5S__combine_select(H5S_t *space1, H5S_seloper_t op, H5S_t *space2) HDassert(op >= H5S_SELECT_OR && op <= H5S_SELECT_NOTA); /* Check if space1 selections has span trees */ - if(NULL == space1->select.sel_info.hslab->span_lst) - if(H5S__hyper_generate_spans(space1) < 0) + if (NULL == space1->select.sel_info.hslab->span_lst) + if (H5S__hyper_generate_spans(space1) < 0) HGOTO_ERROR(H5E_DATASPACE, H5E_UNINITIALIZED, NULL, "dataspace does not have span tree") - if(NULL == space2->select.sel_info.hslab->span_lst) { - hsize_t tmp_start[H5S_MAX_RANK]; - hsize_t tmp_stride[H5S_MAX_RANK]; - hsize_t tmp_count[H5S_MAX_RANK]; - hsize_t tmp_block[H5S_MAX_RANK]; + if (NULL == space2->select.sel_info.hslab->span_lst) { + hsize_t tmp_start[H5S_MAX_RANK]; + hsize_t tmp_stride[H5S_MAX_RANK]; + hsize_t tmp_count[H5S_MAX_RANK]; + hsize_t tmp_block[H5S_MAX_RANK]; unsigned u; - for(u = 0; u < space2->extent.rank; u++) { - tmp_start[u] = space2->select.sel_info.hslab->diminfo.opt[u].start; + for (u = 0; u < space2->extent.rank; u++) { + tmp_start[u] = space2->select.sel_info.hslab->diminfo.opt[u].start; tmp_stride[u] = space2->select.sel_info.hslab->diminfo.opt[u].stride; - tmp_count[u] = space2->select.sel_info.hslab->diminfo.opt[u].count; - tmp_block[u] = space2->select.sel_info.hslab->diminfo.opt[u].block; + tmp_count[u] = space2->select.sel_info.hslab->diminfo.opt[u].count; + tmp_block[u] = space2->select.sel_info.hslab->diminfo.opt[u].block; } /* end for */ /* Combine hyperslab selection with regular selection directly */ - if(H5S_combine_hyperslab(space1, op, tmp_start, tmp_stride, tmp_count, tmp_block, &new_space) < 0) + if (H5S_combine_hyperslab(space1, op, tmp_start, tmp_stride, tmp_count, tmp_block, &new_space) < 0) HGOTO_ERROR(H5E_DATASPACE, H5E_CANTINIT, NULL, "unable to set hyperslab selection") } /* end if */ - else{ + else { /* Combine new_space (a copy of space 1) & space2, with the result in new_space */ - if(H5S__fill_in_select(space1, op, space2, &new_space) < 0) + if (H5S__fill_in_select(space1, op, space2, &new_space) < 0) HGOTO_ERROR(H5E_DATASPACE, H5E_CANTCLIP, NULL, "can't clip hyperslab information") } /* end else */ @@ -10584,13 +10642,12 @@ H5S__combine_select(H5S_t *space1, H5S_seloper_t op, H5S_t *space2) ret_value = new_space; done: - if(ret_value == NULL && new_space) + if (ret_value == NULL && new_space) H5S_close(new_space); FUNC_LEAVE_NOAPI(ret_value) } /* end H5S__combine_select() */ - /*-------------------------------------------------------------------------- NAME H5Scombine_select @@ -10616,27 +10673,27 @@ done: hid_t H5Scombine_select(hid_t space1_id, H5S_seloper_t op, hid_t space2_id) { - H5S_t *space1; /* First Dataspace */ - H5S_t *space2; /* Second Dataspace */ - H5S_t *new_space = NULL; /* New Dataspace */ - hid_t ret_value; /* Return value */ + H5S_t *space1; /* First Dataspace */ + H5S_t *space2; /* Second Dataspace */ + H5S_t *new_space = NULL; /* New Dataspace */ + hid_t ret_value; /* Return value */ FUNC_ENTER_API(H5I_INVALID_HID) H5TRACE3("i", "iSsi", space1_id, op, space2_id); /* Check args */ - if(NULL == (space1 = (H5S_t *)H5I_object_verify(space1_id, H5I_DATASPACE))) + if (NULL == (space1 = (H5S_t *)H5I_object_verify(space1_id, H5I_DATASPACE))) HGOTO_ERROR(H5E_ARGS, H5E_BADTYPE, H5I_INVALID_HID, "not a dataspace") - if(NULL == (space2 = (H5S_t *)H5I_object_verify(space2_id, H5I_DATASPACE))) + if (NULL == (space2 = (H5S_t *)H5I_object_verify(space2_id, H5I_DATASPACE))) HGOTO_ERROR(H5E_ARGS, H5E_BADTYPE, H5I_INVALID_HID, "not a dataspace") - if(!(op >= H5S_SELECT_OR && op <= H5S_SELECT_NOTA)) + if (!(op >= H5S_SELECT_OR && op <= H5S_SELECT_NOTA)) HGOTO_ERROR(H5E_ARGS, H5E_UNSUPPORTED, H5I_INVALID_HID, "invalid selection operation") /* Check that both dataspaces have the same rank */ - if(space1->extent.rank != space2->extent.rank) + if (space1->extent.rank != space2->extent.rank) HGOTO_ERROR(H5E_ARGS, H5E_BADVALUE, H5I_INVALID_HID, "dataspaces not same rank") - /* Note: currently, the offset of each dataspace is ignored */ + /* Note: currently, the offset of each dataspace is ignored */ #if 0 /* Check that both dataspaces have the same offset */ /* Same note as in H5Smodify_select */ @@ -10647,25 +10704,25 @@ H5Scombine_select(hid_t space1_id, H5S_seloper_t op, hid_t space2_id) #endif /* Check that both dataspaces have hyperslab selections */ - if(H5S_GET_SELECT_TYPE(space1) != H5S_SEL_HYPERSLABS || H5S_GET_SELECT_TYPE(space2) != H5S_SEL_HYPERSLABS) + if (H5S_GET_SELECT_TYPE(space1) != H5S_SEL_HYPERSLABS || + H5S_GET_SELECT_TYPE(space2) != H5S_SEL_HYPERSLABS) HGOTO_ERROR(H5E_ARGS, H5E_BADVALUE, H5I_INVALID_HID, "dataspaces don't have hyperslab selections") /* Go combine the dataspaces */ - if(NULL == (new_space = H5S__combine_select(space1, op, space2))) + if (NULL == (new_space = H5S__combine_select(space1, op, space2))) HGOTO_ERROR(H5E_DATASPACE, H5E_CANTINIT, H5I_INVALID_HID, "unable to create hyperslab selection") /* Atomize */ - if((ret_value = H5I_register(H5I_DATASPACE, new_space, TRUE)) < 0) + if ((ret_value = H5I_register(H5I_DATASPACE, new_space, TRUE)) < 0) HGOTO_ERROR(H5E_ATOM, H5E_CANTREGISTER, H5I_INVALID_HID, "unable to register dataspace atom") done: - if(ret_value < 0 && new_space) + if (ret_value < 0 && new_space) H5S_close(new_space); FUNC_LEAVE_API(ret_value) } /* end H5Scombine_select() */ - /*------------------------------------------------------------------------- * Function: H5S__modify_select * @@ -10681,7 +10738,7 @@ done: herr_t H5S__modify_select(H5S_t *space1, H5S_seloper_t op, H5S_t *space2) { - herr_t ret_value = SUCCEED; /* Return value */ + herr_t ret_value = SUCCEED; /* Return value */ FUNC_ENTER_PACKAGE @@ -10691,41 +10748,40 @@ H5S__modify_select(H5S_t *space1, H5S_seloper_t op, H5S_t *space2) HDassert(op >= H5S_SELECT_OR && op <= H5S_SELECT_NOTA); /* Check that the space selections both have span trees */ - if(NULL == space1->select.sel_info.hslab->span_lst) - if(H5S__hyper_generate_spans(space1) < 0) + if (NULL == space1->select.sel_info.hslab->span_lst) + if (H5S__hyper_generate_spans(space1) < 0) HGOTO_ERROR(H5E_DATASPACE, H5E_UNINITIALIZED, FAIL, "dataspace does not have span tree") /* Set unlim_dim */ space1->select.sel_info.hslab->unlim_dim = -1; - if(NULL == space2->select.sel_info.hslab->span_lst) { - hsize_t tmp_start[H5S_MAX_RANK]; - hsize_t tmp_stride[H5S_MAX_RANK]; - hsize_t tmp_count[H5S_MAX_RANK]; - hsize_t tmp_block[H5S_MAX_RANK]; + if (NULL == space2->select.sel_info.hslab->span_lst) { + hsize_t tmp_start[H5S_MAX_RANK]; + hsize_t tmp_stride[H5S_MAX_RANK]; + hsize_t tmp_count[H5S_MAX_RANK]; + hsize_t tmp_block[H5S_MAX_RANK]; unsigned u; - for(u = 0; u < space2->extent.rank; u++) { - tmp_start[u] = space2->select.sel_info.hslab->diminfo.opt[u].start; + for (u = 0; u < space2->extent.rank; u++) { + tmp_start[u] = space2->select.sel_info.hslab->diminfo.opt[u].start; tmp_stride[u] = space2->select.sel_info.hslab->diminfo.opt[u].stride; - tmp_count[u] = space2->select.sel_info.hslab->diminfo.opt[u].count; - tmp_block[u] = space2->select.sel_info.hslab->diminfo.opt[u].block; + tmp_count[u] = space2->select.sel_info.hslab->diminfo.opt[u].count; + tmp_block[u] = space2->select.sel_info.hslab->diminfo.opt[u].block; } /* end for */ /* Call H5S_select_hyperslab directly */ - if(H5S_select_hyperslab(space1, op, tmp_start, tmp_stride, tmp_count, tmp_block) < 0) + if (H5S_select_hyperslab(space1, op, tmp_start, tmp_stride, tmp_count, tmp_block) < 0) HGOTO_ERROR(H5E_DATASPACE, H5E_CANTINIT, FAIL, "unable to set hyperslab selection") } /* end if */ else /* Combine spans from space1 & spans from space2, with the result in space1 */ - if(H5S__fill_in_select(space1, op, space2, &space1) < 0) - HGOTO_ERROR(H5E_DATASPACE, H5E_CANTCLIP, FAIL, "can't perform operation on two selections") + if (H5S__fill_in_select(space1, op, space2, &space1) < 0) + HGOTO_ERROR(H5E_DATASPACE, H5E_CANTCLIP, FAIL, "can't perform operation on two selections") done: FUNC_LEAVE_NOAPI(ret_value) } /* end H5S__modify_select() */ - /*-------------------------------------------------------------------------- NAME H5Smodify_select @@ -10751,43 +10807,43 @@ done: herr_t H5Smodify_select(hid_t space1_id, H5S_seloper_t op, hid_t space2_id) { - H5S_t *space1; /* First Dataspace */ - H5S_t *space2; /* Second Dataspace */ - herr_t ret_value = SUCCEED; /* Return value */ + H5S_t *space1; /* First Dataspace */ + H5S_t *space2; /* Second Dataspace */ + herr_t ret_value = SUCCEED; /* Return value */ FUNC_ENTER_API(FAIL) H5TRACE3("e", "iSsi", space1_id, op, space2_id); /* Check args */ - if(NULL == (space1 = (H5S_t *)H5I_object_verify(space1_id, H5I_DATASPACE))) + if (NULL == (space1 = (H5S_t *)H5I_object_verify(space1_id, H5I_DATASPACE))) HGOTO_ERROR(H5E_ARGS, H5E_BADTYPE, FAIL, "not a dataspace") - if(NULL == (space2 = (H5S_t *)H5I_object_verify(space2_id, H5I_DATASPACE))) + if (NULL == (space2 = (H5S_t *)H5I_object_verify(space2_id, H5I_DATASPACE))) HGOTO_ERROR(H5E_ARGS, H5E_BADTYPE, FAIL, "not a dataspace") - if(!(op >= H5S_SELECT_OR && op <= H5S_SELECT_NOTA)) + if (!(op >= H5S_SELECT_OR && op <= H5S_SELECT_NOTA)) HGOTO_ERROR(H5E_ARGS, H5E_UNSUPPORTED, FAIL, "invalid selection operation") /* Check that both dataspaces have the same rank */ - if(space1->extent.rank != space2->extent.rank) + if (space1->extent.rank != space2->extent.rank) HGOTO_ERROR(H5E_ARGS, H5E_BADVALUE, FAIL, "dataspaces not same rank") - /* Check that both dataspaces have the same offset */ - /** Note that this is a tricky part of this function. It's - * possible that two dataspaces have different "offset". If the - * space2 has smaller offset value than that of space1 in a - * dimension, then the span elements of this dimension in - * space2 could have negative "low" and "high" values relative - * to the offset in space1. In other words, if the bounds of - * span elements in space2 are adjusted relative to the offset - * in space1, then every span element's bound is computed as - * "origin_bound+offset2-offset1". Therefore, if offset2 (the - * offset of space2) is smaller, then - * "origin_bound+offset2-offset1" could be negative which is - * not allowed by the bound type declaration as hsize_t! - * As a result, if the op is an OR selection, then the final - * result may contain span elements that have negative bound! - * So right now, the difference in the offset is totally - * ignored!! - */ + /* Check that both dataspaces have the same offset */ + /** Note that this is a tricky part of this function. It's + * possible that two dataspaces have different "offset". If the + * space2 has smaller offset value than that of space1 in a + * dimension, then the span elements of this dimension in + * space2 could have negative "low" and "high" values relative + * to the offset in space1. In other words, if the bounds of + * span elements in space2 are adjusted relative to the offset + * in space1, then every span element's bound is computed as + * "origin_bound+offset2-offset1". Therefore, if offset2 (the + * offset of space2) is smaller, then + * "origin_bound+offset2-offset1" could be negative which is + * not allowed by the bound type declaration as hsize_t! + * As a result, if the op is an OR selection, then the final + * result may contain span elements that have negative bound! + * So right now, the difference in the offset is totally + * ignored!! + */ #if 0 for(u=0; u<space1->extent.rank; u++) { if(space1->select.offset[u] != space2->select.offset[u]) @@ -10796,18 +10852,18 @@ H5Smodify_select(hid_t space1_id, H5S_seloper_t op, hid_t space2_id) #endif /* Check that both dataspaces have hyperslab selections */ - if(H5S_GET_SELECT_TYPE(space1) != H5S_SEL_HYPERSLABS || H5S_GET_SELECT_TYPE(space2) != H5S_SEL_HYPERSLABS) + if (H5S_GET_SELECT_TYPE(space1) != H5S_SEL_HYPERSLABS || + H5S_GET_SELECT_TYPE(space2) != H5S_SEL_HYPERSLABS) HGOTO_ERROR(H5E_ARGS, H5E_BADVALUE, FAIL, "dataspaces don't have hyperslab selections") /* Go refine the first selection */ - if(H5S__modify_select(space1, op, space2) < 0) + if (H5S__modify_select(space1, op, space2) < 0) HGOTO_ERROR(H5E_DATASPACE, H5E_CANTINIT, FAIL, "unable to modify hyperslab selection") done: FUNC_LEAVE_API(ret_value) } /* end H5Smodify_select() */ - /*-------------------------------------------------------------------------- NAME H5S__hyper_proj_int_build_proj @@ -10830,9 +10886,10 @@ done: REVISION LOG --------------------------------------------------------------------------*/ static herr_t -H5S__hyper_proj_int_build_proj(H5S_hyper_project_intersect_ud_t *udata) { - H5S_hyper_span_info_t *copied_span_info = NULL; /* Temporary span info pointer */ - herr_t ret_value = SUCCEED; /* Return value */ +H5S__hyper_proj_int_build_proj(H5S_hyper_project_intersect_ud_t *udata) +{ + H5S_hyper_span_info_t *copied_span_info = NULL; /* Temporary span info pointer */ + herr_t ret_value = SUCCEED; /* Return value */ FUNC_ENTER_STATIC @@ -10841,35 +10898,37 @@ H5S__hyper_proj_int_build_proj(H5S_hyper_project_intersect_ud_t *udata) { /* * Skip over skipped elements */ - if(udata->skip > 0) { + if (udata->skip > 0) { /* Work upwards, finishing each span tree before moving up */ HDassert(udata->ds_span[udata->depth]); do { /* Check for lowest dimension */ - if(udata->ds_span[udata->depth]->down) { - if(udata->ds_low[udata->depth] <= udata->ds_span[udata->depth]->high) { + if (udata->ds_span[udata->depth]->down) { + if (udata->ds_low[udata->depth] <= udata->ds_span[udata->depth]->high) { /* If we will run out of elements to skip in this span, * advance to the first not fully skipped span and break * out of this loop (start moving downwards) */ - if(udata->skip < H5S__hyper_spans_nelem_helper(udata->ds_span[udata->depth]->down, 0, udata->op_gen) - * (udata->ds_span[udata->depth]->high - udata->ds_low[udata->depth] + 1)) { - udata->ds_low[udata->depth] += udata->skip / udata->ds_span[udata->depth]->down->op_info[0].u.nelmts; + if (udata->skip < + H5S__hyper_spans_nelem_helper(udata->ds_span[udata->depth]->down, 0, udata->op_gen) * + (udata->ds_span[udata->depth]->high - udata->ds_low[udata->depth] + 1)) { + udata->ds_low[udata->depth] += + udata->skip / udata->ds_span[udata->depth]->down->op_info[0].u.nelmts; udata->skip %= udata->ds_span[udata->depth]->down->op_info[0].u.nelmts; break; } /* end if */ /* Skip over this entire span */ - udata->skip -= udata->ds_span[udata->depth]->down->op_info[0].u.nelmts - * (udata->ds_span[udata->depth]->high - udata->ds_low[udata->depth] + 1); + udata->skip -= udata->ds_span[udata->depth]->down->op_info[0].u.nelmts * + (udata->ds_span[udata->depth]->high - udata->ds_low[udata->depth] + 1); } /* end if */ - } /* end if */ + } /* end if */ else { HDassert(udata->ds_rank - udata->depth == 1); /* If we will run out of elements to skip in this span, * skip the remainder of the skipped elements and break out */ HDassert(udata->ds_low[udata->depth] <= udata->ds_span[udata->depth]->high); - if(udata->skip < (udata->ds_span[udata->depth]->high - udata->ds_low[udata->depth] + 1)) { + if (udata->skip < (udata->ds_span[udata->depth]->high - udata->ds_low[udata->depth] + 1)) { udata->ds_low[udata->depth] += udata->skip; udata->skip = 0; break; @@ -10881,15 +10940,15 @@ H5S__hyper_proj_int_build_proj(H5S_hyper_project_intersect_ud_t *udata) { /* Advance to next span */ udata->ds_span[udata->depth] = udata->ds_span[udata->depth]->next; - if(udata->ds_span[udata->depth]) + if (udata->ds_span[udata->depth]) udata->ds_low[udata->depth] = udata->ds_span[udata->depth]->low; - else if(udata->depth > 0) { + else if (udata->depth > 0) { /* If present, append this span tree to the higher dimension's, * and release ownership of it */ - if(udata->ps_span_info[udata->depth]) { - if(H5S__hyper_append_span(&udata->ps_span_info[udata->depth - 1], - udata->ds_rank - udata->depth + 1, udata->ds_low[udata->depth - 1], - udata->ds_low[udata->depth - 1], + if (udata->ps_span_info[udata->depth]) { + if (H5S__hyper_append_span( + &udata->ps_span_info[udata->depth - 1], udata->ds_rank - udata->depth + 1, + udata->ds_low[udata->depth - 1], udata->ds_low[udata->depth - 1], udata->ps_span_info[udata->depth]) < 0) HGOTO_ERROR(H5E_DATASPACE, H5E_CANTAPPEND, FAIL, "can't allocate hyperslab span") H5S__hyper_free_span_info(udata->ps_span_info[udata->depth]); @@ -10902,44 +10961,47 @@ H5S__hyper_proj_int_build_proj(H5S_hyper_project_intersect_ud_t *udata) { udata->ds_low[udata->depth]++; } /* end if */ else - HGOTO_ERROR(H5E_DATASPACE, H5E_BADVALUE, FAIL, "insufficient elements in destination selection") - } while((udata->skip > 0) - || (udata->ds_low[udata->depth] > udata->ds_span[udata->depth]->high)); + HGOTO_ERROR(H5E_DATASPACE, H5E_BADVALUE, FAIL, + "insufficient elements in destination selection") + } while ((udata->skip > 0) || (udata->ds_low[udata->depth] > udata->ds_span[udata->depth]->high)); /* Work downwards until skip is 0 */ HDassert(udata->ds_span[udata->depth]); - while(udata->skip > 0) { + while (udata->skip > 0) { HDassert(udata->ds_span[udata->depth]->down); udata->depth++; udata->ds_span[udata->depth] = udata->ds_span[udata->depth - 1]->down->head; - udata->ds_low[udata->depth] = udata->ds_span[udata->depth]->low; - if(udata->ds_span[udata->depth]->down) { + udata->ds_low[udata->depth] = udata->ds_span[udata->depth]->low; + if (udata->ds_span[udata->depth]->down) { do { /* If we will run out of elements to skip in this span, * advance to the first not fully skipped span and * continue down */ - if(udata->skip < H5S__hyper_spans_nelem_helper(udata->ds_span[udata->depth]->down, 0, udata->op_gen) - * (udata->ds_span[udata->depth]->high - udata->ds_low[udata->depth] + 1)) { - udata->ds_low[udata->depth] += udata->skip / udata->ds_span[udata->depth]->down->op_info[0].u.nelmts; + if (udata->skip < + H5S__hyper_spans_nelem_helper(udata->ds_span[udata->depth]->down, 0, udata->op_gen) * + (udata->ds_span[udata->depth]->high - udata->ds_low[udata->depth] + 1)) { + udata->ds_low[udata->depth] += + udata->skip / udata->ds_span[udata->depth]->down->op_info[0].u.nelmts; udata->skip %= udata->ds_span[udata->depth]->down->op_info[0].u.nelmts; break; } /* end if */ /* Skip over this entire span */ - udata->skip -= udata->ds_span[udata->depth]->down->op_info[0].u.nelmts - * (udata->ds_span[udata->depth]->high - udata->ds_low[udata->depth] + 1); + udata->skip -= udata->ds_span[udata->depth]->down->op_info[0].u.nelmts * + (udata->ds_span[udata->depth]->high - udata->ds_low[udata->depth] + 1); /* Advance to next span */ udata->ds_span[udata->depth] = udata->ds_span[udata->depth]->next; HDassert(udata->ds_span[udata->depth]); udata->ds_low[udata->depth] = udata->ds_span[udata->depth]->low; - } while(udata->skip > 0); + } while (udata->skip > 0); } /* end if */ else { do { /* If we will run out of elements to skip in this span, * skip the remainder of the skipped elements */ - if(udata->skip < (udata->ds_span[udata->depth]->high - udata->ds_low[udata->depth] + 1)) { + if (udata->skip < + (udata->ds_span[udata->depth]->high - udata->ds_low[udata->depth] + 1)) { udata->ds_low[udata->depth] += udata->skip; udata->skip = 0; break; @@ -10952,10 +11014,10 @@ H5S__hyper_proj_int_build_proj(H5S_hyper_project_intersect_ud_t *udata) { udata->ds_span[udata->depth] = udata->ds_span[udata->depth]->next; HDassert(udata->ds_span[udata->depth]); udata->ds_low[udata->depth] = udata->ds_span[udata->depth]->low; - } while(udata->skip > 0); + } while (udata->skip > 0); } /* end else */ - } /* end while */ - } /* end if */ + } /* end while */ + } /* end if */ /* * Add requested number of elements to projected space @@ -10965,77 +11027,92 @@ H5S__hyper_proj_int_build_proj(H5S_hyper_project_intersect_ud_t *udata) { HDassert(udata->ds_span[udata->depth]); do { /* Check for lowest dimension */ - if(udata->ds_span[udata->depth]->down) { - if(udata->ds_low[udata->depth] <= udata->ds_span[udata->depth]->high) { + if (udata->ds_span[udata->depth]->down) { + if (udata->ds_low[udata->depth] <= udata->ds_span[udata->depth]->high) { /* If we will run out of elements to add in this span, add * any complete spans, advance to the first not fully added * span, and break out of this loop (start moving downwards) */ - if(udata->nelem < H5S__hyper_spans_nelem_helper(udata->ds_span[udata->depth]->down, 0, udata->op_gen) - * (udata->ds_span[udata->depth]->high - udata->ds_low[udata->depth] + 1)) { - if(udata->nelem >= udata->ds_span[udata->depth]->down->op_info[0].u.nelmts) { - if(udata->share_selection) { - if(H5S__hyper_append_span(&udata->ps_span_info[udata->depth], - udata->ds_rank - udata->depth, udata->ds_low[udata->depth], - udata->ds_low[udata->depth] + (udata->nelem / udata->ds_span[udata->depth]->down->op_info[0].u.nelmts) - 1, + if (udata->nelem < + H5S__hyper_spans_nelem_helper(udata->ds_span[udata->depth]->down, 0, udata->op_gen) * + (udata->ds_span[udata->depth]->high - udata->ds_low[udata->depth] + 1)) { + if (udata->nelem >= udata->ds_span[udata->depth]->down->op_info[0].u.nelmts) { + if (udata->share_selection) { + if (H5S__hyper_append_span( + &udata->ps_span_info[udata->depth], udata->ds_rank - udata->depth, + udata->ds_low[udata->depth], + udata->ds_low[udata->depth] + + (udata->nelem / + udata->ds_span[udata->depth]->down->op_info[0].u.nelmts) - + 1, udata->ds_span[udata->depth]->down) < 0) - HGOTO_ERROR(H5E_DATASPACE, H5E_CANTAPPEND, FAIL, "can't allocate hyperslab span") + HGOTO_ERROR(H5E_DATASPACE, H5E_CANTAPPEND, FAIL, + "can't allocate hyperslab span") } /* end if */ else { /* If we're not sharing the destination space's * spans, we must copy it first (then release it * afterwards) */ - if(NULL == (copied_span_info = H5S__hyper_copy_span_helper(udata->ds_span[udata->depth]->down, udata->ds_rank - udata->depth, 1, udata->op_gen))) + if (NULL == (copied_span_info = H5S__hyper_copy_span_helper( + udata->ds_span[udata->depth]->down, + udata->ds_rank - udata->depth, 1, udata->op_gen))) HGOTO_ERROR(H5E_DATASPACE, H5E_CANTCOPY, FAIL, "can't copy destination spans") - if(H5S__hyper_append_span(&udata->ps_span_info[udata->depth], - udata->ds_rank - udata->depth, udata->ds_low[udata->depth], - udata->ds_low[udata->depth] + (udata->nelem / udata->ds_span[udata->depth]->down->op_info[0].u.nelmts) - 1, + if (H5S__hyper_append_span( + &udata->ps_span_info[udata->depth], udata->ds_rank - udata->depth, + udata->ds_low[udata->depth], + udata->ds_low[udata->depth] + + (udata->nelem / + udata->ds_span[udata->depth]->down->op_info[0].u.nelmts) - + 1, copied_span_info) < 0) - HGOTO_ERROR(H5E_DATASPACE, H5E_CANTAPPEND, FAIL, "can't allocate hyperslab span") + HGOTO_ERROR(H5E_DATASPACE, H5E_CANTAPPEND, FAIL, + "can't allocate hyperslab span") H5S__hyper_free_span_info(copied_span_info); copied_span_info = NULL; } /* end else */ - udata->ds_low[udata->depth] += udata->nelem / udata->ds_span[udata->depth]->down->op_info[0].u.nelmts; + udata->ds_low[udata->depth] += + udata->nelem / udata->ds_span[udata->depth]->down->op_info[0].u.nelmts; udata->nelem %= udata->ds_span[udata->depth]->down->op_info[0].u.nelmts; } /* end if */ break; } /* end if */ /* Append span tree for entire span */ - if(udata->share_selection) { - if(H5S__hyper_append_span(&udata->ps_span_info[udata->depth], - udata->ds_rank - udata->depth, udata->ds_low[udata->depth], - udata->ds_span[udata->depth]->high, - udata->ds_span[udata->depth]->down) < 0) + if (udata->share_selection) { + if (H5S__hyper_append_span(&udata->ps_span_info[udata->depth], + udata->ds_rank - udata->depth, udata->ds_low[udata->depth], + udata->ds_span[udata->depth]->high, + udata->ds_span[udata->depth]->down) < 0) HGOTO_ERROR(H5E_DATASPACE, H5E_CANTAPPEND, FAIL, "can't allocate hyperslab span") } /* end if */ else { /* If we're not sharing the destination space's * spans, we must copy it first (then release it * afterwards) */ - if(NULL == (copied_span_info = H5S__hyper_copy_span_helper(udata->ds_span[udata->depth]->down, udata->ds_rank - udata->depth, 1, udata->op_gen))) + if (NULL == (copied_span_info = H5S__hyper_copy_span_helper( + udata->ds_span[udata->depth]->down, udata->ds_rank - udata->depth, 1, + udata->op_gen))) HGOTO_ERROR(H5E_DATASPACE, H5E_CANTCOPY, FAIL, "can't copy destination spans") - if(H5S__hyper_append_span(&udata->ps_span_info[udata->depth], - udata->ds_rank - udata->depth, udata->ds_low[udata->depth], - udata->ds_span[udata->depth]->high, - copied_span_info) < 0) + if (H5S__hyper_append_span(&udata->ps_span_info[udata->depth], + udata->ds_rank - udata->depth, udata->ds_low[udata->depth], + udata->ds_span[udata->depth]->high, copied_span_info) < 0) HGOTO_ERROR(H5E_DATASPACE, H5E_CANTAPPEND, FAIL, "can't allocate hyperslab span") H5S__hyper_free_span_info(copied_span_info); copied_span_info = NULL; } /* end else */ - udata->nelem -= udata->ds_span[udata->depth]->down->op_info[0].u.nelmts - * (udata->ds_span[udata->depth]->high - udata->ds_low[udata->depth] + 1); + udata->nelem -= udata->ds_span[udata->depth]->down->op_info[0].u.nelmts * + (udata->ds_span[udata->depth]->high - udata->ds_low[udata->depth] + 1); } /* end if */ - } /* end if */ + } /* end if */ else { HDassert(udata->ds_rank - udata->depth == 1); /* If we will run out of elements to add in this span, add the * remainder of the elements and break out */ HDassert(udata->ds_low[udata->depth] <= udata->ds_span[udata->depth]->high); - if(udata->nelem < (udata->ds_span[udata->depth]->high - udata->ds_low[udata->depth] + 1)) { - if(H5S__hyper_append_span(&udata->ps_span_info[udata->depth], 1, - udata->ds_low[udata->depth], udata->ds_low[udata->depth] + udata->nelem - 1, NULL) < 0) + if (udata->nelem < (udata->ds_span[udata->depth]->high - udata->ds_low[udata->depth] + 1)) { + if (H5S__hyper_append_span(&udata->ps_span_info[udata->depth], 1, udata->ds_low[udata->depth], + udata->ds_low[udata->depth] + udata->nelem - 1, NULL) < 0) HGOTO_ERROR(H5E_DATASPACE, H5E_CANTAPPEND, FAIL, "can't allocate hyperslab span") udata->ds_low[udata->depth] += udata->nelem; udata->nelem = 0; @@ -11043,24 +11120,24 @@ H5S__hyper_proj_int_build_proj(H5S_hyper_project_intersect_ud_t *udata) { } /* end if */ /* Append span tree for entire span */ - if(H5S__hyper_append_span(&udata->ps_span_info[udata->depth], 1, - udata->ds_low[udata->depth], udata->ds_span[udata->depth]->high, NULL) < 0) - HGOTO_ERROR(H5E_DATASPACE, H5E_CANTAPPEND, FAIL, "can't allocate hyperslab span") + if (H5S__hyper_append_span(&udata->ps_span_info[udata->depth], 1, udata->ds_low[udata->depth], + udata->ds_span[udata->depth]->high, NULL) < 0) + HGOTO_ERROR(H5E_DATASPACE, H5E_CANTAPPEND, FAIL, "can't allocate hyperslab span") udata->nelem -= udata->ds_span[udata->depth]->high - udata->ds_low[udata->depth] + 1; } /* end else */ /* Advance to next span */ udata->ds_span[udata->depth] = udata->ds_span[udata->depth]->next; - if(udata->ds_span[udata->depth]) + if (udata->ds_span[udata->depth]) udata->ds_low[udata->depth] = udata->ds_span[udata->depth]->low; - else if(udata->depth > 0) { + else if (udata->depth > 0) { /* Append this span tree to the higher dimension's, and release * ownership of it */ HDassert(udata->ps_span_info[udata->depth]); - if(H5S__hyper_append_span(&udata->ps_span_info[udata->depth - 1], - udata->ds_rank - udata->depth + 1, udata->ds_low[udata->depth - 1], - udata->ds_low[udata->depth - 1], - udata->ps_span_info[udata->depth]) < 0) + if (H5S__hyper_append_span(&udata->ps_span_info[udata->depth - 1], + udata->ds_rank - udata->depth + 1, udata->ds_low[udata->depth - 1], + udata->ds_low[udata->depth - 1], + udata->ps_span_info[udata->depth]) < 0) HGOTO_ERROR(H5E_DATASPACE, H5E_CANTAPPEND, FAIL, "can't allocate hyperslab span") H5S__hyper_free_span_info(udata->ps_span_info[udata->depth]); udata->ps_span_info[udata->depth] = NULL; @@ -11073,87 +11150,102 @@ H5S__hyper_proj_int_build_proj(H5S_hyper_project_intersect_ud_t *udata) { else { /* We have finished the entire destination span tree. If there are * still elements to add, issue an error. */ - if(udata->nelem > 0) - HGOTO_ERROR(H5E_DATASPACE, H5E_BADVALUE, FAIL, "insufficient elements in destination selection") + if (udata->nelem > 0) + HGOTO_ERROR(H5E_DATASPACE, H5E_BADVALUE, FAIL, + "insufficient elements in destination selection") break; } /* end else */ - } while((udata->nelem > 0) - || (udata->ds_low[udata->depth] > udata->ds_span[udata->depth]->high)); + } while ((udata->nelem > 0) || (udata->ds_low[udata->depth] > udata->ds_span[udata->depth]->high)); /* Work downwards until nelem is 0 */ HDassert(udata->ds_span[udata->depth] || (udata->nelem == 0)); - while(udata->nelem > 0) { + while (udata->nelem > 0) { HDassert(udata->ds_span[udata->depth]->down); udata->depth++; udata->ds_span[udata->depth] = udata->ds_span[udata->depth - 1]->down->head; - udata->ds_low[udata->depth] = udata->ds_span[udata->depth]->low; - if(udata->ds_span[udata->depth]->down) { + udata->ds_low[udata->depth] = udata->ds_span[udata->depth]->low; + if (udata->ds_span[udata->depth]->down) { do { /* If we will run out of elements to add in this span, add * any complete spans, advance to the first not fully added * span and continue down */ HDassert(udata->ds_low[udata->depth] <= udata->ds_span[udata->depth]->high); - if(udata->nelem < H5S__hyper_spans_nelem_helper(udata->ds_span[udata->depth]->down, 0, udata->op_gen) - * (udata->ds_span[udata->depth]->high - udata->ds_low[udata->depth] + 1)) { - if(udata->nelem >= udata->ds_span[udata->depth]->down->op_info[0].u.nelmts) { - if(udata->share_selection) { - if(H5S__hyper_append_span(&udata->ps_span_info[udata->depth], - udata->ds_rank - udata->depth, udata->ds_low[udata->depth], - udata->ds_low[udata->depth] + (udata->nelem / udata->ds_span[udata->depth]->down->op_info[0].u.nelmts) - 1, + if (udata->nelem < + H5S__hyper_spans_nelem_helper(udata->ds_span[udata->depth]->down, 0, udata->op_gen) * + (udata->ds_span[udata->depth]->high - udata->ds_low[udata->depth] + 1)) { + if (udata->nelem >= udata->ds_span[udata->depth]->down->op_info[0].u.nelmts) { + if (udata->share_selection) { + if (H5S__hyper_append_span( + &udata->ps_span_info[udata->depth], udata->ds_rank - udata->depth, + udata->ds_low[udata->depth], + udata->ds_low[udata->depth] + + (udata->nelem / + udata->ds_span[udata->depth]->down->op_info[0].u.nelmts) - + 1, udata->ds_span[udata->depth]->down) < 0) - HGOTO_ERROR(H5E_DATASPACE, H5E_CANTAPPEND, FAIL, "can't allocate hyperslab span") + HGOTO_ERROR(H5E_DATASPACE, H5E_CANTAPPEND, FAIL, + "can't allocate hyperslab span") } /* end if */ else { /* If we're not sharing the destination space's * spans, we must copy it first (then release it * afterwards) */ - if(NULL == (copied_span_info = H5S__hyper_copy_span_helper(udata->ds_span[udata->depth]->down, udata->ds_rank - udata->depth, 1, udata->op_gen))) + if (NULL == (copied_span_info = H5S__hyper_copy_span_helper( + udata->ds_span[udata->depth]->down, + udata->ds_rank - udata->depth, 1, udata->op_gen))) HGOTO_ERROR(H5E_DATASPACE, H5E_CANTCOPY, FAIL, "can't copy destination spans") - if(H5S__hyper_append_span(&udata->ps_span_info[udata->depth], - udata->ds_rank - udata->depth, udata->ds_low[udata->depth], - udata->ds_low[udata->depth] + (udata->nelem / udata->ds_span[udata->depth]->down->op_info[0].u.nelmts) - 1, + if (H5S__hyper_append_span( + &udata->ps_span_info[udata->depth], udata->ds_rank - udata->depth, + udata->ds_low[udata->depth], + udata->ds_low[udata->depth] + + (udata->nelem / + udata->ds_span[udata->depth]->down->op_info[0].u.nelmts) - + 1, copied_span_info) < 0) - HGOTO_ERROR(H5E_DATASPACE, H5E_CANTAPPEND, FAIL, "can't allocate hyperslab span") + HGOTO_ERROR(H5E_DATASPACE, H5E_CANTAPPEND, FAIL, + "can't allocate hyperslab span") H5S__hyper_free_span_info(copied_span_info); copied_span_info = NULL; } /* end else */ - udata->ds_low[udata->depth] += udata->nelem / udata->ds_span[udata->depth]->down->op_info[0].u.nelmts; + udata->ds_low[udata->depth] += + udata->nelem / udata->ds_span[udata->depth]->down->op_info[0].u.nelmts; udata->nelem %= udata->ds_span[udata->depth]->down->op_info[0].u.nelmts; } /* end if */ break; } /* end if */ /* Append span tree for entire span */ - if(udata->share_selection) { - if(H5S__hyper_append_span(&udata->ps_span_info[udata->depth], - udata->ds_rank - udata->depth, udata->ds_low[udata->depth], - udata->ds_span[udata->depth]->high, - udata->ds_span[udata->depth]->down) < 0) + if (udata->share_selection) { + if (H5S__hyper_append_span(&udata->ps_span_info[udata->depth], + udata->ds_rank - udata->depth, udata->ds_low[udata->depth], + udata->ds_span[udata->depth]->high, + udata->ds_span[udata->depth]->down) < 0) HGOTO_ERROR(H5E_DATASPACE, H5E_CANTAPPEND, FAIL, "can't allocate hyperslab span") } /* end if */ else { /* If we're not sharing the destination space's * spans, we must copy it first (then release it * afterwards) */ - if(NULL == (copied_span_info = H5S__hyper_copy_span_helper(udata->ds_span[udata->depth]->down, udata->ds_rank - udata->depth, 1, udata->op_gen))) + if (NULL == (copied_span_info = H5S__hyper_copy_span_helper( + udata->ds_span[udata->depth]->down, udata->ds_rank - udata->depth, 1, + udata->op_gen))) HGOTO_ERROR(H5E_DATASPACE, H5E_CANTCOPY, FAIL, "can't copy destination spans") - if(H5S__hyper_append_span(&udata->ps_span_info[udata->depth], - udata->ds_rank - udata->depth, udata->ds_low[udata->depth], - udata->ds_span[udata->depth]->high, - copied_span_info) < 0) + if (H5S__hyper_append_span(&udata->ps_span_info[udata->depth], + udata->ds_rank - udata->depth, udata->ds_low[udata->depth], + udata->ds_span[udata->depth]->high, copied_span_info) < 0) HGOTO_ERROR(H5E_DATASPACE, H5E_CANTAPPEND, FAIL, "can't allocate hyperslab span") H5S__hyper_free_span_info(copied_span_info); copied_span_info = NULL; } /* end else */ - udata->nelem -= udata->ds_span[udata->depth]->down->op_info[0].u.nelmts - * (udata->ds_span[udata->depth]->high - udata->ds_low[udata->depth] + 1); + udata->nelem -= udata->ds_span[udata->depth]->down->op_info[0].u.nelmts * + (udata->ds_span[udata->depth]->high - udata->ds_low[udata->depth] + 1); /* Advance to next span */ udata->ds_span[udata->depth] = udata->ds_span[udata->depth]->next; HDassert(udata->ds_span[udata->depth]); udata->ds_low[udata->depth] = udata->ds_span[udata->depth]->low; - } while(udata->nelem > 0); + } while (udata->nelem > 0); } /* end if */ else { HDassert(udata->ds_rank - udata->depth == 1); @@ -11161,9 +11253,10 @@ H5S__hyper_proj_int_build_proj(H5S_hyper_project_intersect_ud_t *udata) { /* If we will run out of elements to add in this span, add * the remainder of the elements and break out */ HDassert(udata->ds_low[udata->depth] <= udata->ds_span[udata->depth]->high); - if(udata->nelem < (udata->ds_span[udata->depth]->high - udata->ds_low[udata->depth] + 1)) { - if(H5S__hyper_append_span(&udata->ps_span_info[udata->depth], 1, - udata->ds_low[udata->depth], udata->ds_low[udata->depth] + udata->nelem - 1, NULL) < 0) + if (udata->nelem < (udata->ds_span[udata->depth]->high - udata->ds_low[udata->depth] + 1)) { + if (H5S__hyper_append_span(&udata->ps_span_info[udata->depth], 1, + udata->ds_low[udata->depth], + udata->ds_low[udata->depth] + udata->nelem - 1, NULL) < 0) HGOTO_ERROR(H5E_DATASPACE, H5E_CANTAPPEND, FAIL, "can't allocate hyperslab span") udata->ds_low[udata->depth] += udata->nelem; udata->nelem = 0; @@ -11171,8 +11264,8 @@ H5S__hyper_proj_int_build_proj(H5S_hyper_project_intersect_ud_t *udata) { } /* end if */ /* Append span tree for entire span */ - if(H5S__hyper_append_span(&udata->ps_span_info[udata->depth], 1, - udata->ds_low[udata->depth], udata->ds_span[udata->depth]->high, NULL) < 0) + if (H5S__hyper_append_span(&udata->ps_span_info[udata->depth], 1, udata->ds_low[udata->depth], + udata->ds_span[udata->depth]->high, NULL) < 0) HGOTO_ERROR(H5E_DATASPACE, H5E_CANTAPPEND, FAIL, "can't allocate hyperslab span") udata->nelem -= udata->ds_span[udata->depth]->high - udata->ds_low[udata->depth] + 1; @@ -11180,9 +11273,9 @@ H5S__hyper_proj_int_build_proj(H5S_hyper_project_intersect_ud_t *udata) { udata->ds_span[udata->depth] = udata->ds_span[udata->depth]->next; HDassert(udata->ds_span[udata->depth]); udata->ds_low[udata->depth] = udata->ds_span[udata->depth]->low; - } while(udata->nelem > 0); + } while (udata->nelem > 0); } /* end else */ - } /* end while */ + } /* end while */ HDassert(udata->skip == 0); HDassert(udata->nelem == 0); @@ -11192,7 +11285,7 @@ H5S__hyper_proj_int_build_proj(H5S_hyper_project_intersect_ud_t *udata) { done: /* Cleanup on failure */ - if(copied_span_info) { + if (copied_span_info) { HDassert(ret_value < 0); H5S__hyper_free_span_info(copied_span_info); copied_span_info = NULL; @@ -11201,7 +11294,6 @@ done: FUNC_LEAVE_NOAPI(ret_value) } /* end H5S__hyper_proj_int_build_proj() */ - /*-------------------------------------------------------------------------- NAME H5S__hyper_proj_int_iterate @@ -11211,8 +11303,8 @@ done: herr_t H5S__hyper_proj_int_iterate(ss_span_info,sis_span_info,count,depth,udata) const H5S_hyper_span_info_t *ss_span_info; IN: Span tree for source selection const H5S_hyper_span_info_t *sis_span_info; IN: Span tree for source intersect selection - hsize_t count; IN: Number of times to compute the intersection of ss_span_info and sis_span_info - unsigned depth; IN: Depth of iteration (in terms of rank) + hsize_t count; IN: Number of times to compute the intersection of ss_span_info and +sis_span_info unsigned depth; IN: Depth of iteration (in terms of rank) H5S_hyper_project_intersect_ud_t *udata; IN/OUT: Persistent shared data for iteration RETURNS Non-negative on success/Negative on failure. @@ -11232,75 +11324,78 @@ done: --------------------------------------------------------------------------*/ static herr_t H5S__hyper_proj_int_iterate(const H5S_hyper_span_info_t *ss_span_info, - const H5S_hyper_span_info_t *sis_span_info, hsize_t count, unsigned depth, - H5S_hyper_project_intersect_ud_t *udata) + const H5S_hyper_span_info_t *sis_span_info, hsize_t count, unsigned depth, + H5S_hyper_project_intersect_ud_t *udata) { - const H5S_hyper_span_t *ss_span; /* Current span in source space */ - const H5S_hyper_span_t *sis_span; /* Current span in source intersect space */ - hsize_t ss_low; /* Current low bounds of source span */ - hsize_t sis_low; /* Current low bounds of source intersect span */ - hsize_t high; /* High bounds of current intersection */ - hsize_t low; /* Low bounds of current intersection */ - hsize_t old_skip; /* Value of udata->skip before main loop */ - hsize_t old_nelem; /* Value of udata->nelem before main loop */ - hbool_t check_intersect; /* Whether to check for intersecting elements */ - unsigned u; /* Local index variable */ - herr_t ret_value = SUCCEED; /* Return value */ + const H5S_hyper_span_t *ss_span; /* Current span in source space */ + const H5S_hyper_span_t *sis_span; /* Current span in source intersect space */ + hsize_t ss_low; /* Current low bounds of source span */ + hsize_t sis_low; /* Current low bounds of source intersect span */ + hsize_t high; /* High bounds of current intersection */ + hsize_t low; /* Low bounds of current intersection */ + hsize_t old_skip; /* Value of udata->skip before main loop */ + hsize_t old_nelem; /* Value of udata->nelem before main loop */ + hbool_t check_intersect; /* Whether to check for intersecting elements */ + unsigned u; /* Local index variable */ + herr_t ret_value = SUCCEED; /* Return value */ FUNC_ENTER_STATIC /* Check for non-overlapping bounds */ check_intersect = TRUE; - for(u = 0; u < (udata->ss_rank - depth); u++) - if(!H5S_RANGE_OVERLAP(ss_span_info->low_bounds[u], - ss_span_info->high_bounds[u], - sis_span_info->low_bounds[u], - sis_span_info->high_bounds[u])) { + for (u = 0; u < (udata->ss_rank - depth); u++) + if (!H5S_RANGE_OVERLAP(ss_span_info->low_bounds[u], ss_span_info->high_bounds[u], + sis_span_info->low_bounds[u], sis_span_info->high_bounds[u])) { check_intersect = FALSE; break; } /* end if */ /* Only enter main loop if there's something to do */ - if(check_intersect) { + if (check_intersect) { /* Set ps_clean_bitmap */ udata->ps_clean_bitmap |= (((uint32_t)1) << depth); /* Save old skip and nelem */ - old_skip = udata->skip; + old_skip = udata->skip; old_nelem = udata->nelem; /* Intersect spaces once per count */ - for(u = 0; u < count; u++) { - ss_span = ss_span_info->head; + for (u = 0; u < count; u++) { + ss_span = ss_span_info->head; sis_span = sis_span_info->head; HDassert(ss_span && sis_span); - ss_low = ss_span->low; + ss_low = ss_span->low; sis_low = sis_span->low; /* Main loop */ do { /* Check if spans overlap */ - if(H5S_RANGE_OVERLAP(ss_low, ss_span->high, - sis_low, sis_span->high)) { + if (H5S_RANGE_OVERLAP(ss_low, ss_span->high, sis_low, sis_span->high)) { high = MIN(ss_span->high, sis_span->high); - if(ss_span->down) { + if (ss_span->down) { /* Add skipped elements if there's a pre-gap */ - if(ss_low < sis_low) { + if (ss_low < sis_low) { low = sis_low; - H5S_HYPER_PROJ_INT_ADD_SKIP(udata, H5S__hyper_spans_nelem_helper(ss_span->down, 0, udata->op_gen) * (sis_low - ss_low), FAIL); + H5S_HYPER_PROJ_INT_ADD_SKIP( + udata, + H5S__hyper_spans_nelem_helper(ss_span->down, 0, udata->op_gen) * + (sis_low - ss_low), + FAIL); } /* end if */ else low = ss_low; /* Recurse into next dimension down */ - if(H5S__hyper_proj_int_iterate(ss_span->down, sis_span->down, high - low + 1, depth + 1, udata) < 0) - HGOTO_ERROR(H5E_DATASPACE, H5E_CANTCOMPARE, FAIL, "can't iterate over source selections") + if (H5S__hyper_proj_int_iterate(ss_span->down, sis_span->down, high - low + 1, + depth + 1, udata) < 0) + HGOTO_ERROR(H5E_DATASPACE, H5E_CANTCOMPARE, FAIL, + "can't iterate over source selections") } /* end if */ else { HDassert(depth == udata->ss_rank - 1); /* Add skipped elements if there's a pre-gap */ - if(ss_low < sis_low) { + if (ss_low < sis_low) { low = sis_low; H5S_HYPER_PROJ_INT_ADD_SKIP(udata, sis_low - ss_low, FAIL); } /* end if */ @@ -11312,87 +11407,99 @@ H5S__hyper_proj_int_iterate(const H5S_hyper_span_info_t *ss_span_info, } /* end else */ /* Advance spans */ - if(ss_span->high == sis_span->high) { + if (ss_span->high == sis_span->high) { /* Advance both spans */ ss_span = ss_span->next; - if(ss_span) + if (ss_span) ss_low = ss_span->low; sis_span = sis_span->next; - if(sis_span) + if (sis_span) sis_low = sis_span->low; } /* end if */ - else if(ss_span->high == high) { + else if (ss_span->high == high) { /* Advance source span */ HDassert(ss_span->high < sis_span->high); sis_low = high + 1; ss_span = ss_span->next; - if(ss_span) + if (ss_span) ss_low = ss_span->low; } /* end if */ else { /* Advance source intersect span */ HDassert(ss_span->high > sis_span->high); - ss_low = high + 1; + ss_low = high + 1; sis_span = sis_span->next; - if(sis_span) + if (sis_span) sis_low = sis_span->low; } /* end else */ - } /* end if */ + } /* end if */ else { /* Advance spans */ - if(ss_span->high < sis_low) { + if (ss_span->high < sis_low) { /* Add skipped elements */ - if(ss_span->down) - H5S_HYPER_PROJ_INT_ADD_SKIP(udata, H5S__hyper_spans_nelem_helper(ss_span->down, 0, udata->op_gen) * (ss_span->high - ss_low + 1), FAIL); + if (ss_span->down) + H5S_HYPER_PROJ_INT_ADD_SKIP( + udata, + H5S__hyper_spans_nelem_helper(ss_span->down, 0, udata->op_gen) * + (ss_span->high - ss_low + 1), + FAIL); else H5S_HYPER_PROJ_INT_ADD_SKIP(udata, ss_span->high - ss_low + 1, FAIL); /* Advance source span */ ss_span = ss_span->next; - if(ss_span) + if (ss_span) ss_low = ss_span->low; } /* end if */ else { /* Advance source intersect span */ HDassert(ss_low > sis_span->high); sis_span = sis_span->next; - if(sis_span) + if (sis_span) sis_low = sis_span->low; } /* end else */ - } /* end else */ - } while(ss_span && sis_span); + } /* end else */ + } while (ss_span && sis_span); - if(ss_span && !((depth == 0) && (u == count - 1))) { + if (ss_span && !((depth == 0) && (u == count - 1))) { /* Count remaining elements in ss_span_info */ - if(ss_span->down) { - H5S_HYPER_PROJ_INT_ADD_SKIP(udata, H5S__hyper_spans_nelem_helper(ss_span->down, 0, udata->op_gen) * (ss_span->high - ss_low + 1), FAIL); + if (ss_span->down) { + H5S_HYPER_PROJ_INT_ADD_SKIP( + udata, + H5S__hyper_spans_nelem_helper(ss_span->down, 0, udata->op_gen) * + (ss_span->high - ss_low + 1), + FAIL); ss_span = ss_span->next; - while(ss_span) { - H5S_HYPER_PROJ_INT_ADD_SKIP(udata, H5S__hyper_spans_nelem_helper(ss_span->down, 0, udata->op_gen) * (ss_span->high - ss_span->low + 1), FAIL); + while (ss_span) { + H5S_HYPER_PROJ_INT_ADD_SKIP( + udata, + H5S__hyper_spans_nelem_helper(ss_span->down, 0, udata->op_gen) * + (ss_span->high - ss_span->low + 1), + FAIL); ss_span = ss_span->next; } /* end while */ - } /* end if */ + } /* end if */ else { H5S_HYPER_PROJ_INT_ADD_SKIP(udata, ss_span->high - ss_low + 1, FAIL); ss_span = ss_span->next; - while(ss_span) { + while (ss_span) { H5S_HYPER_PROJ_INT_ADD_SKIP(udata, ss_span->high - ss_span->low + 1, FAIL); ss_span = ss_span->next; } /* end while */ - } /* end else */ - } /* end if */ + } /* end else */ + } /* end if */ /* Check if the projected space was not changed since we started the * first iteration of the loop, if so we do not need to continue * looping and can just copy the result */ - if(udata->ps_clean_bitmap & (((uint32_t)1) << depth)) { + if (udata->ps_clean_bitmap & (((uint32_t)1) << depth)) { HDassert(u == 0); - if(udata->skip == old_skip) { + if (udata->skip == old_skip) { /* First case: algorithm added only elements */ HDassert(udata->nelem >= old_nelem); udata->nelem += (count - 1) * (udata->nelem - old_nelem); } /* end if */ - else if(udata->nelem == 0) { + else if (udata->nelem == 0) { /* Second case: algorithm added only skip. In this case, * nelem must be 0 since otherwise adding skip would have * triggered a change in the projected space */ @@ -11411,48 +11518,49 @@ H5S__hyper_proj_int_iterate(const H5S_hyper_span_info_t *ss_span_info, HDassert(udata->skip > old_skip); HDassert(old_nelem == 0); - skip_add = udata->skip - old_skip; + skip_add = udata->skip - old_skip; nelem_add = udata->nelem - old_nelem; - for(u = 1; u < count; u++) { + for (u = 1; u < count; u++) { H5S_HYPER_PROJ_INT_ADD_SKIP(udata, skip_add, FAIL); udata->nelem += nelem_add; } /* end for */ - } /* end else */ + } /* end else */ /* End loop since we already took care of it */ break; } /* end if */ - } /* end for */ - } /* end if */ - else if(depth > 0) + } /* end for */ + } /* end if */ + else if (depth > 0) /* Just count skipped elements */ - H5S_HYPER_PROJ_INT_ADD_SKIP(udata, H5S__hyper_spans_nelem_helper((H5S_hyper_span_info_t *)ss_span_info, 0, udata->op_gen) * count, FAIL); /* Casting away const OK -NAF */ + H5S_HYPER_PROJ_INT_ADD_SKIP( + udata, + H5S__hyper_spans_nelem_helper((H5S_hyper_span_info_t *)ss_span_info, 0, udata->op_gen) * count, + FAIL); /* Casting away const OK -NAF */ /* Clean up if we are done */ - if(depth == 0) { + if (depth == 0) { /* Add remaining elements */ - if(udata->nelem > 0) - if(H5S__hyper_proj_int_build_proj(udata) < 0) + if (udata->nelem > 0) + if (H5S__hyper_proj_int_build_proj(udata) < 0) HGOTO_ERROR(H5E_DATASPACE, H5E_CANTAPPEND, FAIL, "can't add elements to projected selection") /* Append remaining span trees */ - for(u = udata->ds_rank - 1; u > 0; u--) - if(udata->ps_span_info[u]) { - if(H5S__hyper_append_span(&udata->ps_span_info[u - 1], - udata->ds_rank - u + 1, udata->ds_low[u - 1], - udata->ds_low[u - 1], - udata->ps_span_info[u]) < 0) + for (u = udata->ds_rank - 1; u > 0; u--) + if (udata->ps_span_info[u]) { + if (H5S__hyper_append_span(&udata->ps_span_info[u - 1], udata->ds_rank - u + 1, + udata->ds_low[u - 1], udata->ds_low[u - 1], + udata->ps_span_info[u]) < 0) HGOTO_ERROR(H5E_DATASPACE, H5E_CANTAPPEND, FAIL, "can't allocate hyperslab span") H5S__hyper_free_span_info(udata->ps_span_info[u]); udata->ps_span_info[u] = NULL; } /* end if */ - } /* end if */ + } /* end if */ done: FUNC_LEAVE_NOAPI(ret_value) } /* end H5S__hyper_proj_int_iterate() */ - /*-------------------------------------------------------------------------- NAME H5S__hyper_project_intersection @@ -11462,38 +11570,29 @@ done: within the selection of dst_space USAGE herr_t H5S__hyper_project_intersection(src_space,dst_space,src_intersect_space,proj_space,share_selection) - H5S_t *src_space; IN: Selection that is mapped to dst_space, and intersected with src_intersect_space - H5S_t *dst_space; IN: Selection that is mapped to src_space, and which contains the result - H5S_t *src_intersect_space; IN: Selection whose intersection with src_space is projected to dst_space to obtain the result - H5S_t *proj_space; OUT: Will contain the result (intersection of src_intersect_space and src_space projected from src_space to dst_space) after the operation - hbool_t share_selection; IN: Whether we are allowed to share structures inside dst_space with proj_space - RETURNS - Non-negative on success/Negative on failure. - DESCRIPTION - Projects the intersection of of the selections of src_space and - src_intersect_space within the selection of src_space as a selection - within the selection of dst_space. The result is placed in the selection - of proj_space. Note src_space, dst_space, and src_intersect_space do not - need to use hyperslab selections, but they cannot use point selections. - The result is always a hyperslab or none selection. Note also that - proj_space can share some span trees with dst_space, so proj_space - must not be subsequently modified if dst_space must be preserved. - GLOBAL VARIABLES - COMMENTS, BUGS, ASSUMPTIONS - EXAMPLES - REVISION LOG + H5S_t *src_space; IN: Selection that is mapped to dst_space, and intersected with +src_intersect_space H5S_t *dst_space; IN: Selection that is mapped to src_space, and which contains the +result H5S_t *src_intersect_space; IN: Selection whose intersection with src_space is projected to dst_space +to obtain the result H5S_t *proj_space; OUT: Will contain the result (intersection of src_intersect_space +and src_space projected from src_space to dst_space) after the operation hbool_t share_selection; IN: Whether +we are allowed to share structures inside dst_space with proj_space RETURNS Non-negative on success/Negative +on failure. DESCRIPTION Projects the intersection of of the selections of src_space and src_intersect_space +within the selection of src_space as a selection within the selection of dst_space. The result is placed in +the selection of proj_space. Note src_space, dst_space, and src_intersect_space do not need to use hyperslab +selections, but they cannot use point selections. The result is always a hyperslab or none selection. Note +also that proj_space can share some span trees with dst_space, so proj_space must not be subsequently modified +if dst_space must be preserved. GLOBAL VARIABLES COMMENTS, BUGS, ASSUMPTIONS EXAMPLES REVISION LOG --------------------------------------------------------------------------*/ herr_t H5S__hyper_project_intersection(const H5S_t *src_space, const H5S_t *dst_space, - const H5S_t *src_intersect_space, H5S_t *proj_space, - hbool_t share_selection) + const H5S_t *src_intersect_space, H5S_t *proj_space, hbool_t share_selection) { - H5S_hyper_project_intersect_ud_t udata; /* User data for subroutines */ - const H5S_hyper_span_info_t *ss_span_info; - const H5S_hyper_span_info_t *ds_span_info; - H5S_hyper_span_info_t *ss_span_info_buf = NULL; - H5S_hyper_span_info_t *ds_span_info_buf = NULL; - herr_t ret_value = SUCCEED; /* Return value */ + H5S_hyper_project_intersect_ud_t udata; /* User data for subroutines */ + const H5S_hyper_span_info_t * ss_span_info; + const H5S_hyper_span_info_t * ds_span_info; + H5S_hyper_span_info_t * ss_span_info_buf = NULL; + H5S_hyper_span_info_t * ds_span_info_buf = NULL; + herr_t ret_value = SUCCEED; /* Return value */ FUNC_ENTER_PACKAGE @@ -11512,11 +11611,12 @@ H5S__hyper_project_intersection(const H5S_t *src_space, const H5S_t *dst_space, HDassert(H5S_GET_SELECT_TYPE(src_intersect_space) == H5S_SEL_HYPERSLABS); /* Set up ss_span_info */ - if(H5S_GET_SELECT_TYPE(src_space) == H5S_SEL_HYPERSLABS) { + if (H5S_GET_SELECT_TYPE(src_space) == H5S_SEL_HYPERSLABS) { /* Make certain the selection has a span tree */ - if(NULL == src_space->select.sel_info.hslab->span_lst) - if(H5S__hyper_generate_spans((H5S_t *)src_space) < 0) /* Casting away const OK -NAF */ - HGOTO_ERROR(H5E_DATASPACE, H5E_UNINITIALIZED, FAIL, "can't construct span tree for source hyperslab selection") + if (NULL == src_space->select.sel_info.hslab->span_lst) + if (H5S__hyper_generate_spans((H5S_t *)src_space) < 0) /* Casting away const OK -NAF */ + HGOTO_ERROR(H5E_DATASPACE, H5E_UNINITIALIZED, FAIL, + "can't construct span tree for source hyperslab selection") /* Simply point to existing span tree */ ss_span_info = src_space->select.sel_info.hslab->span_lst; @@ -11525,18 +11625,20 @@ H5S__hyper_project_intersection(const H5S_t *src_space, const H5S_t *dst_space, /* Create temporary span tree from all selection */ HDassert(H5S_GET_SELECT_TYPE(src_space) == H5S_SEL_ALL); - if(NULL == (ss_span_info_buf = H5S__hyper_make_spans(H5S_GET_EXTENT_NDIMS(src_space), - H5S_hyper_zeros_g, H5S_hyper_zeros_g, H5S_hyper_ones_g, src_space->extent.size))) + if (NULL == (ss_span_info_buf = + H5S__hyper_make_spans(H5S_GET_EXTENT_NDIMS(src_space), H5S_hyper_zeros_g, + H5S_hyper_zeros_g, H5S_hyper_ones_g, src_space->extent.size))) HGOTO_ERROR(H5E_DATASPACE, H5E_CANTINIT, FAIL, "can't create span tree for ALL source space") ss_span_info = ss_span_info_buf; } /* end else */ /* Set up ds_span_info */ - if(H5S_GET_SELECT_TYPE(dst_space) == H5S_SEL_HYPERSLABS) { + if (H5S_GET_SELECT_TYPE(dst_space) == H5S_SEL_HYPERSLABS) { /* Make certain the selection has a span tree */ - if(NULL == dst_space->select.sel_info.hslab->span_lst) - if(H5S__hyper_generate_spans((H5S_t *)dst_space) < 0) /* Casting away const OK -NAF */ - HGOTO_ERROR(H5E_DATASPACE, H5E_UNINITIALIZED, FAIL, "can't construct span tree for dsetination hyperslab selection") + if (NULL == dst_space->select.sel_info.hslab->span_lst) + if (H5S__hyper_generate_spans((H5S_t *)dst_space) < 0) /* Casting away const OK -NAF */ + HGOTO_ERROR(H5E_DATASPACE, H5E_UNINITIALIZED, FAIL, + "can't construct span tree for dsetination hyperslab selection") /* Simply point to existing span tree */ ds_span_info = dst_space->select.sel_info.hslab->span_lst; @@ -11545,40 +11647,43 @@ H5S__hyper_project_intersection(const H5S_t *src_space, const H5S_t *dst_space, /* Create temporary span tree from all selection */ HDassert(H5S_GET_SELECT_TYPE(dst_space) == H5S_SEL_ALL); - if(NULL == (ds_span_info_buf = H5S__hyper_make_spans(H5S_GET_EXTENT_NDIMS(dst_space), - H5S_hyper_zeros_g, H5S_hyper_zeros_g, H5S_hyper_ones_g, dst_space->extent.size))) + if (NULL == (ds_span_info_buf = + H5S__hyper_make_spans(H5S_GET_EXTENT_NDIMS(dst_space), H5S_hyper_zeros_g, + H5S_hyper_zeros_g, H5S_hyper_ones_g, dst_space->extent.size))) HGOTO_ERROR(H5E_DATASPACE, H5E_CANTINIT, FAIL, "can't create span tree for ALL destination space") ds_span_info = ds_span_info_buf; } /* end else */ /* Make certain the source intersect selection has a span tree */ - if(NULL == src_intersect_space->select.sel_info.hslab->span_lst) - if(H5S__hyper_generate_spans((H5S_t *)src_intersect_space) < 0) /* Casting away const OK -NAF */ - HGOTO_ERROR(H5E_DATASPACE, H5E_UNINITIALIZED, FAIL, "can't construct span tree for source intersect hyperslab selection") + if (NULL == src_intersect_space->select.sel_info.hslab->span_lst) + if (H5S__hyper_generate_spans((H5S_t *)src_intersect_space) < 0) /* Casting away const OK -NAF */ + HGOTO_ERROR(H5E_DATASPACE, H5E_UNINITIALIZED, FAIL, + "can't construct span tree for source intersect hyperslab selection") /* Initialize udata */ /* We will use op_info[0] for nelem and op_info[1] for copied spans */ HDmemset(&udata, 0, sizeof(udata)); - udata.ds_span[0] = ds_span_info->head; - udata.ds_low[0] = udata.ds_span[0]->low; - udata.ss_rank = H5S_GET_EXTENT_NDIMS(src_space); - udata.ds_rank = H5S_GET_EXTENT_NDIMS(dst_space); - udata.op_gen = H5S__hyper_get_op_gen(); + udata.ds_span[0] = ds_span_info->head; + udata.ds_low[0] = udata.ds_span[0]->low; + udata.ss_rank = H5S_GET_EXTENT_NDIMS(src_space); + udata.ds_rank = H5S_GET_EXTENT_NDIMS(dst_space); + udata.op_gen = H5S__hyper_get_op_gen(); udata.share_selection = share_selection; /* Iterate over selections and build projected span tree */ - if(H5S__hyper_proj_int_iterate(ss_span_info, src_intersect_space->select.sel_info.hslab->span_lst, 1, 0, &udata) < 0) + if (H5S__hyper_proj_int_iterate(ss_span_info, src_intersect_space->select.sel_info.hslab->span_lst, 1, 0, + &udata) < 0) HGOTO_ERROR(H5E_DATASPACE, H5E_CANTCOMPARE, FAIL, "selection iteration failed") /* Remove current selection from proj_space */ - if(H5S_SELECT_RELEASE(proj_space) < 0) + if (H5S_SELECT_RELEASE(proj_space) < 0) HGOTO_ERROR(H5E_DATASPACE, H5E_CANTDELETE, FAIL, "can't release selection") /* Check for elements in projected space */ - if(udata.ps_span_info[0]) { + if (udata.ps_span_info[0]) { /* Allocate space for the hyperslab selection information (note this sets * diminfo_valid to FALSE, diminfo arrays to 0, and span list to NULL) */ - if(NULL == (proj_space->select.sel_info.hslab = H5FL_CALLOC(H5S_hyper_sel_t))) + if (NULL == (proj_space->select.sel_info.hslab = H5FL_CALLOC(H5S_hyper_sel_t))) HGOTO_ERROR(H5E_DATASPACE, H5E_CANTALLOC, FAIL, "can't allocate hyperslab info") /* Set selection type */ @@ -11589,7 +11694,7 @@ H5S__hyper_project_intersection(const H5S_t *src_space, const H5S_t *dst_space, /* Set span tree */ proj_space->select.sel_info.hslab->span_lst = udata.ps_span_info[0]; - udata.ps_span_info[0] = NULL; + udata.ps_span_info[0] = NULL; /* Set the number of elements in current selection */ proj_space->select.num_elem = H5S__hyper_spans_nelem(proj_space->select.sel_info.hslab->span_lst); @@ -11601,48 +11706,47 @@ H5S__hyper_project_intersection(const H5S_t *src_space, const H5S_t *dst_space, } /* end if */ else /* If we did not add anything to proj_space, select none instead */ - if(H5S_select_none(proj_space) < 0) - HGOTO_ERROR(H5E_DATASPACE, H5E_CANTDELETE, FAIL, "can't convert selection") + if (H5S_select_none(proj_space) < 0) + HGOTO_ERROR(H5E_DATASPACE, H5E_CANTDELETE, FAIL, "can't convert selection") done: /* Free ss_span_info_buf */ - if(ss_span_info_buf) { + if (ss_span_info_buf) { H5S__hyper_free_span_info(ss_span_info_buf); ss_span_info_buf = NULL; } /* end if */ /* Free ds_span_info_buf */ - if(ds_span_info_buf) { + if (ds_span_info_buf) { H5S__hyper_free_span_info(ds_span_info_buf); ds_span_info_buf = NULL; } /* end if */ /* Cleanup on error */ - if(ret_value < 0) { + if (ret_value < 0) { unsigned u; /* Free span trees */ - for(u = 0; u < udata.ds_rank; u++) - if(udata.ps_span_info[u]) { + for (u = 0; u < udata.ds_rank; u++) + if (udata.ps_span_info[u]) { H5S__hyper_free_span_info(udata.ps_span_info[u]); udata.ps_span_info[u] = NULL; } /* end if */ - } /* end if */ + } /* end if */ #ifndef NDEBUG /* Verify there are no more span trees */ { unsigned u; - for(u = 0; u < H5S_MAX_RANK; u++) + for (u = 0; u < H5S_MAX_RANK; u++) HDassert(!udata.ps_span_info[u]); - } /* end block */ + } /* end block */ #endif /* NDEBUG */ FUNC_LEAVE_NOAPI(ret_value) } /* end H5S__hyper_project_intersection() */ - /*-------------------------------------------------------------------------- NAME H5S__hyper_get_clip_diminfo @@ -11668,20 +11772,19 @@ done: REVISION LOG --------------------------------------------------------------------------*/ static void -H5S__hyper_get_clip_diminfo(hsize_t start, hsize_t stride, hsize_t *count, - hsize_t *block, hsize_t clip_size) +H5S__hyper_get_clip_diminfo(hsize_t start, hsize_t stride, hsize_t *count, hsize_t *block, hsize_t clip_size) { FUNC_ENTER_STATIC_NOERR /* Check for selection outside clip size */ - if(start >= clip_size) { - if(*block == H5S_UNLIMITED) + if (start >= clip_size) { + if (*block == H5S_UNLIMITED) *block = 0; else *count = 0; } /* end if */ /* Check for single block in unlimited dimension */ - else if((*block == H5S_UNLIMITED) || (*block == stride)) { + else if ((*block == H5S_UNLIMITED) || (*block == stride)) { /* Calculate actual block size for this clip size */ *block = clip_size - start; *count = (hsize_t)1; @@ -11697,7 +11800,6 @@ H5S__hyper_get_clip_diminfo(hsize_t start, hsize_t stride, hsize_t *count, FUNC_LEAVE_NOAPI_VOID } /* end H5S__hyper_get_clip_diminfo() */ - /*-------------------------------------------------------------------------- NAME H5S_hyper_clip_unlim @@ -11722,11 +11824,11 @@ H5S__hyper_get_clip_diminfo(hsize_t start, hsize_t stride, hsize_t *count, herr_t H5S_hyper_clip_unlim(H5S_t *space, hsize_t clip_size) { - H5S_hyper_sel_t *hslab = NULL; /* Convenience pointer to hyperslab info */ - hsize_t orig_count; /* Original count in unlimited dimension */ - int orig_unlim_dim; /* Original unliminted dimension */ - H5S_hyper_dim_t *diminfo = NULL; /* Convenience pointer to diminfo.opt in unlimited dimension */ - herr_t ret_value = SUCCEED; /* Return value */ + H5S_hyper_sel_t *hslab = NULL; /* Convenience pointer to hyperslab info */ + hsize_t orig_count; /* Original count in unlimited dimension */ + int orig_unlim_dim; /* Original unliminted dimension */ + H5S_hyper_dim_t *diminfo = NULL; /* Convenience pointer to diminfo.opt in unlimited dimension */ + herr_t ret_value = SUCCEED; /* Return value */ FUNC_ENTER_NOAPI(FAIL) @@ -11753,17 +11855,17 @@ H5S_hyper_clip_unlim(H5S_t *space, hsize_t clip_size) space->select.sel_info.hslab->unlim_dim = -1; /* Check for nothing returned */ - if((diminfo->block == 0) || (diminfo->count == 0)) { + if ((diminfo->block == 0) || (diminfo->count == 0)) { /* Convert to "none" selection */ - if(H5S_select_none(space) < 0) + if (H5S_select_none(space) < 0) HGOTO_ERROR(H5E_DATASPACE, H5E_CANTDELETE, FAIL, "can't convert selection") /* Reset the convenience pointers */ - hslab = NULL; + hslab = NULL; diminfo = NULL; } /* end if */ /* Check for single block in unlimited dimension */ - else if(orig_count == (hsize_t)1) { + else if (orig_count == (hsize_t)1) { /* Calculate number of elements */ space->select.num_elem = diminfo->block * hslab->num_elem_non_unlim; @@ -11777,10 +11879,10 @@ H5S_hyper_clip_unlim(H5S_t *space, hsize_t clip_size) /* Check if last block is partial. If superset is set, just keep the * last block complete to speed computation. */ HDassert(clip_size > diminfo->start); - if(((diminfo->stride * (diminfo->count - (hsize_t)1)) + diminfo->block) - > (clip_size - diminfo->start)) { - hsize_t start[H5S_MAX_RANK]; - hsize_t block[H5S_MAX_RANK]; + if (((diminfo->stride * (diminfo->count - (hsize_t)1)) + diminfo->block) > + (clip_size - diminfo->start)) { + hsize_t start[H5S_MAX_RANK]; + hsize_t block[H5S_MAX_RANK]; unsigned u; /* Last block is partial, need to construct compound selection */ @@ -11789,22 +11891,23 @@ H5S_hyper_clip_unlim(H5S_t *space, hsize_t clip_size) /* Set block to clip_size in unlimited dimension, H5S_MAX_SIZE in * others so only unlimited dimension is clipped */ - for(u = 0; u < space->extent.rank; u++) - if((int)u == orig_unlim_dim) + for (u = 0; u < space->extent.rank; u++) + if ((int)u == orig_unlim_dim) block[u] = clip_size; else block[u] = H5S_MAX_SIZE; /* Generate span tree in selection */ - if(!hslab->span_lst) - if(H5S__hyper_generate_spans(space) < 0) + if (!hslab->span_lst) + if (H5S__hyper_generate_spans(space) < 0) HGOTO_ERROR(H5E_DATASPACE, H5E_CANTINIT, FAIL, "unable to generate span tree") /* Indicate that the regular dimensions are no longer valid */ hslab->diminfo_valid = H5S_DIMINFO_VALID_NO; /* "And" selection with calculated block to perform clip operation */ - if(H5S__generate_hyperslab(space, H5S_SELECT_AND, start, H5S_hyper_ones_g, H5S_hyper_ones_g, block) < 0) + if (H5S__generate_hyperslab(space, H5S_SELECT_AND, start, H5S_hyper_ones_g, H5S_hyper_ones_g, + block) < 0) HGOTO_ERROR(H5E_DATASPACE, H5E_CANTINSERT, FAIL, "can't generate hyperslabs") } /* end if */ else @@ -11813,17 +11916,16 @@ H5S_hyper_clip_unlim(H5S_t *space, hsize_t clip_size) } /* end else */ /* Update the upper bound, if the diminfo is valid */ - if(hslab && (H5S_DIMINFO_VALID_YES == hslab->diminfo_valid)) + if (hslab && (H5S_DIMINFO_VALID_YES == hslab->diminfo_valid)) hslab->diminfo.high_bounds[orig_unlim_dim] = - hslab->diminfo.opt[orig_unlim_dim].start + - hslab->diminfo.opt[orig_unlim_dim].stride * (hslab->diminfo.opt[orig_unlim_dim].count - 1) + - (hslab->diminfo.opt[orig_unlim_dim].block - 1); + hslab->diminfo.opt[orig_unlim_dim].start + + hslab->diminfo.opt[orig_unlim_dim].stride * (hslab->diminfo.opt[orig_unlim_dim].count - 1) + + (hslab->diminfo.opt[orig_unlim_dim].block - 1); done: FUNC_LEAVE_NOAPI(ret_value) } /* end H5S_hyper_clip_unlim() */ - /*-------------------------------------------------------------------------- NAME H5S__hyper_get_clip_extent_real @@ -11852,13 +11954,12 @@ done: REVISION LOG --------------------------------------------------------------------------*/ static hsize_t -H5S__hyper_get_clip_extent_real(const H5S_t *clip_space, hsize_t num_slices, - hbool_t incl_trail) +H5S__hyper_get_clip_extent_real(const H5S_t *clip_space, hsize_t num_slices, hbool_t incl_trail) { const H5S_hyper_dim_t *diminfo; /* Convenience pointer to opt_unlim_diminfo in unlimited dimension */ - hsize_t count; - hsize_t rem_slices; - hsize_t ret_value = 0; /* Return value */ + hsize_t count; + hsize_t rem_slices; + hsize_t ret_value = 0; /* Return value */ FUNC_ENTER_STATIC_NOERR @@ -11869,10 +11970,9 @@ H5S__hyper_get_clip_extent_real(const H5S_t *clip_space, hsize_t num_slices, diminfo = &clip_space->select.sel_info.hslab->diminfo.opt[clip_space->select.sel_info.hslab->unlim_dim]; - if(num_slices == 0) + if (num_slices == 0) ret_value = incl_trail ? diminfo->start : 0; - else if((diminfo->block == H5S_UNLIMITED) - || (diminfo->block == diminfo->stride)) + else if ((diminfo->block == H5S_UNLIMITED) || (diminfo->block == diminfo->stride)) /* Unlimited block, just set the extent large enough for the block size * to match num_slices */ ret_value = diminfo->start + num_slices; @@ -11887,25 +11987,23 @@ H5S__hyper_get_clip_extent_real(const H5S_t *clip_space, hsize_t num_slices, /* Calculate slices remaining */ rem_slices = num_slices - (count * diminfo->block); - if(rem_slices > 0) + if (rem_slices > 0) /* Must end extent in middle of partial block (or beginning of empty * block if include_trailing_space and rem_slices == 0) */ ret_value = diminfo->start + (count * diminfo->stride) + rem_slices; else { - if(incl_trail) + if (incl_trail) /* End extent just before first missing block */ ret_value = diminfo->start + (count * diminfo->stride); else /* End extent at end of last block */ - ret_value = diminfo->start + ((count - (hsize_t)1) - * diminfo->stride) + diminfo->block; + ret_value = diminfo->start + ((count - (hsize_t)1) * diminfo->stride) + diminfo->block; } /* end else */ - } /* end else */ + } /* end else */ FUNC_LEAVE_NOAPI(ret_value) } /* end H5S__hyper_get_clip_extent_real() */ - /*-------------------------------------------------------------------------- NAME H5S_hyper_get_clip_extent @@ -11915,30 +12013,20 @@ H5S__hyper_get_clip_extent_real(const H5S_t *clip_space, hsize_t num_slices, USAGE hsize_t H5S__hyper_get_clip_extent(clip_space,match_space,incl_trail) const H5S_t *clip_space, IN: Space that clip size will be calculated based on - const H5S_t *match_space, IN: Space containing the same number of elements as clip_space should after clipping - hbool_t incl_trail; IN: Whether to include trailing unselected space - RETURNS - Calculated clip extent (never fails) - DESCRIPTION - Calculates and returns the extent that clip_space should be clipped to - (via H5S_hyper_clip_unlim) in order for it to contain the same number - of elements as match_space. If the clipped selection would end - immediately before a section of unselected space (i.e. at the end of a - block), then if incl_trail is TRUE, the returned clip extent is - selected to include that trailing "blank" space, otherwise it is - selected to end at the end before the blank space. - GLOBAL VARIABLES - COMMENTS, BUGS, ASSUMPTIONS - Note this assumes the offset has been normalized. - EXAMPLES - REVISION LOG + const H5S_t *match_space, IN: Space containing the same number of elements as clip_space should after +clipping hbool_t incl_trail; IN: Whether to include trailing unselected space RETURNS Calculated clip +extent (never fails) DESCRIPTION Calculates and returns the extent that clip_space should be clipped to (via +H5S_hyper_clip_unlim) in order for it to contain the same number of elements as match_space. If the clipped +selection would end immediately before a section of unselected space (i.e. at the end of a block), then if +incl_trail is TRUE, the returned clip extent is selected to include that trailing "blank" space, otherwise it +is selected to end at the end before the blank space. GLOBAL VARIABLES COMMENTS, BUGS, ASSUMPTIONS Note this +assumes the offset has been normalized. EXAMPLES REVISION LOG --------------------------------------------------------------------------*/ hsize_t -H5S_hyper_get_clip_extent(const H5S_t *clip_space, const H5S_t *match_space, - hbool_t incl_trail) +H5S_hyper_get_clip_extent(const H5S_t *clip_space, const H5S_t *match_space, hbool_t incl_trail) { - hsize_t num_slices; /* Number of slices in unlimited dimension */ - hsize_t ret_value = 0; /* Return value */ + hsize_t num_slices; /* Number of slices in unlimited dimension */ + hsize_t ret_value = 0; /* Return value */ FUNC_ENTER_NOAPI(0) @@ -11948,17 +12036,15 @@ H5S_hyper_get_clip_extent(const H5S_t *clip_space, const H5S_t *match_space, HDassert(clip_space->select.sel_info.hslab->unlim_dim >= 0); /* Check for "none" match space */ - if(match_space->select.type->type == H5S_SEL_NONE) + if (match_space->select.type->type == H5S_SEL_NONE) num_slices = (hsize_t)0; else { HDassert(match_space->select.type->type == H5S_SEL_HYPERSLABS); HDassert(match_space->select.sel_info.hslab); /* Calculate number of slices */ - num_slices = match_space->select.num_elem - / clip_space->select.sel_info.hslab->num_elem_non_unlim; - HDassert((match_space->select.num_elem - % clip_space->select.sel_info.hslab->num_elem_non_unlim) == 0); + num_slices = match_space->select.num_elem / clip_space->select.sel_info.hslab->num_elem_non_unlim; + HDassert((match_space->select.num_elem % clip_space->select.sel_info.hslab->num_elem_non_unlim) == 0); } /* end else */ /* Call "real" get_clip_extent function */ @@ -11968,7 +12054,6 @@ done: FUNC_LEAVE_NOAPI(ret_value) } /* end H5S_hyper_get_clip_extent() */ - /*-------------------------------------------------------------------------- NAME H5S_hyper_get_clip_extent_match @@ -11979,35 +12064,27 @@ done: USAGE hsize_t H5S__hyper_get_clip_extent_match(clip_space,match_space,match_clip_size,incl_trail) const H5S_t *clip_space, IN: Space that clip size will be calculated based on - const H5S_t *match_space, IN: Space that, after being clipped to match_clip_size, contains the same number of elements as clip_space should after clipping - hsize_t match_clip_size, IN: Extent match_space would be clipped to to match the number of elements in clip_space - hbool_t incl_trail; IN: Whether to include trailing unselected space - RETURNS - Calculated clip extent (never fails) - DESCRIPTION - Calculates and returns the extent that clip_space should be clipped to - (via H5S_hyper_clip_unlim) in order for it to contain the same number - of elements as match_space would have after being clipped to - match_clip_size. If the clipped selection would end immediately - before a section of unselected space (i.e. at the end of a block), - then if incl_trail is TRUE, the returned clip extent is selected to - include that trailing "blank" space, otherwise it is selected to end - at the end before the blank space. - GLOBAL VARIABLES - COMMENTS, BUGS, ASSUMPTIONS - Note this assumes the offset has been normalized. - EXAMPLES - REVISION LOG + const H5S_t *match_space, IN: Space that, after being clipped to match_clip_size, contains the same +number of elements as clip_space should after clipping hsize_t match_clip_size, IN: Extent match_space would +be clipped to to match the number of elements in clip_space hbool_t incl_trail; IN: Whether to include +trailing unselected space RETURNS Calculated clip extent (never fails) DESCRIPTION Calculates and returns the +extent that clip_space should be clipped to (via H5S_hyper_clip_unlim) in order for it to contain the same +number of elements as match_space would have after being clipped to match_clip_size. If the clipped selection +would end immediately before a section of unselected space (i.e. at the end of a block), then if incl_trail is +TRUE, the returned clip extent is selected to include that trailing "blank" space, otherwise it is selected to +end at the end before the blank space. GLOBAL VARIABLES COMMENTS, BUGS, ASSUMPTIONS Note this assumes the +offset has been normalized. EXAMPLES REVISION LOG --------------------------------------------------------------------------*/ hsize_t -H5S_hyper_get_clip_extent_match(const H5S_t *clip_space, - const H5S_t *match_space, hsize_t match_clip_size, hbool_t incl_trail) +H5S_hyper_get_clip_extent_match(const H5S_t *clip_space, const H5S_t *match_space, hsize_t match_clip_size, + hbool_t incl_trail) { - const H5S_hyper_dim_t *match_diminfo; /* Convenience pointer to opt_unlim_diminfo in unlimited dimension in match_space */ - hsize_t count; /* Temporary count */ - hsize_t block; /* Temporary block */ - hsize_t num_slices; /* Number of slices in unlimited dimension */ - hsize_t ret_value = 0; /* Return value */ + const H5S_hyper_dim_t + *match_diminfo; /* Convenience pointer to opt_unlim_diminfo in unlimited dimension in match_space */ + hsize_t count; /* Temporary count */ + hsize_t block; /* Temporary block */ + hsize_t num_slices; /* Number of slices in unlimited dimension */ + hsize_t ret_value = 0; /* Return value */ FUNC_ENTER_NOAPI(0) @@ -12018,10 +12095,11 @@ H5S_hyper_get_clip_extent_match(const H5S_t *clip_space, HDassert(match_space->select.sel_info.hslab); HDassert(clip_space->select.sel_info.hslab->unlim_dim >= 0); HDassert(match_space->select.sel_info.hslab->unlim_dim >= 0); - HDassert(clip_space->select.sel_info.hslab->num_elem_non_unlim - == match_space->select.sel_info.hslab->num_elem_non_unlim); + HDassert(clip_space->select.sel_info.hslab->num_elem_non_unlim == + match_space->select.sel_info.hslab->num_elem_non_unlim); - match_diminfo = &match_space->select.sel_info.hslab->diminfo.opt[match_space->select.sel_info.hslab->unlim_dim]; + match_diminfo = + &match_space->select.sel_info.hslab->diminfo.opt[match_space->select.sel_info.hslab->unlim_dim]; /* Get initial count and block */ count = match_diminfo->count; @@ -12030,10 +12108,10 @@ H5S_hyper_get_clip_extent_match(const H5S_t *clip_space, /* Calculate number of slices */ /* Check for nothing returned */ - if((block == 0) || (count == 0)) + if ((block == 0) || (count == 0)) num_slices = (hsize_t)0; /* Check for single block in unlimited dimension */ - else if(count == (hsize_t)1) + else if (count == (hsize_t)1) num_slices = block; else { /* Calculate initial num_slices */ @@ -12041,15 +12119,15 @@ H5S_hyper_get_clip_extent_match(const H5S_t *clip_space, /* Check for partial last block */ HDassert(match_clip_size >= match_diminfo->start); - if(((match_diminfo->stride * (count - (hsize_t)1)) + block) - > (match_clip_size - match_diminfo->start)) { + if (((match_diminfo->stride * (count - (hsize_t)1)) + block) > + (match_clip_size - match_diminfo->start)) { /* Subtract slices missing from last block */ - HDassert((((match_diminfo->stride * (count - (hsize_t)1)) + block) - - (match_clip_size - match_diminfo->start)) < num_slices); - num_slices -= ((match_diminfo->stride * (count - (hsize_t)1)) - + block) - (match_clip_size - match_diminfo->start); + HDassert((((match_diminfo->stride * (count - (hsize_t)1)) + block) - + (match_clip_size - match_diminfo->start)) < num_slices); + num_slices -= ((match_diminfo->stride * (count - (hsize_t)1)) + block) - + (match_clip_size - match_diminfo->start); } /* end if */ - } /* end else */ + } /* end else */ /* Call "real" get_clip_extent function */ ret_value = H5S__hyper_get_clip_extent_real(clip_space, num_slices, incl_trail); @@ -12058,7 +12136,6 @@ done: FUNC_LEAVE_NOAPI(ret_value) } /* end H5S_hyper_get_clip_extent_match() */ - /*-------------------------------------------------------------------------- NAME H5S_hyper_get_unlim_block @@ -12084,14 +12161,14 @@ done: H5S_t * H5S_hyper_get_unlim_block(const H5S_t *space, hsize_t block_index) { - H5S_hyper_sel_t *hslab; /* Convenience pointer to hyperslab info */ - H5S_t *space_out = NULL; /* Dataspace to return */ - hsize_t start[H5S_MAX_RANK];/* Hyperslab selection info for unlim. selection */ - hsize_t stride[H5S_MAX_RANK]; - hsize_t count[H5S_MAX_RANK]; - hsize_t block[H5S_MAX_RANK]; - unsigned u; /* Local index variable */ - H5S_t *ret_value = NULL; /* Return value */ + H5S_hyper_sel_t *hslab; /* Convenience pointer to hyperslab info */ + H5S_t * space_out = NULL; /* Dataspace to return */ + hsize_t start[H5S_MAX_RANK]; /* Hyperslab selection info for unlim. selection */ + hsize_t stride[H5S_MAX_RANK]; + hsize_t count[H5S_MAX_RANK]; + hsize_t block[H5S_MAX_RANK]; + unsigned u; /* Local index variable */ + H5S_t * ret_value = NULL; /* Return value */ FUNC_ENTER_NOAPI(NULL) @@ -12105,10 +12182,9 @@ H5S_hyper_get_unlim_block(const H5S_t *space, hsize_t block_index) /* Set start to select block_indexth block in unlimited dimension and set * count to 1 in that dimension to only select that block. Copy all other * diminfo parameters. */ - for(u = 0; u < space->extent.rank; u++) { - if((int)u == hslab->unlim_dim){ - start[u] = hslab->diminfo.opt[u].start + (block_index - * hslab->diminfo.opt[u].stride); + for (u = 0; u < space->extent.rank; u++) { + if ((int)u == hslab->unlim_dim) { + start[u] = hslab->diminfo.opt[u].start + (block_index * hslab->diminfo.opt[u].stride); count[u] = (hsize_t)1; } /* end if */ else { @@ -12116,17 +12192,17 @@ H5S_hyper_get_unlim_block(const H5S_t *space, hsize_t block_index) count[u] = hslab->diminfo.opt[u].count; } /* end else */ stride[u] = hslab->diminfo.opt[u].stride; - block[u] = hslab->diminfo.opt[u].block; + block[u] = hslab->diminfo.opt[u].block; } /* end for */ /* Create output space, copy extent */ - if(NULL == (space_out = H5S_create(H5S_SIMPLE))) + if (NULL == (space_out = H5S_create(H5S_SIMPLE))) HGOTO_ERROR(H5E_DATASPACE, H5E_CANTCREATE, NULL, "unable to create output dataspace") - if(H5S__extent_copy_real(&space_out->extent, &space->extent, TRUE) < 0) + if (H5S__extent_copy_real(&space_out->extent, &space->extent, TRUE) < 0) HGOTO_ERROR(H5E_DATASPACE, H5E_CANTCOPY, NULL, "unable to copy destination space extent") /* Select block as defined by start/stride/count/block computed above */ - if(H5S_select_hyperslab(space_out, H5S_SELECT_SET, start, stride, count, block) < 0) + if (H5S_select_hyperslab(space_out, H5S_SELECT_SET, start, stride, count, block) < 0) HGOTO_ERROR(H5E_DATASPACE, H5E_CANTINIT, NULL, "can't select hyperslab") /* Set return value */ @@ -12134,14 +12210,13 @@ H5S_hyper_get_unlim_block(const H5S_t *space, hsize_t block_index) done: /* Free space on error */ - if(!ret_value) - if(space_out && H5S_close(space_out) < 0) + if (!ret_value) + if (space_out && H5S_close(space_out) < 0) HDONE_ERROR(H5E_DATASPACE, H5E_CANTRELEASE, NULL, "unable to release dataspace") FUNC_LEAVE_NOAPI(ret_value) } /* end H5S_hyper_get_unlim_block */ - /*-------------------------------------------------------------------------- NAME H5S_hyper_get_first_inc_block @@ -12167,12 +12242,11 @@ done: REVISION LOG --------------------------------------------------------------------------*/ hsize_t -H5S_hyper_get_first_inc_block(const H5S_t *space, hsize_t clip_size, - hbool_t *partial) +H5S_hyper_get_first_inc_block(const H5S_t *space, hsize_t clip_size, hbool_t *partial) { - H5S_hyper_sel_t *hslab; /* Convenience pointer to hyperslab info */ - H5S_hyper_dim_t *diminfo; /* Convenience pointer to diminfo in unlimited dimension */ - hsize_t ret_value = 0; + H5S_hyper_sel_t *hslab; /* Convenience pointer to hyperslab info */ + H5S_hyper_dim_t *diminfo; /* Convenience pointer to diminfo in unlimited dimension */ + hsize_t ret_value = 0; FUNC_ENTER_NOAPI(0) @@ -12186,30 +12260,28 @@ H5S_hyper_get_first_inc_block(const H5S_t *space, hsize_t clip_size, diminfo = &hslab->diminfo.opt[hslab->unlim_dim]; /* Check for selection outside of clip_size */ - if(diminfo->start >= clip_size) { + if (diminfo->start >= clip_size) { ret_value = 0; - if(partial) + if (partial) partial = FALSE; } /* end if */ else { /* Calculate index of first incomplete block */ - ret_value = (clip_size - diminfo->start + diminfo->stride - - diminfo->block) / diminfo->stride; + ret_value = (clip_size - diminfo->start + diminfo->stride - diminfo->block) / diminfo->stride; - if(partial) { + if (partial) { /* Check for partial block */ - if((diminfo->stride * ret_value) < (clip_size - diminfo->start)) + if ((diminfo->stride * ret_value) < (clip_size - diminfo->start)) *partial = TRUE; else *partial = FALSE; } /* end if */ - } /* end else */ + } /* end else */ done: FUNC_LEAVE_NOAPI(ret_value) } /* end H5S_hyper_get_first_inc_block */ - /*-------------------------------------------------------------------------- NAME H5Sis_regular_hyperslab @@ -12233,16 +12305,16 @@ done: htri_t H5Sis_regular_hyperslab(hid_t spaceid) { - H5S_t *space; /* Dataspace to query */ - htri_t ret_value; /* Return value */ + H5S_t *space; /* Dataspace to query */ + htri_t ret_value; /* Return value */ FUNC_ENTER_API(FAIL) H5TRACE1("t", "i", spaceid); /* Check args */ - if(NULL == (space = (H5S_t *)H5I_object_verify(spaceid, H5I_DATASPACE))) + if (NULL == (space = (H5S_t *)H5I_object_verify(spaceid, H5I_DATASPACE))) HGOTO_ERROR(H5E_ARGS, H5E_BADTYPE, FAIL, "not a dataspace") - if(H5S_GET_SELECT_TYPE(space) != H5S_SEL_HYPERSLABS) + if (H5S_GET_SELECT_TYPE(space) != H5S_SEL_HYPERSLABS) HGOTO_ERROR(H5E_ARGS, H5E_BADTYPE, FAIL, "not a hyperslab selection") ret_value = H5S__hyper_is_regular(space); @@ -12251,7 +12323,6 @@ done: FUNC_LEAVE_API(ret_value) } /* end H5Sis_regular_hyperslab() */ - /*-------------------------------------------------------------------------- NAME H5Sget_regular_hyperslab @@ -12279,39 +12350,37 @@ done: REVISION LOG --------------------------------------------------------------------------*/ herr_t -H5Sget_regular_hyperslab(hid_t spaceid, hsize_t start[], hsize_t stride[], - hsize_t count[], hsize_t block[]) +H5Sget_regular_hyperslab(hid_t spaceid, hsize_t start[], hsize_t stride[], hsize_t count[], hsize_t block[]) { - H5S_t *space; /* Dataspace to query */ - unsigned u; /* Local index variable */ - herr_t ret_value = SUCCEED; /* Return value */ + H5S_t * space; /* Dataspace to query */ + unsigned u; /* Local index variable */ + herr_t ret_value = SUCCEED; /* Return value */ FUNC_ENTER_API(FAIL) H5TRACE5("e", "i*h*h*h*h", spaceid, start, stride, count, block); /* Check args */ - if(NULL == (space = (H5S_t *)H5I_object_verify(spaceid, H5I_DATASPACE))) + if (NULL == (space = (H5S_t *)H5I_object_verify(spaceid, H5I_DATASPACE))) HGOTO_ERROR(H5E_ARGS, H5E_BADTYPE, FAIL, "not a dataspace") - if(H5S_GET_SELECT_TYPE(space) != H5S_SEL_HYPERSLABS) + if (H5S_GET_SELECT_TYPE(space) != H5S_SEL_HYPERSLABS) HGOTO_ERROR(H5E_ARGS, H5E_BADTYPE, FAIL, "not a hyperslab selection") - if(TRUE != H5S__hyper_is_regular(space)) + if (TRUE != H5S__hyper_is_regular(space)) HGOTO_ERROR(H5E_ARGS, H5E_BADTYPE, FAIL, "not a regular hyperslab selection") /* Retrieve hyperslab parameters */ - if(start) - for(u = 0; u < space->extent.rank; u++) + if (start) + for (u = 0; u < space->extent.rank; u++) start[u] = space->select.sel_info.hslab->diminfo.app[u].start; - if(stride) - for(u = 0; u < space->extent.rank; u++) + if (stride) + for (u = 0; u < space->extent.rank; u++) stride[u] = space->select.sel_info.hslab->diminfo.app[u].stride; - if(count) - for(u = 0; u < space->extent.rank; u++) + if (count) + for (u = 0; u < space->extent.rank; u++) count[u] = space->select.sel_info.hslab->diminfo.app[u].count; - if(block) - for(u = 0; u < space->extent.rank; u++) + if (block) + for (u = 0; u < space->extent.rank; u++) block[u] = space->select.sel_info.hslab->diminfo.app[u].block; done: FUNC_LEAVE_API(ret_value) } /* end H5Sget_regular_hyperslab() */ - |