[svn-r27884] Description:

    Update dataspace selection encode/decode routines to avoid type aliasing
errors.

Tested on:
    Linux/64 2.6.x (platypus) w/production
    (h5committest forthcoming)

6 files changed, 123 insertions, 79 deletions

diff --git a/src/H5S.c b/src/H5S.c
index 2c8288c..9585a31 100644
--- a/src/H5S.c
+++ b/src/H5S.c
@@ -1578,11 +1578,12 @@ done:
 static herr_t
 H5S_encode(H5S_t *obj, unsigned char **p, size_t *nalloc)
 {
+    H5F_t       *f = NULL;      /* Fake file structure*/
+    unsigned char *pp = (*p);   /* Local pointer for decoding */
     size_t      extent_size;    /* Size of serialized dataspace extent */
     hssize_t    sselect_size;   /* Signed size of serialized dataspace selection */
     size_t      select_size;    /* Size of serialized dataspace selection */
-    H5F_t       *f = NULL;      /* Fake file structure*/
-    herr_t      ret_value = SUCCEED;
+    herr_t      ret_value = SUCCEED;    /* Return value */
 
     FUNC_ENTER_NOAPI_NOINIT
 
@@ -1601,27 +1602,28 @@ H5S_encode(H5S_t *obj, unsigned char **p, size_t *nalloc)
 
     /* Verify the size of buffer.  If it's not big enough, simply return the
      * right size without filling the buffer. */
-    if(!*p || *nalloc < (extent_size + select_size + 1 + 1 + 1 + 4))
+    if(!pp || *nalloc < (extent_size + select_size + 1 + 1 + 1 + 4))
         *nalloc = extent_size + select_size + 1 + 1 + 1 + 4;
     else {
         /* Encode the type of the information */
-        *(*p)++ = H5O_SDSPACE_ID;
+        *pp++ = H5O_SDSPACE_ID;
 
         /* Encode the version of the dataspace information */
-        *(*p)++ = H5S_ENCODE_VERSION;
+        *pp++ = H5S_ENCODE_VERSION;
 
         /* Encode the "size of size" information */
-        *(*p)++ = (unsigned char)H5F_SIZEOF_SIZE(f);
+        *pp++ = (unsigned char)H5F_SIZEOF_SIZE(f);
 
         /* Encode size of extent information. Pointer is actually moved in this macro. */
-        UINT32ENCODE(*p, extent_size);
+        UINT32ENCODE(pp, extent_size);
 
         /* Encode the extent part of dataspace */
-        if(H5O_msg_encode(f, H5O_SDSPACE_ID, TRUE, *p, obj) < 0)
+        if(H5O_msg_encode(f, H5O_SDSPACE_ID, TRUE, pp, obj) < 0)
             HGOTO_ERROR(H5E_DATASPACE, H5E_CANTENCODE, FAIL, "can't encode extent space")
-        *p += extent_size;
+        pp += extent_size;
 
         /* Encode the selection part of dataspace.  */
+        *p = pp;
         if(H5S_SELECT_SERIALIZE(obj, p) < 0)
             HGOTO_ERROR(H5E_DATASPACE, H5E_CANTENCODE, FAIL, "can't encode select space")
     } /* end else */
@@ -1694,38 +1696,39 @@ done:
 static H5S_t*
 H5S_decode(const unsigned char **p)
 {
-    H5S_t       *ds;
-    H5S_extent_t *extent;
-    size_t      extent_size;            /* size of the extent message*/
     H5F_t       *f = NULL;              /* Fake file structure*/
+    H5S_t       *ds;                    /* Decoded dataspace */
+    H5S_extent_t *extent;               /* Entent of decoded dataspace */
+    const unsigned char *pp = (*p);     /* Local pointer for decoding */
+    size_t      extent_size;            /* size of the extent message*/
     uint8_t     sizeof_size;            /* 'Size of sizes' for file */
     H5S_t       *ret_value = NULL;      /* Return value */
 
     FUNC_ENTER_NOAPI_NOINIT
 
     /* Decode the type of the information */
-    if(*(*p)++ != H5O_SDSPACE_ID)
+    if(*pp++ != H5O_SDSPACE_ID)
 	HGOTO_ERROR(H5E_DATASPACE, H5E_BADMESG, NULL, "not an encoded dataspace")
 
     /* Decode the version of the dataspace information */
-    if(*(*p)++ != H5S_ENCODE_VERSION)
+    if(*pp++ != H5S_ENCODE_VERSION)
 	HGOTO_ERROR(H5E_DATASPACE, H5E_VERSION, NULL, "unknown version of encoded dataspace")
 
     /* Decode the "size of size" information */
-    sizeof_size = *(*p)++;
+    sizeof_size = *pp++;
 
     /* Allocate "fake" file structure */
     if(NULL == (f = H5F_fake_alloc(sizeof_size)))
 	HGOTO_ERROR(H5E_DATASPACE, H5E_CANTALLOC, NULL, "can't allocate fake file struct")
 
     /* Decode size of extent information */
-    UINT32DECODE(*p, extent_size);
+    UINT32DECODE(pp, extent_size);
 
     /* Decode the extent part of dataspace */
     /* (pass mostly bogus file pointer and bogus DXPL) */
-    if((extent = (H5S_extent_t *)H5O_msg_decode(f, H5P_DEFAULT, NULL, H5O_SDSPACE_ID, *p))==NULL)
+    if((extent = (H5S_extent_t *)H5O_msg_decode(f, H5P_DEFAULT, NULL, H5O_SDSPACE_ID, pp))==NULL)
 	HGOTO_ERROR(H5E_DATASPACE, H5E_CANTDECODE, NULL, "can't decode object")
-    *p += extent_size;
+    pp += extent_size;
 
     /* Copy the extent into dataspace structure */
     if((ds = H5FL_CALLOC(H5S_t))==NULL)
@@ -1741,6 +1744,7 @@ H5S_decode(const unsigned char **p)
         HGOTO_ERROR(H5E_DATASPACE, H5E_CANTSET, NULL, "unable to set all selection")
 
     /* Decode the select part of dataspace.  I believe this part always exists. */
+    *p = pp;
     if(H5S_SELECT_DESERIALIZE(&ds, p) < 0)
         HGOTO_ERROR(H5E_DATASPACE, H5E_CANTDECODE, NULL, "can't decode space selection")
 
diff --git a/src/H5Sall.c b/src/H5Sall.c
index c373fd1..b8a39cc 100644
--- a/src/H5Sall.c
+++ b/src/H5Sall.c
@@ -512,19 +512,25 @@ H5S_all_serial_size (const H5S_t H5_ATTR_UNUSED *space)
  REVISION LOG
 --------------------------------------------------------------------------*/
 static herr_t
-H5S_all_serialize (const H5S_t *space, uint8_t **p)
+H5S_all_serialize(const H5S_t *space, uint8_t **p)
 {
+    uint8_t *pp = (*p);         /* Local pointer for decoding */
+
     FUNC_ENTER_NOAPI_NOINIT_NOERR
 
+    /* Check args */
     HDassert(space);
     HDassert(p);
-    HDassert(*p);
+    HDassert(pp);
 
     /* Store the preamble information */
-    UINT32ENCODE(*p, (uint32_t)H5S_GET_SELECT_TYPE(space));  /* Store the type of selection */
-    UINT32ENCODE(*p, (uint32_t)1);  /* Store the version number */
-    UINT32ENCODE(*p, (uint32_t)0);  /* Store the un-used padding */
-    UINT32ENCODE(*p, (uint32_t)0);  /* Store the additional information length */
+    UINT32ENCODE(pp, (uint32_t)H5S_GET_SELECT_TYPE(space));  /* Store the type of selection */
+    UINT32ENCODE(pp, (uint32_t)1);  /* Store the version number */
+    UINT32ENCODE(pp, (uint32_t)0);  /* Store the un-used padding */
+    UINT32ENCODE(pp, (uint32_t)0);  /* Store the additional information length */
+
+    /* Update encoding pointer */
+    *p = pp;
 
     FUNC_LEAVE_NOAPI(SUCCEED)
 }   /* H5S_all_serialize() */
diff --git a/src/H5Shyper.c b/src/H5Shyper.c
index 6b943d3..5ed1722 100644
--- a/src/H5Shyper.c
+++ b/src/H5Shyper.c
@@ -1977,14 +1977,14 @@ H5S_hyper_serial_size(const H5S_t *space)
  PURPOSE
     Serialize the current selection into a user-provided buffer.
  USAGE
-    herr_t H5S_hyper_serialize_helper(spans, start, end, rank, buf)
+    void H5S_hyper_serialize_helper(spans, start, end, rank, buf)
         H5S_hyper_span_info_t *spans;   IN: Hyperslab span tree to serialize
         hssize_t start[];       IN/OUT: Accumulated start points
         hssize_t end[];         IN/OUT: Accumulated end points
         hsize_t rank;           IN: Current rank looking at
         uint8 *buf;             OUT: Buffer to put serialized selection into
  RETURNS
-    Non-negative on success/Negative on failure
+    <none>
  DESCRIPTION
     Serializes the current element selection into a buffer.  (Primarily for
     storing on disk).
@@ -1993,13 +1993,13 @@ H5S_hyper_serial_size(const H5S_t *space)
  EXAMPLES
  REVISION LOG
 --------------------------------------------------------------------------*/
-static herr_t
-H5S_hyper_serialize_helper (const H5S_hyper_span_info_t *spans,
+static void
+H5S_hyper_serialize_helper(const H5S_hyper_span_info_t *spans,
         hsize_t *start, hsize_t *end, hsize_t rank, uint8_t **p)
 {
     H5S_hyper_span_t *curr;     /* Pointer to current hyperslab span */
+    uint8_t *pp = (*p);         /* Local pointer for decoding */
     hsize_t u;                  /* Index variable */
-    herr_t ret_value=SUCCEED;  /* return value */
 
     FUNC_ENTER_NOAPI_NOINIT
 
@@ -2008,7 +2008,7 @@ H5S_hyper_serialize_helper (const H5S_hyper_span_info_t *spans,
     HDassert(start);
     HDassert(end);
     HDassert(rank < H5O_LAYOUT_NDIMS);
-    HDassert(p && *p);
+    HDassert(p && pp);
 
     /* Walk through the list of spans, recursing or outputing them */
     curr=spans->head;
@@ -2020,33 +2020,35 @@ H5S_hyper_serialize_helper (const H5S_hyper_span_info_t *spans,
             end[rank]=curr->high;
 
             /* Recurse down to the next dimension */
-            if(H5S_hyper_serialize_helper(curr->down,start,end,rank+1,p)<0)
-                HGOTO_ERROR(H5E_INTERNAL, H5E_CANTFREE, FAIL, "failed to release hyperslab spans")
+            *p = pp;
+            H5S_hyper_serialize_helper(curr->down, start, end, rank = 1, p);
         } /* end if */
         else {
             /* Encode all the previous dimensions starting & ending points */
 
             /* Encode previous starting points */
             for(u=0; u<rank; u++)
-                UINT32ENCODE(*p, (uint32_t)start[u]);
+                UINT32ENCODE(pp, (uint32_t)start[u]);
 
             /* Encode starting point for this span */
-            UINT32ENCODE(*p, (uint32_t)curr->low);
+            UINT32ENCODE(pp, (uint32_t)curr->low);
 
             /* Encode previous ending points */
             for(u=0; u<rank; u++)
-                UINT32ENCODE(*p, (uint32_t)end[u]);
+                UINT32ENCODE(pp, (uint32_t)end[u]);
 
             /* Encode starting point for this span */
-            UINT32ENCODE(*p, (uint32_t)curr->high);
+            UINT32ENCODE(pp, (uint32_t)curr->high);
         } /* end else */
 
         /* Advance to next node */
         curr=curr->next;
     } /* end while */
 
-done:
-    FUNC_LEAVE_NOAPI(ret_value)
+    /* Update encoding pointer */
+    *p = pp;
+
+    FUNC_LEAVE_NOAPI_VOID
 }   /* H5S_hyper_serialize_helper() */
 
 
@@ -2072,14 +2074,15 @@ done:
  REVISION LOG
 --------------------------------------------------------------------------*/
 static herr_t
-H5S_hyper_serialize (const H5S_t *space, uint8_t **p)
+H5S_hyper_serialize(const H5S_t *space, uint8_t **p)
 {
     const H5S_hyper_dim_t *diminfo;         /* Alias for dataspace's diminfo information */
+    uint8_t *pp = (*p);                     /* Local pointer for decoding */
     hsize_t tmp_count[H5O_LAYOUT_NDIMS];    /* Temporary hyperslab counts */
-    hsize_t offset[H5O_LAYOUT_NDIMS];      /* Offset of element in dataspace */
+    hsize_t offset[H5O_LAYOUT_NDIMS];       /* Offset of element in dataspace */
     hsize_t start[H5O_LAYOUT_NDIMS];   /* Location of start of hyperslab */
     hsize_t end[H5O_LAYOUT_NDIMS];     /* Location of end of hyperslab */
-    hsize_t temp_off;            /* Offset in a given dimension */
+    hsize_t temp_off;       /* Offset in a given dimension */
     uint8_t *lenp;          /* pointer to length location for later storage */
     uint32_t len = 0;       /* number of bytes used */
     hsize_t block_count;    /* block counter for regular hyperslabs */
@@ -2089,17 +2092,20 @@ H5S_hyper_serialize (const H5S_t *space, uint8_t **p)
 
     FUNC_ENTER_NOAPI_NOINIT_NOERR
 
+    /* Check args */
     HDassert(space);
+    HDassert(p);
+    HDassert(pp);
 
     /* Store the preamble information */
-    UINT32ENCODE(*p, (uint32_t)H5S_GET_SELECT_TYPE(space)); /* Store the type of selection */
-    UINT32ENCODE(*p, (uint32_t)1);  /* Store the version number */
-    UINT32ENCODE(*p, (uint32_t)0);  /* Store the un-used padding */
-    lenp = *p;           /* keep the pointer to the length location for later */
-    *p += 4;             /* skip over space for length */
+    UINT32ENCODE(pp, (uint32_t)H5S_GET_SELECT_TYPE(space)); /* Store the type of selection */
+    UINT32ENCODE(pp, (uint32_t)1);  /* Store the version number */
+    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 */
 
     /* Encode number of dimensions */
-    UINT32ENCODE(*p, (uint32_t)space->extent.rank);
+    UINT32ENCODE(pp, (uint32_t)space->extent.rank);
     len += 4;
 
     /* Check for a "regular" hyperslab selection */
@@ -2117,7 +2123,7 @@ H5S_hyper_serialize (const H5S_t *space, uint8_t **p)
 
         /* Encode number of hyperslabs */
         H5_CHECK_OVERFLOW(block_count, hsize_t, uint32_t);
-        UINT32ENCODE(*p, (uint32_t)block_count);
+        UINT32ENCODE(pp, (uint32_t)block_count);
         len+=4;
 
         /* Now serialize the information for the regular hyperslab */
@@ -2140,11 +2146,11 @@ H5S_hyper_serialize (const H5S_t *space, uint8_t **p)
 
                 /* Encode hyperslab starting location */
                 for(u = 0; u < ndims; u++)
-                    UINT32ENCODE(*p, (uint32_t)offset[u]);
+                    UINT32ENCODE(pp, (uint32_t)offset[u]);
 
                 /* Encode hyperslab ending location */
                 for(u = 0; u < ndims; u++)
-                    UINT32ENCODE(*p, (uint32_t)(offset[u] + (diminfo[u].block - 1)));
+                    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;
@@ -2195,7 +2201,7 @@ H5S_hyper_serialize (const H5S_t *space, uint8_t **p)
         /* Encode number of hyperslabs */
         block_count = H5S_hyper_span_nblocks(space->select.sel_info.hslab->span_lst);
         H5_CHECK_OVERFLOW(block_count, hsize_t, uint32_t);
-        UINT32ENCODE(*p, (uint32_t)block_count);
+        UINT32ENCODE(pp, (uint32_t)block_count);
         len+=4;
 
         /* Add 8 bytes times the rank for each hyperslab selected */
@@ -2203,12 +2209,16 @@ H5S_hyper_serialize (const H5S_t *space, uint8_t **p)
         len += (uint32_t)(8 * space->extent.rank * block_count);
 
         /* Encode each hyperslab in selection */
+        *p = pp;
         H5S_hyper_serialize_helper(space->select.sel_info.hslab->span_lst, start, end, (hsize_t)0, p);
     } /* end else */
 
     /* Encode length */
     UINT32ENCODE(lenp, (uint32_t)len);  /* Store the length of the extra information */
 
+    /* Update encoding pointer */
+    *p = pp;
+
     FUNC_LEAVE_NOAPI(SUCCEED)
 }   /* H5S_hyper_serialize() */
 
@@ -2238,6 +2248,7 @@ H5S_hyper_serialize (const H5S_t *space, uint8_t **p)
 static herr_t
 H5S_hyper_deserialize(H5S_t *space, const uint8_t **p)
 {
+    const uint8_t *pp = (*p);   /* Local pointer for decoding */
     unsigned rank;           	/* rank of points */
     size_t num_elem=0;      	/* number of elements in selection */
     hsize_t start[H5O_LAYOUT_NDIMS];	/* hyperslab start information */
@@ -2258,12 +2269,12 @@ H5S_hyper_deserialize(H5S_t *space, const uint8_t **p)
     /* Check args */
     HDassert(space);
     HDassert(p);
-    HDassert(*p);
+    HDassert(pp);
 
     /* Deserialize slabs to select */
     /* (The header and rank have already beed decoded) */
     rank = space->extent.rank;  /* Retrieve rank from space */
-    UINT32DECODE(*p,num_elem);  /* decode the number of points */
+    UINT32DECODE(pp,num_elem);  /* decode the number of points */
 
     /* Set the count & stride for all blocks */
     for(tcount=count,tstride=stride,j=0; j<rank; j++,tstride++,tcount++) {
@@ -2275,11 +2286,11 @@ H5S_hyper_deserialize(H5S_t *space, const uint8_t **p)
     for(i=0; i<num_elem; i++) {
         /* Decode the starting points */
         for(tstart=start,j=0; j<rank; j++,tstart++)
-            UINT32DECODE(*p, *tstart);
+            UINT32DECODE(pp, *tstart);
 
         /* Decode the ending points */
         for(tend=end,j=0; j<rank; j++,tend++)
-            UINT32DECODE(*p, *tend);
+            UINT32DECODE(pp, *tend);
 
         /* Change the ending points into blocks */
         for(tblock=block,tstart=start,tend=end,j=0; j<rank; j++,tstart++,tend++,tblock++)
@@ -2290,6 +2301,9 @@ H5S_hyper_deserialize(H5S_t *space, const uint8_t **p)
             HGOTO_ERROR(H5E_DATASPACE, H5E_CANTDELETE, FAIL, "can't change selection")
     } /* end for */
 
+    /* Update decoding pointer */
+    *p = pp;
+
 done:
     FUNC_LEAVE_NOAPI(ret_value)
 }   /* H5S_hyper_deserialize() */
diff --git a/src/H5Snone.c b/src/H5Snone.c
index 6a4474d..19d5eed 100644
--- a/src/H5Snone.c
+++ b/src/H5Snone.c
@@ -482,15 +482,23 @@ H5S_none_serial_size(const H5S_t H5_ATTR_UNUSED *space)
 static herr_t
 H5S_none_serialize(const H5S_t *space, uint8_t **p)
 {
+    uint8_t *pp = (*p);         /* Local pointer for decoding */
+
     FUNC_ENTER_NOAPI_NOINIT_NOERR
 
+    /* Check args */
     HDassert(space);
+    HDassert(p);
+    HDassert(pp);
 
     /* Store the preamble information */
-    UINT32ENCODE(*p, (uint32_t)H5S_GET_SELECT_TYPE(space));  /* Store the type of selection */
-    UINT32ENCODE(*p, (uint32_t)1);  /* Store the version number */
-    UINT32ENCODE(*p, (uint32_t)0);  /* Store the un-used padding */
-    UINT32ENCODE(*p, (uint32_t)0);  /* Store the additional information length */
+    UINT32ENCODE(pp, (uint32_t)H5S_GET_SELECT_TYPE(space));  /* Store the type of selection */
+    UINT32ENCODE(pp, (uint32_t)1);  /* Store the version number */
+    UINT32ENCODE(pp, (uint32_t)0);  /* Store the un-used padding */
+    UINT32ENCODE(pp, (uint32_t)0);  /* Store the additional information length */
+
+    /* Update encoding pointer */
+    *p = pp;
 
     FUNC_LEAVE_NOAPI(SUCCEED)
 }   /* H5S_none_serialize() */
diff --git a/src/H5Spoint.c b/src/H5Spoint.c
index d225ab2..daee160 100644
--- a/src/H5Spoint.c
+++ b/src/H5Spoint.c
@@ -822,28 +822,32 @@ H5S_point_serial_size (const H5S_t *space)
 static herr_t
 H5S_point_serialize (const H5S_t *space, uint8_t **p)
 {
-    H5S_pnt_node_t *curr;   /* Point information nodes */
-    uint8_t *lenp;          /* pointer to length location for later storage */
-    uint32_t len=0;         /* number of bytes used */
-    unsigned u;                /* local counting variable */
+    H5S_pnt_node_t *curr;       /* Point information nodes */
+    uint8_t *pp = (*p);         /* Local pointer for decoding */
+    uint8_t *lenp;              /* pointer to length location for later storage */
+    uint32_t len=0;             /* number of bytes used */
+    unsigned u;                 /* local counting variable */
 
     FUNC_ENTER_NOAPI_NOINIT_NOERR
 
+    /* Check args */
     HDassert(space);
+    HDassert(p);
+    HDassert(pp);
 
     /* Store the preamble information */
-    UINT32ENCODE(*p, (uint32_t)H5S_GET_SELECT_TYPE(space));  /* Store the type of selection */
-    UINT32ENCODE(*p, (uint32_t)1);  /* Store the version number */
-    UINT32ENCODE(*p, (uint32_t)0);  /* Store the un-used padding */
-    lenp=*p;           /* keep the pointer to the length location for later */
-    *p+=4;             /* skip over space for length */
+    UINT32ENCODE(pp, (uint32_t)H5S_GET_SELECT_TYPE(space));  /* Store the type of selection */
+    UINT32ENCODE(pp, (uint32_t)1);  /* Store the version number */
+    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 */
 
     /* Encode number of dimensions */
-    UINT32ENCODE(*p, (uint32_t)space->extent.rank);
+    UINT32ENCODE(pp, (uint32_t)space->extent.rank);
     len+=4;
 
     /* Encode number of elements */
-    UINT32ENCODE(*p, (uint32_t)space->select.num_elem);
+    UINT32ENCODE(pp, (uint32_t)space->select.num_elem);
     len+=4;
 
     /* Encode each point in selection */
@@ -854,7 +858,7 @@ H5S_point_serialize (const H5S_t *space, uint8_t **p)
 
         /* Encode each point */
         for(u=0; u<space->extent.rank; u++)
-            UINT32ENCODE(*p, (uint32_t)curr->pnt[u]);
+            UINT32ENCODE(pp, (uint32_t)curr->pnt[u]);
 
         curr=curr->next;
     } /* end while */
@@ -862,6 +866,9 @@ H5S_point_serialize (const H5S_t *space, uint8_t **p)
     /* Encode length */
     UINT32ENCODE(lenp, (uint32_t)len);  /* Store the length of the extra information */
 
+    /* Update encoding pointer */
+    *p = pp;
+
     FUNC_LEAVE_NOAPI(SUCCEED)
 }   /* H5S_point_serialize() */
 
@@ -891,24 +898,25 @@ H5S_point_serialize (const H5S_t *space, uint8_t **p)
 static herr_t
 H5S_point_deserialize (H5S_t *space, const uint8_t **p)
 {
-    H5S_seloper_t op=H5S_SELECT_SET;    /* Selection operation */
-    unsigned rank;          /* Rank of points */
-    size_t num_elem=0;      /* Number of elements in selection */
-    hsize_t *coord=NULL, *tcoord;   /* Pointer to array of elements */
+    H5S_seloper_t op = H5S_SELECT_SET;  /* Selection operation */
+    hsize_t *coord = NULL, *tcoord;     /* Pointer to array of elements */
+    const uint8_t *pp = (*p);   /* Local pointer for decoding */
+    size_t num_elem = 0;        /* Number of elements in selection */
+    unsigned rank;              /* Rank of points */
     unsigned i, j;              /* local counting variables */
-    herr_t ret_value = SUCCEED; /* return value */
+    herr_t ret_value = SUCCEED; /* Return value */
 
     FUNC_ENTER_NOAPI_NOINIT
 
     /* Check args */
     HDassert(space);
     HDassert(p);
-    HDassert(*p);
+    HDassert(pp);
 
     /* Deserialize points to select */
     /* (The header and rank have already beed decoded) */
     rank = space->extent.rank;  /* Retrieve rank from space */
-    UINT32DECODE(*p, num_elem); /* decode the number of points */
+    UINT32DECODE(pp, num_elem); /* decode the number of points */
 
     /* Allocate space for the coordinates */
     if(NULL == (coord = (hsize_t *)H5MM_malloc(num_elem * rank * sizeof(hsize_t))))
@@ -917,12 +925,15 @@ H5S_point_deserialize (H5S_t *space, const uint8_t **p)
     /* Retrieve the coordinates from the buffer */
     for(tcoord = coord, i = 0; i < num_elem; i++)
         for(j = 0; j < (unsigned)rank; j++, tcoord++)
-            UINT32DECODE(*p, *tcoord);
+            UINT32DECODE(pp, *tcoord);
 
     /* Select points */
     if(H5S_select_elements(space, op, num_elem, (const hsize_t *)coord) < 0)
         HGOTO_ERROR(H5E_DATASPACE, H5E_CANTDELETE, FAIL, "can't change selection")
 
+    /* Update decoding pointer */
+    *p = pp;
+
 done:
     /* Free the coordinate array if necessary */
     if(coord != NULL)
diff --git a/src/H5Sprivate.h b/src/H5Sprivate.h
index cccfd6d..b6b974d 100644
--- a/src/H5Sprivate.h
+++ b/src/H5Sprivate.h
@@ -206,6 +206,7 @@ H5_DLL int H5S_extend(H5S_t *space, const hsize_t *size);
 H5_DLL hsize_t H5S_extent_nelem(const H5S_extent_t *ext);
 H5_DLL int H5S_extent_get_dims(const H5S_extent_t *ext, hsize_t dims[], hsize_t max_dims[]);
 H5_DLL htri_t H5S_extent_equal(const H5S_t *ds1, const H5S_t *ds2);
+H5_DLL herr_t H5S_extent_copy(H5S_t *dst, const H5S_t *src);
 
 /* Operations on selections */
 H5_DLL herr_t H5S_select_deserialize(H5S_t **space, const uint8_t **p);