[svn-r12736] Description:

    Add "use the latest format" support for dataspace object header encode/
decode routines and clean up format a bit for the latest format (new to 1.8.x
releases)

    Remove storing 'perm' parameter for array datatypes in memory and the file,
and add test to make certain that if any user applications are attempting to
store them, we get some reports back.  (Should be unlikely, since the RefMan
says that the parameter is not implemented and is unsupported).
    Carry those changes into the tests, etc.

    Clean up a bunch more compiler warnings.

Tested on:
    FreeBSD/32 4.11 (sleipnir) w/threadsafe
    Linux/32 2.4 (heping) w/FORTRAN & C++
    Linux/64 2.4 (mir) w/enable-1.6-compat

1 files changed, 142 insertions, 109 deletions

diff --git a/src/H5Osdspace.c b/src/H5Osdspace.c
index f6be82b..32be4bc 100644
--- a/src/H5Osdspace.c
+++ b/src/H5Osdspace.c
@@ -55,11 +55,19 @@ const H5O_msg_class_t H5O_MSG_SDSPACE[1] = {{
     H5O_sdspace_debug	        /* debug the message		    	*/
 }};
 
-/* Initial version of the "old" data space information */
-#define H5O_SDSPACE_VERSION	1
-/* Initial version of the "new" data space information */
+/* Initial version of the dataspace information */
+#define H5O_SDSPACE_VERSION_1	1
+
+/* This version adds support for "null" dataspaces, encodes the type of the
+ *      dataspace in the message and eliminated the rest of the "reserved"
+ *      bytes.
+ */
 #define H5O_SDSPACE_VERSION_2	2
 
+/* The latest version of the format.  Look through the 'encode' 
+ *      and 'size' callbacks for places to change when updating this. */
+#define H5O_SDSPACE_VERSION_LATEST H5O_SDSPACE_VERSION_2
+
 /* Declare external the free list for H5S_extent_t's */
 H5FL_EXTERN(H5S_extent_t);
 
@@ -107,83 +115,87 @@ H5O_sdspace_decode(H5F_t *f, hid_t UNUSED dxpl_id, const uint8_t *p)
     unsigned		i;		/* local counting variable */
     unsigned		flags, version;
 
-    FUNC_ENTER_NOAPI_NOINIT(H5O_sdspace_decode);
+    FUNC_ENTER_NOAPI_NOINIT(H5O_sdspace_decode)
 
     /* check args */
-    assert(f);
-    assert(p);
+    HDassert(f);
+    HDassert(p);
 
     /* decode */
