[1.12 Merge]Hdf5 1 12 warnings fixes (#1715)

* Warnings fixes (#1680)

* Clean stack size warnings in sio_engine (#1687)

* Fixes stack size warnings in tcoords.c (#1688)

* Address some warnings from casting away of const (#1684)

* Fixes stack size warnings in ntypes (#1695)

* Fixes stack size warnings in dtransform (#1696)

* Fixes stack size warnings in set_extent test (#1698)

* Be a bit safer with signed arithmetic, thus quieting some signed-overflow warnings from GCC (#1706)

* Avoid a signed overflow: check the range of `entry_ptr->age` before
increasing it instead of increasing it and then checking the range.
This quiets a GCC warning.

* Avoid the potential for signed overflow by rewriting expressions
`MAX(0, fwidth - n)` as `MAX(n, fwidth) - n` for various `n`.
This change quiets some GCC warnings.

* Change some local variables that cannot take sensible negative values
from signed to unsigned.  This quiets GCC warnings about potential
signed overflow.

* In a handful of instances, check the range of a signed integer before
increasing/decreasing it, just in case the increase/decrease overflows.
This quiets a handful of GCC signed-overflow warnings.

* Committing clang-format changes

Co-authored-by: github-actions <41898282+github-actions[bot]@users.noreply.github.com>

* Fix object size warnings in cache.c test (#1701)

* Fix some const cast and stack/static object size warnings (#1700)

* Fix various warnings

* Move HDfree_const to H5private.h for wider use

* Print output from all ranks in parallel tests on allocation failure

* Move const pointer freeing macro to h5test.h for now

* Stop lying about H5S_t const-ness (#1209)

Hyperslabs can be reworked inside several H5S callbacks, making H5S_t
non-const in some places where it is marked const. This change switches
these incorrectly const H5S_t pointer parameters and variables to
non-const where appropriate.

* Fix a few warnings after recent H5S const-related changes (#1225)

* Adjustments for HDF5 1.12

Co-authored-by: Dana Robinson <43805+derobins@users.noreply.github.com>
Co-authored-by: David Young <dyoung@hdfgroup.org>
Co-authored-by: github-actions <41898282+github-actions[bot]@users.noreply.github.com>

1 files changed, 29 insertions, 49 deletions

diff --git a/src/H5Sselect.c b/src/H5Sselect.c
index 241708a..8209b9a 100644
--- a/src/H5Sselect.c
+++ b/src/H5Sselect.c
@@ -304,7 +304,7 @@ done:
  *-------------------------------------------------------------------------
  */
 hssize_t
-H5S_select_serial_size(const H5S_t *space)
+H5S_select_serial_size(H5S_t *space)
 {
     hssize_t ret_value = -1; /* Return value */
 
@@ -343,7 +343,7 @@ H5S_select_serial_size(const H5S_t *space)
  REVISION LOG
 --------------------------------------------------------------------------*/
 herr_t
-H5S_select_serialize(const H5S_t *space, uint8_t **p)
+H5S_select_serialize(H5S_t *space, uint8_t **p)
 {
     herr_t ret_value = SUCCEED; /* Return value */
 
@@ -880,7 +880,7 @@ H5S_select_is_single(const H5S_t *space)
  REVISION LOG
 --------------------------------------------------------------------------*/
 htri_t
-H5S_select_is_regular(const H5S_t *space)
+H5S_select_is_regular(H5S_t *space)
 {
     herr_t ret_value = FAIL; /* Return value */
 
@@ -1116,7 +1116,7 @@ H5S_select_project_simple(const H5S_t *space, H5S_t *new_space, hsize_t *offset)
     in the dataspace's selection.
 --------------------------------------------------------------------------*/
 herr_t
-H5S_select_iter_init(H5S_sel_iter_t *sel_iter, const H5S_t *space, size_t elmt_size, unsigned flags)
+H5S_select_iter_init(H5S_sel_iter_t *sel_iter, H5S_t *space, size_t elmt_size, unsigned flags)
 {
     herr_t ret_value = FAIL; /* Return value */
 
@@ -1497,8 +1497,7 @@ H5S_select_iter_release(H5S_sel_iter_t *sel_iter)
         the selection is not modified.
 --------------------------------------------------------------------------*/
 herr_t
-H5S_select_iterate(void *buf, const H5T_t *type, const H5S_t *space, const H5S_sel_iter_op_t *op,
-                   void *op_data)
+H5S_select_iterate(void *buf, const H5T_t *type, H5S_t *space, const H5S_sel_iter_op_t *op, void *op_data)
 {
     H5S_sel_iter_t *iter      = NULL;         /* Selection iteration info */
     hbool_t         iter_init = FALSE;        /* Selection iteration info has been initialized */
@@ -1739,7 +1738,7 @@ H5S_get_select_type(const H5S_t *space)
  REVISION LOG
 --------------------------------------------------------------------------*/
 htri_t
-H5S_select_shape_same(const H5S_t *space1, const H5S_t *space2)
+H5S_select_shape_same(H5S_t *space1, H5S_t *space2)
 {
     H5S_sel_iter_t *iter_a      = NULL;  /* Selection a iteration info */
     H5S_sel_iter_t *iter_b      = NULL;  /* Selection b iteration info */
@@ -1760,8 +1759,8 @@ H5S_select_shape_same(const H5S_t *space1, const H5S_t *space2)
     /* Check special cases if both dataspaces aren't scalar */
     /* (If only one is, the number of selected points check is sufficient) */
     if (space1->extent.rank > 0 && space2->extent.rank > 0) {
-        const H5S_t *space_a;      /* Dataspace with larger rank */
-        const H5S_t *space_b;      /* Dataspace with smaller rank */
+        H5S_t *      space_a;      /* Dataspace with larger rank */
+        H5S_t *      space_b;      /* Dataspace with smaller rank */
         unsigned     space_a_rank; /* Number of dimensions of dataspace A */
         unsigned     space_b_rank; /* Number of dimensions of dataspace B */
         int          space_a_dim;  /* Current dimension in dataspace A */
@@ -2063,7 +2062,7 @@ done:
     don't call it directly, use the appropriate macro defined in H5Sprivate.h.
 --------------------------------------------------------------------------*/
 htri_t
-H5S_select_intersect_block(const H5S_t *space, const hsize_t *start, const hsize_t *end)
+H5S_select_intersect_block(H5S_t *space, const hsize_t *start, const hsize_t *end)
 {
     htri_t ret_value = TRUE; /* Return value */
 
@@ -2171,27 +2170,24 @@ done:
 
     Note that if m > n, it is possible that the starting point in the
     buffer associated with the memory dataspace will have to be
-    adjusted to match the projected dataspace.  If the buf parameter
-    is not NULL, the function must return an adjusted buffer base
-    address in *adj_buf_ptr.
+    adjusted to match the projected dataspace. In this case, the amount
+    of adjustment to be applied to the buffer will be returned via the
+    buf_adj parameter, if supplied.
 
  USAGE
     htri_t H5S_select_construct_projection(base_space,
                                            new_space_ptr,
                                            new_space_rank,
-                                           buf,
-                                           adj_buf_ptr)
+                                           element_size,
+                                           buf_adj)
         const H5S_t *base_space;     IN: Ptr to Dataspace to project
         H5S_t ** new_space_ptr;     OUT: Ptr to location in which to return
                                          the address of the projected space
         int new_space_rank;	     IN: Rank of the projected space.
-        const void * buf;            IN: Base address of the buffer
-                                         associated with the base space.
-                                         May be NULL.
-        void ** adj_buf_ptr;        OUT: If buf != NULL, store the base
-                                         address of the section of buf
-                                         that is described by *new_space_ptr
-                                         in *adj_buf_ptr.
+        hsize_t element_size;        IN: size of each element in the selection
+        ptrdiff_t buf_adj;          OUT: amount of adjustment to be applied
+                                         to buffer associated with memory
+                                         dataspace
 
  RETURNS
     Non-negative on success/Negative on failure.
@@ -2201,9 +2197,6 @@ done:
     projection of the supplied dataspace and associated selection into
     the specified rank.  Return it in *new_space_ptr.
 
-    If buf is supplied, computes the base address of the projected
-    selection in buf, and stores the base address in *adj_buf_ptr.
-
  GLOBAL VARIABLES
  COMMENTS, BUGS, ASSUMPTIONS
     The selection in the supplied base_space has thickness 1 in all
@@ -2214,8 +2207,8 @@ done:
  REVISION LOG
 --------------------------------------------------------------------------*/
 herr_t
-H5S_select_construct_projection(const H5S_t *base_space, H5S_t **new_space_ptr, unsigned new_space_rank,
-                                const void *buf, void const **adj_buf_ptr, hsize_t element_size)
+H5S_select_construct_projection(H5S_t *base_space, H5S_t **new_space_ptr, unsigned new_space_rank,
+                                hsize_t element_size, ptrdiff_t *buf_adj)
 {
     H5S_t *  new_space = NULL;                         /* New dataspace constructed */
     hsize_t  base_space_dims[H5S_MAX_RANK];            /* Current dimensions of base dataspace */
@@ -2234,7 +2227,6 @@ H5S_select_construct_projection(const H5S_t *base_space, H5S_t **new_space_ptr,
     HDassert(new_space_ptr != NULL);
     HDassert((new_space_rank != 0) || (H5S_GET_SELECT_NPOINTS(base_space) <= 1));
     HDassert(new_space_rank <= H5S_MAX_RANK);
-    HDassert((buf == NULL) || (adj_buf_ptr != NULL));
     HDassert(element_size > 0);
 
     /* Get the extent info for the base dataspace */
@@ -2397,26 +2389,15 @@ H5S_select_construct_projection(const H5S_t *base_space, H5S_t **new_space_ptr,
     /* load the address of the new space into *new_space_ptr */
     *new_space_ptr = new_space;
 
-    /* now adjust the buffer if required */
-    if (buf != NULL) {
+    /* return the buffer adjustment amount if required */
+    if (buf_adj != NULL) {
         if (new_space_rank < base_space_rank) {
-            /* a bit of pointer magic here:
-             *
-             * Since we can't do pointer arithmetic on void pointers, we first
-             * cast buf to a pointer to byte -- i.e. uint8_t.
-             *
-             * We then multiply the projected space element offset we
-             * calculated earlier by the supplied element size, add this
-             * value to the type cast buf pointer, cast the result back
-             * to a pointer to void, and assign the result to *adj_buf_ptr.
-             */
-            *adj_buf_ptr = (const void *)(((const uint8_t *)buf) +
-                                          ((size_t)(projected_space_element_offset * element_size)));
-        } /* end if */
+            *buf_adj = (ptrdiff_t)(projected_space_element_offset * element_size);
+        }
         else
             /* No adjustment necessary */
-            *adj_buf_ptr = buf;
-    } /* end if */
+            *buf_adj = 0;
+    }
 
 done:
     /* Cleanup on error */
@@ -2452,7 +2433,7 @@ done:
  REVISION LOG
 --------------------------------------------------------------------------*/
 herr_t
-H5S_select_fill(const void *fill, size_t fill_size, const H5S_t *space, void *_buf)
+H5S_select_fill(const void *fill, size_t fill_size, H5S_t *space, void *_buf)
 {
     H5S_sel_iter_t *iter      = NULL;    /* Selection iteration info */
     hbool_t         iter_init = FALSE;   /* Selection iteration info has been initialized */
@@ -2568,9 +2549,8 @@ to share structures inside dst_space with proj_space
  REVISION LOG
 --------------------------------------------------------------------------*/
 herr_t
-H5S_select_project_intersection(const H5S_t *src_space, const H5S_t *dst_space,
-                                const H5S_t *src_intersect_space, H5S_t **new_space_ptr,
-                                hbool_t share_selection)
+H5S_select_project_intersection(H5S_t *src_space, H5S_t *dst_space, H5S_t *src_intersect_space,
+                                H5S_t **new_space_ptr, hbool_t share_selection)
 {
     H5S_t *         new_space               = NULL;    /* New dataspace constructed */
     H5S_t *         tmp_src_intersect_space = NULL;    /* Temporary SIS converted from points->hyperslabs */