[svn-r14902] Merged fortran_1_8 branch changes r14505:14901 into the trunk. New fortran wrappers added.

69 files changed, 1424 insertions, 2094 deletions

diff --git a/tools/h5diff/h5diffgentest.c b/tools/h5diff/h5diffgentest.c
index 2fd6fa6..735dc0f 100644
--- a/tools/h5diff/h5diffgentest.c
+++ b/tools/h5diff/h5diffgentest.c
@@ -254,6 +254,7 @@ int test_basic(const char *fname1,
     */
     {
 
+#if 1
         float data15[6];
         float data16[6];
 
@@ -273,9 +274,48 @@ int test_basic(const char *fname1,
 
         write_dset(gid1,1,dims1,"fp15",H5T_NATIVE_FLOAT,data15);
         write_dset(gid1,1,dims1,"fp16",H5T_NATIVE_FLOAT,data16);
+#else
+
+#define NU_ELMTS 1000000
+
+        hsize_t i;
+
+        hsize_t dims2[1] = { NU_ELMTS };
+
+        float *data15 = malloc (NU_ELMTS * sizeof(float) );
+        float *data16 = malloc (NU_ELMTS * sizeof(float) );
+
+        data15[0] = (float) sqrt( (double)-1 );
+        data15[1] = 1;
+        data15[2] = (float) sqrt( (double)-1 );
+        data15[3] = 1;
+        data15[4] = 1;
+        data15[5] = 1;
+
+        data16[0] = (float) sqrt( (double)-1 );
+        data16[1] = (float) sqrt( (double)-1 );
+        data16[2] = 1;
+        data16[3] = 1;
+        data16[4] = 1;
+        data16[5] = 1;
+
+        for ( i = 6; i < NU_ELMTS; i++ )
+        {
+            data15[i] = /*data15[0];*/ 2;
+            data16[i] = 1;
+        }
+
+        write_dset(gid1,1,dims2,"fp15",H5T_NATIVE_FLOAT,data15);
+        write_dset(gid1,1,dims2,"fp16",H5T_NATIVE_FLOAT,data16);
+
+        free( data15 );
+        free( data16 );
+#endif
 
     }
+
        
+        
    /*-------------------------------------------------------------------------
     * NaNs in H5T_NATIVE_DOUBLE
     *-------------------------------------------------------------------------
@@ -303,7 +343,9 @@ int test_basic(const char *fname1,
         write_dset(gid1,1,dims1,"fp18",H5T_NATIVE_DOUBLE,data18);
 
     }
- 
+        
+
+  
     
    /*-------------------------------------------------------------------------
     * close
@@ -402,7 +444,7 @@ int test_types(const char *fname)
     */
     H5Lcreate_external("filename", "objname", fid1, "ext_link", H5P_DEFAULT, H5P_DEFAULT);
     H5Lregister(UD_link_class);
-    H5Lcreate_ud(fid1, "ud_link", MY_LINKCLASS, NULL, (size_t)0, H5P_DEFAULT, H5P_DEFAULT);
+    H5Lcreate_ud(fid1, "ud_link", MY_LINKCLASS, NULL, 0, H5P_DEFAULT, H5P_DEFAULT);
 
     /*-------------------------------------------------------------------------
     * Close
@@ -730,13 +772,13 @@ int test_datasets(const char *file,
 
     write_dset_in(gid,"/dset",fid,make_diffs);
 
-    /* close */
+    /* Close */
     status = H5Dclose(did);
     assert(status >= 0);
     status = H5Gclose(gid);
     assert(status >= 0);
 
-    /* close file */
+    /* Close file */
     status = H5Fclose(fid);
     assert(status >= 0);
     return status;
@@ -772,13 +814,12 @@ void write_attr_in(hid_t loc_id,
  hid_t   sid;
  hid_t   tid;
  herr_t  status;
- int     val, i, j, k, l, n;
+ int     val, i, j, k, n;
  float   f;
 
  /* create 1D attributes with dimension [2], 2 elements */
  hsize_t    dims[1]={2};
- char       buf1[2][STR_SIZE]= {"ab","de"};        /* string */
- char       *buf1a[2];                             /* VL string */
+ char       buf1[2][2]= {"ab","de"};        /* string */
  char       buf2[2]= {1,2};                 /* bitfield, opaque */
  s_t        buf3[2]= {{1,2},{3,4}};         /* compound */
  hobj_ref_t buf4[2];                        /* reference */
@@ -791,8 +832,7 @@ void write_attr_in(hid_t loc_id,
 
  /* create 2D attributes with dimension [3][2], 6 elements */
  hsize_t    dims2[2]={3,2};
- char       buf12[3][2][STR_SIZE]= {{"ab","cd"},{"ef","gh"},{"ij","kl"}};     /* string */
- char       *buf12a[3][2];                                               /* VL string */
+ char       buf12[6][2]= {"ab","cd","ef","gh","ij","kl"};         /* string */
  char       buf22[3][2]= {{1,2},{3,4},{5,6}};                     /* bitfield, opaque */
  s_t        buf32[6]= {{1,2},{3,4},{5,6},{7,8},{9,10},{11,12}};   /* compound */
  hobj_ref_t buf42[3][2];                                          /* reference */
@@ -804,11 +844,9 @@ void write_attr_in(hid_t loc_id,
 
  /* create 3D attributes with dimension [4][3][2], 24 elements */
  hsize_t    dims3[3]={4,3,2};
- char       buf13[4][3][2][STR_SIZE]= {{{"ab","cd"},{"ef","gh"},{"ij","kl"}},
-                {{"mn","pq"},{"rs","tu"},{"vw","xz"}},
-                {{"AB","CD"},{"EF","GH"},{"IJ","KL"}},
-                {{"MN","PQ"},{"RS","TU"},{"VW","XZ"}}};  /* string */
- char       *buf13a[4][3][2];   /* VL string */
+ char       buf13[24][2]= {"ab","cd","ef","gh","ij","kl","mn","pq",
+ "rs","tu","vw","xz","AB","CD","EF","GH",
+ "IJ","KL","MN","PQ","RS","TU","VW","XZ"};  /* string */
  char       buf23[4][3][2];    /* bitfield, opaque */
  s_t        buf33[4][3][2];    /* compound */
  hobj_ref_t buf43[4][3][2];    /* reference */
@@ -833,7 +871,9 @@ void write_attr_in(hid_t loc_id,
  {
   for (i=0; i<2; i++)
    for (j=0; j<2; j++)
+   {
     buf1[i][j]='z';
+   }
  }
  /*
  buf1[2][2]= {"ab","de"};
@@ -848,17 +888,10 @@ void write_attr_in(hid_t loc_id,
 [ 1 ]          e                z
  */
  tid = H5Tcopy(H5T_C_S1);
- status  = H5Tset_size(tid, (size_t)STR_SIZE);
+ status  = H5Tset_size(tid, 2);
  write_attr(loc_id,1,dims,"string",tid,buf1);
  status = H5Tclose(tid);
 
- for (i=0; i<2; i++)
-  buf1a[i]=buf1[i];
- tid = H5Tcopy(H5T_C_S1);
- status  = H5Tset_size(tid, H5T_VARIABLE);
- write_attr(loc_id,1,dims,"VLstring",tid,buf1a);
- status = H5Tclose(tid);
-
 /*-------------------------------------------------------------------------
  * H5T_BITFIELD
  *-------------------------------------------------------------------------
@@ -902,7 +935,7 @@ void write_attr_in(hid_t loc_id,
 [ 1 ]          2               0               2
 */
 
- tid = H5Tcreate(H5T_OPAQUE, (size_t)1);
+ tid = H5Tcreate(H5T_OPAQUE, 1);
  status = H5Tset_tag(tid, "1-byte opaque type"); /* must set this */
  write_attr(loc_id,1,dims,"opaque",tid,buf2);
  status = H5Tclose(tid);
@@ -1093,10 +1126,7 @@ position        array of </g1>  array of </g1>  difference
  */
  if (make_diffs)
  {
-  for (i=0; i<3; i++)
-   for (j=0; j<2; j++)
-    for (k=0; k<2; k++)
-     buf12[i][j][k]='z';
+  memset(buf12, 'z', sizeof buf12);
  }
 
  /*
@@ -1120,18 +1150,10 @@ position        array of </g1>  array of </g1>  difference
  */
 
  tid = H5Tcopy(H5T_C_S1);
- status  = H5Tset_size(tid, (size_t)STR_SIZE);
+ status  = H5Tset_size(tid, 2);
  write_attr(loc_id,2,dims2,"string2D",tid,buf12);
  status = H5Tclose(tid);
 
- for (i=0; i<3; i++)
-  for (j=0; j<2; j++)
-   buf12a[i][j]=buf12[i][j];
- tid = H5Tcopy(H5T_C_S1);
- status  = H5Tset_size(tid, H5T_VARIABLE);
- write_attr(loc_id,2,dims2,"VLstring2D",tid,buf12a);
- status = H5Tclose(tid);
-
 /*-------------------------------------------------------------------------
  * H5T_BITFIELD
  *-------------------------------------------------------------------------
@@ -1179,7 +1201,7 @@ position        array of </g1>  array of </g1>  difference
 [ 2 0 ]          5               0               5
 [ 2 1 ]          6               0               6
  */
- tid = H5Tcreate(H5T_OPAQUE, (size_t)1);
+ tid = H5Tcreate(H5T_OPAQUE, 1);
  status = H5Tset_tag(tid, "1-byte opaque type"); /* must set this */
  write_attr(loc_id,2,dims2,"opaque2D",tid,buf22);
  status = H5Tclose(tid);
@@ -1266,6 +1288,7 @@ position        enum2D of </g1> enum2D of </g1> difference
  n=0;
  for (i = 0; i < 3; i++) {
   for (j = 0; j < 2; j++) {
+    int l;
     buf52[i][j].p = malloc((i + 1) * sizeof(int));
     buf52[i][j].len = i + 1;
     for (l = 0; l < i + 1; l++)
@@ -1388,11 +1411,7 @@ position        float2D of </g1> float2D of </g1> difference
 
  if (make_diffs)
  {
-  for (i=0; i<4; i++)
-   for (j=0; j<3; j++)
-    for (k=0; k<2; k++)
-     for (l=0; l<2; l++)
-      buf13[i][j][k][l]='z';
+  memset(buf13,'z',sizeof buf13);
  }
 
  /*
@@ -1453,19 +1472,10 @@ position        string3D of </g1> string3D of </g1> difference
  */
 
  tid = H5Tcopy(H5T_C_S1);
- status  = H5Tset_size(tid, (size_t)STR_SIZE);
+ status  = H5Tset_size(tid, 2);
  write_attr(loc_id,3,dims3,"string3D",tid,buf13);
  status = H5Tclose(tid);
 
- for (i=0; i<4; i++)
-  for (j=0; j<3; j++)
-   for (k=0; k<2; k++)
-    buf13a[i][j][k]=buf13[i][j][k];
- tid = H5Tcopy(H5T_C_S1);
- status  = H5Tset_size(tid, H5T_VARIABLE);
- write_attr(loc_id,3,dims3,"VLstring3D",tid,buf13a);
- status = H5Tclose(tid);
-
 /*-------------------------------------------------------------------------
  * H5T_BITFIELD
  *-------------------------------------------------------------------------
@@ -1518,7 +1528,7 @@ position        bitfield3D of </g1> bitfield3D of </g1> difference
  * H5T_OPAQUE
  *-------------------------------------------------------------------------
  */
- tid = H5Tcreate(H5T_OPAQUE, (size_t)1);
+ tid = H5Tcreate(H5T_OPAQUE, 1);
  status = H5Tset_tag(tid, "1-byte opaque type"); /* must set this */
  write_attr(loc_id,3,dims3,"opaque3D",tid,buf23);
  status = H5Tclose(tid);
@@ -1676,6 +1686,7 @@ position        enum3D of </g1> enum3D of </g1> difference
  for (i = 0; i < 4; i++) {
   for (j = 0; j < 3; j++) {
    for (k = 0; k < 2; k++) {
+    int l;
     buf53[i][j][k].p = malloc((i + 1) * sizeof(int));
     buf53[i][j][k].len = i + 1;
     for (l = 0; l < i + 1; l++)
@@ -1810,14 +1821,13 @@ void write_dset_in(hid_t loc_id,
  hid_t   tid;
  hid_t   dcpl;
  herr_t  status;
- int     val, i, j, k, l, n;
+ int     val, i, j, k, n;
  float   f;
  int     fillvalue=2;
 
  /* create 1D attributes with dimension [2], 2 elements */
  hsize_t    dims[1]={2};
  char       buf1[2][STR_SIZE]= {"ab","de"}; /* string */
- char       *buf1a[2];                      /* VL string */
  char       buf2[2]= {1,2};                 /* bitfield, opaque */
  s_t        buf3[2]= {{1,2},{3,4}};         /* compound */
  hobj_ref_t buf4[2];                        /* reference */
@@ -1830,8 +1840,7 @@ void write_dset_in(hid_t loc_id,
 
  /* create 2D attributes with dimension [3][2], 6 elements */
  hsize_t    dims2[2]={3,2};
- char       buf12[3][2][STR_SIZE]= {{"ab","cd"},{"ef","gh"},{"ij","kl"}};     /* string */
- char       *buf12a[3][2];                                        /* VL string */
+ char       buf12[6][STR_SIZE]= {"ab","cd","ef","gh","ij","kl"};  /* string */
  char       buf22[3][2]= {{1,2},{3,4},{5,6}};                     /* bitfield, opaque */
  s_t        buf32[6]= {{1,2},{3,4},{5,6},{7,8},{9,10},{11,12}};   /* compound */
  hobj_ref_t buf42[3][2];                                          /* reference */
@@ -1842,11 +1851,9 @@ void write_dset_in(hid_t loc_id,
 
  /* create 3D attributes with dimension [4][3][2], 24 elements */
  hsize_t    dims3[3]={4,3,2};
- char       buf13[4][3][2][STR_SIZE]= {{{"ab","cd"},{"ef","gh"},{"ij","kl"}},
-                {{"mn","pq"},{"rs","tu"},{"vw","xz"}},
-                {{"AB","CD"},{"EF","GH"},{"IJ","KL"}},
-                {{"MN","PQ"},{"RS","TU"},{"VW","XZ"}}};  /* string */
- char       *buf13a[4][3][2];  /* VL string */
+ char       buf13[24][STR_SIZE]= {"ab","cd","ef","gh","ij","kl","mn","pq",
+ "rs","tu","vw","xz","AB","CD","EF","GH",
+ "IJ","KL","MN","PQ","RS","TU","VW","XZ"};  /* string */
  char       buf23[4][3][2];    /* bitfield, opaque */
  s_t        buf33[4][3][2];    /* compound */
  hobj_ref_t buf43[4][3][2];    /* reference */
@@ -1871,22 +1878,17 @@ void write_dset_in(hid_t loc_id,
  {
   for (i=0; i<2; i++)
    for (j=0; j<2; j++)
+   {
     buf1[i][j]='z';
+   }
  }
 
 
  tid = H5Tcopy(H5T_C_S1);
- status  = H5Tset_size(tid,(size_t)STR_SIZE);
+ status  = H5Tset_size(tid,STR_SIZE);
  write_dset(loc_id,1,dims,"string",tid,buf1);
  status = H5Tclose(tid);
 
- for (i=0; i<2; i++)
-  buf1a[i]=buf1[i];
- tid = H5Tcopy(H5T_C_S1);
- status  = H5Tset_size(tid, H5T_VARIABLE);
- write_dset(loc_id,1,dims,"VLstring",tid,buf1a);
- status = H5Tclose(tid);
-
 /*-------------------------------------------------------------------------
  * H5T_BITFIELD
  *-------------------------------------------------------------------------
@@ -1915,7 +1917,7 @@ void write_dset_in(hid_t loc_id,
   }
  }
 
- tid = H5Tcreate(H5T_OPAQUE, (size_t)1);
+ tid = H5Tcreate(H5T_OPAQUE, 1);
  status = H5Tset_tag(tid, "1-byte opaque type"); /* must set this */
  write_dset(loc_id,1,dims,"opaque",tid,buf2);
  status = H5Tclose(tid);
@@ -2049,26 +2051,15 @@ void write_dset_in(hid_t loc_id,
 
  if (make_diffs)
  {
-  for (i=0; i<3; i++)
-   for (j=0; j<2; j++)
-    for (k=0; k<2; k++)
-     buf12[i][j][k]='z';
+  memset(buf12, 'z', sizeof buf12);
  }
 
 
  tid = H5Tcopy(H5T_C_S1);
- status  = H5Tset_size(tid,(size_t)STR_SIZE);
+ status  = H5Tset_size(tid,STR_SIZE);
  write_dset(loc_id,2,dims2,"string2D",tid,buf12);
  status = H5Tclose(tid);
 
- for (i=0; i<3; i++)
-  for (j=0; j<2; j++)
-   buf12a[i][j]=buf12[i][j];
- tid = H5Tcopy(H5T_C_S1);
- status  = H5Tset_size(tid, H5T_VARIABLE);
- write_dset(loc_id,2,dims2,"VLstring2D",tid,buf12a);
- status = H5Tclose(tid);
-
 /*-------------------------------------------------------------------------
  * H5T_BITFIELD
  *-------------------------------------------------------------------------
@@ -2088,7 +2079,7 @@ void write_dset_in(hid_t loc_id,
  * H5T_OPAQUE
  *-------------------------------------------------------------------------
  */
- tid = H5Tcreate(H5T_OPAQUE, (size_t)1);
+ tid = H5Tcreate(H5T_OPAQUE, 1);
  status = H5Tset_tag(tid, "1-byte opaque type"); /* must set this */
  write_dset(loc_id,2,dims2,"opaque2D",tid,buf22);
  status = H5Tclose(tid);
@@ -2144,6 +2135,8 @@ void write_dset_in(hid_t loc_id,
  n = 0;
  for(i = 0; i < 3; i++)
   for(j = 0; j < 2; j++) {
+    int l;
+
     buf52[i][j].p = malloc((i + 1) * sizeof(int));
     buf52[i][j].len = i + 1;
     for(l = 0; l < i + 1; l++)
@@ -2220,27 +2213,14 @@ void write_dset_in(hid_t loc_id,
 
  if (make_diffs)
  {
-  for (i=0; i<4; i++)
-   for (j=0; j<3; j++)
-    for (k=0; k<2; k++)
-     for (l=0; l<2; l++)
-      buf13[i][j][k][l]='z';
+  memset(buf13,'z',sizeof buf13);
  }
 
  tid = H5Tcopy(H5T_C_S1);
- status  = H5Tset_size(tid,(size_t)STR_SIZE);
+ status  = H5Tset_size(tid,STR_SIZE);
  write_dset(loc_id,3,dims3,"string3D",tid,buf13);
  status = H5Tclose(tid);
 
- for (i=0; i<4; i++)
-  for (j=0; j<3; j++)
-   for (k=0; k<2; k++)
-    buf13a[i][j][k]=buf13[i][j][k];
- tid = H5Tcopy(H5T_C_S1);
- status  = H5Tset_size(tid, H5T_VARIABLE);
- write_dset(loc_id,3,dims3,"VLstring3D",tid,buf13a);
- status = H5Tclose(tid);
-
 /*-------------------------------------------------------------------------
  * H5T_BITFIELD
  *-------------------------------------------------------------------------
@@ -2266,7 +2246,7 @@ void write_dset_in(hid_t loc_id,
  * H5T_OPAQUE
  *-------------------------------------------------------------------------
  */
- tid = H5Tcreate(H5T_OPAQUE, (size_t)1);
+ tid = H5Tcreate(H5T_OPAQUE, 1);
  status = H5Tset_tag(tid, "1-byte opaque type"); /* must set this */
  write_dset(loc_id,3,dims3,"opaque3D",tid,buf23);
  status = H5Tclose(tid);
@@ -2336,6 +2316,8 @@ void write_dset_in(hid_t loc_id,
  for(i = 0; i < 4; i++)
   for(j = 0; j < 3; j++)
    for(k = 0; k < 2; k++) {
+    int l;
+
     buf53[i][j][k].p = malloc((i + 1) * sizeof(int));
     buf53[i][j][k].len = i + 1;
     for(l = 0; l < i + 1; l++)
@@ -2428,7 +2410,7 @@ void gen_datareg(hid_t fid,
  int             i;
 
  /* allocate the buffer for write the references */
- rbuf = calloc((size_t)2, sizeof(hdset_reg_ref_t));
+ rbuf = calloc(2, sizeof(hdset_reg_ref_t));
 
  /* allocate the buffer for write the data dataset */
  buf = malloc(10 * 10 * sizeof(int));
@@ -2473,7 +2455,7 @@ void gen_datareg(hid_t fid,
   coord[3][0]=2; coord[3][1]=5;
   coord[4][0]=1; coord[4][1]=7;
  }
- H5Sselect_elements(sid1,H5S_SELECT_SET,(size_t)5,(const hsize_t *)coord);
+ H5Sselect_elements(sid1,H5S_SELECT_SET,5,coord);
  H5Sget_select_npoints(sid1);
 
  /* store second dataset region */
@@ -2542,7 +2524,7 @@ int test_hyperslab(const char *fname,
   goto out;
  
  /* create a evenly divided buffer from 0 to 127  */
- buf = (char *)HDmalloc((size_t)(nelmts * size));
+ buf = (char *)HDmalloc((unsigned)(nelmts * size));
  s = 1024 * 1024 / 127;
  for(i = 0, j = 0, c = 0; i < 1024 * 1024; j++, i++) {
   if(j == s) {
@@ -2613,35 +2595,31 @@ int write_attr(hid_t loc_id,
                hid_t tid,
                void *buf)
 {
-    hid_t   aid=-1;
-    hid_t   sid=-1;
-    
-    /* create a space  */
-    if((sid = H5Screate_simple(rank, dims, NULL)) < 0)
-        goto out;
-    
-    /* create the attribute */
-    if((aid = H5Acreate2(loc_id, name, tid, sid, H5P_DEFAULT, H5P_DEFAULT)) < 0)
-        goto out;
-    
-    /* write */
-    if(buf)
-    {
-        if(H5Awrite(aid, tid, buf) < 0)
-            goto out;
-    }
-        
-    /* close */
-    H5Aclose(aid);
-    H5Sclose(sid);
-        
-    return SUCCEED;
-        
+ hid_t   aid;
+ hid_t   sid;
+
+ /* create a space  */
+ if((sid = H5Screate_simple(rank, dims, NULL)) < 0)
+     goto out;
+
+ /* create the attribute */
+ if((aid = H5Acreate2(loc_id, name, tid, sid, H5P_DEFAULT, H5P_DEFAULT)) < 0)
+     goto out;
+
+ /* write */
+ if(buf)
+   if(H5Awrite(aid, tid, buf) < 0)
+      goto out;
+
+ /* close */
+ H5Aclose(aid);
+ H5Sclose(sid);
+
+ return SUCCEED;
+
 out:
-    
-    H5Aclose(aid);
-    H5Sclose(sid);
-    return FAIL;
+ 
+ return FAIL;
 }
 
 /*-------------------------------------------------------------------------
@@ -2659,8 +2637,8 @@ int write_dset( hid_t loc_id,
                 hid_t tid,
                 void *buf )
 {
-    hid_t   did=-1;
-    hid_t   sid=-1;
+    hid_t   did;
+    hid_t   sid;
 
     /* create a space  */
     if((sid = H5Screate_simple(rank, dims, NULL)) < 0)
@@ -2672,10 +2650,8 @@ int write_dset( hid_t loc_id,
 
     /* write */
     if(buf)
-    {
         if(H5Dwrite(did, tid, H5S_ALL, H5S_ALL, H5P_DEFAULT, buf) < 0)
             goto out;
-    }
 
     /* close */
     H5Dclose(did);
@@ -2684,9 +2660,6 @@ int write_dset( hid_t loc_id,
     return SUCCEED;
 
 out:
-
-    H5Dclose(did);
-    H5Sclose(sid);
     return FAIL;
 }
 
diff --git a/tools/h5dump/h5dump.c b/tools/h5dump/h5dump.c
index 2389ef4..70d889f 100644
--- a/tools/h5dump/h5dump.c
+++ b/tools/h5dump/h5dump.c
@@ -2440,9 +2440,6 @@ static void dump_fill_value(hid_t dcpl,hid_t type_id, hid_t obj_id)
  *
  * Programmer:  pvn
  *
- * Modifications: pvn, March 28, 2008
- *   Add a COMPRESSION ratio information for cases when filters are present
- *
  *-------------------------------------------------------------------------
  */
 static void
@@ -2458,7 +2455,7 @@ dump_dcpl(hid_t dcpl_id,hid_t type_id, hid_t obj_id)
     unsigned         szip_pixels_per_block;
     hsize_t          chsize[64];     /* chunk size in elements */
     int              rank;           /* rank */
-    char             name[256];      /* external file name       */
+    char                name[256];          /* external file name       */
     off_t            offset;         /* offset of external file     */
     hsize_t          size;           /* size of external file   */
     H5D_fill_value_t fvstatus;
@@ -2470,12 +2467,11 @@ dump_dcpl(hid_t dcpl_id,hid_t type_id, hid_t obj_id)
     unsigned         j;
 
     storage_size=H5Dget_storage_size(obj_id);
-    nfilters = H5Pget_nfilters(dcpl_id);
     ioffset=H5Dget_offset(obj_id);
     next=H5Pget_external_count(dcpl_id);
     strcpy(f_name,"\0");
 
-   /*-------------------------------------------------------------------------
+    /*-------------------------------------------------------------------------
     * STORAGE_LAYOUT
     *-------------------------------------------------------------------------
     */
@@ -2494,72 +2490,7 @@ dump_dcpl(hid_t dcpl_id,hid_t type_id, hid_t obj_id)
             HDfprintf(stdout, ", %Hu", chsize[i]);
         printf(" %s\n", dump_header_format->dataspacedimend);
         indentation(indent + COL);
-
-
-        /* if there are filters, print a compression ratio */
-        if ( nfilters )
-        {
-
-            hid_t sid = H5Dget_space( obj_id );
-            hid_t tid = H5Dget_type( obj_id );
-            size_t datum_size = H5Tget_size( tid );
-            hsize_t dims[H5S_MAX_RANK];
-            int ndims = H5Sget_simple_extent_dims( sid, dims, NULL);  
-            hsize_t nelmts = 1;
-            hsize_t size;
-            double per = 0;
-            hssize_t a, b;
-            int ok = 0;
-
-            /* only print the compression ratio for these filters */
-            for ( i = 0; i < nfilters; i++) 
-            {
-                cd_nelmts = NELMTS(cd_values);
-                filtn = H5Pget_filter2(dcpl_id, (unsigned)i, &filt_flags, &cd_nelmts,
-                    cd_values, sizeof(f_name), f_name, NULL);
-                
-                switch (filtn) 
-                {
-                case H5Z_FILTER_DEFLATE:
-                case H5Z_FILTER_SZIP:
-                case H5Z_FILTER_NBIT:
-                case H5Z_FILTER_SCALEOFFSET:
-                    ok = 1;
-                    break;
-                }
-            }
-            
-            if (ndims && ok )
-            {
-                
-                for (i = 0; i < ndims; i++)
-                {
-                    nelmts *= dims[i];
-                }
-                size = nelmts * datum_size;
-
-                a = size; b = storage_size;
-                if (a!=0)
-                    per = (double) (b-a)/a;
-                
-                per = -per;
-                per *=100;
-
-                HDfprintf(stdout, "SIZE %Hu (%.1f%%COMPRESSION)\n ", storage_size, per);
-                
-            }
-            else
-                HDfprintf(stdout, "SIZE %Hu\n ", storage_size);
-
-
-            H5Sclose(sid);
-            H5Tclose(tid);
-            
-        }
-        else
-        {
-            HDfprintf(stdout, "SIZE %Hu\n ", storage_size);
-        }
+        HDfprintf(stdout, "SIZE %Hu\n ", storage_size);
 
         /*end indent */
         indent -= COL;
@@ -2632,16 +2563,14 @@ dump_dcpl(hid_t dcpl_id,hid_t type_id, hid_t obj_id)
     * FILTERS
     *-------------------------------------------------------------------------
     */
-    
+    nfilters = H5Pget_nfilters(dcpl_id);
 
     indentation(indent + COL);
     printf("%s %s\n", FILTERS, BEGIN);
     indent += COL;
 
-    if (nfilters) 
-    {
-        for (i=0; i<nfilters; i++) 
-        {
+    if (nfilters) {
+        for (i=0; i<nfilters; i++) {
             cd_nelmts = NELMTS(cd_values);
             filtn = H5Pget_filter2(dcpl_id, (unsigned)i, &filt_flags, &cd_nelmts,
                 cd_values, sizeof(f_name), f_name, NULL);
diff --git a/tools/h5dump/h5dumpgentest.c b/tools/h5dump/h5dumpgentest.c
index 4070425..b21a020 100644
--- a/tools/h5dump/h5dumpgentest.c
+++ b/tools/h5dump/h5dumpgentest.c
@@ -5542,7 +5542,8 @@ error:
  *              Contains:
  *              1) an integer dataset
  *              2) a float dataset
- *              4) a double dataset
+ *              3) an array dataset
+ *              4) a large double dataset
  *
  *-------------------------------------------------------------------------
  */
@@ -5550,43 +5551,64 @@ static void
 gent_binary(void)
 {
  hid_t    fid, sid, did, tid;
- hsize_t  dims[1]  = {6};
+ hsize_t  dims[1] = {6};
+ hsize_t  dimarray[1] = {2};
+ hsize_t  dimsl[1] = {100000};
  int      ibuf[6]  = {1,2,3,4,5,6};
  float    fbuf[6]  = {1,2,3,4,5,6};
- double   dbuf[6]  = {1,2,3,4,5,6};
+ int      abuf[2][6] = {{1,2,3,4,5,6},{7,8,9,10,11,12}};  /* array */
+ double   *dbuf=NULL;
 
  fid = H5Fcreate(FILE55, H5F_ACC_TRUNC, H5P_DEFAULT, H5P_DEFAULT);
- sid = H5Screate_simple(1, dims, NULL);
 
 
 /*-------------------------------------------------------------------------
  * integer
  *-------------------------------------------------------------------------
  */
- 
+ sid = H5Screate_simple(1, dims, NULL);
  did = H5Dcreate2(fid, "integer", H5T_NATIVE_INT, sid, H5P_DEFAULT, H5P_DEFAULT, H5P_DEFAULT);
  H5Dwrite(did, H5T_NATIVE_INT, H5S_ALL, H5S_ALL, H5P_DEFAULT, ibuf);
  H5Dclose(did);
+ H5Sclose(sid);
 
 /*-------------------------------------------------------------------------
  * float
  *-------------------------------------------------------------------------
  */
+ sid = H5Screate_simple(1, dims, NULL);
  did = H5Dcreate2(fid, "float", H5T_NATIVE_FLOAT, sid, H5P_DEFAULT, H5P_DEFAULT, H5P_DEFAULT);
  H5Dwrite(did, H5T_NATIVE_FLOAT, H5S_ALL, H5S_ALL, H5P_DEFAULT, fbuf);
  H5Dclose(did);
+ H5Sclose(sid);
+
+/*-------------------------------------------------------------------------
+ * array
+ *-------------------------------------------------------------------------
+ */
+ tid = H5Tarray_create2(H5T_NATIVE_INT, 1, dims);
+ sid = H5Screate_simple(1, dimarray, NULL);
+ did = H5Dcreate2(fid, "array", tid, sid, H5P_DEFAULT, H5P_DEFAULT, H5P_DEFAULT);
+ H5Dwrite(did, tid, H5S_ALL, H5S_ALL, H5P_DEFAULT, abuf);
+ H5Dclose(did);
+ H5Tclose(tid);
+ H5Sclose(sid);
 
 /*-------------------------------------------------------------------------
  * double
  *-------------------------------------------------------------------------
  */
+ sid = H5Screate_simple(1, dimsl, NULL);
  did = H5Dcreate2(fid, "double", H5T_NATIVE_DOUBLE, sid, H5P_DEFAULT, H5P_DEFAULT, H5P_DEFAULT);
- H5Dwrite(did, H5T_NATIVE_DOUBLE, H5S_ALL, H5S_ALL, H5P_DEFAULT, dbuf);
+ dbuf = calloc(100000, sizeof(double));
+ if(dbuf != NULL) {
+  H5Dwrite(did, H5T_NATIVE_DOUBLE, H5S_ALL, H5S_ALL, H5P_DEFAULT, dbuf);
+  free(dbuf);
+ }
  H5Dclose(did);
- 
+ H5Sclose(sid);
 
  /* close */
- H5Sclose(sid);
  H5Fclose(fid);
 }
 
diff --git a/tools/h5dump/testh5dump.sh.in b/tools/h5dump/testh5dump.sh.in
index 1a8c18a..b7b8429 100644
--- a/tools/h5dump/testh5dump.sh.in
+++ b/tools/h5dump/testh5dump.sh.in
@@ -325,7 +325,8 @@ TOOLTEST tall-2B.ddl -A -r tall.h5
 TOOLTEST tall-4s.ddl --dataset=/g1/g1.1/dset1.1.1 --start=1,1 --stride=2,3 --count=3,2 --block=1,1 tall.h5
 TOOLTEST tall-5s.ddl -d "/g1/g1.1/dset1.1.2[0;2;10;]" tall.h5
 TOOLTEST tdset-3s.ddl -d "/dset1[1,1;;;]" tdset.h5
-
+# block
+# TOOLTEST tdset2-1s.ddl -d "/dset1[;3,2;4,4;1,4]" tdset2.h5
 
 # test printing characters in ASCII instead of decimal
 TOOLTEST tchar1.ddl -r tchar.h5
diff --git a/tools/h5import/h5import.c b/tools/h5import/h5import.c
index d1b15bb..f8f518b 100755
--- a/tools/h5import/h5import.c
+++ b/tools/h5import/h5import.c
@@ -45,6 +45,10 @@ int main(int argc, char *argv[])
    (void)HDsetvbuf(stderr, (char *) NULL, _IOLBF, 0);
    (void)HDsetvbuf(stdout, (char *) NULL, _IOLBF, 0);
 
+#if defined __MWERKS__
+    argc = ccommand(&argv);
+#endif
+
     if ( argv[1] && (strcmp("-V",argv[1])==0) )
     {
         print_version("h5import");
@@ -271,7 +275,7 @@ gtoken(char *s)
  * Programmer:  pkmat
  *
  * Modifications: pvn
- *  7/23/2007. Added support for STR type, extra parameter FILE_ID
+ *  7/23/2007. Added support for STR type
  *
  *-------------------------------------------------------------------------
  */
@@ -289,53 +293,12 @@ processDataFile(char *infile, struct Input *in, FILE **strm, hid_t file_id)
   const char *err10 = "Unrecognized input class type.\n";
   const char *err11 = "Error in reading string data.\n";
 
- /*-------------------------------------------------------------------------
-  * special case for opening binary classes in WIN32
-  * "FP" denotes a floating point binary file,
-  * "IN" denotes a signed integer binary file, 
-  * "UIN" denotes an unsigned integer binary file,
-  *-------------------------------------------------------------------------
-  */
-  if ( in->inputClass == 4 /* "IN" */ ||
-       in->inputClass == 3 /* "FP" */ ||
-       in->inputClass == 7 /* "UIN" */ 
-      
-      )
-  {
-
-#ifdef WIN32
-      
-      if ((*strm = fopen(infile, "rb")) == NULL)
-      {
-          (void) fprintf(stderr, err1, infile);
-          return(-1);
-      }
-#else
-
-      if ((*strm = fopen(infile, "r")) == NULL)
-      {
-          (void) fprintf(stderr, err1, infile);
-          return(-1);
-      }
-
-#endif
-
-  }
- /*-------------------------------------------------------------------------
-  * if the input class is not binary, just use "r"
-  *-------------------------------------------------------------------------
-  */
-  else
+  if ((*strm = fopen(infile, "r")) == NULL)
   {
-      if ((*strm = fopen(infile, "r")) == NULL)
-      {
-          (void) fprintf(stderr, err1, infile);
-          return(-1);
-      }
+      (void) fprintf(stderr, err1, infile);
+      return(-1);
   }
 
-
-
   switch(in->inputClass)
   {
     case 0: /*  TEXTIN */
@@ -409,7 +372,7 @@ readIntegerData(FILE **strm, struct Input *in)
   H5DT_INT8 *in08;
   H5DT_INT16 *in16, temp;
   H5DT_INT32 *in32;
-#ifndef WIN32
+#ifndef _WIN32
   H5DT_INT64 *in64;
   char buffer[256];
 #endif
diff --git a/tools/h5import/h5importtest.c b/tools/h5import/h5importtest.c
index 9272632..2a8c827 100755
--- a/tools/h5import/h5importtest.c
+++ b/tools/h5import/h5importtest.c
@@ -21,378 +21,271 @@
  *      h5importtest
  *
  * Description:
- *      This program creates that can be
+ *      This program creates files  that can be
  *      used to test the h5import program.
  *
  */
+/*
+ * Define names for test files
+ */
 
 int
 main(void)
 {
-    int       nrow = 3, ncol = 4, npln = 5;
-    int       i, j, k;
-    FILE      *sp;
-    
+    int         nrow = 3, ncol = 4, npln = 5;
+    int         i, j, k;
+    FILE       *sp;
+
     float     b32r3[5][3][4];
     float     row4[3], col4[4], pln4[5];
     float     rowo4 = (float)11.0e0, colo4 = (float)21.0e0, plno4 = (float)51.0e0;
     float     rowi4 = (float)1.0e0, coli4 = (float)2.0e0, plni4 = (float)5.0e0;
-    
-    int       b32i3[5][3][4];
-    int       row4i[3], col4i[4], pln4i[5];
-    int       rowo4i = (int)11 , colo4i = (int)21 , plno4i = (int)51 ;
-    int       rowi4i = (int)1 , coli4i = (int)2 , plni4i = (int)5 ;
-    
-#ifndef WIN32
-    long_long b64i2[3][4], b64i3[5][3][4];
-    long_long row4i64[3], col4i64[4], pln4i64[5];
-    long_long rowo4i64 = (long_long)11 , colo4i64 = (long_long)21 , plno4i64 = (long_long)51 ;
-    long_long rowi4i64 = (long_long)1 , coli4i64 = (long_long)2 , plni4i64 = (long_long)5 ;
+
+    int     b32i3[5][3][4];
+    int     row4i[3], col4i[4], pln4i[5];
+    int     rowo4i = (int)11 , colo4i = (int)21 , plno4i = (int)51 ;
+    int     rowi4i = (int)1 , coli4i = (int)2 , plni4i = (int)5 ;
+
+#ifndef _WIN32
+    long_long     b64i2[3][4], b64i3[5][3][4];
+    long_long     row4i64[3], col4i64[4], pln4i64[5];
+    long_long     rowo4i64 = (long_long)11 , colo4i64 = (long_long)21 , plno4i64 = (long_long)51 ;
+    long_long     rowi4i64 = (long_long)1 , coli4i64 = (long_long)2 , plni4i64 = (long_long)5 ;
 #endif
-    
+
     short     b16i3[5][3][4];
     short     row4i16[3], col4i16[4], pln4i16[5];
     short     rowo4i16 = (short)11 , colo4i16 = (short)21 , plno4i16 = (short)51 ;
     short     rowi4i16 = (short)1 , coli4i16 = (short)2 , plni4i16 = (short)5 ;
-    
-    char      b8i3[5][3][4];
-    char      row4i8[3], col4i8[4], pln4i8[5];
-    char      rowo4i8 = (char)11 , colo4i8 = (char)21 , plno4i8 = (char)51 ;
-    char      rowi4i8 = (char)1 , coli4i8 = (char)2 , plni4i8 = (char)5 ;
-    
-    double    b64r3[5][3][4];
-    double    row8[3], col8[4], pln8[5];
-    double    rowo8 = 11.0e0, colo8 = 21.0e0, plno8 = 51.0e0;
-    double    rowi8 = 1.0e0, coli8 = 2.0e0, plni8 = 5.0e0;
-    
-    
+
+    char     b8i3[5][3][4];
+    char     row4i8[3], col4i8[4], pln4i8[5];
+    char     rowo4i8 = (char)11 , colo4i8 = (char)21 , plno4i8 = (char)51 ;
+    char     rowi4i8 = (char)1 , coli4i8 = (char)2 , plni4i8 = (char)5 ;
+
+    double     b64r3[5][3][4];
+    double     row8[3], col8[4], pln8[5];
+    double     rowo8 = 11.0e0, colo8 = 21.0e0, plno8 = 51.0e0;
+	double     rowi8 = 1.0e0, coli8 = 2.0e0, plni8 = 5.0e0;
+
+
     /*
-    * initialize the row, column, and plane vectors
-    *
-    * row values start at 11 and increment by 1 => 11, 12, 13
-    * column values start at 21 and increment by 2 => 21, 23, 25, 27
-    * plane values start at 51 and increment by 5 => 51, 56, 61, 66, 71
-    */
-    
-    
+     * initialize the row, column, and plane vectors
+     *
+     * row values start at 11 and increment by 1 => 11, 12, 13
+     * column values start at 21 and increment by 2 => 21, 23, 25, 27
+     * plane values start at 51 and increment by 5 => 51, 56, 61, 66, 71
+     */
+
+
     /*
-    * build array elements - rank 2
-    *
-    * element value = sum of row value and col values
-    */
-    
+     * build array elements - rank 2
+     *
+     * element value = sum of row value and col values
+     */
+
     row4[0] = rowo4;
     col4[0] = colo4;
     pln4[0] = plno4;
-    
+
     row8[0] = rowo8;
     col8[0] = colo8;
     pln8[0] = plno8;
-    
+
     row4i[0] = rowo4i;
     col4i[0] = colo4i;
     pln4i[0] = plno4i;
-    
-#ifndef WIN32
+
+#ifndef _WIN32
     row4i64[0] = rowo4i64;
     col4i64[0] = colo4i64;
     pln4i64[0] = plno4i64;
 #endif
-    
+
     row4i16[0] = rowo4i16;
     col4i16[0] = colo4i16;
     pln4i16[0] = plno4i16;
-    
+
     row4i8[0] = rowo4i8;
     col4i8[0] = colo4i8;
     pln4i8[0] = plno4i8;
-    
+
     for (i = 1; i < nrow; i++)
     {
         row4[i] = row4[i - 1] + rowi4;
         row8[i] = row8[i - 1] + rowi8;
         row4i[i] = row4i[i - 1] + rowi4i;
-#ifndef WIN32
-        row4i64[i] = row4i64[i - 1] + rowi4i64;
+#ifndef _WIN32
+	row4i64[i] = row4i64[i - 1] + rowi4i64;
 #endif
-        row4i16[i] = row4i16[i - 1] + rowi4i16;
-        row4i8[i] = row4i8[i - 1] + rowi4i8;
+	row4i16[i] = row4i16[i - 1] + rowi4i16;
+	row4i8[i] = row4i8[i - 1] + rowi4i8;
     }
 
     for (j = 1; j < ncol; j++)
     {
-        col4[j] = col4[j - 1] + coli4;
-        col8[j] = col8[j - 1] + coli8;
-        col4i[j] = col4i[j - 1] + coli4i;
-#ifndef WIN32
-        col4i64[j] = col4i64[j - 1] + coli4i64;
+          col4[j] = col4[j - 1] + coli4;
+          col8[j] = col8[j - 1] + coli8;
+	  col4i[j] = col4i[j - 1] + coli4i;
+#ifndef _WIN32
+          col4i64[j] = col4i64[j - 1] + coli4i64;
 #endif
-        col4i16[j] = col4i16[j - 1] + coli4i16;
-        col4i8[j] = col4i8[j - 1] + coli4i8;
+	  col4i16[j] = col4i16[j - 1] + coli4i16;
+	  col4i8[j] = col4i8[j - 1] + coli4i8;
     }
     for (k = 1; k < npln; k++)
     {
-        pln4[k] = pln4[k - 1] + plni4;
-        pln8[k] = pln8[k - 1] + plni8;
-        pln4i[k] = pln4i[k - 1] + plni4i;
-#ifndef WIN32
-        pln4i64[k] = pln4i64[k - 1] + plni4i64;
+          pln4[k] = pln4[k - 1] + plni4;
+          pln8[k] = pln8[k - 1] + plni8;
+	  pln4i[k] = pln4i[k - 1] + plni4i;
+#ifndef _WIN32
+    	  pln4i64[k] = pln4i64[k - 1] + plni4i64;
 #endif
-        pln4i16[k] = pln4i16[k - 1] + plni4i16;
-        pln4i8[k] = pln4i8[k - 1] + plni4i8;
-    }
-
-    for (i = 0; i < nrow; i++)
-    {
-        for (j = 0; j < ncol; j++)
-        {
-#ifndef WIN32
-            b64i2[i][j] = row4i64[i] + col4i64[j];
+	  pln4i16[k] = pln4i16[k - 1] + plni4i16;
+	  pln4i8[k] = pln4i8[k - 1] + plni4i8;
+   }
+
+   for (i = 0; i < nrow; i++)
+   {
+     for (j = 0; j < ncol; j++)
+     {
+#ifndef _WIN32
+  	b64i2[i][j] = row4i64[i] + col4i64[j];
 #endif
-        }
-    }
+     }
+   }
 
     /*
-    * build array elements - rank 3
-    *
-    * element value = sum of row value, col, and plane values
-    */
-    
+     * build array elements - rank 3
+     *
+     * element value = sum of row value, col, and plane values
+     */
+
     for (i = 0; i < nrow; i++)
-    {
-        for (j = 0; j < ncol; j++)
-        {
-            for (k = 0; k < npln; k++)
+      {
+          for (j = 0; j < ncol; j++)
             {
-                b32r3[k][i][j] = row4[i] + col4[j] + pln4[k];
-                b64r3[k][i][j] = row8[i] + col8[j] + pln8[k];
-                b32i3[k][i][j] = row4i[i] + col4i[j] + pln4i[k];
-#ifndef WIN32
-                b64i3[k][i][j] = row4i64[i] + col4i64[j] + pln4i64[k];
+                for (k = 0; k < npln; k++)
+                  {
+                      b32r3[k][i][j] = row4[i] + col4[j] + pln4[k];
+                      b64r3[k][i][j] = row8[i] + col8[j] + pln8[k];
+	              b32i3[k][i][j] = row4i[i] + col4i[j] + pln4i[k];
+#ifndef _WIN32
+	     	      b64i3[k][i][j] = row4i64[i] + col4i64[j] + pln4i64[k];
 #endif
-                b16i3[k][i][j] = row4i16[i] + col4i16[j] + pln4i16[k];
-                b8i3[k][i][j] = row4i8[i] + col4i8[j] + pln4i8[k];
+		      b16i3[k][i][j] = row4i16[i] + col4i16[j] + pln4i16[k];
+		      b8i3[k][i][j] = row4i8[i] + col4i8[j] + pln4i8[k];
+                  }
             }
-        }
-    }
+      }
 
-    
+    /*
+     * binary 32-bit file - rank 2 & 3
+     */
 
 #ifndef UNICOS
 
 
-
- /*-------------------------------------------------------------------------
-  * TOOLTEST txtin16.txt -c $srcdir/testfiles/txtin16.conf -o txtin16.h5
-  *-------------------------------------------------------------------------
-  */
-
-
-    sp = fopen("txtin16.txt", "w");
-    for (k = 0; k < npln; k++)
-    {
-        for (i = 0; i < nrow; i++)
+    	sp = fopen("txtin16", "w");
+	for (k = 0; k < npln; k++)
+    	for (i = 0; i < nrow; i++)
         {
-            for (j = 0; j < ncol; j++)
-                (void) fprintf(sp, "%10u", b16i3[k][i][j]);
-            (void) fprintf(sp, "\n");
+          for (j = 0; j < ncol; j++)
+              (void) fprintf(sp, "%10u", b16i3[k][i][j]);
+          (void) fprintf(sp, "\n");
         }
-    }
     (void) fclose(sp);
 
- /*-------------------------------------------------------------------------
-  * TOOLTEST txtin32.txt -c $srcdir/testfiles/textin32.conf -o textin32.h5
-  *-------------------------------------------------------------------------
-  */
-
-    sp = fopen("txtin32.txt", "w");
-    for (k = 0; k < npln; k++)
-    {
-        for (i = 0; i < nrow; i++)
+      sp = fopen("txtin32", "w");
+      for (k = 0; k < npln; k++)
+    	for (i = 0; i < nrow; i++)
         {
-            for (j = 0; j < ncol; j++)
-                (void) fprintf(sp, "%10d", b32i3[k][i][j]);
-            (void) fprintf(sp, "\n");
+          for (j = 0; j < ncol; j++)
+              (void) fprintf(sp, "%10d", b32i3[k][i][j]);
+          (void) fprintf(sp, "\n");
         }
-    }
-    (void) fclose(sp);
-
- /*-------------------------------------------------------------------------
-  * TOOLTEST binin32.bin -c $srcdir/testfiles/binin32.conf -o binin32.h5
-  *-------------------------------------------------------------------------
-  */
+      (void) fclose(sp);
 
-#ifdef WIN32        
-    sp = fopen("binin32.bin", "wb");
-#else
-    sp = fopen("binin32.bin", "w");
-#endif
+    sp = fopen("bin32", "w");
     for (k = 0; k < npln; k++)
-    {
-        for (i = 0; i < nrow; i++)
-        {
-            for (j = 0; j < ncol; j++)
-            {
-                (void) fwrite((char *) &b32i3[k][i][j], sizeof(int), 1, sp);
-            }
-        }
-    }
+    for (i = 0; i < nrow; i++)
+        for (j = 0; j < ncol; j++)
+            (void) fwrite((char *) &b32i3[k][i][j], sizeof(int), 1, sp);
     (void) fclose(sp);
 
- /*-------------------------------------------------------------------------
-  * TOOLTEST binuin32.bin -c $srcdir/testfiles/binuin32.conf -o binuin32.h5
-  *-------------------------------------------------------------------------
-  */
 
-#ifdef WIN32        
-    sp = fopen("binuin32.bin", "wb");
-#else
-    sp = fopen("binuin32.bin", "w");
-#endif
+    sp = fopen("buin32", "w");
     for (k = 0; k < npln; k++)
-    {
-        for (i = 0; i < nrow; i++)
-        {
-            for (j = 0; j < ncol; j++)
-            {
-                (void) fwrite((char *) &b32i3[k][i][j], sizeof(unsigned int), 1, sp);
-            }
-        }
-    }
+    for (i = 0; i < nrow; i++)
+        for (j = 0; j < ncol; j++)
+            (void) fwrite((char *) &b32i3[k][i][j], sizeof(unsigned int), 1, sp);
     (void) fclose(sp);
 
+#ifndef _WIN32
 
-
-
- /*-------------------------------------------------------------------------
-  * TOOLTEST binin16.bin -c $srcdir/testfiles/binin16.conf -o binin16.h5
-  *-------------------------------------------------------------------------
-  */
-
-#ifdef WIN32        
-    sp = fopen("binin16.bin", "wb");
-#else
-    sp = fopen("binin16.bin", "w");
-#endif
-    for (k = 0; k < npln; k++)
-    {
-        for (i = 0; i < nrow; i++)
-        {
-            for (j = 0; j < ncol; j++)
-            {
-                (void) fwrite((char *) &b16i3[k][i][j], sizeof(short), 1, sp);
-            }
-        }
-    }
+    sp = fopen("bin64-2", "w");
+    for (i = 0; i < nrow; i++)
+        for (j = 0; j < ncol; j++)
+            (void) fwrite((char *) &b64i2[i][j], sizeof(long_long), 1, sp);
     (void) fclose(sp);
-
- /*-------------------------------------------------------------------------
-  * TOOLTEST binuin16.bin -c $srcdir/testfiles/binuin16.conf -o binuin16.h5
-  *-------------------------------------------------------------------------
-  */
-#ifdef WIN32
-    sp = fopen("binuin16.bin", "wb");
-#else
-    sp = fopen("binuin16.bin", "w");
 #endif
+
+    sp = fopen("bfp32", "w");
     for (k = 0; k < npln; k++)
-    {
         for (i = 0; i < nrow; i++)
-        {
             for (j = 0; j < ncol; j++)
-            {
-                (void) fwrite((char *) &b16i3[k][i][j], sizeof(unsigned short), 1, sp);
-            }
-        }
-    }
+                (void) fwrite((char *) &b32r3[k][i][j],
+                              sizeof(float), 1, sp);
     (void) fclose(sp);
 
+        sp = fopen("bin16", "w");
+	for (k = 0; k < npln; k++)
+    	for (i = 0; i < nrow; i++)
+        for (j = 0; j < ncol; j++)
+            (void) fwrite((char *) &b16i3[k][i][j], sizeof(short), 1,
+                          sp);
+    (void) fclose(sp);
 
+        sp = fopen("buin16", "w");
+	for (k = 0; k < npln; k++)
+    	for (i = 0; i < nrow; i++)
+        for (j = 0; j < ncol; j++)
+            (void) fwrite((char *) &b16i3[k][i][j], sizeof(unsigned short), 1,
+                          sp);
+    (void) fclose(sp);
 
- /*-------------------------------------------------------------------------
-  * TOOLTEST binin8.bin -c $srcdir/testfiles/binin8.conf  -o binin8.h5
-  *-------------------------------------------------------------------------
-  */
+#ifndef _WIN32
 
-#ifdef WIN32
-    sp = fopen("binin8.bin", "wb");
-#else
-    sp = fopen("binin8.bin", "w");
+        sp = fopen("bin64-3", "w");
+	for (k = 0; k < npln; k++)
+    	for (i = 0; i < nrow; i++)
+        for (j = 0; j < ncol; j++)
+            (void) fwrite((char *) &b64i3[k][i][j], sizeof(long_long), 1,
+                          sp);
+    (void) fclose(sp);
 #endif
+
+    sp = fopen("bin8", "w");
     for (k = 0; k < npln; k++)
-    {
-        for (i = 0; i < nrow; i++)
-        {
-            for (j = 0; j < ncol; j++)
-            {
-                (void) fwrite((char *) &b8i3[k][i][j], sizeof(char), 1, sp);
-            }
-        }
-    }
+    	for (i = 0; i < nrow; i++)
+        for (j = 0; j < ncol; j++)
+            (void) fwrite((char *) &b8i3[k][i][j], sizeof(char), 1,
+                          sp);
     (void) fclose(sp);
 
-#endif /* UNICOS */
-
-
-
-
- /*-------------------------------------------------------------------------
-  * TOOLTEST binfp64.bin -c $srcdir/testfiles/binfp64.conf -o binfp64.h5
-  *-------------------------------------------------------------------------
-  */
+#endif
 
- /*
-  * binary 64-bit file - rank 2 & 3
-  */
+    /*
+     * binary 64-bit file - rank 2 & 3
+     */
 
-#ifdef WIN32
-    sp = fopen("binfp64.bin", "wb");
-#else
-    sp = fopen("binfp64.bin", "w");
-#endif
+    sp = fopen("bfp64", "w");
     for (k = 0; k < npln; k++)
-    {
         for (i = 0; i < nrow; i++)
-        {
             for (j = 0; j < ncol; j++)
-            {
-                (void) fwrite((char *) &b64r3[k][i][j], sizeof(double), 1, sp);
-            }
-        }
-    }
+                (void) fwrite((char *) &b64r3[k][i][j],
+                              sizeof(double), 1, sp);
     (void) fclose(sp);
-
-
-
- /*-------------------------------------------------------------------------
-  * TOOLTEST binin8w.bin -c $srcdir/testfiles/binin8w.conf -o binin8w.h5
-  *-------------------------------------------------------------------------
-  */
-
-    {
-        /* test CR+LF (13,10) and EOF (26) in windows */
-        char bin8w[4] = {13,10,26,0};
-        
-#ifdef WIN32
-        sp = fopen("binin8w.bin", "wb");
-#else
-        sp = fopen("binin8w.bin", "w");
-#endif
-        for (i = 0; i < 4; i++)
-        {
-            char c = bin8w[i];
-            if ( fwrite( &c, sizeof(char), 1, sp) != 1 )
-                printf("error writing file\n");
-        }
-        fclose(sp);
-        
-        
-    }
-
-
-
-
-
     return (0);
 }
 
diff --git a/tools/h5import/h5importtestutil.sh b/tools/h5import/h5importtestutil.sh
index ff7dc35..0687871 100755
--- a/tools/h5import/h5importtestutil.sh
+++ b/tools/h5import/h5importtestutil.sh
@@ -60,72 +60,49 @@ cp $srcdir/testfiles/*.h5 tmp_testfiles/
 $RUNSERIAL ./h5importtest
 
 TESTING "ASCII I32 rank 3 - Output BE " ;
-#TOOLTEST txtin32 -c $srcdir/testfiles/textin32 -o test1.h5
-TOOLTEST $srcdir/testfiles/txtin16.txt -c $srcdir/testfiles/txtin32.conf -o txtin32.h5
+TOOLTEST txtin32 -c $srcdir/testfiles/textin32 -o test1.h5
 
 TESTING "ASCII I16 rank 3 - Output LE - CHUNKED - extended" 
-#TOOLTEST txtin16 -c $srcdir/testfiles/textin16 -o test2.h5
-TOOLTEST $srcdir/testfiles/txtin16.txt -c $srcdir/testfiles/txtin16.conf -o txtin16.h5
-
+TOOLTEST txtin16 -c $srcdir/testfiles/textin16 -o test2.h5
 
 TESTING "ASCII I8 - rank 3 - Output I16 LE-Chunked+Extended+Compressed " 
-#TOOLTEST txtin16 -c $srcdir/testfiles/textin8  -o test3.h5
-TOOLTEST $srcdir/testfiles/txtin16.txt -c $srcdir/testfiles/txtin8.conf  -o txtin8.h5
+TOOLTEST txtin16 -c $srcdir/testfiles/textin8  -o test3.h5
 
 TESTING "ASCII UI32 - rank 3 - Output BE" 
-#TOOLTEST $srcdir/testfiles/in1 -c $srcdir/testfiles/textuin32 -o test4.h5
-TOOLTEST $srcdir/testfiles/txtuin32.txt -c $srcdir/testfiles/txtuin32.conf -o txtuin32.h5
+TOOLTEST $srcdir/testfiles/in1 -c $srcdir/testfiles/textuin32 -o test4.h5
 
 TESTING "ASCII UI16 - rank 2 - Output LE+Chunked+Compressed " 
-#TOOLTEST $srcdir/testfiles/in1 -c $srcdir/testfiles/textuin16 -o test5.h5
-TOOLTEST $srcdir/testfiles/txtuin32.txt -c $srcdir/testfiles/txtuin16.conf -o txtuin16.h5
+TOOLTEST $srcdir/testfiles/in1 -c $srcdir/testfiles/textuin16 -o test5.h5
 
 TESTING "ASCII F32 - rank 3 - Output LE " 
-#TOOLTEST $srcdir/testfiles/fp1 -c $srcdir/testfiles/textfp32 -o test6.h5
-TOOLTEST $srcdir/testfiles/txtfp32.txt -c $srcdir/testfiles/txtfp32.conf -o txtfp32.h5
-
+TOOLTEST $srcdir/testfiles/fp1 -c $srcdir/testfiles/textfp32 -o test6.h5
 
 TESTING "ASCII F64 - rank 3 - Output BE + CHUNKED+Extended+Compressed " 
-#TOOLTEST $srcdir/testfiles/fp2 -c $srcdir/testfiles/textfp64 -o test7.h5
-TOOLTEST $srcdir/testfiles/txtfp64.txt -c $srcdir/testfiles/txtfp64.conf -o txtfp64.h5
+TOOLTEST $srcdir/testfiles/fp2 -c $srcdir/testfiles/textfp64 -o test7.h5
 
 TESTING "BINARY F64 - rank 3 - Output LE+CHUNKED+Extended+Compressed " 
-#TOOLTEST bfp64 -c $srcdir/testfiles/conbfp64 -o test8.h5
-TOOLTEST binfp64.bin -c $srcdir/testfiles/binfp64.conf -o binfp64.h5
-
+TOOLTEST bfp64 -c $srcdir/testfiles/conbfp64 -o test8.h5
 
 TESTING "BINARY I16 - rank 3 - Output order LE + CHUNKED + extended " 
-#TOOLTEST bin16 -c $srcdir/testfiles/conbin16 -o test9.h5
-TOOLTEST binin16.bin -c $srcdir/testfiles/binin16.conf -o binin16.h5
-
+TOOLTEST bin16 -c $srcdir/testfiles/conbin16 -o test9.h5
 
 TESTING "BINARY I8 - rank 3 - Output I16LE + Chunked+Extended+Compressed " 
-#TOOLTEST bin8 -c $srcdir/testfiles/conbin8  -o test10.h5
-TOOLTEST binin8.bin -c $srcdir/testfiles/binin8.conf  -o binin8.h5
-
+TOOLTEST bin8 -c $srcdir/testfiles/conbin8  -o test10.h5
 
 TESTING "BINARY I32 - rank 3 - Output BE + CHUNKED " 
-#TOOLTEST bin32 -c $srcdir/testfiles/conbin32 -o test11.h5
-TOOLTEST binin32.bin -c $srcdir/testfiles/binin32.conf -o binin32.h5
-
+TOOLTEST bin32 -c $srcdir/testfiles/conbin32 -o test11.h5
 
 TESTING "BINARY UI16 - rank 3 - Output byte BE + CHUNKED " 
-#TOOLTEST buin16 -c $srcdir/testfiles/conbuin16 -o test12.h5
-TOOLTEST binuin16.bin -c $srcdir/testfiles/binuin16.conf -o binuin16.h5
+TOOLTEST buin16 -c $srcdir/testfiles/conbuin16 -o test12.h5
 
 TESTING "BINARY UI32 - rank 3 - Output LE + CHUNKED " 
-#TOOLTEST buin32 -c $srcdir/testfiles/conbuin32 -o test13.h5
-TOOLTEST binuin32.bin -c $srcdir/testfiles/binuin32.conf -o binuin32.h5
-
+TOOLTEST buin32 -c $srcdir/testfiles/conbuin32 -o test13.h5
 
 TESTING "STR" 
-TOOLTEST $srcdir/testfiles/txtstr.txt -c $srcdir/testfiles/txtstr.conf -o txtstr.h5
-
-TESTING "BINARY I8 CR LF EOF" 
-TOOLTEST binin8w.bin -c $srcdir/testfiles/binin8w.conf -o binin8w.h5
-
+TOOLTEST $srcdir/testfiles/txtstr -c $srcdir/testfiles/textstr -o teststr.h5
 
-rm -f  *.txt *.bin *.h5
+rm -f  tx* b* *.dat
+rm -f  test*.h5 
 rm -rf tmp_testfiles
 else
 	echo "** h5import or h5importtest not available ***"
diff --git a/tools/h5import/testfiles/binin8w.conf b/tools/h5import/testfiles/binin8w.conf
deleted file mode 100644
index fccb4ac..0000000
--- a/tools/h5import/testfiles/binin8w.conf
+++ /dev/null
@@ -1,9 +0,0 @@
-
-INPUT-CLASS IN
-INPUT-SIZE  8
-RANK 1
-DIMENSION-SIZES 4
-OUTPUT-BYTE-ORDER LE
-OUTPUT-CLASS IN
-OUTPUT-SIZE 8
-OUTPUT-ARCHITECTURE STD
diff --git a/tools/h5import/testfiles/binin8w.h5 b/tools/h5import/testfiles/binin8w.h5
deleted file mode 100644
index 64acaed..0000000
--- a/tools/h5import/testfiles/binin8w.h5
+++ /dev/null
diff --git a/tools/h5import/testfiles/conbfp32 b/tools/h5import/testfiles/conbfp32
new file mode 100755
index 0000000..66e6b35
--- /dev/null
+++ b/tools/h5import/testfiles/conbfp32
@@ -0,0 +1,12 @@
+PATH /fpbin/32-bit
+INPUT-CLASS FP
+INPUT-SIZE	32
+RANK 3
+DIMENSION-SIZES 5 3 4
+OUTPUT-ARCHITECTURE IEEE
+OUTPUT-BYTE-ORDER BE
+CHUNKED-DIMENSION-SIZES 2 2 2 
+COMPRESSION-PARAM 2
+
+
+
diff --git a/tools/h5import/testfiles/binfp64.conf b/tools/h5import/testfiles/conbfp64
index 6b4c361..6b4c361 100755
--- a/tools/h5import/testfiles/binfp64.conf
+++ b/tools/h5import/testfiles/conbfp64
diff --git a/tools/h5import/testfiles/binin16.conf b/tools/h5import/testfiles/conbin16
index 06869cb..06869cb 100755
--- a/tools/h5import/testfiles/binin16.conf
+++ b/tools/h5import/testfiles/conbin16
diff --git a/tools/h5import/testfiles/binin32.conf b/tools/h5import/testfiles/conbin32
index 11996ef..11996ef 100755
--- a/tools/h5import/testfiles/binin32.conf
+++ b/tools/h5import/testfiles/conbin32
diff --git a/tools/h5import/testfiles/binin8.conf b/tools/h5import/testfiles/conbin8
index 1edd80a..1edd80a 100755
--- a/tools/h5import/testfiles/binin8.conf
+++ b/tools/h5import/testfiles/conbin8
diff --git a/tools/h5import/testfiles/binuin16.conf b/tools/h5import/testfiles/conbuin16
index a4603df..a4603df 100755
--- a/tools/h5import/testfiles/binuin16.conf
+++ b/tools/h5import/testfiles/conbuin16
diff --git a/tools/h5import/testfiles/binuin32.conf b/tools/h5import/testfiles/conbuin32
index a649e97..a649e97 100755
--- a/tools/h5import/testfiles/binuin32.conf
+++ b/tools/h5import/testfiles/conbuin32
diff --git a/tools/h5import/testfiles/txtfp32.txt b/tools/h5import/testfiles/fp1
index 142c94f..142c94f 100755
--- a/tools/h5import/testfiles/txtfp32.txt
+++ b/tools/h5import/testfiles/fp1
diff --git a/tools/h5import/testfiles/txtfp64.txt b/tools/h5import/testfiles/fp2
index 6c83dc3..6c83dc3 100755
--- a/tools/h5import/testfiles/txtfp64.txt
+++ b/tools/h5import/testfiles/fp2
diff --git a/tools/h5import/testfiles/txtuin32.txt b/tools/h5import/testfiles/in1
index 0688e9b..0688e9b 100755
--- a/tools/h5import/testfiles/txtuin32.txt
+++ b/tools/h5import/testfiles/in1
diff --git a/tools/h5import/testfiles/txtin32.h5 b/tools/h5import/testfiles/test1.h5
index 350333c..350333c 100644
--- a/tools/h5import/testfiles/txtin32.h5
+++ b/tools/h5import/testfiles/test1.h5
diff --git a/tools/h5import/testfiles/binin8.h5 b/tools/h5import/testfiles/test10.h5
index a1d1a37..a1d1a37 100644
--- a/tools/h5import/testfiles/binin8.h5
+++ b/tools/h5import/testfiles/test10.h5
diff --git a/tools/h5import/testfiles/binin32.h5 b/tools/h5import/testfiles/test11.h5
index fd8faa9..fd8faa9 100644
--- a/tools/h5import/testfiles/binin32.h5
+++ b/tools/h5import/testfiles/test11.h5
diff --git a/tools/h5import/testfiles/binuin16.h5 b/tools/h5import/testfiles/test12.h5
index c486c89..c486c89 100644
--- a/tools/h5import/testfiles/binuin16.h5
+++ b/tools/h5import/testfiles/test12.h5
diff --git a/tools/h5import/testfiles/binuin32.h5 b/tools/h5import/testfiles/test13.h5
index 41699d7..41699d7 100644
--- a/tools/h5import/testfiles/binuin32.h5
+++ b/tools/h5import/testfiles/test13.h5
diff --git a/tools/h5import/testfiles/txtin16.h5 b/tools/h5import/testfiles/test2.h5
index dc6c1ea..dc6c1ea 100644
--- a/tools/h5import/testfiles/txtin16.h5
+++ b/tools/h5import/testfiles/test2.h5
diff --git a/tools/h5import/testfiles/txtin8.h5 b/tools/h5import/testfiles/test3.h5
index 42e7727..42e7727 100644
--- a/tools/h5import/testfiles/txtin8.h5
+++ b/tools/h5import/testfiles/test3.h5
diff --git a/tools/h5import/testfiles/txtuin32.h5 b/tools/h5import/testfiles/test4.h5
index 1a4dda5..1a4dda5 100644
--- a/tools/h5import/testfiles/txtuin32.h5
+++ b/tools/h5import/testfiles/test4.h5
diff --git a/tools/h5import/testfiles/txtuin16.h5 b/tools/h5import/testfiles/test5.h5
index 9ee166a..9ee166a 100644
--- a/tools/h5import/testfiles/txtuin16.h5
+++ b/tools/h5import/testfiles/test5.h5
diff --git a/tools/h5import/testfiles/txtfp32.h5 b/tools/h5import/testfiles/test6.h5
index f74e003..f74e003 100644
--- a/tools/h5import/testfiles/txtfp32.h5
+++ b/tools/h5import/testfiles/test6.h5
diff --git a/tools/h5import/testfiles/txtfp64.h5 b/tools/h5import/testfiles/test7.h5
index b6ba4f5..b6ba4f5 100644
--- a/tools/h5import/testfiles/txtfp64.h5
+++ b/tools/h5import/testfiles/test7.h5
diff --git a/tools/h5import/testfiles/binfp64.h5 b/tools/h5import/testfiles/test8.h5
index 80e3a8a..80e3a8a 100644
--- a/tools/h5import/testfiles/binfp64.h5
+++ b/tools/h5import/testfiles/test8.h5
diff --git a/tools/h5import/testfiles/binin16.h5 b/tools/h5import/testfiles/test9.h5
index 0825bbc..0825bbc 100644
--- a/tools/h5import/testfiles/binin16.h5
+++ b/tools/h5import/testfiles/test9.h5
diff --git a/tools/h5import/testfiles/txtstr.h5 b/tools/h5import/testfiles/teststr.h5
index ceb0810..ceb0810 100644
--- a/tools/h5import/testfiles/txtstr.h5
+++ b/tools/h5import/testfiles/teststr.h5
diff --git a/tools/h5import/testfiles/txtfp32.conf b/tools/h5import/testfiles/textfp32
index 9696a7f..9696a7f 100755
--- a/tools/h5import/testfiles/txtfp32.conf
+++ b/tools/h5import/testfiles/textfp32
diff --git a/tools/h5import/testfiles/txtfp64.conf b/tools/h5import/testfiles/textfp64
index fbab6a6..fbab6a6 100755
--- a/tools/h5import/testfiles/txtfp64.conf
+++ b/tools/h5import/testfiles/textfp64
diff --git a/tools/h5import/testfiles/txtin16.conf b/tools/h5import/testfiles/textin16
index d2d11c3..d2d11c3 100755
--- a/tools/h5import/testfiles/txtin16.conf
+++ b/tools/h5import/testfiles/textin16
diff --git a/tools/h5import/testfiles/txtin32.conf b/tools/h5import/testfiles/textin32
index ca4802a..ca4802a 100755
--- a/tools/h5import/testfiles/txtin32.conf
+++ b/tools/h5import/testfiles/textin32
diff --git a/tools/h5import/testfiles/txtin8.conf b/tools/h5import/testfiles/textin8
index 4405338..4405338 100755
--- a/tools/h5import/testfiles/txtin8.conf
+++ b/tools/h5import/testfiles/textin8
diff --git a/tools/h5import/testfiles/txtstr.conf b/tools/h5import/testfiles/textstr
index 85079e0..85079e0 100644
--- a/tools/h5import/testfiles/txtstr.conf
+++ b/tools/h5import/testfiles/textstr
diff --git a/tools/h5import/testfiles/txtuin16.conf b/tools/h5import/testfiles/textuin16
index 753e6e8..753e6e8 100755
--- a/tools/h5import/testfiles/txtuin16.conf
+++ b/tools/h5import/testfiles/textuin16
diff --git a/tools/h5import/testfiles/txtuin32.conf b/tools/h5import/testfiles/textuin32
index d61e1a1..d61e1a1 100755
--- a/tools/h5import/testfiles/txtuin32.conf
+++ b/tools/h5import/testfiles/textuin32
diff --git a/tools/h5import/testfiles/txtin16.txt b/tools/h5import/testfiles/txtin16.txt
deleted file mode 100644
index 0688e9b..0000000
--- a/tools/h5import/testfiles/txtin16.txt
+++ /dev/null
@@ -1,15 +0,0 @@
-        83        85        87        89
-        84        86        88        90
-        85        87        89        91
-        88        90        92        94
-        89        91        93        95
-        90        92        94        96
-        93        95        97        99
-        94        96        98       100
-        95        97        99       101
-        98       100       102       104
-        99       101       103       105
-       100       102       104       106
-       103       105       107       109
-       104       106       108       110
-       105       107       109       111
diff --git a/tools/h5import/testfiles/txtin32.txt b/tools/h5import/testfiles/txtin32.txt
deleted file mode 100644
index 0688e9b..0000000
--- a/tools/h5import/testfiles/txtin32.txt
+++ /dev/null
@@ -1,15 +0,0 @@
-        83        85        87        89
-        84        86        88        90
-        85        87        89        91
-        88        90        92        94
-        89        91        93        95
-        90        92        94        96
-        93        95        97        99
-        94        96        98       100
-        95        97        99       101
-        98       100       102       104
-        99       101       103       105
-       100       102       104       106
-       103       105       107       109
-       104       106       108       110
-       105       107       109       111
diff --git a/tools/h5import/testfiles/txtstr.txt b/tools/h5import/testfiles/txtstr
index 25be0a6..25be0a6 100644
--- a/tools/h5import/testfiles/txtstr.txt
+++ b/tools/h5import/testfiles/txtstr
diff --git a/tools/h5repack/h5repack.c b/tools/h5repack/h5repack.c
index febf7d7..954f3e7 100644
--- a/tools/h5repack/h5repack.c
+++ b/tools/h5repack/h5repack.c
@@ -45,7 +45,7 @@ static int have_request(pack_opt_t *options);
  * Purpose: locate all high-level HDF5 objects in the file
  *  and compress/chunk them using options
  *
- * Algorithm: 2 traversals are made to the file; the 1st builds a list of
+ * Algorythm: 2 traversals are made to the file; the 1st builds a list of
  *  the objects, the 2nd makes a copy of them, using the options;
  *  the reason for the 1st traversal is to check for invalid
  *  object name requests
diff --git a/tools/h5repack/h5repack.h b/tools/h5repack/h5repack.h
index 80fb1b0..baa888e 100644
--- a/tools/h5repack/h5repack.h
+++ b/tools/h5repack/h5repack.h
@@ -19,12 +19,17 @@
 
 #include "hdf5.h"
 #include "h5trav.h"
+#include "H5Zprivate.h"	/* H5Z_COMMON_CD_VALUES */	
+
+
 
 #define H5FOPENERROR "unable to open file"
-#define PFORMAT  "%-7s %-7s %-7s\n"   /* chunk info, compression info, name*/
-#define PFORMAT1 "%-7s %-7s %-7s"     /* chunk info, compression info, name*/
-#define MAX_NC_NAME 256               /* max length of a name */
-#define MAX_VAR_DIMS 32               /* max per variable dimensions */
+
+#define PFORMAT  "%-7s %-7s %-7s\n" /*chunk info, compression info, name*/
+#define PFORMAT1 "%-7s %-7s %-7s"     /*chunk info, compression info, name*/
+
+#define MAX_NC_NAME 256 /* max length of a name */
+#define MAX_VAR_DIMS 32 /* max per variable dimensions */
 
 /*-------------------------------------------------------------------------
  * data structures for command line options
@@ -48,6 +53,7 @@ typedef struct {
  H5Z_FILTER_SCALEOFFSET 6 , scaleoffset compression
 */
 
+/* #define CD_VALUES H5Z_COMMON_CD_VALUES */
 #define CD_VALUES 20
 
 typedef struct {
diff --git a/tools/h5stat/h5stat_gentest.c b/tools/h5stat/h5stat_gentest.c
index ef644d8..28d20ce 100644
--- a/tools/h5stat/h5stat_gentest.c
+++ b/tools/h5stat/h5stat_gentest.c
@@ -29,7 +29,7 @@
 #define DATASET_NAME	"DATASET_NAME"
 #define GROUP_NAME	"GROUP"
 #define ATTR_NAME	"ATTR"
-#define NUM_GRPS 	35000
+#define NUM_GRPS 	350
 #define NUM_ATTRS	100
 
 /* 
diff --git a/tools/h5stat/testfiles/h5stat_newgrat.ddl b/tools/h5stat/testfiles/h5stat_newgrat.ddl
index d704f00..6881ca9 100644
--- a/tools/h5stat/testfiles/h5stat_newgrat.ddl
+++ b/tools/h5stat/testfiles/h5stat_newgrat.ddl
@@ -3,20 +3,20 @@ Expected output for 'h5stat h5stat_newgrat.h5'
 #############################
 Filename: h5stat_newgrat.h5
 File information
-	# of unique groups: 35001
+	# of unique groups: 351
 	# of unique datasets: 1
 	# of unique named dataypes: 0
 	# of unique links: 0
 	# of unique other: 0
 	Max. # of links to object: 1
-	Max. # of objects in group: 35001
+	Max. # of objects in group: 351
 Object header size: (total/unused)
-	Groups: 5145147/3220092
+	Groups: 51597/32292
 	Datasets: 414/312
 Storage information:
 	Groups:
-		B-tree/List: 470054
-		Heap: 739128
+		B-tree/List: 5158
+		Heap: 7643
 	Attributes:
 		B-tree/List: 2598
 		Heap: 4442
@@ -28,12 +28,12 @@ Storage information:
 		Heap: 0
 	Superblock extension: 0
 Small groups:
-	# of groups of size 0: 35000
-	Total # of small groups: 35000
+	# of groups of size 0: 350
+	Total # of small groups: 350
 Group bins:
-	# of groups of size 0: 35000
-	# of groups of size 10000 - 99999: 1
-	Total # of groups: 35001
+	# of groups of size 0: 350
+	# of groups of size 100 - 999: 1
+	Total # of groups: 351
 Dataset dimension information:
 	Max. rank of datasets: 0
 	Dataset ranks:
diff --git a/tools/h5stat/testfiles/h5stat_newgrat.h5 b/tools/h5stat/testfiles/h5stat_newgrat.h5
index 8083122..cab98bb 100644
--- a/tools/h5stat/testfiles/h5stat_newgrat.h5
+++ b/tools/h5stat/testfiles/h5stat_newgrat.h5
diff --git a/tools/lib/h5diff.c b/tools/lib/h5diff.c
index 9d64e44..4f4074f 100644
--- a/tools/lib/h5diff.c
+++ b/tools/lib/h5diff.c
@@ -47,7 +47,7 @@
 int
 print_objname (diff_opt_t * options, hsize_t nfound)
 {
-    return ((options->m_verbose || nfound) && !options->m_quiet) ? 1 : 0;
+ return ((options->m_verbose || nfound) && !options->m_quiet) ? 1 : 0;
 }
 
 /*-------------------------------------------------------------------------
@@ -186,17 +186,15 @@ hsize_t h5diff(const char *fname1,
                const char *objname2,
                diff_opt_t *options)
 {
-    trav_info_t  *info1=NULL;
-    trav_info_t  *info2=NULL;
-    hid_t        file1_id = (-1);
-    hid_t        file2_id = (-1);
+    trav_info_t  *info1;
+    trav_info_t  *info2;
+    hid_t        file1_id = (-1), file2_id = (-1);
     char         filenames[2][1024];
     hsize_t      nfound = 0;
 
     HDmemset(filenames, 0, 1024 * 2);
 
-    if(options->m_quiet && (options->m_verbose || options->m_report)) 
-    {
+    if(options->m_quiet && (options->m_verbose || options->m_report)) {
         printf("Error: -q (quiet mode) cannot be added to verbose or report modes\n");
         options->err_stat=1;
         return 0;
@@ -208,11 +206,9 @@ hsize_t h5diff(const char *fname1,
     */
 
     /* disable error reporting */
-    H5E_BEGIN_TRY 
-    {
-        /* open the files */
-        if((file1_id = H5Fopen(fname1, H5F_ACC_RDONLY, H5P_DEFAULT)) < 0) 
-        {
+    H5E_BEGIN_TRY {
+        /* Open the files */
+        if((file1_id = H5Fopen(fname1, H5F_ACC_RDONLY, H5P_DEFAULT)) < 0) {
             printf("h5diff: <%s>: unable to open file\n", fname1);
             options->err_stat = 1;
 
@@ -223,8 +219,7 @@ hsize_t h5diff(const char *fname1,
 #endif
             goto out;
         } /* end if */
-        if((file2_id = H5Fopen(fname2, H5F_ACC_RDONLY, H5P_DEFAULT)) < 0) 
-        {
+        if((file2_id = H5Fopen(fname2, H5F_ACC_RDONLY, H5P_DEFAULT)) < 0) {
             printf("h5diff: <%s>: unable to open file\n", fname2);
             options->err_stat = 1;
 
@@ -260,12 +255,11 @@ hsize_t h5diff(const char *fname1,
         goto out;
     } /* end if */
 
-   /*-------------------------------------------------------------------------
+    /*-------------------------------------------------------------------------
     * object name was supplied
     *-------------------------------------------------------------------------
     */
-    if( objname1 ) 
-    {
+    if(objname1) {
 #ifdef H5_HAVE_PARALLEL
         if(g_Parallel)
             /* Let tasks know that they won't be needed */
@@ -273,31 +267,22 @@ hsize_t h5diff(const char *fname1,
 #endif
         assert(objname2);
         options->cmn_objs = 1; /* eliminate warning */
-        nfound = diff_compare(file1_id, 
-                              fname1, 
-                              objname1, 
-                              info1,
-                              file2_id, 
-                              fname2, 
-                              objname2, 
-                              info2,
+        nfound = diff_compare(file1_id, fname1, objname1, info1,
+                              file2_id, fname2, objname2, info2,
                               options);
     } /* end if */
 
-   /*-------------------------------------------------------------------------
+    /*-------------------------------------------------------------------------
     * compare all
     *-------------------------------------------------------------------------
     */
 
-    else 
-    {
+    else {
 #ifdef H5_HAVE_PARALLEL
-        if(g_Parallel) 
-        {
+        if(g_Parallel) {
             int i;
 
-            if((HDstrlen(fname1) > 1024) || (HDstrlen(fname2) > 1024)) 
-            {
+            if((HDstrlen(fname1) > 1024) || (HDstrlen(fname2) > 1024)) {
                 fprintf(stderr, "The parallel diff only supports path names up to 1024 characters\n");
                 MPI_Abort(MPI_COMM_WORLD, 0);
             } /* end if */
@@ -310,12 +295,7 @@ hsize_t h5diff(const char *fname1,
                 MPI_Send(filenames, (1024 * 2), MPI_CHAR, i, MPI_TAG_PARALLEL, MPI_COMM_WORLD);
         } /* end if */
 #endif
-
-        nfound = diff_match(file1_id, 
-                            info1, 
-                            file2_id, 
-                            info2, 
-                            options);
+        nfound = diff_match(file1_id, info1, file2_id, info2, options);
     } /* end else */
 
     trav_info_free(info1);
@@ -323,8 +303,7 @@ hsize_t h5diff(const char *fname1,
 
 out:
     /* close */
-    H5E_BEGIN_TRY 
-    {
+    H5E_BEGIN_TRY {
         H5Fclose(file1_id);
         H5Fclose(file2_id);
     } H5E_END_TRY;
@@ -353,23 +332,22 @@ out:
  *-------------------------------------------------------------------------
  */
 hsize_t diff_match(hid_t file1_id,
-                   trav_info_t *info1,
-                   hid_t file2_id,
-                   trav_info_t *info2,
-                   diff_opt_t *options)
+                    trav_info_t * info1,
+                    hid_t file2_id,
+                    trav_info_t * info2,
+                    diff_opt_t * options)
 {
     trav_table_t *table = NULL;
-    size_t       curr1;
-    size_t       curr2;
-    unsigned     infile[2];
-    hsize_t      nfound = 0;
-    unsigned     i;
+    size_t curr1, curr2;
+    unsigned infile[2];
+    hsize_t nfound = 0;
+    unsigned i;
 
     /*-------------------------------------------------------------------------
     * build the list
     *-------------------------------------------------------------------------
     */
-    trav_table_init( &table );
+    trav_table_init(&table);
 
     curr1 = 0;
     curr2 = 0;
@@ -415,12 +393,11 @@ hsize_t diff_match(hid_t file1_id,
         curr2++;
     } /* end while */
 
-   /*-------------------------------------------------------------------------
+    /*-------------------------------------------------------------------------
     * print the list
     *-------------------------------------------------------------------------
     */
-    if(options->m_verbose) 
-    {
+    if(options->m_verbose) {
         printf("\n");
         printf("file1     file2\n");
         printf("---------------------------------------\n");
@@ -725,64 +702,59 @@ hsize_t diff_match(hid_t file1_id,
  *-------------------------------------------------------------------------
  */
 
-hsize_t diff_compare(hid_t file1_id,
-                     const char *file1_name,
-                     const char *obj1_name,
-                     trav_info_t *info1,
-                     hid_t file2_id,
-                     const char *file2_name,
-                     const char *obj2_name,
-                     trav_info_t *info2,
-                     diff_opt_t *options)
+hsize_t diff_compare (hid_t file1_id,
+                      const char *file1_name,
+                      const char *obj1_name,
+                      trav_info_t * info1,
+                      hid_t file2_id,
+                      const char *file2_name,
+                      const char *obj2_name,
+                      trav_info_t * info2,
+                      diff_opt_t * options)
 {
-    int     f1 = 0;
-    int     f2 = 0;
-    hsize_t nfound = 0;
-    
-    ssize_t i = h5trav_getindex (info1, obj1_name);
-    ssize_t j = h5trav_getindex (info2, obj2_name);
-    
-    if (i == -1)
-    {
-        parallel_print ("Object <%s> could not be found in <%s>\n", obj1_name,
-            file1_name);
-        f1 = 1;
-    }
-    if (j == -1)
-    {
-        parallel_print ("Object <%s> could not be found in <%s>\n", obj2_name,
-            file2_name);
-        f2 = 1;
-    }
-    if (f1 || f2)
-    {
-        options->err_stat = 1;
-        return 0;
-    }
-    
-    /* use the name with "/" first, as obtained by iterator function */
-    obj1_name = info1->paths[i].path;
-    obj2_name = info2->paths[j].path;
-    
-    /* objects are not the same type */
-    if (info1->paths[i].type != info2->paths[j].type)
-    {
-        if (options->m_verbose)
-            parallel_print("Comparison not possible: <%s> is of type %s and <%s> is of type %s\n",
-            obj1_name, get_type(info1->paths[i].type), obj2_name,
-            get_type(info2->paths[j].type));
-        options->not_cmp=1;
-        return 0;
-    }
-    
-    nfound = diff(file1_id, 
-                  obj1_name, 
-                  file2_id, 
-                  obj2_name, 
-                  options, 
-                  info1->paths[i].type);
-    
-    return nfound;
+ int f1 = 0, f2 = 0;
+ hsize_t nfound = 0;
+
+ ssize_t i = h5trav_getindex (info1, obj1_name);
+ ssize_t j = h5trav_getindex (info2, obj2_name);
+
+ if (i == -1)
+ {
+  parallel_print ("Object <%s> could not be found in <%s>\n", obj1_name,
+   file1_name);
+  f1 = 1;
+ }
+ if (j == -1)
+ {
+  parallel_print ("Object <%s> could not be found in <%s>\n", obj2_name,
+   file2_name);
+  f2 = 1;
+ }
+ if (f1 || f2)
+ {
+  options->err_stat = 1;
+  return 0;
+ }
+
+ /* use the name with "/" first, as obtained by iterator function */
+ obj1_name = info1->paths[i].path;
+ obj2_name = info2->paths[j].path;
+
+ /* objects are not the same type */
+ if (info1->paths[i].type != info2->paths[j].type)
+ {
+  if (options->m_verbose)
+   parallel_print("Comparison not possible: <%s> is of type %s and <%s> is of type %s\n",
+     obj1_name, get_type(info1->paths[i].type), obj2_name,
+     get_type(info2->paths[j].type));
+  options->not_cmp=1;
+  return 0;
+ }
+
+ nfound =
+  diff (file1_id, obj1_name, file2_id, obj2_name, options, info1->paths[i].type);
+
+ return nfound;
 }
 
 
@@ -812,15 +784,14 @@ hsize_t diff(hid_t file1_id,
               diff_opt_t * options, 
               h5trav_type_t type)
 {
-    hid_t   type1_id = (-1);
-    hid_t   type2_id = (-1);
-    hid_t   grp1_id = (-1);
-    hid_t   grp2_id = (-1);
-    int     ret;
+    hid_t       type1_id = (-1);
+    hid_t       type2_id = (-1);
+    hid_t       grp1_id = (-1);
+    hid_t       grp2_id = (-1);
+    int ret;
     hsize_t nfound = 0;
     
-    switch(type) 
-    {
+    switch(type) {
        /*-------------------------------------------------------------------------
         * H5TRAV_TYPE_DATASET
         *-------------------------------------------------------------------------
@@ -830,8 +801,7 @@ hsize_t diff(hid_t file1_id,
             * verbose, always print name
             *-------------------------------------------------------------------------
             */
-            if(options->m_verbose) 
-            {
+            if(options->m_verbose) {
                 if(print_objname(options, (hsize_t)1))
                     do_print_objname("dataset", path1, path2);
                 nfound = diff_dataset(file1_id, file2_id, path1, path2, options);
@@ -843,18 +813,15 @@ hsize_t diff(hid_t file1_id,
             * disabling quiet mode
             *-------------------------------------------------------------------------
             */
-            else 
-            {
-                if(options->m_quiet == 0) 
-                {
+            else {
+                if(options->m_quiet == 0) {
                     /* shut up temporarily */
                     options->m_quiet = 1;
                     nfound = diff_dataset(file1_id, file2_id, path1, path2, options);
 
                     /* print again */
                     options->m_quiet = 0;
-                    if(nfound) 
-                    {
+                    if(nfound) {
                         if(print_objname(options,nfound))
                             do_print_objname("dataset", path1, path2);
                         nfound = diff_dataset(file1_id, file2_id, path1, path2, options);
diff --git a/tools/lib/h5diff_array.c b/tools/lib/h5diff_array.c
index c5646ed..008b6b9 100644
--- a/tools/lib/h5diff_array.c
+++ b/tools/lib/h5diff_array.c
@@ -119,7 +119,7 @@ static int   not_comparable;
     is_zero=1;                                       \
 }
 
-#define PDIFF(a,b)      ( (b>a) ? (b-a) : (a-b))
+#   define PDIFF(a,b)		( (b>a) ? (b-a) : (a-b))
 
 /*-------------------------------------------------------------------------
  * local prototypes
@@ -127,12 +127,11 @@ static int   not_comparable;
  */
 static hsize_t diff_region(hid_t obj1_id, hid_t obj2_id,hid_t region1_id, hid_t region2_id, diff_opt_t *options);
 static hbool_t all_zero(const void *_mem, size_t size);
+static int     ull2float(unsigned long_long ull_value, float *f_value);
 static hsize_t character_compare(unsigned char *mem1,unsigned char *mem2,hsize_t i,int rank,hsize_t *dims,hsize_t *acc,hsize_t *pos,diff_opt_t *options,const char *obj1,const char *obj2,int *ph);
 static hsize_t character_compare_opt(unsigned char *mem1,unsigned char *mem2,hsize_t i,int rank,hsize_t *dims,hsize_t *acc,hsize_t *pos,diff_opt_t *options,const char *obj1,const char *obj2,int *ph);
 static hbool_t equal_float(float value, float expected);
 static hbool_t equal_double(double value, double expected);
-static int     ull2float(unsigned long_long ull_value, float *f_value);
-
 
 /*-------------------------------------------------------------------------
  * NaN detection
@@ -267,6 +266,8 @@ hsize_t diff_array( void *_mem1,
     size_t        size;              /* size of datum */
     unsigned char *mem1 = (unsigned char*)_mem1;
     unsigned char *mem2 = (unsigned char*)_mem2;
+    unsigned char *tmp1;
+    unsigned char *tmp2;
     hsize_t       acc[32];    /* accumulator position */
     hsize_t       pos[32];    /* matrix position */
     int           ph=1;       /* print header  */
@@ -287,26 +288,23 @@ hsize_t diff_array( void *_mem1,
     
     if(H5Tis_variable_str(m_type))
     {
-        for ( i = 0; i < nelmts; i++)
-        {
-            nfound+=diff_datum(
-                ((unsigned char**)mem1)[(size_t)i],
-                ((unsigned char**)mem2)[(size_t)i],
-                m_type,
-                i,
-                rank,
-                dims,
-                acc,
-                pos,
-                options,
-                name1,
-                name2,
-                container1_id,
-                container2_id,
-                &ph);
-            if (options->n && nfound>=options->count)
-                return nfound;
-        } /* i */
+        tmp1 = ((unsigned char**)mem1)[0];
+        tmp2 = ((unsigned char**)mem2)[0];
+        nfound+=diff_datum(
+            tmp1,
+            tmp2,
+            m_type,
+            (hsize_t)0,
+            rank,
+            dims,
+            acc,
+            pos,
+            options,
+            name1,
+            name2,
+            container1_id,
+            container2_id,
+            &ph);
     }
     
     else
@@ -517,35 +515,42 @@ hsize_t diff_datum(void       *_mem1,
     case H5T_STRING:
 
         {
+            
             H5T_str_t pad;
             char      *s;
             
-            /* Get pointer to first string to compare */
-            s = (char *)mem1;
-
-            /* check for NULL pointer for string */
-            if(s!=NULL)
+            if(H5Tis_variable_str(m_type))
             {
-                if(H5Tis_variable_str(m_type))
+               /* mem1 is the pointer into the struct where a `char*' is stored. So we have
+                * to dereference the pointer to get the `char*' to pass to HDstrlen(). */
+                s = *(char**)mem1;
+                if(s!=NULL)
                     size = HDstrlen(s);
-                else
-                    size = H5Tget_size(m_type);
-                
-                pad = H5Tget_strpad(m_type);
+            }
+            else
+            {
+                s = (char *)mem1;
+                size = H5Tget_size(m_type);
+            }
+            
+            pad = H5Tget_strpad(m_type);
             
+            /* check for NULL pointer for string */
+            if(s!=NULL)
+            {
                 for (u=0; u<size && (s[u] || pad!=H5T_STR_NULLTERM); u++)
                     nfound+=character_compare(
-                        mem1 + u,
-                        mem2 + u, /* offset */
-                        i,        /* index position */
-                        rank,
-                        dims,
-                        acc,
-                        pos,
-                        options,
-                        obj1,
-                        obj2,
-                        ph);
+                    mem1 + u,
+                    mem2 + u, /* offset */
+                    i,        /* index position */
+                    rank,
+                    dims,
+                    acc,
+                    pos,
+                    options,
+                    obj1,
+                    obj2,
+                    ph);
             }
                 
         }
@@ -692,6 +697,7 @@ hsize_t diff_datum(void       *_mem1,
             H5Tclose(memb_type);
         }
         break;
+        
    
         
    /*-------------------------------------------------------------------------
@@ -2861,6 +2867,7 @@ hsize_t diff_float(unsigned char *mem1,
 }
 
 
+
 /*-------------------------------------------------------------------------
  * Function: diff_double
  *
@@ -2890,111 +2897,80 @@ hsize_t diff_double(unsigned char *mem1,
     hsize_t     i;
     double      per;
     int         both_zero;
-    int         isnan1;
-    int         isnan2;
     
-
- /*-------------------------------------------------------------------------
-  * -d and !-p 
-  *-------------------------------------------------------------------------
-  */
- 
+    
+    /* -d and !-p */
     if (options->d && !options->p)
     {
+        
         for ( i = 0; i < nelmts; i++)
         {
             memcpy(&temp1_double, mem1, sizeof(double));
             memcpy(&temp2_double, mem2, sizeof(double));
-
-           /*-------------------------------------------------------------------------
-            * detect NaNs
-            *-------------------------------------------------------------------------
-            */
-            isnan1 = my_isnan(FLT_DOUBLE,&temp1_double);
-            isnan2 = my_isnan(FLT_DOUBLE,&temp2_double);
-
-            if ( !isnan1 && !isnan2)
-            {             
-                if (ABS(temp1_double-temp2_double) > options->delta)
+            
+            if (ABS(temp1_double-temp2_double) > options->delta)
+            {
+                if ( print_data(options) )
                 {
-                    if ( print_data(options) )
-                    {
-                        print_pos(ph,0,hyper_start+i,acc,pos,rank,dims,obj1,obj2);
-                        parallel_print(SPACES);
-                        parallel_print(F_FORMAT,temp1_double,temp2_double,ABS(temp1_double-temp2_double));
-                    }
-                    nfound++;
+                    print_pos(ph,0,hyper_start+i,acc,pos,rank,dims,obj1,obj2);
+                    parallel_print(SPACES);
+                    parallel_print(F_FORMAT,temp1_double,temp2_double,ABS(temp1_double-temp2_double));
                 }
-            } /* NaN */
+                nfound++;
+            }
             mem1+=sizeof(double);
             mem2+=sizeof(double);
             if (options->n && nfound>=options->count)
                 return nfound;
-        } /* i */
+        }
     }
-
- /*-------------------------------------------------------------------------
-  * !-d and -p 
-  *-------------------------------------------------------------------------
-  */
+    
+    /* !-d and -p */
     else if (!options->d && options->p)
     {
+        
         for ( i = 0; i < nelmts; i++)
         {
             memcpy(&temp1_double, mem1, sizeof(double));
             memcpy(&temp2_double, mem2, sizeof(double));
             
-           /*-------------------------------------------------------------------------
-            * detect NaNs
-            *-------------------------------------------------------------------------
-            */
-            isnan1 = my_isnan(FLT_DOUBLE,&temp1_double);
-            isnan2 = my_isnan(FLT_DOUBLE,&temp2_double);
+            PER(temp1_double,temp2_double);
             
-            if ( !isnan1 && !isnan2)
-            {        
-                
-                PER(temp1_double,temp2_double);
+            if (not_comparable && !both_zero) /* not comparable */
+            {
+                if ( print_data(options) )
+                {
+                    print_pos(ph,1,hyper_start+i,acc,pos,rank,dims,obj1,obj2);
+                    parallel_print(SPACES);
+                    parallel_print(F_FORMAT_P_NOTCOMP,temp1_double,temp2_double,
+                        ABS(temp1_double-temp2_double));
+                }
+                options->not_cmp=1;
+                nfound++;
+            }
+            
+            else
                 
-                if (not_comparable && !both_zero) /* not comparable */
+                if ( per > options->percent )
                 {
                     if ( print_data(options) )
                     {
                         print_pos(ph,1,hyper_start+i,acc,pos,rank,dims,obj1,obj2);
                         parallel_print(SPACES);
-                        parallel_print(F_FORMAT_P_NOTCOMP,temp1_double,temp2_double,
-                            ABS(temp1_double-temp2_double));
+                        parallel_print(F_FORMAT_P,temp1_double,temp2_double,
+                            ABS(temp1_double-temp2_double),
+                            ABS(1-temp2_double/temp1_double));
                     }
-                    options->not_cmp=1;
                     nfound++;
                 }
-                
-                else
-                    
-                    if ( per > options->percent )
-                    {
-                        if ( print_data(options) )
-                        {
-                            print_pos(ph,1,hyper_start+i,acc,pos,rank,dims,obj1,obj2);
-                            parallel_print(SPACES);
-                            parallel_print(F_FORMAT_P,temp1_double,temp2_double,
-                                ABS(temp1_double-temp2_double),
-                                ABS(1-temp2_double/temp1_double));
-                        }
-                        nfound++;
-                    }
-            } /* NaN */
-            mem1+=sizeof(double);
-            mem2+=sizeof(double);
-            if (options->n && nfound>=options->count)
-                return nfound;
-        } /* i */
+                mem1+=sizeof(double);
+                mem2+=sizeof(double);
+                if (options->n && nfound>=options->count)
+                    return nfound;
+        }
     }
     
- /*-------------------------------------------------------------------------
-  * -d and -p 
-  *-------------------------------------------------------------------------
-  */
+    /* -d and -p */
     else if ( options->d && options->p)
     {
         
@@ -3003,58 +2979,41 @@ hsize_t diff_double(unsigned char *mem1,
             memcpy(&temp1_double, mem1, sizeof(double));
             memcpy(&temp2_double, mem2, sizeof(double));
             
-            /*-------------------------------------------------------------------------
-            * detect NaNs
-            *-------------------------------------------------------------------------
-            */
-            isnan1 = my_isnan(FLT_DOUBLE,&temp1_double);
-            isnan2 = my_isnan(FLT_DOUBLE,&temp2_double);
+            PER(temp1_double,temp2_double);
             
-            if ( !isnan1 && !isnan2)
-            {        
-                
-                PER(temp1_double,temp2_double);
+            if (not_comparable && !both_zero) /* not comparable */
+            {
+                if ( print_data(options) )
+                {
+                    print_pos(ph,1,hyper_start+i,acc,pos,rank,dims,obj1,obj2);
+                    parallel_print(SPACES);
+                    parallel_print(F_FORMAT_P_NOTCOMP,temp1_double,temp2_double,
+                        ABS(temp1_double-temp2_double));
+                }
+                options->not_cmp=1;
+                nfound++;
+            }
+            
+            else
                 
-                if (not_comparable && !both_zero) /* not comparable */
+                if ( per > options->percent && ABS(temp1_double-temp2_double) > options->delta )
                 {
                     if ( print_data(options) )
                     {
                         print_pos(ph,1,hyper_start+i,acc,pos,rank,dims,obj1,obj2);
                         parallel_print(SPACES);
-                        parallel_print(F_FORMAT_P_NOTCOMP,temp1_double,temp2_double,
-                            ABS(temp1_double-temp2_double));
+                        parallel_print(F_FORMAT_P,temp1_double,temp2_double,
+                            ABS(temp1_double-temp2_double),
+                            ABS(1-temp2_double/temp1_double));
                     }
-                    options->not_cmp=1;
                     nfound++;
                 }
-                
-                else
-                    
-                    if ( per > options->percent && ABS(temp1_double-temp2_double) > options->delta )
-                    {
-                        if ( print_data(options) )
-                        {
-                            print_pos(ph,1,hyper_start+i,acc,pos,rank,dims,obj1,obj2);
-                            parallel_print(SPACES);
-                            parallel_print(F_FORMAT_P,temp1_double,temp2_double,
-                                ABS(temp1_double-temp2_double),
-                                ABS(1-temp2_double/temp1_double));
-                        }
-                        nfound++;
-                    }
-                    
-            } /* NaN */
-            mem1+=sizeof(double);
-            mem2+=sizeof(double);
-            if (options->n && nfound>=options->count)
-                return nfound;
-        } /* i */
+                mem1+=sizeof(double);
+                mem2+=sizeof(double);
+                if (options->n && nfound>=options->count)
+                    return nfound;
+        }
     }
-
- /*-------------------------------------------------------------------------
-  * no -d and -p 
-  *-------------------------------------------------------------------------
-  */
     else
     {
         
@@ -3085,9 +3044,6 @@ hsize_t diff_double(unsigned char *mem1,
     return nfound;
 }
 
-
-
-
 /*-------------------------------------------------------------------------
  * Function: diff_schar
  *
diff --git a/tools/lib/h5diff_dset.c b/tools/lib/h5diff_dset.c
index 3f4e6a3..ea833db 100644
--- a/tools/lib/h5diff_dset.c
+++ b/tools/lib/h5diff_dset.c
@@ -19,6 +19,33 @@
 #include "h5tools.h"
 
 /*-------------------------------------------------------------------------
+ * Function: print_size
+ *
+ * Purpose: print dimensions 
+ *
+ *-------------------------------------------------------------------------
+ */
+#if defined (H5DIFF_DEBUG)
+static void
+print_size (int rank, hsize_t *dims)
+{
+    int i;
+
+    parallel_print("[" );
+    for ( i = 0; i < rank-1; i++)
+    {
+        parallel_print("%"H5_PRINTF_LL_WIDTH"u", (unsigned long_long)dims[i]);
+        parallel_print("x");
+    }
+    parallel_print("%"H5_PRINTF_LL_WIDTH"u", (unsigned long_long)dims[rank-1]);
+    parallel_print("]\n" );
+    
+}
+#endif /* H5DIFF_DEBUG */
+
+
+
+/*-------------------------------------------------------------------------
  * Function: diff_dataset
  *
  * Purpose: check for comparable datasets and read into a compatible
@@ -38,85 +65,79 @@ hsize_t diff_dataset( hid_t file1_id,
                       const char *obj2_name,
                       diff_opt_t *options)
 {
-    hid_t   did1 = -1;
-    hid_t   did2 = -1;
-    hid_t   dcpl1 = -1;
-    hid_t   dcpl2 = -1;
-    hsize_t nfound = 0;
-    
-   /*-------------------------------------------------------------------------
-    * open the handles
-    *-------------------------------------------------------------------------
-    */
-    /* disable error reporting */
-    H5E_BEGIN_TRY 
-    {
-        /* open the datasets */
-        if((did1 = H5Dopen2(file1_id, obj1_name, H5P_DEFAULT)) < 0) 
-        {
-            printf("Cannot open dataset <%s>\n", obj1_name);
-            goto error;
-        }
-        
-        if((did2 = H5Dopen2(file2_id, obj2_name, H5P_DEFAULT)) < 0) 
-        {
-            printf("Cannot open dataset <%s>\n", obj2_name);
-            goto error;
-        }
-        /* enable error reporting */
-    } H5E_END_TRY;
-    
-    
-    if ((dcpl1 = H5Dget_create_plist(did1)) < 0)
-        goto error;
-    if ((dcpl2 = H5Dget_create_plist(did2)) < 0)
-        goto error;
-    
-   /*-------------------------------------------------------------------------
-    * check if the dataset creation property list has filters that
-    * are not registered in the current configuration
-    * 1) the external filters GZIP and SZIP might not be available
-    * 2) the internal filters might be turned off
-    *-------------------------------------------------------------------------
-    */
-    if ((h5tools_canreadf((options->m_verbose?obj1_name:NULL),dcpl1)==1) &&
-        (h5tools_canreadf((options->m_verbose?obj2_name:NULL),dcpl2)==1))
-    {
-        nfound=diff_datasetid(did1,
-            did2,
-            obj1_name,
-            obj2_name,
-            options);
-    }
-   /*-------------------------------------------------------------------------
-    * close
-    *-------------------------------------------------------------------------
-    */
-    /* disable error reporting */
-    H5E_BEGIN_TRY 
-    {
-        H5Pclose(dcpl1);
-        H5Pclose(dcpl2);
-        H5Dclose(did1);
-        H5Dclose(did2);
-        /* enable error reporting */
-    } H5E_END_TRY;
-    
-    return nfound;
-    
+ hid_t   did1 = -1;
+ hid_t   did2 = -1;
+ hid_t   dcpl1 = -1;
+ hid_t   dcpl2 = -1;
+ hsize_t nfound = 0;
+
+/*-------------------------------------------------------------------------
+ * open the handles
+ *-------------------------------------------------------------------------
+ */
+ /* disable error reporting */
+ H5E_BEGIN_TRY {
+ /* Open the datasets */
+ if((did1 = H5Dopen2(file1_id, obj1_name, H5P_DEFAULT)) < 0) {
+  printf("Cannot open dataset <%s>\n", obj1_name);
+  goto error;
+ }
+ if((did2 = H5Dopen2(file2_id, obj2_name, H5P_DEFAULT)) < 0) {
+  printf("Cannot open dataset <%s>\n", obj2_name);
+  goto error;
+ }
+ /* enable error reporting */
+ } H5E_END_TRY;
+
+
+ if((dcpl1 = H5Dget_create_plist(did1)) < 0)
+  goto error;
+ if((dcpl2 = H5Dget_create_plist(did2)) < 0)
+  goto error;
+
+/*-------------------------------------------------------------------------
+ * check if the dataset creation property list has filters that
+ * are not registered in the current configuration
+ * 1) the external filters GZIP and SZIP might not be available
+ * 2) the internal filters might be turned off
+ *-------------------------------------------------------------------------
+ */
+ if ((h5tools_canreadf((options->m_verbose?obj1_name:NULL),dcpl1)==1) &&
+     (h5tools_canreadf((options->m_verbose?obj2_name:NULL),dcpl2)==1))
+ {
+  nfound=diff_datasetid(did1,
+                        did2,
+                        obj1_name,
+                        obj2_name,
+                        options);
+ }
+/*-------------------------------------------------------------------------
+ * close
+ *-------------------------------------------------------------------------
+ */
+ /* disable error reporting */
+ H5E_BEGIN_TRY {
+  H5Pclose(dcpl1);
+  H5Pclose(dcpl2);
+  H5Dclose(did1);
+  H5Dclose(did2);
+   /* enable error reporting */
+ } H5E_END_TRY;
+
+ return nfound;
+
 error:
-    options->err_stat=1;
-    /* disable error reporting */
-    H5E_BEGIN_TRY 
-    {
-        H5Pclose(dcpl1);
-        H5Pclose(dcpl2);
-        H5Dclose(did1);
-        H5Dclose(did2);
-        /* enable error reporting */
-    } H5E_END_TRY;
-    
-    return nfound;
+ options->err_stat=1;
+ /* disable error reporting */
+ H5E_BEGIN_TRY {
+  H5Pclose(dcpl1);
+  H5Pclose(dcpl2);
+  H5Dclose(did1);
+  H5Dclose(did2);
+   /* enable error reporting */
+ } H5E_END_TRY;
+
+ return nfound;
 }
 
 /*-------------------------------------------------------------------------
@@ -133,6 +154,7 @@ error:
  *
  * Modifications: 
  *
+ *
  * October 2006:  Read by hyperslabs for big datasets.
  *
  *  A threshold of H5TOOLS_MALLOCSIZE (128 MB) is the limit upon which I/O hyperslab is done
@@ -182,456 +204,448 @@ hsize_t diff_datasetid( hid_t did1,
                         const char *obj2_name,
                         diff_opt_t *options)
 {
-    hid_t      sid1=-1;
-    hid_t      sid2=-1;
-    hid_t      f_tid1=-1;
-    hid_t      f_tid2=-1;                
-    hid_t      m_tid1=-1;
-    hid_t      m_tid2=-1;                
-    size_t     m_size1;
-    size_t     m_size2;               
-    H5T_sign_t sign1;
-    H5T_sign_t sign2;                 
-    int        rank1;
-    int        rank2;
-    hsize_t    nelmts1;
-    hsize_t    nelmts2;
-    hsize_t    dims1[H5S_MAX_RANK];
-    hsize_t    dims2[H5S_MAX_RANK];
-    hsize_t    maxdim1[H5S_MAX_RANK];
-    hsize_t    maxdim2[H5S_MAX_RANK];
-    const char *name1=NULL;            /* relative names */
-    const char *name2=NULL;
-    hsize_t    storage_size1;
-    hsize_t    storage_size2;
-    hsize_t    nfound=0;               /* number of differences found */
-    int        cmp=1;                  /* do diff or not */
-    void       *buf1=NULL;                  
-    void       *buf2=NULL; 
-    void       *sm_buf1=NULL;                
-    void       *sm_buf2=NULL;
-    size_t     need;                   /* bytes needed for malloc */
-    int        i;
-    
-    /* get the dataspace handle */
-    if ( (sid1 = H5Dget_space(did1)) < 0 )
-        goto error;
-    
-    /* get rank */
-    if ( (rank1 = H5Sget_simple_extent_ndims(sid1)) < 0 )
-        goto error;
-    
-    /* get the dataspace handle */
-    if ( (sid2 = H5Dget_space(did2)) < 0 )
-        goto error;
-    
-    /* get rank */
-    if ( (rank2 = H5Sget_simple_extent_ndims(sid2)) < 0 )
-        goto error;
-    
-    /* get dimensions */
-    if ( H5Sget_simple_extent_dims(sid1,dims1,maxdim1) < 0 )
-        goto error;
-    
-    /* get dimensions */
-    if ( H5Sget_simple_extent_dims(sid2,dims2,maxdim2) < 0 )
-        goto error;
-    
-    /*-------------------------------------------------------------------------
-     * get the file data type
-     *-------------------------------------------------------------------------
-     */
-    
-    /* get the data type */
-    if ( (f_tid1 = H5Dget_type(did1)) < 0 )
-        goto error;
-    
-    /* get the data type */
-    if ( (f_tid2 = H5Dget_type(did2)) < 0 )
-        goto error;
-    
-    /*-------------------------------------------------------------------------
-     * check for empty datasets
-     *-------------------------------------------------------------------------
-     */
-    
-    storage_size1=H5Dget_storage_size(did1);
-    storage_size2=H5Dget_storage_size(did2);
-    if (storage_size1<0 || storage_size2<0)
-        goto error;
-    
-    if (storage_size1==0 || storage_size2==0)
-    {
-        if (options->m_verbose && obj1_name && obj2_name)
-            parallel_print("<%s> or <%s> are empty datasets\n", obj1_name, obj2_name);
-        cmp=0;
-        options->not_cmp=1;
-    }
-    
-   /*-------------------------------------------------------------------------
-    * check for comparable TYPE and SPACE
-    *-------------------------------------------------------------------------
-    */
-    
-    if (diff_can_type(f_tid1,
-        f_tid2,
-        rank1,
-        rank2,
-        dims1,
-        dims2,
-        maxdim1,
-        maxdim2,
-        obj1_name,
-        obj2_name,
-        options)!=1)
-    {
-        cmp=0;
-        options->not_cmp=1;
-    }
-    
-   /*-------------------------------------------------------------------------
-    * memory type and sizes
-    *-------------------------------------------------------------------------
-    */
-    if ((m_tid1=h5tools_get_native_type(f_tid1)) < 0)
-        goto error;
-    
-    if ((m_tid2=h5tools_get_native_type(f_tid2)) < 0)
-        goto error;
-    
-    m_size1 = H5Tget_size( m_tid1 );
-    m_size2 = H5Tget_size( m_tid2 );
-    
-   /*-------------------------------------------------------------------------
-    * check for different signed/unsigned types
-    *-------------------------------------------------------------------------
-    */
-    
-    sign1=H5Tget_sign(m_tid1);
-    sign2=H5Tget_sign(m_tid2);
-    if ( sign1 != sign2 )
-    {
-        if (options->m_verbose && obj1_name) 
-        {
-            parallel_print("Comparison not supported: <%s> has sign %s ", obj1_name, get_sign(sign1));
-            parallel_print("and <%s> has sign %s\n", obj2_name, get_sign(sign2));
-        }
-        
-        cmp=0;
-        options->not_cmp=1;
-    }
-    
-   /*-------------------------------------------------------------------------
-    * only attempt to compare if possible
-    *-------------------------------------------------------------------------
-    */
-    if (cmp)
-    {
-        
-       /*-------------------------------------------------------------------------
-        * get number of elements
-        *-------------------------------------------------------------------------
-        */
-        nelmts1 = 1;
-        for (i = 0; i < rank1; i++)
-        {
-            nelmts1 *= dims1[i];
-        }
-        
-        nelmts2 = 1;
-        for (i = 0; i < rank2; i++)
-        {
-            nelmts2 *= dims2[i];
-        }
-        
-        assert(nelmts1==nelmts2);
-        
-       /*-------------------------------------------------------------------------
-        * "upgrade" the smaller memory size
-        *-------------------------------------------------------------------------
-        */
-        
-        if ( m_size1 != m_size2 )
-        {
-            if ( m_size1 < m_size2 )
-            {
-                H5Tclose(m_tid1);
-                
-                if ((m_tid1=h5tools_get_native_type(f_tid2)) < 0)
-                    goto error;
-                
-                m_size1 = H5Tget_size( m_tid1 );
-            }
-            else
-            {
-                H5Tclose(m_tid2);
-                
-                if ((m_tid2=h5tools_get_native_type(f_tid1)) < 0)
-                    goto error;
-                
-                m_size2 = H5Tget_size( m_tid2 );
-            }
-        }
-        assert(m_size1==m_size2);
-        
-        /* print names */
-        if (obj1_name) {
-            name1=diff_basename(obj1_name);
-        }
-        if (obj2_name) {
-            name2=diff_basename(obj2_name);
-        }
-        
-        
-       /*-------------------------------------------------------------------------
-        * read/compare
-        *-------------------------------------------------------------------------
-        */
-        
-        need = (size_t)(nelmts1*m_size1);  /* bytes needed */
-        if ( need < H5TOOLS_MALLOCSIZE)
-        {
-            buf1 = HDmalloc(need);
-            buf2 = HDmalloc(need);
-        }
-        
-        if ( buf1!=NULL && buf2!=NULL)
-        {
-            if ( H5Dread(did1,m_tid1,H5S_ALL,H5S_ALL,H5P_DEFAULT,buf1) < 0 )
-                goto error;
-            if ( H5Dread(did2,m_tid2,H5S_ALL,H5S_ALL,H5P_DEFAULT,buf2) < 0 )
-                goto error;
-            
-            /* array diff */
-            nfound = diff_array(buf1,
-                buf2,
-                nelmts1,
-                (hsize_t)0,
-                rank1,
-                dims1,
-                options,
-                name1,
-                name2,
-                m_tid1,
-                did1,
-                did2);
-        }
-        
-        else /* possibly not enough memory, read/compare by hyperslabs */
-            
-        {
-            size_t        p_type_nbytes = m_size1; /*size of memory type */
-            hsize_t       p_nelmts = nelmts1;      /*total selected elmts */
-            hsize_t       elmtno;                  /*counter  */
-            int           carry;                   /*counter carry value */
-            unsigned int  vl_data = 0;             /*contains VL datatypes */
-            
-            /* stripmine info */
-            hsize_t       sm_size[H5S_MAX_RANK];   /*stripmine size */
-            hsize_t       sm_nbytes;               /*bytes per stripmine */
-            hsize_t       sm_nelmts;               /*elements per stripmine*/
-            hid_t         sm_space;                /*stripmine data space */
-            
-            /* hyperslab info */
-            hsize_t       hs_offset[H5S_MAX_RANK]; /*starting offset */
-            hsize_t       hs_size[H5S_MAX_RANK];   /*size this pass */
-            hsize_t       hs_nelmts;               /*elements in request */
-            hsize_t       zero[8];                 /*vector of zeros */
-            
-            /* check if we have VL data in the dataset's datatype */
-            if (H5Tdetect_class(m_tid1, H5T_VLEN) == TRUE)
-                vl_data = TRUE;
-            
-            /*
-             * determine the strip mine size and allocate a buffer. The strip mine is
-             * a hyperslab whose size is manageable.
-             */
-            sm_nbytes = p_type_nbytes;
-            
-            for (i = rank1; i > 0; --i) 
-            {
-                sm_size[i - 1] = MIN(dims1[i - 1], H5TOOLS_BUFSIZE / sm_nbytes);
-                sm_nbytes *= sm_size[i - 1];
-                assert(sm_nbytes > 0);
-            }
-            
-            sm_buf1 = malloc((size_t)sm_nbytes);
-            sm_buf2 = malloc((size_t)sm_nbytes);
-            
-            sm_nelmts = sm_nbytes / p_type_nbytes;
-            sm_space = H5Screate_simple(1, &sm_nelmts, NULL);
-            
-            /* the stripmine loop */
-            memset(hs_offset, 0, sizeof hs_offset);
-            memset(zero, 0, sizeof zero);
-            
-            for (elmtno = 0; elmtno < p_nelmts; elmtno += hs_nelmts) 
-            {
-                /* calculate the hyperslab size */
-                if (rank1 > 0) 
-                {
-                    for (i = 0, hs_nelmts = 1; i < rank1; i++) 
-                    {
-                        hs_size[i] = MIN(dims1[i] - hs_offset[i], sm_size[i]);
-                        hs_nelmts *= hs_size[i];
-                    }
-                    if (H5Sselect_hyperslab(sid1, H5S_SELECT_SET, hs_offset, NULL, hs_size, NULL) < 0)
-                        goto error;
-                    if (H5Sselect_hyperslab(sid2, H5S_SELECT_SET, hs_offset, NULL, hs_size, NULL) < 0)
-                        goto error;
-                    if (H5Sselect_hyperslab(sm_space, H5S_SELECT_SET, zero, NULL, &hs_nelmts, NULL) < 0)
-                        goto error;
-                } 
-                else 
-                {
-                    H5Sselect_all(sid1);
-                    H5Sselect_all(sid2);
-                    H5Sselect_all(sm_space);
-                    hs_nelmts = 1;
-                } /* rank */
-                
-                if ( H5Dread(did1,m_tid1,sm_space,sid1,H5P_DEFAULT,sm_buf1) < 0 )
-                    goto error;
-                if ( H5Dread(did2,m_tid2,sm_space,sid2,H5P_DEFAULT,sm_buf2) < 0 )
-                    goto error;
-                
-                /* get array differences. in the case of hyperslab read, increment the 
-                   number of differences found in each hyperslab and pass the 
-                   position at the beggining for printing
-                 */
-                nfound += diff_array(sm_buf1,
-                    sm_buf2,
-                    hs_nelmts,
-                    elmtno,
-                    rank1,
-                    dims1,
-                    options,
-                    name1,
-                    name2,
-                    m_tid1,
-                    did1,
-                    did2);
-                
-                /* reclaim any VL memory, if necessary */
-                if(vl_data)
-                {
-                    H5Dvlen_reclaim(m_tid1, sm_space, H5P_DEFAULT, sm_buf1);
-                    H5Dvlen_reclaim(m_tid1, sm_space, H5P_DEFAULT, sm_buf2);
-                }
-                
-                /* calculate the next hyperslab offset */
-                for (i = rank1, carry = 1; i > 0 && carry; --i) 
-                {
-                    hs_offset[i - 1] += hs_size[i - 1];
-                    if (hs_offset[i - 1] == dims1[i - 1])
-                        hs_offset[i - 1] = 0;
-                    else
-                        carry = 0;
-                } /* i */
-            } /* elmtno */
-            
-            H5Sclose(sm_space);
-            /* free */
-            if (sm_buf1!=NULL)
-            {
-                free(sm_buf1);
-                sm_buf1=NULL;
-            }
-            if (sm_buf2!=NULL)
-            {
-                free(sm_buf2);
-                sm_buf2=NULL;
-            }
-            
-  } /* hyperslab read */
- }/*cmp*/
- 
- /*-------------------------------------------------------------------------
-  * compare attributes
-  * the if condition refers to cases when the dataset is a referenced object
-  *-------------------------------------------------------------------------
-  */
-  
-  if (obj1_name)
-      nfound += diff_attr(did1,did2,obj1_name,obj2_name,options);
-  
- /*-------------------------------------------------------------------------
-  * close
-  *-------------------------------------------------------------------------
-  */
-  
-  /* free */
-  if (buf1!=NULL)
-  {
-      free(buf1);
-      buf1=NULL;
-  }
-  if (buf2!=NULL)
-  {
-      free(buf2);
-      buf2=NULL;
+ hid_t      sid1=-1;
+ hid_t      sid2=-1;
+ hid_t      f_tid1=-1;
+ hid_t      f_tid2=-1;                
+ hid_t      m_tid1=-1;
+ hid_t      m_tid2=-1;                
+ size_t     m_size1;
+ size_t     m_size2;               
+ H5T_sign_t sign1;
+ H5T_sign_t sign2;                 
+ int        rank1;
+ int        rank2;
+ hsize_t    nelmts1;
+ hsize_t    nelmts2;
+ hsize_t    dims1[H5S_MAX_RANK];
+ hsize_t    dims2[H5S_MAX_RANK];
+ hsize_t    maxdim1[H5S_MAX_RANK];
+ hsize_t    maxdim2[H5S_MAX_RANK];
+ const char *name1=NULL;            /* relative names */
+ const char *name2=NULL;
+ hsize_t    storage_size1;
+ hsize_t    storage_size2;
+ hsize_t    nfound=0;               /* number of differences found */
+ int        cmp=1;                  /* do diff or not */
+ void       *buf1=NULL;                  
+ void       *buf2=NULL; 
+ void       *sm_buf1=NULL;                
+ void       *sm_buf2=NULL;
+ size_t     need;                   /* bytes needed for malloc */
+ int        i;
+
+  /* Get the dataspace handle */
+ if ( (sid1 = H5Dget_space(did1)) < 0 )
+  goto error;
+
+ /* Get rank */
+ if ( (rank1 = H5Sget_simple_extent_ndims(sid1)) < 0 )
+  goto error;
+
+ /* Get the dataspace handle */
+ if ( (sid2 = H5Dget_space(did2)) < 0 )
+  goto error;
+
+ /* Get rank */
+ if ( (rank2 = H5Sget_simple_extent_ndims(sid2)) < 0 )
+  goto error;
+
+ /* Get dimensions */
+ if ( H5Sget_simple_extent_dims(sid1,dims1,maxdim1) < 0 )
+  goto error;
+
+ /* Get dimensions */
+ if ( H5Sget_simple_extent_dims(sid2,dims2,maxdim2) < 0 )
+  goto error;
+
+/*-------------------------------------------------------------------------
+ * Get the file data type
+ *-------------------------------------------------------------------------
+ */
+
+ /* Get the data type */
+ if ( (f_tid1 = H5Dget_type(did1)) < 0 )
+  goto error;
+
+ /* Get the data type */
+ if ( (f_tid2 = H5Dget_type(did2)) < 0 )
+  goto error;
+
+/*-------------------------------------------------------------------------
+ * check for empty datasets
+ *-------------------------------------------------------------------------
+ */
+
+ storage_size1=H5Dget_storage_size(did1);
+ storage_size2=H5Dget_storage_size(did2);
+
+ if (storage_size1==0 || storage_size2==0)
+ {
+  if (options->m_verbose && obj1_name && obj2_name)
+   parallel_print("<%s> or <%s> are empty datasets\n", obj1_name, obj2_name);
+  cmp=0;
+  options->not_cmp=1;
+ }
+
+/*-------------------------------------------------------------------------
+ * check for comparable TYPE and SPACE
+ *-------------------------------------------------------------------------
+ */
+
+ if (diff_can_type(f_tid1,
+                   f_tid2,
+                   rank1,
+                   rank2,
+                   dims1,
+                   dims2,
+                   maxdim1,
+                   maxdim2,
+                   obj1_name,
+                   obj2_name,
+                   options)!=1)
+ {
+  cmp=0;
+  options->not_cmp=1;
+ }
+
+/*-------------------------------------------------------------------------
+ * memory type and sizes
+ *-------------------------------------------------------------------------
+ */
+ if ((m_tid1=h5tools_get_native_type(f_tid1)) < 0)
+  goto error;
+
+ if ((m_tid2=h5tools_get_native_type(f_tid2)) < 0)
+  goto error;
+
+ m_size1 = H5Tget_size( m_tid1 );
+ m_size2 = H5Tget_size( m_tid2 );
+
+/*-------------------------------------------------------------------------
+ * check for different signed/unsigned types
+ *-------------------------------------------------------------------------
+ */
+
+ sign1=H5Tget_sign(m_tid1);
+ sign2=H5Tget_sign(m_tid2);
+ if ( sign1 != sign2 )
+ {
+  if (options->m_verbose && obj1_name) {
+   parallel_print("Comparison not supported: <%s> has sign %s ", obj1_name, get_sign(sign1));
+   parallel_print("and <%s> has sign %s\n", obj2_name, get_sign(sign2));
   }
-  if (sm_buf1!=NULL)
+
+  cmp=0;
+  options->not_cmp=1;
+ }
+
+/*-------------------------------------------------------------------------
+ * only attempt to compare if possible
+ *-------------------------------------------------------------------------
+ */
+ if (cmp)
+ {
+
+/*-------------------------------------------------------------------------
+ * get number of elements
+ *-------------------------------------------------------------------------
+ */
+ nelmts1 = 1;
+ for (i = 0; i < rank1; i++)
+ {
+  nelmts1 *= dims1[i];
+ }
+
+ nelmts2 = 1;
+ for (i = 0; i < rank2; i++)
+ {
+  nelmts2 *= dims2[i];
+ }
+
+ assert(nelmts1==nelmts2);
+
+/*-------------------------------------------------------------------------
+ * "upgrade" the smaller memory size
+ *-------------------------------------------------------------------------
+ */
+
+ if ( m_size1 != m_size2 )
+ {
+  if ( m_size1 < m_size2 )
   {
-      free(sm_buf1);
-      sm_buf1=NULL;
+   H5Tclose(m_tid1);
+
+   if ((m_tid1=h5tools_get_native_type(f_tid2)) < 0)
+    goto error;
+
+   m_size1 = H5Tget_size( m_tid1 );
   }
-  if (sm_buf2!=NULL)
+  else
   {
-      free(sm_buf2);
-      sm_buf2=NULL;
+   H5Tclose(m_tid2);
+
+   if ((m_tid2=h5tools_get_native_type(f_tid1)) < 0)
+    goto error;
+
+   m_size2 = H5Tget_size( m_tid2 );
   }
+ }
+ assert(m_size1==m_size2);
+
+ /* print names */
+ if (obj1_name) {
+  name1=diff_basename(obj1_name);
+ }
+ if (obj2_name) {
+  name2=diff_basename(obj2_name);
+ }
+
+ 
+/*-------------------------------------------------------------------------
+ * read/compare
+ *-------------------------------------------------------------------------
+ */
+
+ need = (size_t)(nelmts1*m_size1);  /* bytes needed */
+ if ( need < H5TOOLS_MALLOCSIZE)
+ {
+  buf1 = HDmalloc(need);
+  buf2 = HDmalloc(need);
+ }
+
+ if ( buf1!=NULL && buf2!=NULL)
+ {
+  if ( H5Dread(did1,m_tid1,H5S_ALL,H5S_ALL,H5P_DEFAULT,buf1) < 0 )
+   goto error;
+  if ( H5Dread(did2,m_tid2,H5S_ALL,H5S_ALL,H5P_DEFAULT,buf2) < 0 )
+   goto error;
+
+  /* array diff */
+  nfound = diff_array(buf1,
+                      buf2,
+                      nelmts1,
+                      (hsize_t)0,
+                      rank1,
+                      dims1,
+                      options,
+                      name1,
+                      name2,
+                      m_tid1,
+                      did1,
+                      did2);
+ }
+ 
+ else /* possibly not enough memory, read/compare by hyperslabs */
   
-  H5E_BEGIN_TRY 
-  {
-      H5Sclose(sid1);
-      H5Sclose(sid2);
-      H5Tclose(f_tid1);
-      H5Tclose(f_tid2);
-      H5Tclose(m_tid1);
-      H5Tclose(m_tid2);
-  } H5E_END_TRY;
+ {
+  size_t        p_type_nbytes = m_size1; /*size of memory type */
+  hsize_t       p_nelmts = nelmts1;      /*total selected elmts */
+  hsize_t       elmtno;                  /*counter  */
+  int           carry;                   /*counter carry value */
+  unsigned int  vl_data = 0;             /*contains VL datatypes */
   
-  return nfound;
+  /* stripmine info */
+  hsize_t       sm_size[H5S_MAX_RANK];   /*stripmine size */
+  hsize_t       sm_nbytes;               /*bytes per stripmine */
+  hsize_t       sm_nelmts;               /*elements per stripmine*/
+  hid_t         sm_space;                /*stripmine data space */
   
-error:
-  options->err_stat=1;
+  /* hyperslab info */
+  hsize_t       hs_offset[H5S_MAX_RANK]; /*starting offset */
+  hsize_t       hs_size[H5S_MAX_RANK];   /*size this pass */
+  hsize_t       hs_nelmts;               /*elements in request */
+  hsize_t       zero[8];                 /*vector of zeros */
   
-  /* free */
-  if (buf1!=NULL)
-  {
-      free(buf1);
-      buf1=NULL;
+  /* check if we have VL data in the dataset's datatype */
+  if (H5Tdetect_class(m_tid1, H5T_VLEN) == TRUE)
+   vl_data = TRUE;
+  
+  /*
+   * determine the strip mine size and allocate a buffer. The strip mine is
+   * a hyperslab whose size is manageable.
+   */
+  sm_nbytes = p_type_nbytes;
+  
+  for (i = rank1; i > 0; --i) {
+   sm_size[i - 1] = MIN(dims1[i - 1], H5TOOLS_BUFSIZE / sm_nbytes);
+   sm_nbytes *= sm_size[i - 1];
+   assert(sm_nbytes > 0);
   }
-  if (buf2!=NULL)
+  
+  sm_buf1 = malloc((size_t)sm_nbytes);
+  sm_buf2 = malloc((size_t)sm_nbytes);
+  
+  sm_nelmts = sm_nbytes / p_type_nbytes;
+  sm_space = H5Screate_simple(1, &sm_nelmts, NULL);
+  
+  /* the stripmine loop */
+  memset(hs_offset, 0, sizeof hs_offset);
+  memset(zero, 0, sizeof zero);
+
+  for (elmtno = 0; elmtno < p_nelmts; elmtno += hs_nelmts) 
   {
-      free(buf2);
-      buf2=NULL;
-  }
+   /* calculate the hyperslab size */
+   if (rank1 > 0) 
+   {
+    for (i = 0, hs_nelmts = 1; i < rank1; i++) 
+    {
+     hs_size[i] = MIN(dims1[i] - hs_offset[i], sm_size[i]);
+     hs_nelmts *= hs_size[i];
+    }
+    if (H5Sselect_hyperslab(sid1, H5S_SELECT_SET, hs_offset, NULL, hs_size, NULL) < 0)
+     goto error;
+    if (H5Sselect_hyperslab(sid2, H5S_SELECT_SET, hs_offset, NULL, hs_size, NULL) < 0)
+     goto error;
+    if (H5Sselect_hyperslab(sm_space, H5S_SELECT_SET, zero, NULL, &hs_nelmts, NULL) < 0)
+     goto error;
+   } 
+   else 
+   {
+    H5Sselect_all(sid1);
+    H5Sselect_all(sid2);
+    H5Sselect_all(sm_space);
+    hs_nelmts = 1;
+   } /* rank */
+ 
+   if ( H5Dread(did1,m_tid1,sm_space,sid1,H5P_DEFAULT,sm_buf1) < 0 )
+    goto error;
+   if ( H5Dread(did2,m_tid2,sm_space,sid2,H5P_DEFAULT,sm_buf2) < 0 )
+    goto error;
+   
+   /* get array differences. in the case of hyperslab read, increment the number of differences 
+      found in each hyperslab and pass the position at the beggining for printing */
+   nfound += diff_array(sm_buf1,
+                        sm_buf2,
+                        hs_nelmts,
+                        elmtno,
+                        rank1,
+                        dims1,
+                        options,
+                        name1,
+                        name2,
+                        m_tid1,
+                        did1,
+                        did2);
+
+   /* reclaim any VL memory, if necessary */
+   if(vl_data)
+   {
+    H5Dvlen_reclaim(m_tid1, sm_space, H5P_DEFAULT, sm_buf1);
+    H5Dvlen_reclaim(m_tid1, sm_space, H5P_DEFAULT, sm_buf2);
+   }
+   
+   /* calculate the next hyperslab offset */
+   for (i = rank1, carry = 1; i > 0 && carry; --i) 
+   {
+    hs_offset[i - 1] += hs_size[i - 1];
+    if (hs_offset[i - 1] == dims1[i - 1])
+     hs_offset[i - 1] = 0;
+    else
+     carry = 0;
+   } /* i */
+  } /* elmtno */
+  
+  H5Sclose(sm_space);
+  /* free */
   if (sm_buf1!=NULL)
   {
-      free(sm_buf1);
-      sm_buf1=NULL;
+   free(sm_buf1);
+   sm_buf1=NULL;
   }
   if (sm_buf2!=NULL)
   {
-      free(sm_buf2);
-      sm_buf2=NULL;
+   free(sm_buf2);
+   sm_buf2=NULL;
   }
   
-  /* disable error reporting */
-  H5E_BEGIN_TRY 
-  {
-      H5Sclose(sid1);
-      H5Sclose(sid2);
-      H5Tclose(f_tid1);
-      H5Tclose(f_tid2);
-      H5Tclose(m_tid1);
-      H5Tclose(m_tid2);
-      /* enable error reporting */
-  } H5E_END_TRY;
-  
-  return nfound;
+ } /* hyperslab read */
+ }/*cmp*/
+ 
+/*-------------------------------------------------------------------------
+ * compare attributes
+ * the if condition refers to cases when the dataset is a referenced object
+ *-------------------------------------------------------------------------
+ */
+
+ if (obj1_name)
+  nfound += diff_attr(did1,did2,obj1_name,obj2_name,options);
+
+/*-------------------------------------------------------------------------
+ * close
+ *-------------------------------------------------------------------------
+ */
+ 
+ /* free */
+ if (buf1!=NULL)
+ {
+  free(buf1);
+  buf1=NULL;
+ }
+ if (buf2!=NULL)
+ {
+  free(buf2);
+  buf2=NULL;
+ }
+ if (sm_buf1!=NULL)
+ {
+  free(sm_buf1);
+  sm_buf1=NULL;
+ }
+ if (sm_buf2!=NULL)
+ {
+  free(sm_buf2);
+  sm_buf2=NULL;
+ }
+
+ H5E_BEGIN_TRY {
+  H5Sclose(sid1);
+  H5Sclose(sid2);
+  H5Tclose(f_tid1);
+  H5Tclose(f_tid2);
+  H5Tclose(m_tid1);
+  H5Tclose(m_tid2);
+ } H5E_END_TRY;
+
+ return nfound;
+
+error:
+ options->err_stat=1;
+ 
+ /* free */
+ if (buf1!=NULL)
+ {
+  free(buf1);
+  buf1=NULL;
+ }
+ if (buf2!=NULL)
+ {
+  free(buf2);
+  buf2=NULL;
+ }
+ if (sm_buf1!=NULL)
+ {
+  free(sm_buf1);
+  sm_buf1=NULL;
+ }
+ if (sm_buf2!=NULL)
+ {
+  free(sm_buf2);
+  sm_buf2=NULL;
+ }
+
+ /* disable error reporting */
+ H5E_BEGIN_TRY {
+  H5Sclose(sid1);
+  H5Sclose(sid2);
+  H5Tclose(f_tid1);
+  H5Tclose(f_tid2);
+  H5Tclose(m_tid1);
+  H5Tclose(m_tid2);
+   /* enable error reporting */
+ } H5E_END_TRY;
+
+ return nfound;
 }
 
 /*-------------------------------------------------------------------------
@@ -663,164 +677,163 @@ int diff_can_type( hid_t       f_tid1, /* file data type */
                    const char  *obj2_name,
                    diff_opt_t  *options )
 {
-    H5T_class_t  tclass1;
-    H5T_class_t  tclass2;
-    int          maxdim_diff=0;          /* maximum dimensions are different */
-    int          dim_diff=0;             /* current dimensions are different */
-    int          i;
-    
-   /*-------------------------------------------------------------------------
-    * check for the same class
-    *-------------------------------------------------------------------------
-    */
-    
-    if ((tclass1=H5Tget_class(f_tid1)) < 0)
-        return -1;
-    
-    if ((tclass2=H5Tget_class(f_tid2)) < 0)
-        return -1;
-    
-    if ( tclass1 != tclass2 )
-    {
-        if (options->m_verbose && obj1_name) 
-        {
-            printf("Comparison not possible: <%s> is of class %s and <%s> is of class %s\n",
-                obj1_name, get_class(tclass1),
-                obj2_name, get_class(tclass2) );
-        }
-        return 0;
-    }
-    
-   /*-------------------------------------------------------------------------
-    * check for non supported classes
-    *-------------------------------------------------------------------------
-    */
-    
-    assert(tclass1==tclass2);
-    switch (tclass1)
-    {
-    case H5T_INTEGER:
-    case H5T_FLOAT:
-    case H5T_COMPOUND:
-    case H5T_STRING:
-    case H5T_ARRAY:
-    case H5T_BITFIELD:
-    case H5T_OPAQUE:
-    case H5T_ENUM:
-    case H5T_VLEN:
-    case H5T_REFERENCE:
-        
-        break;
-        
-    default: /*H5T_TIME */
-        if (options->m_verbose && obj1_name )
-            printf("Comparison not supported: <%s> and <%s> are of class %s\n",
-            obj1_name,obj2_name,get_class(tclass2) );
-        return 0;
-    }
-    
-   /*-------------------------------------------------------------------------
-    * check for equal file datatype; warning only
-    *-------------------------------------------------------------------------
-    */
-    
-    if ( (H5Tequal(f_tid1, f_tid2)==0) && options->m_verbose && obj1_name)
-    {
-        printf("Warning: different storage datatype\n");
-        printf("<%s> has file datatype ", obj1_name);
-        print_type(f_tid1);
-        printf("\n");
-        printf("<%s> has file datatype ", obj2_name);
-        print_type(f_tid2);
-        printf("\n");
-    }
-    
-   /*-------------------------------------------------------------------------
-    * check for the same rank
-    *-------------------------------------------------------------------------
-    */
-    
-    if ( rank1 != rank2 )
-    {
-        if (options->m_verbose && obj1_name) 
-        {
-            printf("Comparison not supported: <%s> has rank %d, dimensions ", obj1_name, rank1);
-            print_dimensions(rank1,dims1);
-            printf(", max dimensions ");
-            print_dimensions(rank1,maxdim1);
-            printf("\n" );
-            printf("<%s> has rank %d, dimensions ", obj2_name, rank2);
-            print_dimensions(rank2,dims2);
-            printf(", max dimensions ");
-            print_dimensions(rank2,maxdim2);
-        }
-        return 0;
-    }
-    
-   /*-------------------------------------------------------------------------
-    * check for different dimensions
-    *-------------------------------------------------------------------------
-    */
-    
-    assert(rank1==rank2);
-    for ( i=0; i<rank1; i++)
-    {
-        if (maxdim1 && maxdim2)
-        {
-            if ( maxdim1[i] != maxdim2[i] )
-                maxdim_diff=1;
-        }
-        if ( dims1[i] != dims2[i] )
-            dim_diff=1;
-    }
-    
-   /*-------------------------------------------------------------------------
-    * current dimensions
-    *-------------------------------------------------------------------------
-    */
-    
-    if (dim_diff==1)
-    {
-        if (options->m_verbose && obj1_name) 
-        {
-            printf("Comparison not supported: <%s> has rank %d, dimensions ", obj1_name, rank1);
-            print_dimensions(rank1,dims1);
-            if (maxdim1 && maxdim2) 
-            {
-                printf(", max dimensions ");
-                print_dimensions(rank1,maxdim1);
-                printf("\n" );
-                printf("<%s> has rank %d, dimensions ", obj2_name, rank2);
-                print_dimensions(rank2,dims2);
-                printf(", max dimensions ");
-                print_dimensions(rank2,maxdim2);
-            }
-        }
-        return 0;
-    }
-    
-   /*-------------------------------------------------------------------------
-    * maximum dimensions; just give a warning
-    *-------------------------------------------------------------------------
-    */
-    if (maxdim1 && maxdim2 && maxdim_diff==1 && obj1_name )
-    {
-        if (options->m_verbose) 
-        {
-            printf( "Warning: different maximum dimensions\n");
-            printf("<%s> has max dimensions ", obj1_name);
-            print_dimensions(rank1,maxdim1);
-            printf("\n");
-            printf("<%s> has max dimensions ", obj2_name);
-            print_dimensions(rank2,maxdim2);
-            printf("\n");
-        }
-    }
-    
-    return 1;
+
+
+ H5T_class_t  tclass1;
+ H5T_class_t  tclass2;
+ int          maxdim_diff=0;          /* maximum dimensions are different */
+ int          dim_diff=0;             /* current dimensions are different */
+ int          i;
+
+/*-------------------------------------------------------------------------
+ * check for the same class
+ *-------------------------------------------------------------------------
+ */
+
+ if ((tclass1=H5Tget_class(f_tid1)) < 0)
+  return -1;
+
+ if ((tclass2=H5Tget_class(f_tid2)) < 0)
+  return -1;
+
+ if ( tclass1 != tclass2 )
+ {
+  if (options->m_verbose && obj1_name) {
+   printf("Comparison not possible: <%s> is of class %s and <%s> is of class %s\n",
+    obj1_name, get_class(tclass1),
+    obj2_name, get_class(tclass2) );
+  }
+  return 0;
+ }
+
+/*-------------------------------------------------------------------------
+ * check for non supported classes
+ *-------------------------------------------------------------------------
+ */
+
+ assert(tclass1==tclass2);
+ switch (tclass1)
+ {
+ case H5T_INTEGER:
+ case H5T_FLOAT:
+ case H5T_COMPOUND:
+ case H5T_STRING:
+ case H5T_ARRAY:
+ case H5T_BITFIELD:
+ case H5T_OPAQUE:
+ case H5T_ENUM:
+ case H5T_VLEN:
+ case H5T_REFERENCE:
+
+  break;
+
+ default: /*H5T_TIME */
+  if (options->m_verbose && obj1_name )
+   printf("Comparison not supported: <%s> and <%s> are of class %s\n",
+    obj1_name,obj2_name,get_class(tclass2) );
+  return 0;
+ }
+
+/*-------------------------------------------------------------------------
+ * check for equal file datatype; warning only
+ *-------------------------------------------------------------------------
+ */
+
+ if ( (H5Tequal(f_tid1, f_tid2)==0) && options->m_verbose && obj1_name)
+ {
+  printf("Warning: different storage datatype\n");
+  printf("<%s> has file datatype ", obj1_name);
+  print_type(f_tid1);
+  printf("\n");
+  printf("<%s> has file datatype ", obj2_name);
+  print_type(f_tid2);
+  printf("\n");
+ }
+
+/*-------------------------------------------------------------------------
+ * check for the same rank
+ *-------------------------------------------------------------------------
+ */
+
+ if ( rank1 != rank2 )
+ {
+  if (options->m_verbose && obj1_name) {
+   printf("Comparison not supported: <%s> has rank %d, dimensions ", obj1_name, rank1);
+   print_dimensions(rank1,dims1);
+   printf(", max dimensions ");
+   print_dimensions(rank1,maxdim1);
+   printf("\n" );
+   printf("<%s> has rank %d, dimensions ", obj2_name, rank2);
+   print_dimensions(rank2,dims2);
+   printf(", max dimensions ");
+   print_dimensions(rank2,maxdim2);
+  }
+  return 0;
+ }
+
+/*-------------------------------------------------------------------------
+ * check for different dimensions
+ *-------------------------------------------------------------------------
+ */
+
+ assert(rank1==rank2);
+ for ( i=0; i<rank1; i++)
+ {
+  if (maxdim1 && maxdim2)
+  {
+   if ( maxdim1[i] != maxdim2[i] )
+    maxdim_diff=1;
+  }
+  if ( dims1[i] != dims2[i] )
+   dim_diff=1;
+ }
+
+/*-------------------------------------------------------------------------
+ * current dimensions
+ *-------------------------------------------------------------------------
+ */
+
+ if (dim_diff==1)
+ {
+  if (options->m_verbose && obj1_name) {
+   printf("Comparison not supported: <%s> has rank %d, dimensions ", obj1_name, rank1);
+   print_dimensions(rank1,dims1);
+   if (maxdim1 && maxdim2) {
+    printf(", max dimensions ");
+    print_dimensions(rank1,maxdim1);
+    printf("\n" );
+    printf("<%s> has rank %d, dimensions ", obj2_name, rank2);
+    print_dimensions(rank2,dims2);
+    printf(", max dimensions ");
+    print_dimensions(rank2,maxdim2);
+   }
+  }
+  return 0;
+ }
+
+/*-------------------------------------------------------------------------
+ * maximum dimensions; just give a warning
+ *-------------------------------------------------------------------------
+ */
+ if (maxdim1 && maxdim2 && maxdim_diff==1 && obj1_name )
+ {
+  if (options->m_verbose) {
+   printf( "Warning: different maximum dimensions\n");
+   printf("<%s> has max dimensions ", obj1_name);
+   print_dimensions(rank1,maxdim1);
+   printf("\n");
+   printf("<%s> has max dimensions ", obj2_name);
+   print_dimensions(rank2,maxdim2);
+   printf("\n");
+  }
+ }
+
+ return 1;
 }
 
 
+
+
 /*-------------------------------------------------------------------------
  * Function: print_sizes
  *
@@ -874,29 +887,3 @@ void print_sizes( const char *obj1,
  printf("\n");
 }
 #endif /* H5DIFF_DEBUG */
-
-/*-------------------------------------------------------------------------
- * Function: print_size
- *
- * Purpose: print dimensions 
- *
- *-------------------------------------------------------------------------
- */
-#if defined (H5DIFF_DEBUG)
-static void
-print_size (int rank, hsize_t *dims)
-{
-    int i;
-
-    parallel_print("[" );
-    for ( i = 0; i < rank-1; i++)
-    {
-        parallel_print("%"H5_PRINTF_LL_WIDTH"u", (unsigned long_long)dims[i]);
-        parallel_print("x");
-    }
-    parallel_print("%"H5_PRINTF_LL_WIDTH"u", (unsigned long_long)dims[rank-1]);
-    parallel_print("]\n" );
-    
-}
-#endif /* H5DIFF_DEBUG */
-
diff --git a/tools/lib/h5diff_util.c b/tools/lib/h5diff_util.c
index 4cddbfb..9e9c556 100644
--- a/tools/lib/h5diff_util.c
+++ b/tools/lib/h5diff_util.c
@@ -131,91 +131,91 @@ print_dimensions (int rank, hsize_t *dims)
  */
 void print_type(hid_t type)
 {
-    switch (H5Tget_class(type))
-    {
-    default:
-        return;
-    case H5T_INTEGER:
-        if (H5Tequal(type, H5T_STD_I8BE)) {
-            printf("H5T_STD_I8BE");
-        } else if (H5Tequal(type, H5T_STD_I8LE)) {
-            printf("H5T_STD_I8LE");
-        } else if (H5Tequal(type, H5T_STD_I16BE)) {
-            printf("H5T_STD_I16BE");
-        } else if (H5Tequal(type, H5T_STD_I16LE)) {
-            printf("H5T_STD_I16LE");
-        } else if (H5Tequal(type, H5T_STD_I32BE)) {
-            printf("H5T_STD_I32BE");
-        } else if (H5Tequal(type, H5T_STD_I32LE)) {
-            printf("H5T_STD_I32LE");
-        } else if (H5Tequal(type, H5T_STD_I64BE)) {
-            printf("H5T_STD_I64BE");
-        } else if (H5Tequal(type, H5T_STD_I64LE)) {
-            printf("H5T_STD_I64LE");
-        } else if (H5Tequal(type, H5T_STD_U8BE)) {
-            printf("H5T_STD_U8BE");
-        } else if (H5Tequal(type, H5T_STD_U8LE)) {
-            printf("H5T_STD_U8LE");
-        } else if (H5Tequal(type, H5T_STD_U16BE)) {
-            printf("H5T_STD_U16BE");
-        } else if (H5Tequal(type, H5T_STD_U16LE)) {
-            printf("H5T_STD_U16LE");
-        } else if (H5Tequal(type, H5T_STD_U32BE)) {
-            printf("H5T_STD_U32BE");
-        } else if (H5Tequal(type, H5T_STD_U32LE)) {
-            printf("H5T_STD_U32LE");
-        } else if (H5Tequal(type, H5T_STD_U64BE)) {
-            printf("H5T_STD_U64BE");
-        } else if (H5Tequal(type, H5T_STD_U64LE)) {
-            printf("H5T_STD_U64LE");
-        } else if (H5Tequal(type, H5T_NATIVE_SCHAR)) {
-            printf("H5T_NATIVE_SCHAR");
-        } else if (H5Tequal(type, H5T_NATIVE_UCHAR)) {
-            printf("H5T_NATIVE_UCHAR");
-        } else if (H5Tequal(type, H5T_NATIVE_SHORT)) {
-            printf("H5T_NATIVE_SHORT");
-        } else if (H5Tequal(type, H5T_NATIVE_USHORT)) {
-            printf("H5T_NATIVE_USHORT");
-        } else if (H5Tequal(type, H5T_NATIVE_INT)) {
-            printf("H5T_NATIVE_INT");
-        } else if (H5Tequal(type, H5T_NATIVE_UINT)) {
-            printf("H5T_NATIVE_UINT");
-        } else if (H5Tequal(type, H5T_NATIVE_LONG)) {
-            printf("H5T_NATIVE_LONG");
-        } else if (H5Tequal(type, H5T_NATIVE_ULONG)) {
-            printf("H5T_NATIVE_ULONG");
-        } else if (H5Tequal(type, H5T_NATIVE_LLONG)) {
-            printf("H5T_NATIVE_LLONG");
-        } else if (H5Tequal(type, H5T_NATIVE_ULLONG)) {
-            printf("H5T_NATIVE_ULLONG");
-        } else {
-            printf("undefined integer");
-        }
-        break;
-        
-    case H5T_FLOAT:
-        if (H5Tequal(type, H5T_IEEE_F32BE)) {
-            printf("H5T_IEEE_F32BE");
-        } else if (H5Tequal(type, H5T_IEEE_F32LE)) {
-            printf("H5T_IEEE_F32LE");
-        } else if (H5Tequal(type, H5T_IEEE_F64BE)) {
-            printf("H5T_IEEE_F64BE");
-        } else if (H5Tequal(type, H5T_IEEE_F64LE)) {
-            printf("H5T_IEEE_F64LE");
-        } else if (H5Tequal(type, H5T_NATIVE_FLOAT)) {
-            printf("H5T_NATIVE_FLOAT");
-        } else if (H5Tequal(type, H5T_NATIVE_DOUBLE)) {
-            printf("H5T_NATIVE_DOUBLE");
+ switch (H5Tget_class(type))
+ {
+ default:
+  return;
+ case H5T_INTEGER:
+  if (H5Tequal(type, H5T_STD_I8BE)) {
+   printf("H5T_STD_I8BE");
+  } else if (H5Tequal(type, H5T_STD_I8LE)) {
+   printf("H5T_STD_I8LE");
+  } else if (H5Tequal(type, H5T_STD_I16BE)) {
+   printf("H5T_STD_I16BE");
+  } else if (H5Tequal(type, H5T_STD_I16LE)) {
+   printf("H5T_STD_I16LE");
+  } else if (H5Tequal(type, H5T_STD_I32BE)) {
+   printf("H5T_STD_I32BE");
+  } else if (H5Tequal(type, H5T_STD_I32LE)) {
+   printf("H5T_STD_I32LE");
+  } else if (H5Tequal(type, H5T_STD_I64BE)) {
+   printf("H5T_STD_I64BE");
+  } else if (H5Tequal(type, H5T_STD_I64LE)) {
+   printf("H5T_STD_I64LE");
+  } else if (H5Tequal(type, H5T_STD_U8BE)) {
+   printf("H5T_STD_U8BE");
+  } else if (H5Tequal(type, H5T_STD_U8LE)) {
+   printf("H5T_STD_U8LE");
+  } else if (H5Tequal(type, H5T_STD_U16BE)) {
+   printf("H5T_STD_U16BE");
+  } else if (H5Tequal(type, H5T_STD_U16LE)) {
+   printf("H5T_STD_U16LE");
+  } else if (H5Tequal(type, H5T_STD_U32BE)) {
+   printf("H5T_STD_U32BE");
+  } else if (H5Tequal(type, H5T_STD_U32LE)) {
+   printf("H5T_STD_U32LE");
+  } else if (H5Tequal(type, H5T_STD_U64BE)) {
+   printf("H5T_STD_U64BE");
+  } else if (H5Tequal(type, H5T_STD_U64LE)) {
+   printf("H5T_STD_U64LE");
+  } else if (H5Tequal(type, H5T_NATIVE_SCHAR)) {
+   printf("H5T_NATIVE_SCHAR");
+  } else if (H5Tequal(type, H5T_NATIVE_UCHAR)) {
+   printf("H5T_NATIVE_UCHAR");
+  } else if (H5Tequal(type, H5T_NATIVE_SHORT)) {
+   printf("H5T_NATIVE_SHORT");
+  } else if (H5Tequal(type, H5T_NATIVE_USHORT)) {
+   printf("H5T_NATIVE_USHORT");
+  } else if (H5Tequal(type, H5T_NATIVE_INT)) {
+   printf("H5T_NATIVE_INT");
+  } else if (H5Tequal(type, H5T_NATIVE_UINT)) {
+   printf("H5T_NATIVE_UINT");
+  } else if (H5Tequal(type, H5T_NATIVE_LONG)) {
+   printf("H5T_NATIVE_LONG");
+  } else if (H5Tequal(type, H5T_NATIVE_ULONG)) {
+   printf("H5T_NATIVE_ULONG");
+  } else if (H5Tequal(type, H5T_NATIVE_LLONG)) {
+   printf("H5T_NATIVE_LLONG");
+  } else if (H5Tequal(type, H5T_NATIVE_ULLONG)) {
+   printf("H5T_NATIVE_ULLONG");
+  } else {
+   printf("undefined integer");
+  }
+  break;
+
+ case H5T_FLOAT:
+  if (H5Tequal(type, H5T_IEEE_F32BE)) {
+   printf("H5T_IEEE_F32BE");
+  } else if (H5Tequal(type, H5T_IEEE_F32LE)) {
+   printf("H5T_IEEE_F32LE");
+  } else if (H5Tequal(type, H5T_IEEE_F64BE)) {
+   printf("H5T_IEEE_F64BE");
+  } else if (H5Tequal(type, H5T_IEEE_F64LE)) {
+   printf("H5T_IEEE_F64LE");
+  } else if (H5Tequal(type, H5T_NATIVE_FLOAT)) {
+   printf("H5T_NATIVE_FLOAT");
+  } else if (H5Tequal(type, H5T_NATIVE_DOUBLE)) {
+   printf("H5T_NATIVE_DOUBLE");
 #if H5_SIZEOF_LONG_DOUBLE !=0
-        } else if (H5Tequal(type, H5T_NATIVE_LDOUBLE)) {
-            printf("H5T_NATIVE_LDOUBLE");
+  } else if (H5Tequal(type, H5T_NATIVE_LDOUBLE)) {
+   printf("H5T_NATIVE_LDOUBLE");
 #endif
-        } else {
-            printf("undefined float");
-        }
-        break;
-        
-    }/*switch*/
+  } else {
+   printf("undefined float");
+  }
+  break;
+
+ }/*switch*/
 }
 
 /*-------------------------------------------------------------------------
@@ -232,21 +232,21 @@ void print_type(hid_t type)
 const char*
 diff_basename(const char *name)
 {
-    size_t i;
-    
-    if (name==NULL)
-        return NULL;
-    
-    /* Find the end of the base name */
-    i = strlen(name);
-    while (i>0 && '/'==name[i-1])
-        --i;
-    
-    /* Skip backward over base name */
-    while (i>0 && '/'!=name[i-1])
-        --i;
-    
-    return(name+i);
+ size_t i;
+
+ if (name==NULL)
+  return NULL;
+
+ /* Find the end of the base name */
+ i = strlen(name);
+ while (i>0 && '/'==name[i-1])
+  --i;
+
+ /* Skip backward over base name */
+ while (i>0 && '/'!=name[i-1])
+  --i;
+
+ return(name+i);
 }
 
 /*-------------------------------------------------------------------------
@@ -295,15 +295,15 @@ get_type(h5trav_type_t type)
 const char*
 get_sign(H5T_sign_t sign)
 {
-    switch (sign)
-    {
-    default:
-        return("H5T_SGN_ERROR");
-    case H5T_SGN_NONE:
-        return("H5T_SGN_NONE");
-    case H5T_SGN_2:
-        return("H5T_SGN_2");
-    }
+ switch (sign)
+ {
+ default:
+  return("H5T_SGN_ERROR");
+ case H5T_SGN_NONE:
+  return("H5T_SGN_NONE");
+ case H5T_SGN_2:
+  return("H5T_SGN_2");
+ }
 }
 
 
@@ -321,33 +321,33 @@ get_sign(H5T_sign_t sign)
 const char*
 get_class(H5T_class_t tclass)
 {
-    switch (tclass)
-    {
-    default:
-        return("Invalid class");
-    case H5T_TIME:
-        return("H5T_TIME");
-    case H5T_INTEGER:
-        return("H5T_INTEGER");
-    case H5T_FLOAT:
-        return("H5T_FLOAT");
-    case H5T_STRING:
-        return("H5T_STRING");
-    case H5T_BITFIELD:
-        return("H5T_BITFIELD");
-    case H5T_OPAQUE:
-        return("H5T_OPAQUE");
-    case H5T_COMPOUND:
-        return("H5T_COMPOUND");
-    case H5T_REFERENCE:
-        return("H5T_REFERENCE");
-    case H5T_ENUM:
-        return("H5T_ENUM");
-    case H5T_VLEN:
-        return("H5T_VLEN");
-    case H5T_ARRAY:
-        return("H5T_ARRAY");
-    }
+ switch (tclass)
+ {
+ default:
+  return("Invalid class");
+ case H5T_TIME:
+  return("H5T_TIME");
+ case H5T_INTEGER:
+  return("H5T_INTEGER");
+ case H5T_FLOAT:
+  return("H5T_FLOAT");
+ case H5T_STRING:
+  return("H5T_STRING");
+ case H5T_BITFIELD:
+  return("H5T_BITFIELD");
+ case H5T_OPAQUE:
+  return("H5T_OPAQUE");
+ case H5T_COMPOUND:
+  return("H5T_COMPOUND");
+ case H5T_REFERENCE:
+  return("H5T_REFERENCE");
+ case H5T_ENUM:
+  return("H5T_ENUM");
+ case H5T_VLEN:
+  return("H5T_VLEN");
+ case H5T_ARRAY:
+  return("H5T_ARRAY");
+ }
 }
 
 /*-------------------------------------------------------------------------
diff --git a/tools/lib/h5tools.c b/tools/lib/h5tools.c
index 120d433..6fc09d7 100644
--- a/tools/lib/h5tools.c
+++ b/tools/lib/h5tools.c
@@ -538,31 +538,29 @@ h5tools_dump_simple_data(FILE *stream, const h5tool_format_t *info, hid_t contai
                          hsize_t nelmts, hid_t type, void *_mem)
 {
     unsigned char *mem = (unsigned char*)_mem;
-    hsize_t       i;          /*element counter  */
-    char          *s;
-    char          *section;   /*a section of output  */
-    int           secnum;     /*section sequence number */
-    size_t        size;       /*size of each datum  */
-    size_t        ncols = 80; /*available output width */
-    h5tools_str_t buffer;     /*string into which to render */
-    int           multiline;  /*datum was multiline  */
-    hsize_t       curr_pos;   /* total data element position   */
-    int           elmt_counter = 0;/*counts the # elements printed.
-                                    *I (ptl?) needed something that
-                                    *isn't going to get reset when a new
-                                    *line is formed. I'm going to use
-                                    *this var to count elements and
-                                    *break after we see a number equal
-                                    *to the ctx->size_last_dim.   */
+    hsize_t  i;  /*element counter  */
+    char  *s, *section; /*a section of output  */
+    int   secnum;  /*section sequence number */
+    size_t  size;  /*size of each datum  */
+    size_t  ncols = 80; /*available output width */
+    h5tools_str_t buffer;  /*string into which to render */
+    int   multiline; /*datum was multiline  */
+    hsize_t  curr_pos;  /* total data element position   */
+    int                 elmt_counter = 0;/*counts the # elements printed.
+                                          *I (ptl?) needed something that
+                                          *isn't going to get reset when a new
+                                          *line is formed. I'm going to use
+                                          *this var to count elements and
+                                          *break after we see a number equal
+                                          *to the ctx->size_last_dim.   */
 
      /* binary dump */
-    if(bin_output) 
-    {
+    if(bin_output) {
         do_bin_output(stream, nelmts, type, _mem);
+        bin_output = 0;
     } /* end if */
-    else 
-    {
-        /* setup */
+    else {
+        /* Setup */
         HDmemset(&buffer, 0, sizeof(h5tools_str_t));
         size = H5Tget_size(type);
 
@@ -615,7 +613,7 @@ h5tools_dump_simple_data(FILE *stream, const h5tool_format_t *info, hid_t contai
             }
 
             /*
-             * We need to break after each row of a dimension---> we should
+             * We need to break after each row_counter of a dimension---> we should
              * break at the end of the each last dimension well that is the
              * way the dumper did it before
              */
diff --git a/tools/testfiles/h5diff_58.txt b/tools/testfiles/h5diff_58.txt
index b582c88..38d3177 100644
--- a/tools/testfiles/h5diff_58.txt
+++ b/tools/testfiles/h5diff_58.txt
@@ -2,7 +2,7 @@
 Expected output for 'h5diff -v h5diff_dset1.h5 h5diff_dset2.h5 refreg'
 #############################
 dataset: </refreg> and </refreg>
-Referenced dataset      10272            10272
+Referenced dataset      5904            5904
 ------------------------------------------------------------
 Region blocks
 block #0           (2,2)-(7,7)           (0,0)-(2,2)
diff --git a/tools/testfiles/h5diff_70.txt b/tools/testfiles/h5diff_70.txt
index bc9efbe..fe3e03f 100644
--- a/tools/testfiles/h5diff_70.txt
+++ b/tools/testfiles/h5diff_70.txt
@@ -19,15 +19,6 @@ position        string of </>   string of </>   difference
 [ 1 ]          d                z                
 [ 1 ]          e                z                
 4 differences found
-attribute: <VLstring of </>> and <VLstring of </>>
-size:           [2]           [2]
-position        VLstring of </> VLstring of </> difference          
-------------------------------------------------------------
-[ 0 ]          a                z                
-[ 0 ]          b                z                
-[ 1 ]          d                z                
-[ 1 ]          e                z                
-4 differences found
 attribute: <bitfield of </>> and <bitfield of </>>
 size:           [2]           [2]
 position        bitfield of </> bitfield of </> difference          
@@ -108,23 +99,6 @@ position        string2D of </> string2D of </> difference
 [ 2 1 ]          k                z                
 [ 2 1 ]          l                z                
 12 differences found
-attribute: <VLstring2D of </>> and <VLstring2D of </>>
-size:           [3x2]           [3x2]
-position        VLstring2D of </> VLstring2D of </> difference          
-------------------------------------------------------------
-[ 0 0 ]          a                z                
-[ 0 0 ]          b                z                
-[ 0 1 ]          c                z                
-[ 0 1 ]          d                z                
-[ 1 0 ]          e                z                
-[ 1 0 ]          f                z                
-[ 1 1 ]          g                z                
-[ 1 1 ]          h                z                
-[ 2 0 ]          i                z                
-[ 2 0 ]          j                z                
-[ 2 1 ]          k                z                
-[ 2 1 ]          l                z                
-12 differences found
 attribute: <bitfield2D of </>> and <bitfield2D of </>>
 size:           [3x2]           [3x2]
 position        bitfield2D of </> bitfield2D of </> difference          
@@ -288,58 +262,6 @@ position        string3D of </> string3D of </> difference
 [ 3 2 1 ]          X                z                
 [ 3 2 1 ]          Z                z                
 47 differences found
-attribute: <VLstring3D of </>> and <VLstring3D of </>>
-size:           [4x3x2]           [4x3x2]
-position        VLstring3D of </> VLstring3D of </> difference          
-------------------------------------------------------------
-[ 0 0 0 ]          a                z                
-[ 0 0 0 ]          b                z                
-[ 0 0 1 ]          c                z                
-[ 0 0 1 ]          d                z                
-[ 0 1 0 ]          e                z                
-[ 0 1 0 ]          f                z                
-[ 0 1 1 ]          g                z                
-[ 0 1 1 ]          h                z                
-[ 0 2 0 ]          i                z                
-[ 0 2 0 ]          j                z                
-[ 0 2 1 ]          k                z                
-[ 0 2 1 ]          l                z                
-[ 1 0 0 ]          m                z                
-[ 1 0 0 ]          n                z                
-[ 1 0 1 ]          p                z                
-[ 1 0 1 ]          q                z                
-[ 1 1 0 ]          r                z                
-[ 1 1 0 ]          s                z                
-[ 1 1 1 ]          t                z                
-[ 1 1 1 ]          u                z                
-[ 1 2 0 ]          v                z                
-[ 1 2 0 ]          w                z                
-[ 1 2 1 ]          x                z                
-[ 2 0 0 ]          A                z                
-[ 2 0 0 ]          B                z                
-[ 2 0 1 ]          C                z                
-[ 2 0 1 ]          D                z                
-[ 2 1 0 ]          E                z                
-[ 2 1 0 ]          F                z                
-[ 2 1 1 ]          G                z                
-[ 2 1 1 ]          H                z                
-[ 2 2 0 ]          I                z                
-[ 2 2 0 ]          J                z                
-[ 2 2 1 ]          K                z                
-[ 2 2 1 ]          L                z                
-[ 3 0 0 ]          M                z                
-[ 3 0 0 ]          N                z                
-[ 3 0 1 ]          P                z                
-[ 3 0 1 ]          Q                z                
-[ 3 1 0 ]          R                z                
-[ 3 1 0 ]          S                z                
-[ 3 1 1 ]          T                z                
-[ 3 1 1 ]          U                z                
-[ 3 2 0 ]          V                z                
-[ 3 2 0 ]          W                z                
-[ 3 2 1 ]          X                z                
-[ 3 2 1 ]          Z                z                
-47 differences found
 attribute: <bitfield3D of </>> and <bitfield3D of </>>
 size:           [4x3x2]           [4x3x2]
 position        bitfield3D of </> bitfield3D of </> difference          
@@ -690,15 +612,6 @@ position        string of </dset> string of </dset> difference
 [ 1 ]          d                z                
 [ 1 ]          e                z                
 4 differences found
-attribute: <VLstring of </dset>> and <VLstring of </dset>>
-size:           [2]           [2]
-position        VLstring of </dset> VLstring of </dset> difference          
-------------------------------------------------------------
-[ 0 ]          a                z                
-[ 0 ]          b                z                
-[ 1 ]          d                z                
-[ 1 ]          e                z                
-4 differences found
 attribute: <bitfield of </dset>> and <bitfield of </dset>>
 size:           [2]           [2]
 position        bitfield of </dset> bitfield of </dset> difference          
@@ -781,23 +694,6 @@ position        string2D of </dset> string2D of </dset> difference
 [ 2 1 ]          k                z                
 [ 2 1 ]          l                z                
 12 differences found
-attribute: <VLstring2D of </dset>> and <VLstring2D of </dset>>
-size:           [3x2]           [3x2]
-position        VLstring2D of </dset> VLstring2D of </dset> difference          
-------------------------------------------------------------
-[ 0 0 ]          a                z                
-[ 0 0 ]          b                z                
-[ 0 1 ]          c                z                
-[ 0 1 ]          d                z                
-[ 1 0 ]          e                z                
-[ 1 0 ]          f                z                
-[ 1 1 ]          g                z                
-[ 1 1 ]          h                z                
-[ 2 0 ]          i                z                
-[ 2 0 ]          j                z                
-[ 2 1 ]          k                z                
-[ 2 1 ]          l                z                
-12 differences found
 attribute: <bitfield2D of </dset>> and <bitfield2D of </dset>>
 size:           [3x2]           [3x2]
 position        bitfield2D of </dset> bitfield2D of </dset> difference          
@@ -963,58 +859,6 @@ position        string3D of </dset> string3D of </dset> difference
 [ 3 2 1 ]          X                z                
 [ 3 2 1 ]          Z                z                
 47 differences found
-attribute: <VLstring3D of </dset>> and <VLstring3D of </dset>>
-size:           [4x3x2]           [4x3x2]
-position        VLstring3D of </dset> VLstring3D of </dset> difference          
-------------------------------------------------------------
-[ 0 0 0 ]          a                z                
-[ 0 0 0 ]          b                z                
-[ 0 0 1 ]          c                z                
-[ 0 0 1 ]          d                z                
-[ 0 1 0 ]          e                z                
-[ 0 1 0 ]          f                z                
-[ 0 1 1 ]          g                z                
-[ 0 1 1 ]          h                z                
-[ 0 2 0 ]          i                z                
-[ 0 2 0 ]          j                z                
-[ 0 2 1 ]          k                z                
-[ 0 2 1 ]          l                z                
-[ 1 0 0 ]          m                z                
-[ 1 0 0 ]          n                z                
-[ 1 0 1 ]          p                z                
-[ 1 0 1 ]          q                z                
-[ 1 1 0 ]          r                z                
-[ 1 1 0 ]          s                z                
-[ 1 1 1 ]          t                z                
-[ 1 1 1 ]          u                z                
-[ 1 2 0 ]          v                z                
-[ 1 2 0 ]          w                z                
-[ 1 2 1 ]          x                z                
-[ 2 0 0 ]          A                z                
-[ 2 0 0 ]          B                z                
-[ 2 0 1 ]          C                z                
-[ 2 0 1 ]          D                z                
-[ 2 1 0 ]          E                z                
-[ 2 1 0 ]          F                z                
-[ 2 1 1 ]          G                z                
-[ 2 1 1 ]          H                z                
-[ 2 2 0 ]          I                z                
-[ 2 2 0 ]          J                z                
-[ 2 2 1 ]          K                z                
-[ 2 2 1 ]          L                z                
-[ 3 0 0 ]          M                z                
-[ 3 0 0 ]          N                z                
-[ 3 0 1 ]          P                z                
-[ 3 0 1 ]          Q                z                
-[ 3 1 0 ]          R                z                
-[ 3 1 0 ]          S                z                
-[ 3 1 1 ]          T                z                
-[ 3 1 1 ]          U                z                
-[ 3 2 0 ]          V                z                
-[ 3 2 0 ]          W                z                
-[ 3 2 1 ]          X                z                
-[ 3 2 1 ]          Z                z                
-47 differences found
 attribute: <bitfield3D of </dset>> and <bitfield3D of </dset>>
 size:           [4x3x2]           [4x3x2]
 position        bitfield3D of </dset> bitfield3D of </dset> difference          
@@ -1356,7 +1200,7 @@ position        float3D of </dset> float3D of </dset> difference
 [ 3 2 0 ]          23              0               23             
 [ 3 2 1 ]          24              0               24             
 24 differences found
-519 differences found
+456 differences found
 group  : </g1> and </g1>
 0 differences found
 attribute: <string of </g1>> and <string of </g1>>
@@ -1368,15 +1212,6 @@ position        string of </g1> string of </g1> difference
 [ 1 ]          d                z                
 [ 1 ]          e                z                
 4 differences found
-attribute: <VLstring of </g1>> and <VLstring of </g1>>
-size:           [2]           [2]
-position        VLstring of </g1> VLstring of </g1> difference          
-------------------------------------------------------------
-[ 0 ]          a                z                
-[ 0 ]          b                z                
-[ 1 ]          d                z                
-[ 1 ]          e                z                
-4 differences found
 attribute: <bitfield of </g1>> and <bitfield of </g1>>
 size:           [2]           [2]
 position        bitfield of </g1> bitfield of </g1> difference          
@@ -1457,23 +1292,6 @@ position        string2D of </g1> string2D of </g1> difference
 [ 2 1 ]          k                z                
 [ 2 1 ]          l                z                
 12 differences found
-attribute: <VLstring2D of </g1>> and <VLstring2D of </g1>>
-size:           [3x2]           [3x2]
-position        VLstring2D of </g1> VLstring2D of </g1> difference          
-------------------------------------------------------------
-[ 0 0 ]          a                z                
-[ 0 0 ]          b                z                
-[ 0 1 ]          c                z                
-[ 0 1 ]          d                z                
-[ 1 0 ]          e                z                
-[ 1 0 ]          f                z                
-[ 1 1 ]          g                z                
-[ 1 1 ]          h                z                
-[ 2 0 ]          i                z                
-[ 2 0 ]          j                z                
-[ 2 1 ]          k                z                
-[ 2 1 ]          l                z                
-12 differences found
 attribute: <bitfield2D of </g1>> and <bitfield2D of </g1>>
 size:           [3x2]           [3x2]
 position        bitfield2D of </g1> bitfield2D of </g1> difference          
@@ -1637,58 +1455,6 @@ position        string3D of </g1> string3D of </g1> difference
 [ 3 2 1 ]          X                z                
 [ 3 2 1 ]          Z                z                
 47 differences found
-attribute: <VLstring3D of </g1>> and <VLstring3D of </g1>>
-size:           [4x3x2]           [4x3x2]
-position        VLstring3D of </g1> VLstring3D of </g1> difference          
-------------------------------------------------------------
-[ 0 0 0 ]          a                z                
-[ 0 0 0 ]          b                z                
-[ 0 0 1 ]          c                z                
-[ 0 0 1 ]          d                z                
-[ 0 1 0 ]          e                z                
-[ 0 1 0 ]          f                z                
-[ 0 1 1 ]          g                z                
-[ 0 1 1 ]          h                z                
-[ 0 2 0 ]          i                z                
-[ 0 2 0 ]          j                z                
-[ 0 2 1 ]          k                z                
-[ 0 2 1 ]          l                z                
-[ 1 0 0 ]          m                z                
-[ 1 0 0 ]          n                z                
-[ 1 0 1 ]          p                z                
-[ 1 0 1 ]          q                z                
-[ 1 1 0 ]          r                z                
-[ 1 1 0 ]          s                z                
-[ 1 1 1 ]          t                z                
-[ 1 1 1 ]          u                z                
-[ 1 2 0 ]          v                z                
-[ 1 2 0 ]          w                z                
-[ 1 2 1 ]          x                z                
-[ 2 0 0 ]          A                z                
-[ 2 0 0 ]          B                z                
-[ 2 0 1 ]          C                z                
-[ 2 0 1 ]          D                z                
-[ 2 1 0 ]          E                z                
-[ 2 1 0 ]          F                z                
-[ 2 1 1 ]          G                z                
-[ 2 1 1 ]          H                z                
-[ 2 2 0 ]          I                z                
-[ 2 2 0 ]          J                z                
-[ 2 2 1 ]          K                z                
-[ 2 2 1 ]          L                z                
-[ 3 0 0 ]          M                z                
-[ 3 0 0 ]          N                z                
-[ 3 0 1 ]          P                z                
-[ 3 0 1 ]          Q                z                
-[ 3 1 0 ]          R                z                
-[ 3 1 0 ]          S                z                
-[ 3 1 1 ]          T                z                
-[ 3 1 1 ]          U                z                
-[ 3 2 0 ]          V                z                
-[ 3 2 0 ]          W                z                
-[ 3 2 1 ]          X                z                
-[ 3 2 1 ]          Z                z                
-47 differences found
 attribute: <bitfield3D of </g1>> and <bitfield3D of </g1>>
 size:           [4x3x2]           [4x3x2]
 position        bitfield3D of </g1> bitfield3D of </g1> difference          
diff --git a/tools/testfiles/h5diff_80.txt b/tools/testfiles/h5diff_80.txt
index 9c0bd33..90ee5c0 100644
--- a/tools/testfiles/h5diff_80.txt
+++ b/tools/testfiles/h5diff_80.txt
@@ -8,9 +8,6 @@ file1     file2
     x      x    /dset          
     x      x    /dsetref       
     x      x    /g1            
-    x      x    /g1/VLstring   
-    x      x    /g1/VLstring2D 
-    x      x    /g1/VLstring3D 
     x      x    /g1/array      
     x      x    /g1/array2D    
     x      x    /g1/array3D    
@@ -56,84 +53,6 @@ dataset: </dsetref> and </dsetref>
 0 differences found
 group  : </g1> and </g1>
 0 differences found
-dataset: </g1/VLstring> and </g1/VLstring>
-size:           [2]           [2]
-position        VLstring        VLstring        difference          
-------------------------------------------------------------
-[ 0 ]          a                z                
-[ 0 ]          b                z                
-[ 1 ]          d                z                
-[ 1 ]          e                z                
-4 differences found
-dataset: </g1/VLstring2D> and </g1/VLstring2D>
-size:           [3x2]           [3x2]
-position        VLstring2D      VLstring2D      difference          
-------------------------------------------------------------
-[ 0 0 ]          a                z                
-[ 0 0 ]          b                z                
-[ 0 1 ]          c                z                
-[ 0 1 ]          d                z                
-[ 1 0 ]          e                z                
-[ 1 0 ]          f                z                
-[ 1 1 ]          g                z                
-[ 1 1 ]          h                z                
-[ 2 0 ]          i                z                
-[ 2 0 ]          j                z                
-[ 2 1 ]          k                z                
-[ 2 1 ]          l                z                
-12 differences found
-dataset: </g1/VLstring3D> and </g1/VLstring3D>
-size:           [4x3x2]           [4x3x2]
-position        VLstring3D      VLstring3D      difference          
-------------------------------------------------------------
-[ 0 0 0 ]          a                z                
-[ 0 0 0 ]          b                z                
-[ 0 0 1 ]          c                z                
-[ 0 0 1 ]          d                z                
-[ 0 1 0 ]          e                z                
-[ 0 1 0 ]          f                z                
-[ 0 1 1 ]          g                z                
-[ 0 1 1 ]          h                z                
-[ 0 2 0 ]          i                z                
-[ 0 2 0 ]          j                z                
-[ 0 2 1 ]          k                z                
-[ 0 2 1 ]          l                z                
-[ 1 0 0 ]          m                z                
-[ 1 0 0 ]          n                z                
-[ 1 0 1 ]          p                z                
-[ 1 0 1 ]          q                z                
-[ 1 1 0 ]          r                z                
-[ 1 1 0 ]          s                z                
-[ 1 1 1 ]          t                z                
-[ 1 1 1 ]          u                z                
-[ 1 2 0 ]          v                z                
-[ 1 2 0 ]          w                z                
-[ 1 2 1 ]          x                z                
-[ 2 0 0 ]          A                z                
-[ 2 0 0 ]          B                z                
-[ 2 0 1 ]          C                z                
-[ 2 0 1 ]          D                z                
-[ 2 1 0 ]          E                z                
-[ 2 1 0 ]          F                z                
-[ 2 1 1 ]          G                z                
-[ 2 1 1 ]          H                z                
-[ 2 2 0 ]          I                z                
-[ 2 2 0 ]          J                z                
-[ 2 2 1 ]          K                z                
-[ 2 2 1 ]          L                z                
-[ 3 0 0 ]          M                z                
-[ 3 0 0 ]          N                z                
-[ 3 0 1 ]          P                z                
-[ 3 0 1 ]          Q                z                
-[ 3 1 0 ]          R                z                
-[ 3 1 0 ]          S                z                
-[ 3 1 1 ]          T                z                
-[ 3 1 1 ]          U                z                
-[ 3 2 0 ]          V                z                
-[ 3 2 0 ]          W                z                
-[ 3 2 1 ]          X                z                
-[ 3 2 1 ]          Z                z                
-47 differences found
 dataset: </g1/array> and </g1/array>
 size:           [2]           [2]
 position        array           array           difference          
@@ -857,7 +776,7 @@ position        vlen3D          vlen3D          difference
 [ 3 2 1 ]          59              0               59             
 59 differences found
 dataset: </refreg> and </refreg>
-Referenced dataset      10272            10272
+Referenced dataset      5904            5904
 ------------------------------------------------------------
 Region blocks
 block #0           (2,2)-(7,7)           (0,0)-(2,2)
diff --git a/tools/testfiles/h5diff_attr1.h5 b/tools/testfiles/h5diff_attr1.h5
index c44066b..e261486 100644
--- a/tools/testfiles/h5diff_attr1.h5
+++ b/tools/testfiles/h5diff_attr1.h5
diff --git a/tools/testfiles/h5diff_attr2.h5 b/tools/testfiles/h5diff_attr2.h5
index 5de3303..0a59fc5 100644
--- a/tools/testfiles/h5diff_attr2.h5
+++ b/tools/testfiles/h5diff_attr2.h5
diff --git a/tools/testfiles/h5diff_basic2.h5 b/tools/testfiles/h5diff_basic2.h5
index ad45cc0..209485f 100644
--- a/tools/testfiles/h5diff_basic2.h5
+++ b/tools/testfiles/h5diff_basic2.h5
diff --git a/tools/testfiles/h5diff_dset1.h5 b/tools/testfiles/h5diff_dset1.h5
index ab6b96f..3f853be 100644
--- a/tools/testfiles/h5diff_dset1.h5
+++ b/tools/testfiles/h5diff_dset1.h5
diff --git a/tools/testfiles/h5diff_dset2.h5 b/tools/testfiles/h5diff_dset2.h5
index 3db0c8e..1f14d29 100644
--- a/tools/testfiles/h5diff_dset2.h5
+++ b/tools/testfiles/h5diff_dset2.h5
diff --git a/tools/testfiles/tallfilters.ddl b/tools/testfiles/tallfilters.ddl
index 43c27a9..282c085 100644
--- a/tools/testfiles/tallfilters.ddl
+++ b/tools/testfiles/tallfilters.ddl
@@ -7,7 +7,7 @@ DATASET "all" {
    DATASPACE  SIMPLE { ( 20, 10 ) / ( 20, 10 ) }
    STORAGE_LAYOUT {
       CHUNKED ( 10, 5 )
-      SIZE 458 (42.8%COMPRESSION)
+      SIZE 458
     }
    FILTERS {
       PREPROCESSING SHUFFLE
diff --git a/tools/testfiles/tbin4.ddl b/tools/testfiles/tbin4.ddl
index 78a6cd2..89849e4 100644
--- a/tools/testfiles/tbin4.ddl
+++ b/tools/testfiles/tbin4.ddl
@@ -1,7 +1,7 @@
 HDF5 "tbinary.h5" {
 DATASET "double" {
    DATATYPE  H5T_IEEE_F64LE
-   DATASPACE  SIMPLE { ( 6 ) / ( 6 ) }
+   DATASPACE  SIMPLE { ( 100000 ) / ( 100000 ) }
    DATA {
    }
 }
diff --git a/tools/testfiles/tbinary.h5 b/tools/testfiles/tbinary.h5
index adc5b15..691b008 100644
--- a/tools/testfiles/tbinary.h5
+++ b/tools/testfiles/tbinary.h5
diff --git a/tools/testfiles/tdeflate.ddl b/tools/testfiles/tdeflate.ddl
index cc5b49b..fc98432 100644
--- a/tools/testfiles/tdeflate.ddl
+++ b/tools/testfiles/tdeflate.ddl
@@ -7,7 +7,7 @@ DATASET "deflate" {
    DATASPACE  SIMPLE { ( 20, 10 ) / ( 20, 10 ) }
    STORAGE_LAYOUT {
       CHUNKED ( 10, 5 )
-      SIZE 385 (51.9%COMPRESSION)
+      SIZE 385
     }
    FILTERS {
       COMPRESSION DEFLATE { LEVEL 9 }
diff --git a/tools/testfiles/tnbit.ddl b/tools/testfiles/tnbit.ddl
index 2f932b5..a8bf549 100644
--- a/tools/testfiles/tnbit.ddl
+++ b/tools/testfiles/tnbit.ddl
@@ -7,7 +7,7 @@ DATASET "nbit" {
    DATASPACE  SIMPLE { ( 20, 10 ) / ( 20, 10 ) }
    STORAGE_LAYOUT {
       CHUNKED ( 10, 5 )
-      SIZE 76 (90.5%COMPRESSION)
+      SIZE 76
     }
    FILTERS {
       COMPRESSION NBIT
diff --git a/tools/testfiles/tscaleoffset.ddl b/tools/testfiles/tscaleoffset.ddl
index c9a46f4..6693f92 100644
--- a/tools/testfiles/tscaleoffset.ddl
+++ b/tools/testfiles/tscaleoffset.ddl
@@ -7,7 +7,7 @@ DATASET "scaleoffset" {
    DATASPACE  SIMPLE { ( 20, 10 ) / ( 20, 10 ) }
    STORAGE_LAYOUT {
       CHUNKED ( 10, 5 )
-      SIZE 152 (81.0%COMPRESSION)
+      SIZE 152
     }
    FILTERS {
       COMPRESSION SCALEOFFSET { MIN BITS 4 }
diff --git a/tools/testfiles/tszip.ddl b/tools/testfiles/tszip.ddl
index 6411bc3..4c6af47 100644
--- a/tools/testfiles/tszip.ddl
+++ b/tools/testfiles/tszip.ddl
@@ -7,7 +7,7 @@ DATASET "szip" {
    DATASPACE  SIMPLE { ( 20, 10 ) / ( 20, 10 ) }
    STORAGE_LAYOUT {
       CHUNKED ( 10, 5 )
-      SIZE 372 (53.5%COMPRESSION)
+      SIZE 372
     }
    FILTERS {
       COMPRESSION SZIP {