-    if ((sdim = H5FL_CALLOC(H5S_extent_t)) != NULL) {
-        /* Check version */
-        version = *p++;
-        if (version!=H5O_SDSPACE_VERSION && version!=H5O_SDSPACE_VERSION_2)
-            HGOTO_ERROR(H5E_OHDR, H5E_CANTINIT, NULL, "wrong version number in data space message");
-
-        /* Get rank */
-        sdim->rank = *p++;
-        if (sdim->rank>H5S_MAX_RANK)
-            HGOTO_ERROR(H5E_OHDR, H5E_CANTINIT, NULL, "simple data space dimensionality is too large");
-
-        /* Get dataspace flags for later */
-        flags = *p++;
-
-        /* Get the type of the extent */
-        if(version>=H5O_SDSPACE_VERSION_2)
-            sdim->type = (H5S_class_t)*p++;
-        else {
-            /* Set the dataspace type to be simple or scalar as appropriate */
-            if(sdim->rank>0)
-                sdim->type = H5S_SIMPLE;
-            else
-                sdim->type = H5S_SCALAR;
-
-            /* Increment past reserved byte */
-            p++;
-        } /* end else */
-
+    if(NULL == (sdim = H5FL_CALLOC(H5S_extent_t)))
+        HGOTO_ERROR(H5E_DATASPACE, H5E_NOSPACE, NULL, "dataspace structure allocation failed")
+
+    /* Check version */
+    version = *p++;
+    if(version < H5O_SDSPACE_VERSION_1 || version > H5O_SDSPACE_VERSION_2)
+        HGOTO_ERROR(H5E_OHDR, H5E_CANTINIT, NULL, "wrong version number in dataspace message")
+
+    /* Get rank */
+    sdim->rank = *p++;
+    if(sdim->rank > H5S_MAX_RANK)
+        HGOTO_ERROR(H5E_OHDR, H5E_CANTINIT, NULL, "simple dataspace dimensionality is too large")
+
+    /* Get dataspace flags for later */
+    flags = *p++;
+
+    /* Get or determine the type of the extent */
+    if(version >= H5O_SDSPACE_VERSION_2)
+        sdim->type = (H5S_class_t)*p++;
+    else {
+        /* Set the dataspace type to be simple or scalar as appropriate */
+        if(sdim->rank > 0)
+            sdim->type = H5S_SIMPLE;
+        else
+            sdim->type = H5S_SCALAR;
+
+        /* Increment past reserved byte */
+        p++;
+    } /* end else */
+
+    /* Only Version 1 has these reserved bytes */
+    if(version == H5O_SDSPACE_VERSION_1)
         p += 4; /*reserved*/
 
-        if(sdim->rank > 0) {
-            if(NULL == (sdim->size = H5FL_ARR_MALLOC(hsize_t, (size_t)sdim->rank)))
-                HGOTO_ERROR(H5E_RESOURCE, H5E_NOSPACE, NULL, "memory allocation failed")
-            for(i = 0; i < sdim->rank; i++) {
-                H5F_DECODE_LENGTH (f, p, sdim->size[i]);
+    /* Decode dimension sizes */
+    if(sdim->rank > 0) {
+        if(NULL == (sdim->size = H5FL_ARR_MALLOC(hsize_t, (size_t)sdim->rank)))
+            HGOTO_ERROR(H5E_RESOURCE, H5E_NOSPACE, NULL, "memory allocation failed")
+        for(i = 0; i < sdim->rank; i++) {
+            H5F_DECODE_LENGTH(f, p, sdim->size[i]);
 #ifndef H5_HAVE_LARGE_HSIZET
-                /* Rudimentary check for overflow of the dimension size */
-                if(sdim->size[i] == 0)
-                    HGOTO_ERROR(H5E_DATASPACE, H5E_BADSIZE, NULL, "invalid size detected");
+            /* Rudimentary check for overflow of the dimension size */
+            if(sdim->size[i] == 0)
+                HGOTO_ERROR(H5E_DATASPACE, H5E_BADSIZE, NULL, "invalid size detected")
 #endif /* H5_HAVE_LARGE_HSIZET */
-            } /* end for */
+        } /* end for */
 
-            if(flags & H5S_VALID_MAX) {
-                if(NULL == (sdim->max = H5FL_ARR_MALLOC(hsize_t, (size_t)sdim->rank)))
-                    HGOTO_ERROR(H5E_RESOURCE, H5E_NOSPACE, NULL, "memory allocation failed")
-                for(i = 0; i < sdim->rank; i++)
-                    H5F_DECODE_LENGTH (f, p, sdim->max[i]);
-            }
-        }
+        if(flags & H5S_VALID_MAX) {
+            if(NULL == (sdim->max = H5FL_ARR_MALLOC(hsize_t, (size_t)sdim->rank)))
+                HGOTO_ERROR(H5E_RESOURCE, H5E_NOSPACE, NULL, "memory allocation failed")
+            for(i = 0; i < sdim->rank; i++)
+                H5F_DECODE_LENGTH (f, p, sdim->max[i]);
+        } /* end if */
+    } /* end if */
 
-        /* Compute the number of elements in the extent */
-        if(sdim->type == H5S_NULL)
-            sdim->nelem = 0;
-        else {
-            for(i=0, sdim->nelem=1; i<sdim->rank; i++)
-                sdim->nelem*=sdim->size[i];
-        }
-    }
+    /* Compute the number of elements in the extent */
+    if(sdim->type == H5S_NULL)
+        sdim->nelem = 0;
+    else {
+        for(i = 0, sdim->nelem = 1; i < sdim->rank; i++)
+            sdim->nelem *= sdim->size[i];
+    } /* end else */
 
     /* Set return value */
     ret_value = (void*)sdim;	/*success*/
 
 done:
-    if (!ret_value && sdim) {
+    if(!ret_value && sdim) {
         H5S_extent_release(sdim);
-        H5FL_FREE(H5S_extent_t,sdim);
+        H5FL_FREE(H5S_extent_t, sdim);
     } /* end if */
 
-    FUNC_LEAVE_NOAPI(ret_value);
-}
+    FUNC_LEAVE_NOAPI(ret_value)
+} /* end H5O_sdspace_decode() */
 
 
 /*--------------------------------------------------------------------------
@@ -218,50 +230,64 @@ done:
 
 --------------------------------------------------------------------------*/
 static herr_t
