[svn-r511] Changes since 19980715

----------------------

./src/H5Flow.c
./src/H5Fprivate.h
./src/H5Fsplit.c
	Changed the allocation size request from `size_t' to `hsize_t'
	because it was overflowing for the `big' test.

./src/H5detect.c
	If `long double' and `double' are the same size then we define
	H5T_NATIVE_LDOUBLE to be the same as H5T_NATIVE_DOUBLE.
	Similarly for `long' vs. `long long' and `unsigned long' vs.
	`unsigned long long'.

./test/Makefile.in
	Added `big' to the list of tests to normally run.

./test/big.c
	Added a check to see if the file system supports holes and if
	it doesn't then the test is skipped.

5 files changed, 41 insertions, 20 deletions

diff --git a/src/H5D.c b/src/H5D.c
index eea820c..ac91502 100644
--- a/src/H5D.c
+++ b/src/H5D.c
@@ -821,11 +821,10 @@ H5D_create(H5G_t *loc, const char *name, const H5T_t *type, const H5S_t *space,
 	 * Also, only the slowest varying dimension of a simple data space
 	 * can be extendible.
 	 */
-	if ((ndims=H5S_extent_dims(space, new_dset->layout.dim, max_dim)) < 0) {
+	if ((ndims=H5S_extent_dims(space, new_dset->layout.dim, max_dim))<0) {
 	    HGOTO_ERROR(H5E_DATASET, H5E_CANTINIT, NULL,
 			"unable to initialize contiguous storage");
 	}
-
 	for (i=1; i<ndims; i++) {
 	    if (max_dim[i]>new_dset->layout.dim[i]) {
 		HGOTO_ERROR (H5E_DATASET, H5E_CANTINIT, NULL,
diff --git a/src/H5Flow.c b/src/H5Flow.c
index dc4195f..2196341 100644
--- a/src/H5Flow.c
+++ b/src/H5Flow.c
@@ -545,7 +545,7 @@ H5F_low_extend(H5F_low_t *lf, const H5F_access_t *access_parms, intn op,
  */
 intn
 H5F_low_alloc (H5F_low_t *lf, intn op, hsize_t alignment, hsize_t threshold,
-	       size_t size, H5MF_free_t *blk, haddr_t *addr/*out*/)
+	       hsize_t size, H5MF_free_t *blk, haddr_t *addr/*out*/)
 {
     intn	ret_value = FAIL;
     hsize_t	wasted;
diff --git a/src/H5Fprivate.h b/src/H5Fprivate.h
index dd2b5a8..b9d0c59 100644
--- a/src/H5Fprivate.h
+++ b/src/H5Fprivate.h
@@ -323,7 +323,7 @@ typedef struct H5F_low_class_t {
 			  const H5F_access_t *access_parms,
 			  intn op, hsize_t size, haddr_t *addr/*out*/);
     intn        (*alloc)(struct H5F_low_t *lf, intn op, hsize_t alignment,
-			 hsize_t threshold, size_t size, H5MF_free_t *blk,
+			 hsize_t threshold, hsize_t size, H5MF_free_t *blk,
 			 haddr_t *addr/*out*/);
 } H5F_low_class_t;
 
@@ -557,7 +557,7 @@ herr_t H5F_low_extend(H5F_low_t *lf, const H5F_access_t *access_parms,
 		      intn op, hsize_t size, haddr_t *addr/*out*/);
 herr_t H5F_low_seteof(H5F_low_t *lf, const haddr_t *addr);
 intn H5F_low_alloc (H5F_low_t *lf, intn op, hsize_t alignment,
-		    hsize_t threshold, size_t size, H5MF_free_t *blk,
+		    hsize_t threshold, hsize_t size, H5MF_free_t *blk,
 		    haddr_t *addr/*out*/);
 hbool_t H5F_low_access(const H5F_low_class_t *type, const char *name,
 		       const H5F_access_t *access_parms, int mode,
diff --git a/src/H5Fsplit.c b/src/H5Fsplit.c
index 6e87192..c49d2e0 100644
--- a/src/H5Fsplit.c
+++ b/src/H5Fsplit.c
@@ -44,7 +44,7 @@ static herr_t H5F_split_flush(H5F_low_t *lf, const H5F_access_t *access_parms);
 static herr_t H5F_split_extend(H5F_low_t *lf, const H5F_access_t *access_parms,
 			       intn op, hsize_t size, haddr_t *addr/*out*/);
 static intn H5F_split_alloc (H5F_low_t *lf, intn op, hsize_t alignment,
-			     hsize_t threshold, size_t size, H5MF_free_t *blk,
+			     hsize_t threshold, hsize_t size, H5MF_free_t *blk,
 			     haddr_t *addr/*out*/);
 
 const H5F_low_class_t	H5F_LOW_SPLIT_g[1] = {{
@@ -487,7 +487,7 @@ H5F_split_extend(H5F_low_t *lf, const H5F_access_t *access_parms, intn op,
  */
 static intn
 H5F_split_alloc (H5F_low_t *lf, intn op, hsize_t alignment, hsize_t threshold,
-		 size_t size, H5MF_free_t *blk, haddr_t *addr/*out*/)
+		 hsize_t size, H5MF_free_t *blk, haddr_t *addr/*out*/)
 {
     intn	ret_value = FAIL;
     hsize_t	wasted;
diff --git a/src/H5detect.c b/src/H5detect.c
index 9e07688..7398cc1 100644
--- a/src/H5detect.c
+++ b/src/H5detect.c
@@ -937,19 +937,41 @@ main(void)
 
     print_header();
 
-    DETECT_I (signed char,        CHAR,    d[nd]); nd++;
-    DETECT_I (unsigned char,      UCHAR,   d[nd]); nd++;
-    DETECT_I (short,              SHORT,   d[nd]); nd++;
-    DETECT_I (unsigned short,     USHORT,  d[nd]); nd++;
-    DETECT_I (int,                INT,     d[nd]); nd++;
-    DETECT_I (unsigned int,       UINT,    d[nd]); nd++;
-    DETECT_I (long,               LONG,    d[nd]); nd++;
-    DETECT_I (unsigned long,      ULONG,   d[nd]); nd++;
-    DETECT_I (long long,          LLONG,   d[nd]); nd++;
-    DETECT_I (unsigned long long, ULLONG,  d[nd]); nd++;
-    DETECT_F (float,              FLOAT,   d[nd]); nd++;
-    DETECT_F (double,             DOUBLE,  d[nd]); nd++;
-    DETECT_F (long double,        LDOUBLE, d[nd]); nd++;
+    DETECT_I(signed char,	  CHAR,	   d[nd]); nd++;
+    DETECT_I(unsigned char,	  UCHAR,   d[nd]); nd++;
+    DETECT_I(short,		  SHORT,   d[nd]); nd++;
+    DETECT_I(unsigned short,	  USHORT,  d[nd]); nd++;
+    DETECT_I(int,		  INT,	   d[nd]); nd++;
+    DETECT_I(unsigned int,	  UINT,	   d[nd]); nd++;
+    DETECT_I(long,		  LONG,	   d[nd]); nd++;
+    DETECT_I(unsigned long,	  ULONG,   d[nd]); nd++;
+
+#if SIZEOF_LONG == SIZEOF_LONG_LONG
+    /*
+     * If sizeof(long)==sizeof(long long) then assume that `long long' isn't
+     * supported and use `long' instead.  This suppresses warnings on some
+     * systems.
+     */
+    DETECT_I(long,                LLONG,   d[nd]); nd++;
+    DETECT_I(unsigned long,       ULLONG,  d[nd]); dn++;
+#else
+    DETECT_I(long long,	  	  LLONG,   d[nd]); nd++;
+    DETECT_I(unsigned long long,  ULLONG,  d[nd]); nd++;
+#endif
+    
+    DETECT_F(float,		  FLOAT,   d[nd]); nd++;
+    DETECT_F(double,		  DOUBLE,  d[nd]); nd++;
+
+#if SIZEOF_DOUBLE == SIZEOF_LONG_DOUBLE
+    /*
+     * If sizeof(double)==sizeof(long double) then assume that `long double'
+     * isn't supported and use `double' instead.  This suppresses warnings on
+     * some systems.
+     */
+    DETECT_F(double, 		  LDOUBLE, d[nd]); nd++;
+#else
+    DETECT_F(long double,	  LDOUBLE, d[nd]); nd++;
+#endif
 
     print_results (nd, d);
     return 0;