-H5O_sdspace_encode(H5F_t *f, uint8_t *p, const void *mesg)
+H5O_sdspace_encode(H5F_t *f, uint8_t *p, const void *_mesg)
 {
-    const H5S_extent_t	*sdim = (const H5S_extent_t *) mesg;
-    unsigned		u;  /* Local counting variable */
+    const H5S_extent_t	*sdim = (const H5S_extent_t *)_mesg;
     unsigned		flags = 0;
+    unsigned		version;
+    hbool_t             use_latest_format;      /* Flag indicating the new group format should be used */
+    unsigned		u;  /* Local counting variable */
 
-    FUNC_ENTER_NOAPI_NOINIT_NOFUNC(H5O_sdspace_encode);
+    FUNC_ENTER_NOAPI_NOINIT_NOFUNC(H5O_sdspace_encode)
 
     /* check args */
-    assert(f);
-    assert(p);
-    assert(sdim);
-
-    /* set flags */
-    if (sdim->max)
-        flags |= H5S_VALID_MAX;
-
-    /* encode */
-    if(sdim->type!=H5S_NULL)
-        *p++ = H5O_SDSPACE_VERSION;
+    HDassert(f);
+    HDassert(p);
+    HDassert(sdim);
+
+    /* Get the file's 'use the latest version of the format' flag */
+    use_latest_format = H5F_USE_LATEST_FORMAT(f);
+
+    /* Version */
+    if(use_latest_format)
+        version = H5O_SDSPACE_VERSION_LATEST;
+    else if(sdim->type == H5S_NULL || use_latest_format)
+        version = H5O_SDSPACE_VERSION_2;
     else
-        *p++ = H5O_SDSPACE_VERSION_2;
+        version = H5O_SDSPACE_VERSION_1;
+    *p++ = version;
+
+    /* Rank */
     *p++ = sdim->rank;
+
+    /* Flags */
+    if(sdim->max)
+        flags |= H5S_VALID_MAX;
     *p++ = flags;
-    if(sdim->type!=H5S_NULL)
-        *p++ = 0; /*reserved*/
-    else
-        *p++ = sdim->type;
-    *p++ = 0; /*reserved*/
-    *p++ = 0; /*reserved*/
-    *p++ = 0; /*reserved*/
-    *p++ = 0; /*reserved*/
 
-    if (sdim->rank > 0) {
-        for (u = 0; u < sdim->rank; u++)
-            H5F_ENCODE_LENGTH (f, p, sdim->size[u]);
-        if (flags & H5S_VALID_MAX) {
-            for (u = 0; u < sdim->rank; u++)
-                H5F_ENCODE_LENGTH (f, p, sdim->max[u]);
-        }
-    }
+    /* Dataspace type */
+    if(version > H5O_SDSPACE_VERSION_1)
+        *p++ = sdim->type;
+    else {
+        *p++ = 0; /*reserved*/
+        *p++ = 0; /*reserved*/
+        *p++ = 0; /*reserved*/
+        *p++ = 0; /*reserved*/
+        *p++ = 0; /*reserved*/
+    } /* end else */
+
+    /* Current & maximum dimensions */
+    if(sdim->rank > 0) {
+        for(u = 0; u < sdim->rank; u++)
+            H5F_ENCODE_LENGTH(f, p, sdim->size[u]);
+        if(flags & H5S_VALID_MAX) {
+            for(u = 0; u < sdim->rank; u++)
+                H5F_ENCODE_LENGTH(f, p, sdim->max[u]);
+        } /* end if */
+    } /* end if */
 
-    FUNC_LEAVE_NOAPI(SUCCEED);
-}
+    FUNC_LEAVE_NOAPI(SUCCEED)
+} /* end H5O_sdspace_encode() */
 
 
 /*--------------------------------------------------------------------------
@@ -332,25 +358,32 @@ done:
 	instead of just four bytes.
 --------------------------------------------------------------------------*/
 static size_t
-H5O_sdspace_size(const H5F_t *f, const void *mesg)
+H5O_sdspace_size(const H5F_t *f, const void *_mesg)
 {
-    const H5S_extent_t	   *space = (const H5S_extent_t *) mesg;
+    const H5S_extent_t	*space = (const H5S_extent_t *)_mesg;
+    hbool_t             use_latest_format;      /* Flag indicating the new group format should be used */
+    size_t		ret_value;
 
-    /*
-     * All dimensionality messages are at least 8 bytes long.
-     */
-    size_t		    ret_value = 8;
+    FUNC_ENTER_NOAPI_NOINIT_NOFUNC(H5O_sdspace_size)
 
-    FUNC_ENTER_NOAPI_NOINIT_NOFUNC(H5O_sdspace_size);
+    /* Get the file's 'use the latest version of the format' flag */
+    use_latest_format = H5F_USE_LATEST_FORMAT(f);
 
-    /* add in the dimension sizes */
-    ret_value += space->rank * H5F_SIZEOF_SIZE (f);
+    /* Basic information for all dataspace messages */
+    ret_value = 1 +             /* Version */
+            1 +                 /* Rank */
+            1 +                 /* Flags */
+            1 +                 /* Dataspace type/reserved */
+            (use_latest_format ? 0 : 4); /* Eliminated/reserved */
 
-    /* add in the space for the maximum dimensions, if they are present */
-    ret_value += space->max ? space->rank * H5F_SIZEOF_SIZE (f) : 0;
+    /* Add in the dimension sizes */
+    ret_value += space->rank * H5F_SIZEOF_SIZE(f);
 
-    FUNC_LEAVE_NOAPI(ret_value);
-}
+    /* Add in the space for the maximum dimensions, if they are present */
+    ret_value += space->max ? (space->rank * H5F_SIZEOF_SIZE(f)) : 0;
+
+    FUNC_LEAVE_NOAPI(ret_value)
+} /* end H5O_sdspace_size() */
 
 
 /*-------------------------------------------------------------------------