[svn-r16786] merge 16785

added missing test and compare cases inside compounds for nan
tested: linux

2 files changed, 1022 insertions, 673 deletions

diff --git a/tools/h5diff/h5diffgentest.c b/tools/h5diff/h5diffgentest.c
index 92e5493..b07c425 100644
--- a/tools/h5diff/h5diffgentest.c
+++ b/tools/h5diff/h5diffgentest.c
@@ -1,17 +1,17 @@
 /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
- * Copyright by The HDF Group.                                               *
- * Copyright by the Board of Trustees of the University of Illinois.         *
- * All rights reserved.                                                      *
- *                                                                           *
- * This file is part of HDF5.  The full HDF5 copyright notice, including     *
- * terms governing use, modification, and redistribution, is contained in    *
- * the files COPYING and Copyright.html.  COPYING can be found at the root   *
- * of the source code distribution tree; Copyright.html can be found at the  *
- * root level of an installed copy of the electronic HDF5 document set and   *
- * is linked from the top-level documents page.  It can also be found at     *
- * http://hdfgroup.org/HDF5/doc/Copyright.html.  If you do not have          *
- * access to either file, you may request a copy from help@hdfgroup.org.     *
- * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
+* Copyright by The HDF Group.                                               *
+* Copyright by the Board of Trustees of the University of Illinois.         *
+* All rights reserved.                                                      *
+*                                                                           *
+* This file is part of HDF5.  The full HDF5 copyright notice, including     *
+* terms governing use, modification, and redistribution, is contained in    *
+* the files COPYING and Copyright.html.  COPYING can be found at the root   *
+* of the source code distribution tree; Copyright.html can be found at the  *
+* root level of an installed copy of the electronic HDF5 document set and   *
+* is linked from the top-level documents page.  It can also be found at     *
+* http://hdfgroup.org/HDF5/doc/Copyright.html.  If you do not have          *
+* access to either file, you may request a copy from help@hdfgroup.org.     *
+* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
 
 #include <stdio.h>
 #include <stdlib.h>
@@ -21,16 +21,16 @@
 
 
 /*-------------------------------------------------------------------------
- * Program: h5diffgentest
- *
- * Purpose: generate files for h5diff testing
- *
- * Programmer: Pedro Vicente, pvn@ncsa.uiuc.edu
- *
- * Date: November 12, 2003
- *
- *-------------------------------------------------------------------------
- */
+* Program: h5diffgentest
+*
+* Purpose: generate files for h5diff testing
+*
+* Programmer: Pedro Vicente, pvn@ncsa.uiuc.edu
+*
+* Date: November 12, 2003
+*
+*-------------------------------------------------------------------------
+*/
 
 #define FILE1    "h5diff_basic1.h5"
 #define FILE2    "h5diff_basic2.h5"
@@ -51,27 +51,27 @@
 #define MY_LINKCLASS 187
 /* A UD link traversal function.  Shouldn't actually be called. */
 static hid_t UD_traverse(UNUSED const char * link_name, UNUSED hid_t cur_group,
-    UNUSED const void * udata, UNUSED size_t udata_size, UNUSED hid_t lapl_id)
+                         UNUSED const void * udata, UNUSED size_t udata_size, UNUSED hid_t lapl_id)
 {
-return -1;
+    return -1;
 }
 const H5L_class_t UD_link_class[1] = {{
     H5L_LINK_CLASS_T_VERS,    /* H5L_class_t version       */
-    (H5L_type_t)MY_LINKCLASS,             /* Link type id number            */
-    "UD link class",          /* name for debugging             */
-    NULL,                     /* Creation callback              */
-    NULL,                     /* Move/rename callback           */
-    NULL,                     /* Copy callback                  */
-    UD_traverse,              /* The actual traversal function  */
-    NULL,                     /* Deletion callback              */
-    NULL                      /* Query callback                 */
+        (H5L_type_t)MY_LINKCLASS,             /* Link type id number            */
+        "UD link class",          /* name for debugging             */
+        NULL,                     /* Creation callback              */
+        NULL,                     /* Move/rename callback           */
+        NULL,                     /* Copy callback                  */
+        UD_traverse,              /* The actual traversal function  */
+        NULL,                     /* Deletion callback              */
+        NULL                      /* Query callback                 */
 }};
 
 
 /*-------------------------------------------------------------------------
- * prototypes
- *-------------------------------------------------------------------------
- */
+* prototypes
+*-------------------------------------------------------------------------
+*/
 
 /* tests called in main() */
 static int test_basic(const char *fname1, const char *fname2, const char *fname3);
@@ -90,43 +90,43 @@ static int write_dset(hid_t loc_id,int rank,hsize_t *dims,const char *name,hid_t
 
 
 /*-------------------------------------------------------------------------
- * Function: main
- *
- * Purpose: main program
- *
- *-------------------------------------------------------------------------
- */
+* Function: main
+*
+* Purpose: main program
+*
+*-------------------------------------------------------------------------
+*/
 
 int main(void)
 {
     test_basic(FILE1, FILE2, FILE11);
-    
+
     test_types (FILE3);
     test_datatypes(FILE4);
-    
+
     /* generate 2 files, the second call creates a similar file with differences */
     test_attributes(FILE5,0);
     test_attributes(FILE6,1);
-    
+
     /* generate 2 files, the second call creates a similar file with differences */
     test_datasets(FILE7,0);
     test_datasets(FILE8,1);
-    
+
     /* generate 2 files, the second call creates a similar file with differences */
     test_hyperslab(FILE9,0);
     test_hyperslab(FILE10,1);
     return 0;
-    
+
 }
 
 /*-------------------------------------------------------------------------
- * Function: test_basic
- *
- * Purpose: Create basic test files, first two contains different data, the
- * third one is just an empty file.
- *
- *-------------------------------------------------------------------------
- */
+* Function: test_basic
+*
+* Purpose: Create basic test files, first two contains different data, the
+* third one is just an empty file.
+*
+*-------------------------------------------------------------------------
+*/
 
 static
 int test_basic(const char *fname1, const char *fname2, const char *fname3)
@@ -135,7 +135,7 @@ int test_basic(const char *fname1, const char *fname2, const char *fname3)
     hid_t   gid1, gid2, gid3;
     hsize_t dims1[1] = { 6 };
     hsize_t dims2[2] = { 3,2 };
-    
+
     /* create the empty file */
     if ((fid1=H5Fcreate(fname3, H5F_ACC_TRUNC, H5P_DEFAULT, H5P_DEFAULT)) < 0){
         fprintf(stderr, "empty file (%s) creation failed.\n", fname3);
@@ -145,12 +145,12 @@ int test_basic(const char *fname1, const char *fname2, const char *fname3)
         fprintf(stderr, "empty file (%s) close failed.\n", fname3);
         goto out;
     }
-    
+
     /*-------------------------------------------------------------------------
     * create two files
     *-------------------------------------------------------------------------
     */
-    
+
     if (( fid1 = H5Fcreate (fname1, H5F_ACC_TRUNC, H5P_DEFAULT, H5P_DEFAULT)) < 0 )
         goto out;
     if (( fid2 = H5Fcreate (fname2, H5F_ACC_TRUNC, H5P_DEFAULT, H5P_DEFAULT)) < 0 )
@@ -164,7 +164,7 @@ int test_basic(const char *fname1, const char *fname2, const char *fname3)
     gid1 = H5Gcreate2(fid1, "g1", H5P_DEFAULT, H5P_DEFAULT, H5P_DEFAULT);
     gid2 = H5Gcreate2(fid2, "g1", H5P_DEFAULT, H5P_DEFAULT, H5P_DEFAULT);
     gid3 = H5Gcreate2(fid2, "g2", H5P_DEFAULT, H5P_DEFAULT, H5P_DEFAULT);
-    
+
     /*-------------------------------------------------------------------------
     * tests:
     * # 1.1 normal mode
@@ -174,19 +174,19 @@ int test_basic(const char *fname1, const char *fname2, const char *fname3)
     * # 1.5 with -d
     *-------------------------------------------------------------------------
     */
-    
+
     {
         double data1[3][2] = {{1,1},  {1,1},       {0,0}};
         double data2[3][2] = {{0,1.1},{1.01,1.001},{0,1}};
         double data3[3][2] = {{100,100},{100,100},{100,100}};
         double data4[3][2] = {{105,120},{160,95},{80,40}};
-        
+
         write_dset(gid1,2,dims2,"dset1",H5T_NATIVE_DOUBLE,data1);
         write_dset(gid2,2,dims2,"dset2",H5T_NATIVE_DOUBLE,data2);
         write_dset(gid1,2,dims2,"dset3",H5T_NATIVE_DOUBLE,data3);
         write_dset(gid2,2,dims2,"dset4",H5T_NATIVE_DOUBLE,data4);
         write_dset(gid2,2,dims2,"dset1",H5T_NATIVE_DOUBLE,data2);
-        
+
     }
     /*-------------------------------------------------------------------------
     * relative error, compare divide by zero, both zero
@@ -196,12 +196,12 @@ int test_basic(const char *fname1, const char *fname2, const char *fname3)
     {
         int data5[3][2] = {{100,100},{100,0},{0,100}};
         int data6[3][2] = {{120,80}, {0,100},{0,50}};
-        
+
         write_dset(gid1,2,dims2,"dset5",H5T_NATIVE_INT,data5);
         write_dset(gid1,2,dims2,"dset6",H5T_NATIVE_INT,data6);
-        
+
     }
-    
+
     /*-------------------------------------------------------------------------
     * relative error, compare divide by zero, both zero
     * # 1.6.2 with -p (unsigned long long)
@@ -210,12 +210,12 @@ int test_basic(const char *fname1, const char *fname2, const char *fname3)
     {
         unsigned long long data7[3][2] = {{100,100},{100,0},{0,100}};
         unsigned long long data8[3][2] = {{120,80}, {0,100},{0,50}};
-        
+
         write_dset(gid1,2,dims2,"dset7",H5T_NATIVE_ULLONG,data7);
         write_dset(gid1,2,dims2,"dset8",H5T_NATIVE_ULLONG,data8);
-        
+
     }
-    
+
     /*-------------------------------------------------------------------------
     * relative error, compare divide by zero, both zero
     * # 1.6.3 with -p (double)
@@ -232,13 +232,13 @@ int test_basic(const char *fname1, const char *fname2, const char *fname3)
     {
         double data9[3][2] = {{100,100},{100,0},{0,100}};
         double data10[3][2] ={{120,80}, {0,100},{0,50}};
-        
+
         write_dset(gid1,2,dims2,"dset9",H5T_NATIVE_DOUBLE,data9);
         write_dset(gid1,2,dims2,"dset10",H5T_NATIVE_DOUBLE,data10);
-        
+
     }
-    
-    
+
+
     /*-------------------------------------------------------------------------
     * test floating point comparison
     *-------------------------------------------------------------------------
@@ -249,86 +249,124 @@ int test_basic(const char *fname1, const char *fname2, const char *fname3)
         float  data12[3][2] ={{0.00000f,0.00002f},{0.000009f,0.00001f},{0.00000f,0.00001f}};
         double data13[3][2] ={{0.000000000,0.000000001},{0.000000001, 0.000000000},{0.000000001,0.000000001}};
         double data14[3][2] ={{0.000000000,0.000000002},{0.0000000009,0.000000001},{0.000000000,0.000000001}};
-        
+
         write_dset(gid1,2,dims2,"fp1",H5T_NATIVE_FLOAT,data11);
         write_dset(gid1,2,dims2,"fp2",H5T_NATIVE_FLOAT,data12);
         write_dset(gid1,2,dims2,"d1",H5T_NATIVE_DOUBLE,data13);
         write_dset(gid1,2,dims2,"d2",H5T_NATIVE_DOUBLE,data14);
-        
+
     }
-    
-    
+
+
 #if H5_SIZEOF_LONG_DOUBLE !=0
     {
-        
-    /*-------------------------------------------------------------------------
-    * H5T_NATIVE_LDOUBLE
-    *-------------------------------------------------------------------------
+
+        /*-------------------------------------------------------------------------
+        * H5T_NATIVE_LDOUBLE
+        *-------------------------------------------------------------------------
         */
-        
+
         long double data15[3][2] ={{1,1},{1,1},{1,1}};
-        
+
         write_dset(gid1,2,dims2,"ld",H5T_NATIVE_LDOUBLE,data15);
-        
+
     }
 #endif
-    
-    
-    
+
+
+
     /*-------------------------------------------------------------------------
     * NaNs in H5T_NATIVE_FLOAT
     *-------------------------------------------------------------------------
     */
     {
-        
+
         float data15[6];
         float data16[6];
-        
+
         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;
-        
+
         write_dset(gid1,1,dims1,"fp15",H5T_NATIVE_FLOAT,data15);
         write_dset(gid1,1,dims1,"fp16",H5T_NATIVE_FLOAT,data16);
-        
+
     }
-    
+
     /*-------------------------------------------------------------------------
     * NaNs in H5T_NATIVE_DOUBLE
     *-------------------------------------------------------------------------
     */
     {
-        
+
         double data17[6];
         double data18[6];
-        
+
         data17[0] = sqrt( (double)-1 );
         data17[1] = 1;
         data17[2] = sqrt( (double)-1 );
         data17[3] = 1;
         data17[4] = 1;
         data17[5] = 1;
-        
+
         data18[0] = (float) sqrt( (double)-1 );
         data18[1] = (float) sqrt( (double)-1 );
         data18[2] = 1;
         data18[3] = 1;
         data18[4] = 1;
         data18[5] = 1;
-        
+
         write_dset(gid1,1,dims1,"fp17",H5T_NATIVE_DOUBLE,data17);
         write_dset(gid1,1,dims1,"fp18",H5T_NATIVE_DOUBLE,data18);
-        
+
+    }
+
+    /*-------------------------------------------------------------------------
+    * NaNs in H5T_NATIVE_DOUBLE and H5T_NATIVE_FLOAT inside H5T_COMPOUND
+    *-------------------------------------------------------------------------
+    */
+    {
+        typedef struct cmp1_t
+        {
+            double d;
+            float  f;
+        } cmp1_t;
+
+        cmp1_t   buf1[2];
+        cmp1_t   buf2[2];
+        hsize_t  dims[1] = {2};
+        size_t   type_size;
+        hid_t    tid;
+
+        buf1[0].d = sqrt( (double)-1 );
+        buf1[0].f = (float) sqrt( (double)-1 );
+        buf2[0].d = sqrt( (double)-1 );
+        buf2[0].f = (float) sqrt( (double)-1 );
+
+        buf1[1].d = sqrt( (double)-1 );
+        buf1[1].f = (float) sqrt( (double)-1 );
+        buf2[1].d = 0;
+        buf2[1].f = 0;
+
+        type_size = sizeof( cmp1_t );
+        tid = H5Tcreate (H5T_COMPOUND, type_size );
+        H5Tinsert(tid, "d", HOFFSET( cmp1_t, d ), H5T_NATIVE_DOUBLE );
+        H5Tinsert(tid, "f", HOFFSET( cmp1_t, f ), H5T_NATIVE_FLOAT );
+        write_dset(gid1,1,dims,"dset11",tid,buf1);
+        write_dset(gid1,1,dims,"dset12",tid,buf2);
+        H5Tclose(tid);
+
+
     }
 
     /* not comparable objects */
@@ -336,19 +374,19 @@ int test_basic(const char *fname1, const char *fname2, const char *fname3)
 
         typedef struct cmp1_t
         {
-            double       d;
-            int          i;
+            double d;
+            int    i;
         } cmp1_t;
 
         typedef struct cmp2_t
         {
-            int          i;
-            double       d;
+            int    i;
+            double d;
         } cmp2_t;
 
         typedef struct cmp3_t
         {
-            int          i;
+            int i;
         } cmp3_t;
 
         double       data2[6] = {0,0,0,0,0,0};
@@ -363,7 +401,7 @@ int test_basic(const char *fname1, const char *fname2, const char *fname3)
         size_t       type_size;
         hid_t        tid;
 
-        
+
 
         write_dset(gid3,1,dims1,"dset1",H5T_NATIVE_DOUBLE,NULL);
         write_dset(gid3,1,dims1,"dset2",H5T_NATIVE_DOUBLE,data2);
@@ -393,10 +431,10 @@ int test_basic(const char *fname1, const char *fname2, const char *fname3)
         H5Tinsert(tid, "i", HOFFSET( cmp2_t, i ), H5T_NATIVE_INT  );
         write_dset(gid3,1,dims4,"dset9",tid,NULL);
         H5Tclose(tid);
-        
+
     }
-    
-    
+
+
     /*-------------------------------------------------------------------------
     * close
     *-------------------------------------------------------------------------
@@ -407,21 +445,21 @@ int test_basic(const char *fname1, const char *fname2, const char *fname3)
     H5Fclose(fid1);
     H5Fclose(fid2);
     return SUCCEED;
-    
+
 out:
-    
+
     return FAIL;
 }
 
 
 /*-------------------------------------------------------------------------
- * Function: test_types
- *
- * Purpose: Compare different HDF5 object & link types:
- * H5G_DATASET, H5G_TYPE, H5G_GROUP, H5G_LINK, H5G_UDLINK
- *
- *-------------------------------------------------------------------------
- */
+* Function: test_types
+*
+* Purpose: Compare different HDF5 object & link types:
+* H5G_DATASET, H5G_TYPE, H5G_GROUP, H5G_LINK, H5G_UDLINK
+*
+*-------------------------------------------------------------------------
+*/
 static
 int test_types(const char *fname)
 {
@@ -441,19 +479,19 @@ int test_types(const char *fname)
     {
         int    a;
     } s2_t;
-    
+
     /*-------------------------------------------------------------------------
     * Create one file
     *-------------------------------------------------------------------------
     */
     fid1 = H5Fcreate (fname, H5F_ACC_TRUNC, H5P_DEFAULT, H5P_DEFAULT);
-    
+
     /*-------------------------------------------------------------------------
     * H5G_DATASET
     *-------------------------------------------------------------------------
     */
     write_dset(fid1,1,dims,"dset",H5T_NATIVE_INT,0);
-    
+
     /*-------------------------------------------------------------------------
     * H5G_GROUP
     *-------------------------------------------------------------------------
@@ -462,12 +500,12 @@ int test_types(const char *fname)
     status = H5Gclose(gid1);
     gid2 = H5Gcreate2(fid1, "g2", H5P_DEFAULT, H5P_DEFAULT, H5P_DEFAULT);
     status = H5Gclose(gid2);
-    
+
     /*-------------------------------------------------------------------------
     * H5G_TYPE
     *-------------------------------------------------------------------------
     */
-    
+
     /* create and commit datatype 1 */
     tid1 = H5Tcreate(H5T_COMPOUND, sizeof(s1_t));
     H5Tinsert(tid1, "a", HOFFSET(s1_t, a), H5T_NATIVE_INT);
@@ -479,15 +517,15 @@ int test_types(const char *fname)
     H5Tinsert(tid2, "a", HOFFSET(s2_t, a), H5T_NATIVE_INT);
     H5Tcommit2(fid1, "t2", tid2, H5P_DEFAULT, H5P_DEFAULT, H5P_DEFAULT);
     H5Tclose(tid2);
-    
+
     /*-------------------------------------------------------------------------
     * H5G_LINK
     *-------------------------------------------------------------------------
     */
-    
+
     status = H5Lcreate_soft("g1", fid1, "l1", H5P_DEFAULT, H5P_DEFAULT);
     status = H5Lcreate_soft("g2", fid1, "l2", H5P_DEFAULT, H5P_DEFAULT);
-    
+
     /*-------------------------------------------------------------------------
     * H5G_UDLINK
     *-------------------------------------------------------------------------
@@ -495,7 +533,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", (H5L_type_t)MY_LINKCLASS, NULL, (size_t)0, H5P_DEFAULT, H5P_DEFAULT);
-    
+
     /*-------------------------------------------------------------------------
     * Close
     *-------------------------------------------------------------------------
@@ -544,16 +582,16 @@ TOOLTEST h5diff_28.txt file3.h5 file3.h5 -v l1 l2
 */
 
 /*-------------------------------------------------------------------------
- * Function: test_datatypes
- *
- * Purpose: test dataset datatypes
- *
- *-------------------------------------------------------------------------
- */
+* Function: test_datatypes
+*
+* Purpose: test dataset datatypes
+*
+*-------------------------------------------------------------------------
+*/
 static
 int test_datatypes(const char *fname)
 {
-    
+
     hid_t   fid1;
     hsize_t dims[2]={3,2};
     herr_t  status;
@@ -569,114 +607,114 @@ int test_datatypes(const char *fname)
     float   buf5b[3][2] = {{1,1},{3,4},{5,6}};
     double  buf6a[3][2] = {{1,1},{1,1},{1,1}};
     double  buf6b[3][2] = {{1,1},{3,4},{5,6}};
-    
+
     /*unsigned/signed test
     signed char -128 to 127
     unsigned char 0 to 255
     */
     char          buf7a[3][2] = {{-1,-128},{-1,-1},{-1,-1}};
     unsigned char buf7b[3][2] = {{1,128},{1,1},{1,1}};
-    
+
     /* long long test */
     long long            buf8a[3][2] = {{1,1},{1,1},{1,1}};
     long long            buf8b[3][2] = {{1,1},{3,4},{5,6}};
     unsigned long long   buf9a[3][2] = {{1,1},{1,1},{1,1}};
     unsigned long long   buf9b[3][2] = {{1,1},{3,4},{5,6}};
-    
+
     unsigned int    buf10a[3][2] = {{UIMAX,1},{1,1},{1,1}};
     unsigned int    buf10b[3][2] = {{UIMAX-1,1},{3,4},{5,6}};
-    
-    
+
+
     /*-------------------------------------------------------------------------
     * Create a file
     *-------------------------------------------------------------------------
     */
     fid1 = H5Fcreate (fname, H5F_ACC_TRUNC, H5P_DEFAULT, H5P_DEFAULT);
-    
+
     /*-------------------------------------------------------------------------
     * Check for different storage order. Give a warning if they are different
     *-------------------------------------------------------------------------
     */
-    
+
     write_dset(fid1,2,dims,"dset0a",H5T_STD_I16LE,buf2a);
     write_dset(fid1,2,dims,"dset0b",H5T_STD_I32LE,buf3b);
-    
+
     /*-------------------------------------------------------------------------
     * H5T_NATIVE_CHAR
     *-------------------------------------------------------------------------
     */
     write_dset(fid1,2,dims,"dset1a",H5T_NATIVE_CHAR,buf1a);
     write_dset(fid1,2,dims,"dset1b",H5T_NATIVE_CHAR,buf1b);
-    
+
     /*-------------------------------------------------------------------------
     * H5T_NATIVE_SHORT
     *-------------------------------------------------------------------------
     */
     write_dset(fid1,2,dims,"dset2a",H5T_NATIVE_SHORT,buf2a);
     write_dset(fid1,2,dims,"dset2b",H5T_NATIVE_SHORT,buf2b);
-    
+
     /*-------------------------------------------------------------------------
     * H5T_NATIVE_INT
     *-------------------------------------------------------------------------
     */
     write_dset(fid1,2,dims,"dset3a",H5T_NATIVE_INT,buf3a);
     write_dset(fid1,2,dims,"dset3b",H5T_NATIVE_INT,buf3b);
-    
+
     /*-------------------------------------------------------------------------
     * H5T_NATIVE_LONG
     *-------------------------------------------------------------------------
     */
     write_dset(fid1,2,dims,"dset4a",H5T_NATIVE_LONG,buf4a);
     write_dset(fid1,2,dims,"dset4b",H5T_NATIVE_LONG,buf4b);
-    
+
     /*-------------------------------------------------------------------------
     * H5T_NATIVE_FLOAT
     *-------------------------------------------------------------------------
     */
     write_dset(fid1,2,dims,"dset5a",H5T_NATIVE_FLOAT,buf5a);
     write_dset(fid1,2,dims,"dset5b",H5T_NATIVE_FLOAT,buf5b);
-    
+
     /*-------------------------------------------------------------------------
     * H5T_NATIVE_DOUBLE
     *-------------------------------------------------------------------------
     */
-    
+
     write_dset(fid1,2,dims,"dset6a",H5T_NATIVE_DOUBLE,buf6a);
     write_dset(fid1,2,dims,"dset6b",H5T_NATIVE_DOUBLE,buf6b);
-    
+
     /*-------------------------------------------------------------------------
     * H5T_NATIVE_CHAR and H5T_NATIVE_UCHAR
     *-------------------------------------------------------------------------
     */
-    
+
     write_dset(fid1,2,dims,"dset7a",H5T_NATIVE_CHAR,buf7a);
     write_dset(fid1,2,dims,"dset7b",H5T_NATIVE_UCHAR,buf7b);
-    
+
     /*-------------------------------------------------------------------------
     * H5T_NATIVE_LLONG
     *-------------------------------------------------------------------------
     */
-    
+
     write_dset(fid1,2,dims,"dset8a",H5T_NATIVE_LLONG,buf8a);
     write_dset(fid1,2,dims,"dset8b",H5T_NATIVE_LLONG,buf8b);
-    
+
     /*-------------------------------------------------------------------------
     * H5T_NATIVE_ULLONG
     *-------------------------------------------------------------------------
     */
-    
+
     write_dset(fid1,2,dims,"dset9a",H5T_NATIVE_ULLONG,buf9a);
     write_dset(fid1,2,dims,"dset9b",H5T_NATIVE_ULLONG,buf9b);
-    
+
     /*-------------------------------------------------------------------------
     * H5T_NATIVE_INT
     *-------------------------------------------------------------------------
     */
-    
+
     write_dset(fid1,2,dims,"dset10a",H5T_NATIVE_UINT,buf10a);
     write_dset(fid1,2,dims,"dset10b",H5T_NATIVE_UINT,buf10b);
-    
-    
+
+
     /*-------------------------------------------------------------------------
     * Close
     *-------------------------------------------------------------------------
@@ -719,12 +757,12 @@ TOOLTEST h5diff_58.txt file7.h5 file8.h5 -v refreg
 */
 
 /*-------------------------------------------------------------------------
- * Function: test_attributes
- *
- * Purpose: test attributes
- *
- *-------------------------------------------------------------------------
- */
+* Function: test_attributes
+*
+* Purpose: test attributes
+*
+*-------------------------------------------------------------------------
+*/
 static
 int test_attributes(const char *file,
                     int make_diffs /* flag to modify data buffers */)
@@ -736,31 +774,31 @@ int test_attributes(const char *file,
     hid_t   sid;
     hsize_t dims[1]={2};
     herr_t  status;
-    
+
     /* Create a file  */
     if((fid  = H5Fcreate(file, H5F_ACC_TRUNC, H5P_DEFAULT, H5P_DEFAULT)) < 0)
         return -1;
-    
+
     /* Create a 1D dataset */
     sid = H5Screate_simple(1, dims, NULL);
     did = H5Dcreate2(fid, "dset", H5T_NATIVE_INT, sid, H5P_DEFAULT, H5P_DEFAULT, H5P_DEFAULT);
     status = H5Sclose(sid);
     assert(status >= 0);
-    
+
     /* Create groups */
     gid  = H5Gcreate2(fid, "g1", H5P_DEFAULT, H5P_DEFAULT, H5P_DEFAULT);
     root_id   = H5Gopen2(fid, "/", H5P_DEFAULT);
-    
+
     /*-------------------------------------------------------------------------
     * write a series of attributes on the dataset, group, and root group
     *-------------------------------------------------------------------------
     */
-    
+
     write_attr_in(did,"dset",fid,make_diffs);
     write_attr_in(gid,NULL,0,make_diffs);
     write_attr_in(root_id,NULL,0,make_diffs);
-    
-    
+
+
     /* Close */
     status = H5Dclose(did);
     assert(status >= 0);
@@ -768,7 +806,7 @@ int test_attributes(const char *file,
     assert(status >= 0);
     status = H5Gclose(root_id);
     assert(status >= 0);
-    
+
     /* Close file */
     status = H5Fclose(fid);
     assert(status >= 0);
@@ -777,15 +815,15 @@ int test_attributes(const char *file,
 
 
 /*-------------------------------------------------------------------------
- * Function: test_datasets
- *
- * Purpose: Check all HDF5 classes
- * H5T_INTEGER, H5T_FLOAT
- * H5T_TIME, H5T_STRING, H5T_BITFIELD, H5T_OPAQUE, H5T_COMPOUND, H5T_REFERENCE,
- * H5T_ENUM, H5T_VLEN, H5T_ARRAY
- *
- *-------------------------------------------------------------------------
- */
+* Function: test_datasets
+*
+* Purpose: Check all HDF5 classes
+* H5T_INTEGER, H5T_FLOAT
+* H5T_TIME, H5T_STRING, H5T_BITFIELD, H5T_OPAQUE, H5T_COMPOUND, H5T_REFERENCE,
+* H5T_ENUM, H5T_VLEN, H5T_ARRAY
+*
+*-------------------------------------------------------------------------
+*/
 static
 int test_datasets(const char *file,
                   int make_diffs /* flag to modify data buffers */)
@@ -797,37 +835,37 @@ int test_datasets(const char *file,
     hsize_t dims[1]={2};
     herr_t  status;
     int     buf[2]={1,2};
-    
+
     if(make_diffs)
         memset(buf, 0, sizeof buf);
-    
+
     /* Create a file  */
     if((fid = H5Fcreate(file, H5F_ACC_TRUNC, H5P_DEFAULT, H5P_DEFAULT)) < 0)
         return -1;
-    
+
     /* Create a 1D dataset */
     sid = H5Screate_simple(1, dims, NULL);
     did  = H5Dcreate2(fid, "dset", H5T_NATIVE_INT, sid, H5P_DEFAULT, H5P_DEFAULT, H5P_DEFAULT);
     status = H5Dwrite(did, H5T_NATIVE_INT, H5S_ALL, H5S_ALL, H5P_DEFAULT, buf);
     status = H5Sclose(sid);
     assert(status >= 0);
-    
+
     /* Create a group */
     gid  = H5Gcreate2(fid, "g1", H5P_DEFAULT, H5P_DEFAULT, H5P_DEFAULT);
-    
+
     /*-------------------------------------------------------------------------
     * write a series of datasets on the group
     *-------------------------------------------------------------------------
     */
-    
+
     write_dset_in(gid,"/dset",fid,make_diffs);
-    
+
     /* close */
     status = H5Dclose(did);
     assert(status >= 0);
     status = H5Gclose(gid);
     assert(status >= 0);
-    
+
     /* close file */
     status = H5Fclose(fid);
     assert(status >= 0);
@@ -835,12 +873,12 @@ int test_datasets(const char *file,
 }
 
 /*-------------------------------------------------------------------------
- * Function: write_attr_in
- *
- * Purpose: write attributes in LOC_ID (dataset, group, named datatype)
- *
- *-------------------------------------------------------------------------
- */
+* Function: write_attr_in
+*
+* Purpose: write attributes in LOC_ID (dataset, group, named datatype)
+*
+*-------------------------------------------------------------------------
+*/
 static
 void write_attr_in(hid_t loc_id,
                    const char* dset_name, /* for saving reference to dataset*/
@@ -853,20 +891,20 @@ void write_attr_in(hid_t loc_id,
         char   a;
         double b;
     } s_t;
-    
+
     typedef enum
     {
         RED,
-            GREEN
+        GREEN
     } e_t;
-    
+
     hid_t   aid;
     hid_t   sid;
     hid_t   tid;
     herr_t  status;
     int     val, i, j, k, l, n;
     float   f;
-    
+
     /* create 1D attributes with dimension [2], 2 elements */
     hsize_t    dims[1]={2};
     char       buf1[2][STR_SIZE]= {"ab","de"};        /* string */
@@ -880,7 +918,7 @@ void write_attr_in(hid_t loc_id,
     int        buf6[2][3]= {{1,2,3},{4,5,6}};  /* array */
     int        buf7[2]= {1,2};                 /* integer */
     float      buf8[2]= {1,2};                 /* float */
-    
+
     /* 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 */
@@ -893,7 +931,7 @@ void write_attr_in(hid_t loc_id,
     int        buf62[6][3]= {{1,2,3},{4,5,6},{7,8,9},{10,11,12},{13,14,15},{16,17,18}};  /* array */
     int        buf72[3][2]= {{1,2},{3,4},{5,6}};                     /* integer */
     float      buf82[3][2]= {{1,2},{3,4},{5,6}};                     /* float */
-    
+
     /* 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"}},
@@ -909,18 +947,18 @@ void write_attr_in(hid_t loc_id,
     int        buf63[24][3];      /* array */
     int        buf73[4][3][2];    /* integer */
     float      buf83[4][3][2];    /* float */
-    
-    
+
+
     /*-------------------------------------------------------------------------
     * 1D attributes
     *-------------------------------------------------------------------------
     */
-    
+
     /*-------------------------------------------------------------------------
     * H5T_STRING
     *-------------------------------------------------------------------------
     */
-    
+
     if (make_diffs)
     {
         for (i=0; i<2; i++)
@@ -947,19 +985,19 @@ void write_attr_in(hid_t loc_id,
     status  = H5Tset_size(tid, (size_t)STR_SIZE);
     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
     *-------------------------------------------------------------------------
     */
-    
+
     if (make_diffs)
     {
         for (i=0; i<2; i++)
@@ -976,16 +1014,16 @@ void write_attr_in(hid_t loc_id,
     [ 0 ]          1               0               1
     [ 1 ]          2               0               2
     */
-    
+
     tid = H5Tcopy(H5T_STD_B8LE);
     write_attr(loc_id,1,dims,"bitfield",tid,buf2);
     status = H5Tclose(tid);
-    
+
     /*-------------------------------------------------------------------------
     * H5T_OPAQUE
     *-------------------------------------------------------------------------
     */
-    
+
     /*
     buf2[2]= {1,2};
     $h5diff file7.h5 file6.h5 g1 g1 -v
@@ -997,17 +1035,17 @@ void write_attr_in(hid_t loc_id,
     [ 0 ]          1               0               1
     [ 1 ]          2               0               2
     */
-    
+
     tid = H5Tcreate(H5T_OPAQUE, (size_t)1);
     status = H5Tset_tag(tid, "1-byte opaque type"); /* must set this */
     write_attr(loc_id,1,dims,"opaque",tid,buf2);
     status = H5Tclose(tid);
-    
+
     /*-------------------------------------------------------------------------
     * H5T_COMPOUND
     *-------------------------------------------------------------------------
     */
-    
+
     if (make_diffs)
     {
         for (i=0; i<2; i++)
@@ -1015,7 +1053,7 @@ void write_attr_in(hid_t loc_id,
             buf3[i].a=0; buf3[i].b=0;
         }
     }
-    
+
     /*
     buf3[2]= {{1,2},{3,4}};
     $h5diff file7.h5 file6.h5 g1 g1 -v
@@ -1028,13 +1066,13 @@ void write_attr_in(hid_t loc_id,
     [ 1 ]          3               5               2
     [ 1 ]          4               5               1
     */
-    
+
     tid = H5Tcreate (H5T_COMPOUND, sizeof(s_t));
     H5Tinsert(tid, "a", HOFFSET(s_t, a), H5T_NATIVE_CHAR);
     H5Tinsert(tid, "b", HOFFSET(s_t, b), H5T_NATIVE_DOUBLE);
     write_attr(loc_id,1,dims,"compound",tid,buf3);
     status = H5Tclose(tid);
-    
+
     /*-------------------------------------------------------------------------
     * H5T_REFERENCE (H5R_OBJECT object reference)
     *-------------------------------------------------------------------------
@@ -1046,7 +1084,7 @@ void write_attr_in(hid_t loc_id,
         status=H5Rcreate(&buf4[1],fid,dset_name,H5R_OBJECT,-1);
         write_attr(loc_id,1,dims,"reference",H5T_STD_REF_OBJ,buf4);
     }
-    
+
     /*-------------------------------------------------------------------------
     * H5T_ENUM
     *-------------------------------------------------------------------------
@@ -1073,14 +1111,14 @@ void write_attr_in(hid_t loc_id,
     H5Tenum_insert(tid, "GREEN", (val = 1, &val));
     write_attr(loc_id,1,dims,"enum",tid,buf45);
     status = H5Tclose(tid);
-    
+
     /*-------------------------------------------------------------------------
     * H5T_VLEN
     *-------------------------------------------------------------------------
     */
-    
+
     /* Allocate and initialize VL dataset to write */
-    
+
     buf5[0].len = 1;
     buf5[0].p = malloc( 1 * sizeof(int));
     ((int *)buf5[0].p)[0]=1;
@@ -1088,7 +1126,7 @@ void write_attr_in(hid_t loc_id,
     buf5[1].p = malloc( 2 * sizeof(int));
     ((int *)buf5[1].p)[0]=2;
     ((int *)buf5[1].p)[1]=3;
-    
+
     if (make_diffs)
     {
         ((int *)buf5[0].p)[0]=0;
@@ -1104,7 +1142,7 @@ void write_attr_in(hid_t loc_id,
     [ 1 ]          2               0               2
     [ 1 ]          3               0               3
     */
-    
+
     sid = H5Screate_simple(1, dims, NULL);
     tid = H5Tvlen_create(H5T_NATIVE_INT);
     aid = H5Acreate2(loc_id, "vlen", tid, sid, H5P_DEFAULT, H5P_DEFAULT);
@@ -1115,12 +1153,12 @@ void write_attr_in(hid_t loc_id,
     status = H5Aclose(aid);
     status = H5Tclose(tid);
     status = H5Sclose(sid);
-    
+
     /*-------------------------------------------------------------------------
     * H5T_ARRAY
     *-------------------------------------------------------------------------
     */
-    
+
     if (make_diffs)
     {
         for (i=0; i<2; i++)
@@ -1146,12 +1184,12 @@ void write_attr_in(hid_t loc_id,
     tid = H5Tarray_create2(H5T_NATIVE_INT, 1, dimarray);
     write_attr(loc_id, 1, dims, "array", tid, buf6);
     status = H5Tclose(tid);
-    
+
     /*-------------------------------------------------------------------------
     * H5T_INTEGER and H5T_FLOAT
     *-------------------------------------------------------------------------
     */
-    
+
     if (make_diffs)
     {
         for (i=0; i<2; i++)
@@ -1176,13 +1214,13 @@ void write_attr_in(hid_t loc_id,
     */
     write_attr(loc_id,1,dims,"integer",H5T_NATIVE_INT,buf7);
     write_attr(loc_id,1,dims,"float",H5T_NATIVE_FLOAT,buf8);
-    
-    
+
+
     /*-------------------------------------------------------------------------
     * 2D attributes
     *-------------------------------------------------------------------------
     */
-    
+
     /*-------------------------------------------------------------------------
     * H5T_STRING
     *-------------------------------------------------------------------------
@@ -1194,7 +1232,7 @@ void write_attr_in(hid_t loc_id,
                 for (k=0; k<2; k++)
                     buf12[i][j][k]='z';
     }
-    
+
     /*
     buf12[6][2]= {"ab","cd","ef","gh","ij","kl"};
     $h5diff file7.h5 file6.h5 g1 g1 -v
@@ -1214,17 +1252,17 @@ void write_attr_in(hid_t loc_id,
     [ 2 1 ]          k                z
     [ 2 1 ]          l                z
     */
-    
+
     tid = H5Tcopy(H5T_C_S1);
     status  = H5Tset_size(tid, (size_t)STR_SIZE);
     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];
         }
     }
@@ -1232,17 +1270,17 @@ void write_attr_in(hid_t loc_id,
     status  = H5Tset_size(tid, H5T_VARIABLE);
     write_attr(loc_id,2,dims2,"VLstring2D",tid,buf12a);
     status = H5Tclose(tid);
-    
+
     /*-------------------------------------------------------------------------
     * H5T_BITFIELD
     *-------------------------------------------------------------------------
     */
-    
+
     if (make_diffs)
     {
         memset(buf22,0,sizeof buf22);
     }
-    
+
     /*
     buf22[3][2]= {{1,2},{3,4},{5,6}};
     $h5diff file7.h5 file6.h5 g1 g1 -v
@@ -1256,17 +1294,17 @@ void write_attr_in(hid_t loc_id,
     [ 2 0 ]          5               0               5
     [ 2 1 ]          6               0               6
     */
-    
-    
+
+
     tid = H5Tcopy(H5T_STD_B8LE);
     write_attr(loc_id,2,dims2,"bitfield2D",tid,buf22);
     status = H5Tclose(tid);
-    
+
     /*-------------------------------------------------------------------------
     * H5T_OPAQUE
     *-------------------------------------------------------------------------
     */
-    
+
     /*
     buf22[3][2]= {{1,2},{3,4},{5,6}};
     $h5diff file7.h5 file6.h5 g1 g1 -v
@@ -1284,7 +1322,7 @@ void write_attr_in(hid_t loc_id,
     status = H5Tset_tag(tid, "1-byte opaque type"); /* must set this */
     write_attr(loc_id,2,dims2,"opaque2D",tid,buf22);
     status = H5Tclose(tid);
-    
+
     /*-------------------------------------------------------------------------
     * H5T_COMPOUND
     *-------------------------------------------------------------------------
@@ -1293,7 +1331,7 @@ void write_attr_in(hid_t loc_id,
     {
         memset(buf32,0,sizeof buf32);
     }
-    
+
     /*
     buf32[6]= {{1,2},{3,4},{5,6},{7,8},{9,10},{11,12}};
     $h5diff file7.h5 file6.h5 g1 g1 -v
@@ -1307,14 +1345,14 @@ void write_attr_in(hid_t loc_id,
     [ 2 0 ]          5               0               5
     [ 2 1 ]          6               0               6
     */
-    
-    
+
+
     tid = H5Tcreate (H5T_COMPOUND, sizeof(s_t));
     H5Tinsert(tid, "a", HOFFSET(s_t, a), H5T_NATIVE_CHAR);
     H5Tinsert(tid, "b", HOFFSET(s_t, b), H5T_NATIVE_DOUBLE);
     write_attr(loc_id,2,dims2,"compound2D",tid,buf32);
     status = H5Tclose(tid);
-    
+
     /*-------------------------------------------------------------------------
     * H5T_REFERENCE (H5R_OBJECT object reference)
     *-------------------------------------------------------------------------
@@ -1329,7 +1367,7 @@ void write_attr_in(hid_t loc_id,
         }
         write_attr(loc_id,2,dims2,"reference2D",H5T_STD_REF_OBJ,buf42);
     }
-    
+
     /*-------------------------------------------------------------------------
     * H5T_ENUM
     *-------------------------------------------------------------------------
@@ -1341,7 +1379,7 @@ void write_attr_in(hid_t loc_id,
             if (make_diffs) buf452[i][j]=GREEN; else buf452[i][j]=RED;
         }
     }
-    
+
     /*
     Attribute:   <enum2D> and <enum2D>
     position        enum2D of </g1> enum2D of </g1> difference
@@ -1353,18 +1391,18 @@ void write_attr_in(hid_t loc_id,
     [ 2 0 ]          RED              GREEN
     [ 2 1 ]          RED              GREEN
     */
-    
+
     tid = H5Tcreate(H5T_ENUM, sizeof(e_t));
     H5Tenum_insert(tid, "RED",   (val = 0, &val));
     H5Tenum_insert(tid, "GREEN", (val = 1, &val));
     write_attr(loc_id,2,dims2,"enum2D",tid,buf452);
     status = H5Tclose(tid);
-    
+
     /*-------------------------------------------------------------------------
     * H5T_VLEN
     *-------------------------------------------------------------------------
     */
-    
+
     /* Allocate and initialize VL dataset to write */
     n=0;
     for (i = 0; i < 3; i++) {
@@ -1376,7 +1414,7 @@ void write_attr_in(hid_t loc_id,
                 else ((int *)buf52[i][j].p)[l] = n++;
         }
     }
-    
+
     /*
     position        vlen2D of </g1> vlen2D of </g1> difference
     ------------------------------------------------------------
@@ -1392,7 +1430,7 @@ void write_attr_in(hid_t loc_id,
     [ 2 1 ]          10              0               10
     [ 2 1 ]          11              0               11
     */
-    
+
     sid = H5Screate_simple(2, dims2, NULL);
     tid = H5Tvlen_create(H5T_NATIVE_INT);
     aid = H5Acreate2(loc_id, "vlen2D", tid, sid, H5P_DEFAULT, H5P_DEFAULT);
@@ -1403,12 +1441,12 @@ void write_attr_in(hid_t loc_id,
     status = H5Aclose(aid);
     status = H5Tclose(tid);
     status = H5Sclose(sid);
-    
+
     /*-------------------------------------------------------------------------
     * H5T_ARRAY
     *-------------------------------------------------------------------------
     */
-    
+
     if (make_diffs)
     {
         memset(buf62,0,sizeof buf62);
@@ -1442,12 +1480,12 @@ void write_attr_in(hid_t loc_id,
     tid = H5Tarray_create2(H5T_NATIVE_INT, 1, dimarray);
     write_attr(loc_id, 2, dims2, "array2D", tid, buf62);
     status = H5Tclose(tid);
-    
+
     /*-------------------------------------------------------------------------
     * H5T_INTEGER and H5T_FLOAT
     *-------------------------------------------------------------------------
     */
-    
+
     if (make_diffs)
     {
         memset(buf72,0,sizeof buf72);
@@ -1474,21 +1512,21 @@ void write_attr_in(hid_t loc_id,
     [ 2 0 ]          5               0               5
     [ 2 1 ]          6               0               6
     */
-    
+
     write_attr(loc_id,2,dims2,"integer2D",H5T_NATIVE_INT,buf72);
     write_attr(loc_id,2,dims2,"float2D",H5T_NATIVE_FLOAT,buf82);
-    
-    
+
+
     /*-------------------------------------------------------------------------
     * 3D attributes
     *-------------------------------------------------------------------------
     */
-    
+
     /*-------------------------------------------------------------------------
     * H5T_STRING
     *-------------------------------------------------------------------------
     */
-    
+
     if (make_diffs)
     {
         for (i=0; i<4; i++)
@@ -1497,69 +1535,69 @@ void write_attr_in(hid_t loc_id,
                     for (l=0; l<2; l++)
                         buf13[i][j][k][l]='z';
     }
-    
+
     /*
     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"};
-    
-      Attribute:   <string3D> and <string3D>
-      position        string3D of </g1> string3D 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
-    */
-    
+
+    Attribute:   <string3D> and <string3D>
+    position        string3D of </g1> string3D 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
+    */
+
     tid = H5Tcopy(H5T_C_S1);
     status  = H5Tset_size(tid, (size_t)STR_SIZE);
     write_attr(loc_id,3,dims3,"string3D",tid,buf13);
     status = H5Tclose(tid);
-        
+
     for (i=0; i<4; i++)
     {
         for (j=0; j<3; j++)
@@ -1574,12 +1612,12 @@ void write_attr_in(hid_t loc_id,
     status  = H5Tset_size(tid, H5T_VARIABLE);
     write_attr(loc_id,3,dims3,"VLstring3D",tid,buf13a);
     status = H5Tclose(tid);
-    
+
     /*-------------------------------------------------------------------------
     * H5T_BITFIELD
     *-------------------------------------------------------------------------
     */
-    
+
     n=1;
     for (i = 0; i < 4; i++) {
         for (j = 0; j < 3; j++) {
@@ -1589,7 +1627,7 @@ void write_attr_in(hid_t loc_id,
             }
         }
     }
-    
+
     /*
     position        bitfield3D of </g1> bitfield3D of </g1> difference
     ------------------------------------------------------------
@@ -1618,11 +1656,11 @@ void write_attr_in(hid_t loc_id,
     [ 3 2 0 ]          23              0               23
     [ 3 2 1 ]          24              0               24
     */
-    
+
     tid = H5Tcopy(H5T_STD_B8LE);
     write_attr(loc_id,3,dims3,"bitfield3D",tid,buf23);
     status = H5Tclose(tid);
-    
+
     /*-------------------------------------------------------------------------
     * H5T_OPAQUE
     *-------------------------------------------------------------------------
@@ -1631,12 +1669,12 @@ void write_attr_in(hid_t loc_id,
     status = H5Tset_tag(tid, "1-byte opaque type"); /* must set this */
     write_attr(loc_id,3,dims3,"opaque3D",tid,buf23);
     status = H5Tclose(tid);
-    
+
     /*-------------------------------------------------------------------------
     * H5T_COMPOUND
     *-------------------------------------------------------------------------
     */
-    
+
     n=1;
     for (i = 0; i < 4; i++) {
         for (j = 0; j < 3; j++) {
@@ -1703,13 +1741,13 @@ void write_attr_in(hid_t loc_id,
     [ 3 2 1 ]          47              0               47
     [ 3 2 1 ]          48              0               48
     */
-    
+
     tid = H5Tcreate (H5T_COMPOUND, sizeof(s_t));
     H5Tinsert(tid, "a", HOFFSET(s_t, a), H5T_NATIVE_CHAR);
     H5Tinsert(tid, "b", HOFFSET(s_t, b), H5T_NATIVE_DOUBLE);
     write_attr(loc_id,3,dims3,"compound3D",tid,buf33);
     status = H5Tclose(tid);
-    
+
     /*-------------------------------------------------------------------------
     * H5T_REFERENCE (H5R_OBJECT object reference)
     *-------------------------------------------------------------------------
@@ -1725,12 +1763,12 @@ void write_attr_in(hid_t loc_id,
         }
         write_attr(loc_id,3,dims3,"reference3D",H5T_STD_REF_OBJ,buf43);
     }
-    
+
     /*-------------------------------------------------------------------------
     * H5T_ENUM
     *-------------------------------------------------------------------------
     */
-    
+
     for (i = 0; i < 4; i++) {
         for (j = 0; j < 3; j++) {
             for (k = 0; k < 2; k++) {
@@ -1738,7 +1776,7 @@ void write_attr_in(hid_t loc_id,
             }
         }
     }
-    
+
     /*
     position        enum3D of </g1> enum3D of </g1> difference
     ------------------------------------------------------------
@@ -1767,19 +1805,19 @@ void write_attr_in(hid_t loc_id,
     [ 3 2 0 ]          GREEN            RED
     [ 3 2 1 ]          GREEN            RED
     */
-    
-    
+
+
     tid = H5Tcreate(H5T_ENUM, sizeof(e_t));
     H5Tenum_insert(tid, "RED",   (val = 0, &val));
     H5Tenum_insert(tid, "GREEN", (val = 1, &val));
     write_attr(loc_id,3,dims3,"enum3D",tid,buf453);
     status = H5Tclose(tid);
-    
+
     /*-------------------------------------------------------------------------
     * H5T_VLEN
     *-------------------------------------------------------------------------
     */
-    
+
     /* Allocate and initialize VL dataset to write */
     n=0;
     for (i = 0; i < 4; i++) {
@@ -1818,7 +1856,7 @@ void write_attr_in(hid_t loc_id,
     status = H5Aclose(aid);
     status = H5Tclose(tid);
     status = H5Sclose(sid);
-    
+
     /*-------------------------------------------------------------------------
     * H5T_ARRAY
     *-------------------------------------------------------------------------
@@ -1842,11 +1880,11 @@ void write_attr_in(hid_t loc_id,
     [ 0 1 0 ]          7               0               7
     etc
     */
-    
+
     tid = H5Tarray_create2(H5T_NATIVE_INT, 1, dimarray);
     write_attr(loc_id, 3, dims3, "array3D", tid, buf63);
     status = H5Tclose(tid);
-    
+
     /*-------------------------------------------------------------------------
     * H5T_INTEGER and H5T_FLOAT
     *-------------------------------------------------------------------------
@@ -1866,7 +1904,7 @@ void write_attr_in(hid_t loc_id,
             }
         }
     }
-    
+
     /*
     position        integer3D of </g1> integer3D of </g1> difference
     ------------------------------------------------------------
@@ -1889,12 +1927,12 @@ void write_attr_in(hid_t loc_id,
 
 
 /*-------------------------------------------------------------------------
- * Function: write_dset_in
- *
- * Purpose: write datasets in LOC_ID
- *
- *-------------------------------------------------------------------------
- */
+* Function: write_dset_in
+*
+* Purpose: write datasets in LOC_ID
+*
+*-------------------------------------------------------------------------
+*/
 static
 void write_dset_in(hid_t loc_id,
                    const char* dset_name, /* for saving reference to dataset*/
@@ -1907,13 +1945,13 @@ void write_dset_in(hid_t loc_id,
         char   a;
         double b;
     } s_t;
-    
+
     typedef enum
     {
         RED,
         GREEN
     } e_t;
-    
+
     hid_t   did;
     hid_t   sid;
     hid_t   tid;
@@ -1923,7 +1961,7 @@ void write_dset_in(hid_t loc_id,
     float   f;
     int     fillvalue=2;
     int     scalar_data = 2;
-    
+
     /* create 1D attributes with dimension [2], 2 elements */
     hsize_t    dims[1]={2};
     char       buf1[2][STR_SIZE]= {"ab","de"}; /* string */
@@ -1937,7 +1975,7 @@ void write_dset_in(hid_t loc_id,
     int        buf6[2][3]= {{1,2,3},{4,5,6}};  /* array */
     int        buf7[2]= {1,2};                 /* integer */
     float      buf8[2]= {1,2};                 /* float */
-    
+
     /* 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 */
@@ -1949,7 +1987,7 @@ void write_dset_in(hid_t loc_id,
     int        buf62[6][3]= {{1,2,3},{4,5,6},{7,8,9},{10,11,12},{13,14,15},{16,17,18}};  /* array */
     int        buf72[3][2]= {{1,2},{3,4},{5,6}};                     /* integer */
     float      buf82[3][2]= {{1,2},{3,4},{5,6}};                     /* float */
-    
+
     /* 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"}},
@@ -1964,59 +2002,59 @@ void write_dset_in(hid_t loc_id,
     int        buf63[24][3];      /* array */
     int        buf73[4][3][2];    /* integer */
     float      buf83[4][3][2];    /* float */
-    
-    
+
+
     /*-------------------------------------------------------------------------
     * H5S_SCALAR
     *-------------------------------------------------------------------------
     */
-    
-    
-    
+
+
+
     if ( make_diffs )
     {
-        
+
         scalar_data = 1;
     }
-    
+
     /* create a space  */
     sid = H5Screate(H5S_SCALAR);
-    
+
     /* create a dataset */
     did = H5Dcreate2(loc_id, "scalar", H5T_NATIVE_INT, sid, H5P_DEFAULT, H5P_DEFAULT, H5P_DEFAULT);
-    
+
     /* write */
     H5Dwrite(did, H5T_NATIVE_INT, H5S_ALL, H5S_ALL, H5P_DEFAULT, &scalar_data);
-    
+
     /* close */
     H5Dclose(did);
     H5Sclose(sid);
-    
-    
+
+
     /*-------------------------------------------------------------------------
     * 1D
     *-------------------------------------------------------------------------
     */
-    
+
     /*-------------------------------------------------------------------------
     * H5T_STRING
     *-------------------------------------------------------------------------
     */
-    
-    
+
+
     if (make_diffs)
     {
         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);
     write_dset(loc_id,1,dims,"string",tid,buf1);
     status = H5Tclose(tid);
-    
+
     for (i=0; i<2; i++)
     {
         buf1a[i]=buf1[i];
@@ -2025,27 +2063,27 @@ void write_dset_in(hid_t loc_id,
     status  = H5Tset_size(tid, H5T_VARIABLE);
     write_dset(loc_id,1,dims,"VLstring",tid,buf1a);
     status = H5Tclose(tid);
-    
+
     /*-------------------------------------------------------------------------
     * H5T_BITFIELD
     *-------------------------------------------------------------------------
     */
-    
+
     if (make_diffs)
     {
         for (i=0; i<2; i++)
             buf2[i]=buf2[1]=0;
     }
-    
+
     tid = H5Tcopy(H5T_STD_B8LE);
     write_dset(loc_id,1,dims,"bitfield",tid,buf2);
     status = H5Tclose(tid);
-    
+
     /*-------------------------------------------------------------------------
     * H5T_OPAQUE
     *-------------------------------------------------------------------------
     */
-    
+
     if (make_diffs)
     {
         for (i=0; i<2; i++)
@@ -2053,18 +2091,18 @@ void write_dset_in(hid_t loc_id,
             buf3[i].a=0; buf3[i].b=0;
         }
     }
-    
+
     tid = H5Tcreate(H5T_OPAQUE, (size_t)1);
     status = H5Tset_tag(tid, "1-byte opaque type"); /* must set this */
     write_dset(loc_id,1,dims,"opaque",tid,buf2);
     status = H5Tclose(tid);
-    
+
     /*-------------------------------------------------------------------------
     * H5T_COMPOUND
     *-------------------------------------------------------------------------
     */
-    
-    
+
+
     if (make_diffs)
     {
         for (i=0; i<2; i++)
@@ -2072,13 +2110,13 @@ void write_dset_in(hid_t loc_id,
             buf45[i]=GREEN;
         }
     }
-    
+
     tid = H5Tcreate (H5T_COMPOUND, sizeof(s_t));
     H5Tinsert(tid, "a", HOFFSET(s_t, a), H5T_NATIVE_CHAR);
     H5Tinsert(tid, "b", HOFFSET(s_t, b), H5T_NATIVE_DOUBLE);
     write_dset(loc_id,1,dims,"compound",tid,buf3);
     status = H5Tclose(tid);
-    
+
     /*-------------------------------------------------------------------------
     * H5T_REFERENCE (H5R_OBJECT object reference)
     *-------------------------------------------------------------------------
@@ -2090,14 +2128,14 @@ void write_dset_in(hid_t loc_id,
         status=H5Rcreate(&buf4[1],fid,dset_name,H5R_OBJECT,-1);
         write_dset(loc_id,1,dims,"reference",H5T_STD_REF_OBJ,buf4);
     }
-    
+
     /*-------------------------------------------------------------------------
     * H5T_REFERENCE (H5R_DATASET_REGION dataset region reference)
     *-------------------------------------------------------------------------
     */
-    
+
     gen_datareg(fid,make_diffs);
-    
+
     /*-------------------------------------------------------------------------
     * H5T_ENUM
     *-------------------------------------------------------------------------
@@ -2107,14 +2145,14 @@ void write_dset_in(hid_t loc_id,
     H5Tenum_insert(tid, "GREEN", (val = 1, &val));
     write_dset(loc_id,1,dims,"enum",tid,buf45);
     status = H5Tclose(tid);
-    
+
     /*-------------------------------------------------------------------------
     * H5T_VLEN
     *-------------------------------------------------------------------------
     */
-    
+
     /* Allocate and initialize VL dataset to write */
-    
+
     buf5[0].len = 1;
     buf5[0].p = malloc( 1 * sizeof(int));
     ((int *)buf5[0].p)[0]=1;
@@ -2122,13 +2160,13 @@ void write_dset_in(hid_t loc_id,
     buf5[1].p = malloc( 2 * sizeof(int));
     ((int *)buf5[1].p)[0]=2;
     ((int *)buf5[1].p)[1]=3;
-    
+
     if(make_diffs) {
         ((int *)buf5[0].p)[0] = 0;
         ((int *)buf5[1].p)[0] = 0;
         ((int *)buf5[1].p)[1]=0;
     }
-    
+
     sid = H5Screate_simple(1, dims, NULL);
     tid = H5Tvlen_create(H5T_NATIVE_INT);
     did = H5Dcreate2(loc_id, "vlen", tid, sid, H5P_DEFAULT, H5P_DEFAULT, H5P_DEFAULT);
@@ -2139,12 +2177,12 @@ void write_dset_in(hid_t loc_id,
     status = H5Dclose(did);
     status = H5Tclose(tid);
     status = H5Sclose(sid);
-    
+
     /*-------------------------------------------------------------------------
     * H5T_ARRAY
     *-------------------------------------------------------------------------
     */
-    
+
     if (make_diffs)
     {
         for (i=0; i<2; i++)
@@ -2153,7 +2191,7 @@ void write_dset_in(hid_t loc_id,
                 buf6[i][j]=0;
             }
     }
-    
+
     tid = H5Tarray_create2(H5T_NATIVE_INT, 1, dimarray);
     write_dset(loc_id, 1, dims, "array", tid, buf6);
     status = H5Tclose(tid);
@@ -2202,7 +2240,7 @@ void write_dset_in(hid_t loc_id,
     * H5T_INTEGER and H5T_FLOAT
     *-------------------------------------------------------------------------
     */
-    
+
     if (make_diffs)
     {
         for (i=0; i<2; i++)
@@ -2211,21 +2249,21 @@ void write_dset_in(hid_t loc_id,
             buf8[i]=0;
         }
     }
-    
+
     write_dset(loc_id,1,dims,"integer",H5T_NATIVE_INT,buf7);
     write_dset(loc_id,1,dims,"float",H5T_NATIVE_FLOAT,buf8);
-    
-    
+
+
     /*-------------------------------------------------------------------------
     * 2D
     *-------------------------------------------------------------------------
     */
-    
+
     /*-------------------------------------------------------------------------
     * H5T_STRING
     *-------------------------------------------------------------------------
     */
-    
+
     if (make_diffs)
     {
         for (i=0; i<3; i++)
@@ -2233,13 +2271,13 @@ void write_dset_in(hid_t loc_id,
                 for (k=0; k<2; k++)
                     buf12[i][j][k]='z';
     }
-    
-    
+
+
     tid = H5Tcopy(H5T_C_S1);
     status  = H5Tset_size(tid,(size_t)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++)
@@ -2251,22 +2289,22 @@ void write_dset_in(hid_t loc_id,
     status  = H5Tset_size(tid, H5T_VARIABLE);
     write_dset(loc_id,2,dims2,"VLstring2D",tid,buf12a);
     status = H5Tclose(tid);
-    
+
     /*-------------------------------------------------------------------------
     * H5T_BITFIELD
     *-------------------------------------------------------------------------
     */
-    
-    
+
+
     if (make_diffs)
     {
         memset(buf22,0,sizeof buf22);
     }
-    
+
     tid = H5Tcopy(H5T_STD_B8LE);
     write_dset(loc_id,2,dims2,"bitfield2D",tid,buf22);
     status = H5Tclose(tid);
-    
+
     /*-------------------------------------------------------------------------
     * H5T_OPAQUE
     *-------------------------------------------------------------------------
@@ -2275,23 +2313,23 @@ void write_dset_in(hid_t loc_id,
     status = H5Tset_tag(tid, "1-byte opaque type"); /* must set this */
     write_dset(loc_id,2,dims2,"opaque2D",tid,buf22);
     status = H5Tclose(tid);
-    
+
     /*-------------------------------------------------------------------------
     * H5T_COMPOUND
     *-------------------------------------------------------------------------
     */
-    
+
     if (make_diffs)
     {
         memset(buf32,0,sizeof buf32);
     }
-    
+
     tid = H5Tcreate (H5T_COMPOUND, sizeof(s_t));
     H5Tinsert(tid, "a", HOFFSET(s_t, a), H5T_NATIVE_CHAR);
     H5Tinsert(tid, "b", HOFFSET(s_t, b), H5T_NATIVE_DOUBLE);
     write_dset(loc_id,2,dims2,"compound2D",tid,buf32);
     status = H5Tclose(tid);
-    
+
     /*-------------------------------------------------------------------------
     * H5T_REFERENCE (H5R_OBJECT object reference)
     *-------------------------------------------------------------------------
@@ -2306,23 +2344,23 @@ void write_dset_in(hid_t loc_id,
         }
         write_dset(loc_id,2,dims2,"reference2D",H5T_STD_REF_OBJ,buf42);
     }
-    
+
     /*-------------------------------------------------------------------------
     * H5T_ENUM
     *-------------------------------------------------------------------------
     */
-    
+
     tid = H5Tcreate(H5T_ENUM, sizeof(e_t));
     H5Tenum_insert(tid, "RED",   (val = 0, &val));
     H5Tenum_insert(tid, "GREEN", (val = 1, &val));
     write_dset(loc_id,2,dims2,"enum2D",tid,0);
     status = H5Tclose(tid);
-    
+
     /*-------------------------------------------------------------------------
     * H5T_VLEN
     *-------------------------------------------------------------------------
     */
-    
+
     /* Allocate and initialize VL dataset to write */
     n = 0;
     for(i = 0; i < 3; i++)
@@ -2340,7 +2378,7 @@ void write_dset_in(hid_t loc_id,
             }
         }
     }
-    
+
     sid = H5Screate_simple(2, dims2, NULL);
     tid = H5Tvlen_create(H5T_NATIVE_INT);
     did = H5Dcreate2(loc_id, "vlen2D", tid, sid, H5P_DEFAULT, H5P_DEFAULT, H5P_DEFAULT);
@@ -2351,35 +2389,35 @@ void write_dset_in(hid_t loc_id,
     status = H5Dclose(did);
     status = H5Tclose(tid);
     status = H5Sclose(sid);
-    
+
     /*-------------------------------------------------------------------------
     * H5T_ARRAY
     *-------------------------------------------------------------------------
     */
-    
+
     if (make_diffs)
     {
         memset(buf62,0,sizeof buf62);
     }
-    
-    
+
+
     tid = H5Tarray_create2(H5T_NATIVE_INT, 1, dimarray);
     write_dset(loc_id, 2, dims2, "array2D", tid, buf62);
     status = H5Tclose(tid);
-    
+
     /*-------------------------------------------------------------------------
     * H5T_INTEGER, write a fill value
     *-------------------------------------------------------------------------
     */
-    
-    
+
+
     if (make_diffs) 
     {
         memset(buf72, 0, sizeof buf72);
         memset(buf82, 0, sizeof buf82);
     }
-    
-    
+
+
     dcpl = H5Pcreate(H5P_DATASET_CREATE);
     status = H5Pset_fill_value(dcpl, H5T_NATIVE_INT, &fillvalue);
     sid = H5Screate_simple(2, dims2, NULL);
@@ -2388,25 +2426,25 @@ void write_dset_in(hid_t loc_id,
     status = H5Pclose(dcpl);
     status = H5Dclose(did);
     status = H5Sclose(sid);
-    
+
     /*-------------------------------------------------------------------------
     * H5T_FLOAT
     *-------------------------------------------------------------------------
     */
-    
+
     write_dset(loc_id,2,dims2,"float2D",H5T_NATIVE_FLOAT,buf82);
-    
-    
+
+
     /*-------------------------------------------------------------------------
     * 3D
     *-------------------------------------------------------------------------
     */
-    
+
     /*-------------------------------------------------------------------------
     * H5T_STRING
     *-------------------------------------------------------------------------
     */
-    
+
     if (make_diffs)
     {
         for (i=0; i<4; i++)
@@ -2415,12 +2453,12 @@ void write_dset_in(hid_t loc_id,
                     for (l=0; l<2; l++)
                         buf13[i][j][k][l]='z';
     }
-    
+
     tid = H5Tcopy(H5T_C_S1);
     status  = H5Tset_size(tid,(size_t)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++)
@@ -2435,13 +2473,13 @@ void write_dset_in(hid_t loc_id,
     status  = H5Tset_size(tid, H5T_VARIABLE);
     write_dset(loc_id,3,dims3,"VLstring3D",tid,buf13a);
     status = H5Tclose(tid);
-    
+
     /*-------------------------------------------------------------------------
     * H5T_BITFIELD
     *-------------------------------------------------------------------------
     */
-    
-    
+
+
     n=1;
     for (i = 0; i < 4; i++) 
     {
@@ -2455,12 +2493,12 @@ void write_dset_in(hid_t loc_id,
             }
         }
     }
-    
-    
+
+
     tid = H5Tcopy(H5T_STD_B8LE);
     write_dset(loc_id,3,dims3,"bitfield3D",tid,buf23);
     status = H5Tclose(tid);
-    
+
     /*-------------------------------------------------------------------------
     * H5T_OPAQUE
     *-------------------------------------------------------------------------
@@ -2469,12 +2507,12 @@ void write_dset_in(hid_t loc_id,
     status = H5Tset_tag(tid, "1-byte opaque type"); /* must set this */
     write_dset(loc_id,3,dims3,"opaque3D",tid,buf23);
     status = H5Tclose(tid);
-    
+
     /*-------------------------------------------------------------------------
     * H5T_COMPOUND
     *-------------------------------------------------------------------------
     */
-    
+
     n=1;
     for (i = 0; i < 4; i++) 
     {
@@ -2494,14 +2532,14 @@ void write_dset_in(hid_t loc_id,
             }
         }
     }
-    
-    
+
+
     tid = H5Tcreate (H5T_COMPOUND, sizeof(s_t));
     H5Tinsert(tid, "a", HOFFSET(s_t, a), H5T_NATIVE_CHAR);
     H5Tinsert(tid, "b", HOFFSET(s_t, b), H5T_NATIVE_DOUBLE);
     write_dset(loc_id,3,dims3,"compound3D",tid,buf33);
     status = H5Tclose(tid);
-    
+
     /*-------------------------------------------------------------------------
     * H5T_REFERENCE (H5R_OBJECT object reference)
     *-------------------------------------------------------------------------
@@ -2517,23 +2555,23 @@ void write_dset_in(hid_t loc_id,
         }
         write_dset(loc_id,3,dims3,"reference3D",H5T_STD_REF_OBJ,buf43);
     }
-    
+
     /*-------------------------------------------------------------------------
     * H5T_ENUM
     *-------------------------------------------------------------------------
     */
-    
+
     tid = H5Tcreate(H5T_ENUM, sizeof(e_t));
     H5Tenum_insert(tid, "RED",   (val = 0, &val));
     H5Tenum_insert(tid, "GREEN", (val = 1, &val));
     write_dset(loc_id,3,dims3,"enum3D",tid,0);
     status = H5Tclose(tid);
-    
+
     /*-------------------------------------------------------------------------
     * H5T_VLEN
     *-------------------------------------------------------------------------
     */
-    
+
     /* Allocate and initialize VL dataset to write */
     n=0;
     for(i = 0; i < 4; i++)
@@ -2554,7 +2592,7 @@ void write_dset_in(hid_t loc_id,
             }
         }
     }
-    
+
     sid = H5Screate_simple(3, dims3, NULL);
     tid = H5Tvlen_create(H5T_NATIVE_INT);
     did = H5Dcreate2(loc_id, "vlen3D", tid, sid, H5P_DEFAULT, H5P_DEFAULT, H5P_DEFAULT);
@@ -2565,13 +2603,13 @@ void write_dset_in(hid_t loc_id,
     status = H5Dclose(did);
     status = H5Tclose(tid);
     status = H5Sclose(sid);
-    
+
     /*-------------------------------------------------------------------------
     * H5T_ARRAY
     *-------------------------------------------------------------------------
     */
-    
-    
+
+
     n=1;
     for (i = 0; i < 24; i++) {
         for (j = 0; j < (int)dimarray[0]; j++) {
@@ -2579,11 +2617,11 @@ void write_dset_in(hid_t loc_id,
             else buf63[i][j]=n++;
         }
     }
-    
+
     tid = H5Tarray_create2(H5T_NATIVE_INT, 1, dimarray);
     write_dset(loc_id, 3, dims3, "array3D", tid, buf63);
     status = H5Tclose(tid);
-    
+
     /*-------------------------------------------------------------------------
     * H5T_INTEGER and H5T_FLOAT
     *-------------------------------------------------------------------------
@@ -2608,14 +2646,14 @@ void write_dset_in(hid_t loc_id,
 }
 
 /*-------------------------------------------------------------------------
- * Function: gen_datareg
- *
- * Purpose: generate a dataset region and its reference
- *
- * Date: April 19, 2006
- *
- *-------------------------------------------------------------------------
- */
+* Function: gen_datareg
+*
+* Purpose: generate a dataset region and its reference
+*
+* Date: April 19, 2006
+*
+*-------------------------------------------------------------------------
+*/
 
 static
 void gen_datareg(hid_t fid,
@@ -2636,44 +2674,44 @@ void gen_datareg(hid_t fid,
     hsize_t         coord[5][2];       /* coordinates for point selection */
     herr_t          status;
     int             i;
-    
+
     /* allocate the buffer for write the references */
     rbuf = calloc((size_t)2, sizeof(hdset_reg_ref_t));
-    
+
     /* allocate the buffer for write the data dataset */
     buf = malloc(10 * 10 * sizeof(int));
-    
+
     for(i = 0; i < 10 * 10; i++)
         buf[i] = i;
-    
+
     /* create the data dataset */
     sid1   = H5Screate_simple(2, dims1, NULL);
     did1   = H5Dcreate2(fid, "dsetref", H5T_NATIVE_INT, sid1, H5P_DEFAULT, H5P_DEFAULT, H5P_DEFAULT);
     status = H5Dwrite(did1, H5T_NATIVE_INT, H5S_ALL, H5S_ALL, H5P_DEFAULT, buf);
     assert(status >= 0);
-    
+
     /* create the reference dataset */
     sid2   = H5Screate_simple(1, dims2, NULL);
     did2   = H5Dcreate2(fid, "refreg", H5T_STD_REF_DSETREG, sid2, H5P_DEFAULT, H5P_DEFAULT, H5P_DEFAULT);
-    
+
     /* create the references */
     /* select hyperslab for first reference */
-    
+
     start[0] = 2; start[1] = 2;
     count[0] = 6; count[1] = 6;
     if(make_diffs) {
         start[0] = 0; start[1] = 0;
         count[0] = 3; count[1] = 3;
     }
-    
+
     status = H5Sselect_hyperslab(sid1, H5S_SELECT_SET, start, NULL, count, NULL);
     assert(status >= 0);
     H5Sget_select_npoints(sid1);
-    
+
     /* store first dataset region */
     status = H5Rcreate(&rbuf[0], fid, "dsetref", H5R_DATASET_REGION, sid1);
     assert(status >= 0);
-    
+
     /* select sequence of five points for second reference */
     coord[0][0]=6; coord[0][1]=9;
     coord[1][0]=2; coord[1][1]=2;
@@ -2688,14 +2726,14 @@ void gen_datareg(hid_t fid,
     }
     H5Sselect_elements(sid1,H5S_SELECT_SET,(size_t)5,(const hsize_t *)coord);
     H5Sget_select_npoints(sid1);
-    
+
     /* store second dataset region */
     H5Rcreate(&rbuf[1],fid,"dsetref",H5R_DATASET_REGION,sid1);
-    
+
     /* write */
     status = H5Dwrite(did2,H5T_STD_REF_DSETREG,H5S_ALL,H5S_ALL,H5P_DEFAULT,rbuf);
     assert(status >= 0);
-    
+
     /* close, free memory buffers */
     status = H5Dclose(did1);
     assert(status >= 0);
@@ -2712,13 +2750,13 @@ void gen_datareg(hid_t fid,
 
 
 /*-------------------------------------------------------------------------
- * Function: test_hyperslab
- *
- * Purpose: test diff by hyperslabs. create a dataset with 1GB dimensions
- *  by iterating trough 1KB hyperslabs
- *
- *-------------------------------------------------------------------------
- */
+* Function: test_hyperslab
+*
+* Purpose: test diff by hyperslabs. create a dataset with 1GB dimensions
+*  by iterating trough 1KB hyperslabs
+*
+*-------------------------------------------------------------------------
+*/
 static
 int test_hyperslab(const char *fname,
                    int make_diffs /* flag to modify data buffers */)
@@ -2739,7 +2777,7 @@ int test_hyperslab(const char *fname,
     char    *buf=NULL;
     int     i, j, s;
     char    c;
-    
+
     /* create */
     fid = H5Fcreate(fname, H5F_ACC_TRUNC, H5P_DEFAULT, H5P_DEFAULT);
     if((dcpl = H5Pcreate(H5P_DATASET_CREATE)) < 0)
@@ -2758,7 +2796,7 @@ int test_hyperslab(const char *fname,
         goto out;
     if((size = H5Tget_size(tid)) <= 0)
         goto out;
-    
+
     /* create a evenly divided buffer from 0 to 127  */
     buf = (char *)HDmalloc((size_t)(nelmts * size));
     s = 1024 * 1024 / 127;
@@ -2767,29 +2805,29 @@ int test_hyperslab(const char *fname,
             c++;
             j = 0;
         }
-        
+
         /* set the hyperslab values */
         HDmemset(buf, c, nelmts);
-        
+
         /* make a different hyperslab at this position */
         if(make_diffs && i == 512 * 512)
             HDmemset(buf, 0, nelmts);
-        
+
         hs_start[0] = i * GBLL/(1024*1024);
         if (H5Sselect_hyperslab (f_sid,H5S_SELECT_SET,hs_start,NULL,hs_size, NULL) < 0)
             goto out;
-        
+
         /* write only one hyperslab */
         if ( i==512*512)
         {
             if (H5Dwrite (did,H5T_NATIVE_CHAR,m_sid,f_sid,H5P_DEFAULT,buf) < 0)
                 goto out;
         }
-        
+
     }
     free(buf);
     buf=NULL;
-    
+
     /* close */
     if(H5Sclose(f_sid) < 0)
         goto out;
@@ -2800,9 +2838,9 @@ int test_hyperslab(const char *fname,
     if(H5Dclose(did) < 0)
         goto out;
     H5Fclose(fid);
-    
+
     return 0;
-    
+
 out:
     H5E_BEGIN_TRY {
         H5Pclose(dcpl);
@@ -2812,17 +2850,17 @@ out:
         H5Fclose(fid);
     } H5E_END_TRY;
     return -1;
-    
+
 }
 
 
 /*-------------------------------------------------------------------------
- * Function: write_attr
- *
- * Purpose: utility function to write an attribute in LOC_ID
- *
- *-------------------------------------------------------------------------
- */
+* Function: write_attr
+*
+* Purpose: utility function to write an attribute in LOC_ID
+*
+*-------------------------------------------------------------------------
+*/
 static
 int write_attr(hid_t loc_id,
                int rank,
@@ -2863,19 +2901,19 @@ out:
 }
 
 /*-------------------------------------------------------------------------
- * Function: write_dset
- *
- * Purpose: utility function to create and write a dataset in LOC_ID
- *
- *-------------------------------------------------------------------------
- */
+* Function: write_dset
+*
+* Purpose: utility function to create and write a dataset in LOC_ID
+*
+*-------------------------------------------------------------------------
+*/
 static
 int write_dset( hid_t loc_id,
-                int rank,
-                hsize_t *dims,
-                const char *name,
-                hid_t tid,
-                void *buf )
+               int rank,
+               hsize_t *dims,
+               const char *name,
+               hid_t tid,
+               void *buf )
 {
     hid_t   did=-1;
     hid_t   sid=-1;
diff --git a/tools/lib/h5diff_array.c b/tools/lib/h5diff_array.c
index c1b3f0e..2cda3ba 100644
--- a/tools/lib/h5diff_array.c
+++ b/tools/lib/h5diff_array.c
@@ -274,12 +274,10 @@ hsize_t diff_array( void *_mem1,
                 nfound=diff_float(mem1,mem2,nelmts,hyper_start,rank,dims,acc,pos,options,name1,name2,&ph);
             else if (H5Tequal(m_type, H5T_NATIVE_DOUBLE))
                 nfound=diff_double(mem1,mem2,nelmts,hyper_start,rank,dims,acc,pos,options,name1,name2,&ph);
-
 #if H5_SIZEOF_LONG_DOUBLE !=0
             else if (H5Tequal(m_type, H5T_NATIVE_LDOUBLE))
                 nfound=diff_ldouble(mem1,mem2,nelmts,hyper_start,rank,dims,acc,pos,options,name1,name2,&ph);
-#endif
-            
+#endif            
             break;
 
         case H5T_INTEGER:
@@ -1843,7 +1841,8 @@ hsize_t diff_datum(void       *_mem1,
                     isnan2 = my_isnan(FLT_FLOAT,&temp2_float);
                 }
 
-                if ( !isnan1 && !isnan2)
+                 /* both not NaN, do the comparison */
+                if ( isnan1==0 && isnan2==0)
                 {
 
                     if (ABS(temp1_float-temp2_float) > options->delta)
@@ -1857,7 +1856,19 @@ hsize_t diff_datum(void       *_mem1,
                         nfound++;
                     }
 
-                } /* NaN */
+                } 
+                /* one is NaN, assume difference */
+                else if ( isnan1==1 || isnan2==1)
+                {
+                    if ( print_data(options) )
+                    {
+                        print_pos(ph,0,i,acc,pos,rank,dims,obj1,obj2);
+                        parallel_print(SPACES);
+                        parallel_print(F_FORMAT,temp1_float,temp2_float,ABS(temp1_float-temp2_float));
+                    }
+                    nfound++;
+
+                }
             }
            /*-------------------------------------------------------------------------
             * !-d and -p
@@ -1876,7 +1887,8 @@ hsize_t diff_datum(void       *_mem1,
                     isnan2 = my_isnan(FLT_FLOAT,&temp2_float);
                 }
 
-                if ( !isnan1 && !isnan2)
+                /* both not NaN, do the comparison */
+                if ( isnan1==0 && isnan2==0)
                 {
 
                     PER(temp1_float,temp2_float);
@@ -1907,7 +1919,19 @@ hsize_t diff_datum(void       *_mem1,
                             nfound++;
                         }
 
-                } /* NaN */
+                } 
+                /* one is NaN, assume difference */
+                else if ( isnan1==1 || isnan2==1)
+                {
+                    if ( print_data(options) )
+                    {
+                        print_pos(ph,0,i,acc,pos,rank,dims,obj1,obj2);
+                        parallel_print(SPACES);
+                        parallel_print(F_FORMAT,temp1_float,temp2_float,ABS(temp1_float-temp2_float));
+                    }
+                    nfound++;
+
+                }
             }
 
            /*-------------------------------------------------------------------------
@@ -1928,7 +1952,8 @@ hsize_t diff_datum(void       *_mem1,
                     isnan2 = my_isnan(FLT_FLOAT,&temp2_float);
                 }
 
-                if ( !isnan1 && !isnan2)
+                 /* both not NaN, do the comparison */
+                if ( isnan1==0 && isnan2==0)
                 {
 
                     PER(temp1_float,temp2_float);
@@ -1960,7 +1985,19 @@ hsize_t diff_datum(void       *_mem1,
                             nfound++;
                         }
 
-                } /* NaN */
+                } 
+                /* one is NaN, assume difference */
+                else if ( isnan1==1 || isnan2==1)
+                {
+                    if ( print_data(options) )
+                    {
+                        print_pos(ph,0,i,acc,pos,rank,dims,obj1,obj2);
+                        parallel_print(SPACES);
+                        parallel_print(F_FORMAT,temp1_float,temp2_float,ABS(temp1_float-temp2_float));
+                    }
+                    nfound++;
+
+                }
             }
 
            /*-------------------------------------------------------------------------
@@ -1992,7 +2029,6 @@ hsize_t diff_datum(void       *_mem1,
             int    isnan1=0;
             int    isnan2=0;
 
-
             assert(type_size==sizeof(double));
 
             memcpy(&temp1_double, mem1, sizeof(double));
@@ -2017,7 +2053,8 @@ hsize_t diff_datum(void       *_mem1,
                     isnan2 = my_isnan(FLT_DOUBLE,&temp2_double);
                 }
 
-                if ( !isnan1 && !isnan2)
+                /* both not NaN, do the comparison */
+                if ( isnan1==0 && isnan2==0)
                 {
 
                     if (ABS(temp1_double-temp2_double) > options->delta)
@@ -2031,8 +2068,20 @@ hsize_t diff_datum(void       *_mem1,
                         nfound++;
                     }
 
-                } /* NaN */
-            }
+                } 
+                /* one is NaN, assume difference */
+                else if ( isnan1==1 || isnan2==1)
+                {
+                    if ( print_data(options) )
+                    {
+                        print_pos(ph,0,i,acc,pos,rank,dims,obj1,obj2);
+                        parallel_print(SPACES);
+                        parallel_print(F_FORMAT,temp1_double,temp2_double,ABS(temp1_double-temp2_double));
+                    }
+                    nfound++;
+
+                }
+            } /* options->d && !options->p */
 
            /*-------------------------------------------------------------------------
             * !-d and -p
@@ -2051,7 +2100,8 @@ hsize_t diff_datum(void       *_mem1,
                     isnan2 = my_isnan(FLT_DOUBLE,&temp2_double);
                 }
 
-                if ( !isnan1 && !isnan2)
+                /* both not NaN, do the comparison */
+                if ( isnan1==0 && isnan2==0)
                 {
 
                     PER(temp1_double,temp2_double);
@@ -2083,7 +2133,19 @@ hsize_t diff_datum(void       *_mem1,
                             nfound++;
                         }
 
-                } /* NaN */
+                } 
+                /* one is NaN, assume difference */
+                else if ( isnan1==1 || isnan2==1)
+                {
+                    if ( print_data(options) )
+                    {
+                        print_pos(ph,0,i,acc,pos,rank,dims,obj1,obj2);
+                        parallel_print(SPACES);
+                        parallel_print(F_FORMAT,temp1_double,temp2_double,ABS(temp1_double-temp2_double));
+                    }
+                    nfound++;
+
+                }
             }
 
            /*-------------------------------------------------------------------------
@@ -2103,7 +2165,8 @@ hsize_t diff_datum(void       *_mem1,
                     isnan2 = my_isnan(FLT_DOUBLE,&temp2_double);
                 }
 
-                if ( !isnan1 && !isnan2)
+                /* both not NaN, do the comparison */
+                if ( isnan1==0 && isnan2==0)
                 {
 
                     PER(temp1_double,temp2_double);
@@ -2136,7 +2199,19 @@ hsize_t diff_datum(void       *_mem1,
                             nfound++;
                         }
 
-                } /* NaN */
+                } 
+                /* one is NaN, assume difference */
+                else if ( isnan1==1 || isnan2==1)
+                {
+                    if ( print_data(options) )
+                    {
+                        print_pos(ph,0,i,acc,pos,rank,dims,obj1,obj2);
+                        parallel_print(SPACES);
+                        parallel_print(F_FORMAT,temp1_double,temp2_double,ABS(temp1_double-temp2_double));
+                    }
+                    nfound++;
+
+                }
             }
 
            /*-------------------------------------------------------------------------
@@ -2195,7 +2270,8 @@ hsize_t diff_datum(void       *_mem1,
                     isnan2 = my_isnan(FLT_LDOUBLE,&temp2_double);
                 }
 
-                if ( !isnan1 && !isnan2)
+                 /* both not NaN, do the comparison */
+                if ( isnan1==0 && isnan2==0)
                 {
 
                     if (ABS(temp1_double-temp2_double) > options->delta)
@@ -2229,7 +2305,8 @@ hsize_t diff_datum(void       *_mem1,
                     isnan2 = my_isnan(FLT_LDOUBLE,&temp2_double);
                 }
 
-                if ( !isnan1 && !isnan2)
+                 /* both not NaN, do the comparison */
+                if ( isnan1==0 && isnan2==0)
                 {
 
                     PER(temp1_double,temp2_double);
@@ -2281,7 +2358,8 @@ hsize_t diff_datum(void       *_mem1,
                     isnan2 = my_isnan(FLT_LDOUBLE,&temp2_double);
                 }
 
-                if ( !isnan1 && !isnan2)
+                 /* both not NaN, do the comparison */
+                if ( isnan1==0 && isnan2==0)
                 {
 
                     PER(temp1_double,temp2_double);
@@ -2792,7 +2870,8 @@ hsize_t diff_float(unsigned char *mem1,
                 isnan2 = my_isnan(FLT_FLOAT,&temp2_float);
             }
 
-            if ( !isnan1 && !isnan2)
+            /* both not NaN, do the comparison */
+            if ( isnan1==0 && isnan2==0)
             {
                 if (ABS(temp1_float-temp2_float) > options->delta)
                 {
@@ -2804,7 +2883,19 @@ hsize_t diff_float(unsigned char *mem1,
                     }
                     nfound++;
                 }
-            } /* NaN */
+            } 
+            /* one is NaN, assume difference */
+            else if ( isnan1==1 || isnan2==1)
+            {
+                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_float,temp2_float,ABS(temp1_float-temp2_float));
+                }
+                nfound++;
+
+            }
             mem1+=sizeof(float);
             mem2+=sizeof(float);
             if (options->n && nfound>=options->count)
@@ -2832,8 +2923,8 @@ hsize_t diff_float(unsigned char *mem1,
                 isnan1 = my_isnan(FLT_FLOAT,&temp1_float);
                 isnan2 = my_isnan(FLT_FLOAT,&temp2_float);
             }
-
-            if ( !isnan1 && !isnan2)
+            /* both not NaN, do the comparison */
+            if ( isnan1==0 && isnan2==0)
             {
 
                 PER(temp1_float,temp2_float);
@@ -2864,7 +2955,19 @@ hsize_t diff_float(unsigned char *mem1,
                         }
                         nfound++;
                     }
-            } /* NaN */
+            } 
+            /* one is NaN, assume difference */
+            else if ( isnan1==1 || isnan2==1)
+            {
+                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_float,temp2_float,ABS(temp1_float-temp2_float));
+                }
+                nfound++;
+
+            }
             mem1+=sizeof(float);
             mem2+=sizeof(float);
             if (options->n && nfound>=options->count)
@@ -2894,7 +2997,8 @@ hsize_t diff_float(unsigned char *mem1,
                 isnan2 = my_isnan(FLT_FLOAT,&temp2_float);
             }
 
-            if ( !isnan1 && !isnan2)
+            /* both not NaN, do the comparison */
+            if ( isnan1==0 && isnan2==0)
             {
 
                 PER(temp1_float,temp2_float);
@@ -2926,7 +3030,19 @@ hsize_t diff_float(unsigned char *mem1,
                         nfound++;
                     }
 
-            } /* NaN */
+            } 
+            /* one is NaN, assume difference */
+            else if ( isnan1==1 || isnan2==1)
+            {
+                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_float,temp2_float,ABS(temp1_float-temp2_float));
+                }
+                nfound++;
+
+            }
             mem1+=sizeof(float);
             mem2+=sizeof(float);
             if (options->n && nfound>=options->count)
@@ -2977,7 +3093,6 @@ hsize_t diff_float(unsigned char *mem1,
 }
 
 
-
 /*-------------------------------------------------------------------------
  * Function: diff_double
  *
@@ -2988,17 +3103,17 @@ hsize_t diff_float(unsigned char *mem1,
  *-------------------------------------------------------------------------
  */
 hsize_t diff_double(unsigned char *mem1,
-                    unsigned char *mem2,
-                    hsize_t       nelmts,
-                    hsize_t       hyper_start,
-                    int           rank,
-                    hsize_t       *dims,
-                    hsize_t       *acc,
-                    hsize_t       *pos,
-                    diff_opt_t    *options,
-                    const char    *obj1,
-                    const char    *obj2,
-                    int           *ph)
+                   unsigned char *mem2,
+                   hsize_t       nelmts,
+                   hsize_t       hyper_start,
+                   int           rank,
+                   hsize_t       *dims,
+                   hsize_t       *acc,
+                   hsize_t       *pos,
+                   diff_opt_t    *options,
+                   const char    *obj1,
+                   const char    *obj2,
+                   int           *ph)
 
 {
     hsize_t     nfound=0;          /* number of differences found */
@@ -3007,18 +3122,48 @@ hsize_t diff_double(unsigned char *mem1,
     hsize_t     i;
     double      per;
     int         both_zero;
+    int         isnan1=0;
+    int         isnan2=0;
 
 
-    /* -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));
 
-            if (ABS(temp1_double-temp2_double) > options->delta)
+           /*-------------------------------------------------------------------------
+            * detect NaNs
+            *-------------------------------------------------------------------------
+            */
+            if ( options->do_nans )
+            {
+                isnan1 = my_isnan(FLT_DOUBLE,&temp1_double);
+                isnan2 = my_isnan(FLT_DOUBLE,&temp2_double);
+            }
+
+            /* both not NaN, do the comparison */
+            if ( isnan1==0 && isnan2==0)
+            {
+                if (ABS(temp1_double-temp2_double) > options->delta)
+                {
+                    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++;
+                }
+            } 
+            /* one is NaN, assume difference */
+            else if ( isnan1==1 || isnan2==1)
             {
                 if ( print_data(options) )
                 {
@@ -3027,59 +3172,91 @@ hsize_t diff_double(unsigned char *mem1,
                     parallel_print(F_FORMAT,temp1_double,temp2_double,ABS(temp1_double-temp2_double));
                 }
                 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));
 
-            PER(temp1_double,temp2_double);
-
-            if (not_comparable && !both_zero) /* not comparable */
+           /*-------------------------------------------------------------------------
+            * detect NaNs
+            *-------------------------------------------------------------------------
+            */
+            if ( options->do_nans )
             {
-                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));
-                }
-                nfound++;
+                isnan1 = my_isnan(FLT_DOUBLE,&temp1_double);
+                isnan2 = my_isnan(FLT_DOUBLE,&temp2_double);
             }
+            /* both not NaN, do the comparison */
+            if ( isnan1==0 && isnan2==0)
+            {
 
-            else
+                PER(temp1_double,temp2_double);
 
-                if ( per > options->percent )
+                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,temp1_double,temp2_double,
-                            ABS(temp1_double-temp2_double),
-                            ABS(1-temp2_double/temp1_double));
+                        parallel_print(F_FORMAT_P_NOTCOMP,temp1_double,temp2_double,
+                            ABS(temp1_double-temp2_double));
                     }
                     nfound++;
                 }
-                mem1+=sizeof(double);
-                mem2+=sizeof(double);
-                if (options->n && nfound>=options->count)
-                    return 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++;
+                    }
+            } 
+            /* one is NaN, assume difference */
+            else if ( isnan1==1 || isnan2==1)
+            {
+                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++;
+
+            }
+            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)
     {
 
@@ -3088,48 +3265,84 @@ hsize_t diff_double(unsigned char *mem1,
             memcpy(&temp1_double, mem1, sizeof(double));
             memcpy(&temp2_double, mem2, sizeof(double));
 
-            PER(temp1_double,temp2_double);
-
-            if (not_comparable && !both_zero) /* not comparable */
+            /*-------------------------------------------------------------------------
+            * detect NaNs
+            *-------------------------------------------------------------------------
+            */
+            if ( options->do_nans )
             {
-                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));
-                }
-                nfound++;
+                isnan1 = my_isnan(FLT_DOUBLE,&temp1_double);
+                isnan2 = my_isnan(FLT_DOUBLE,&temp2_double);
             }
 
-            else
+            /* both not NaN, do the comparison */
+            if ( isnan1==0 && isnan2==0)
+            {
+
+                PER(temp1_double,temp2_double);
 
-                if ( per > options->percent && ABS(temp1_double-temp2_double) > options->delta )
+                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,temp1_double,temp2_double,
-                            ABS(temp1_double-temp2_double),
-                            ABS(1-temp2_double/temp1_double));
+                        parallel_print(F_FORMAT_P_NOTCOMP,temp1_double,temp2_double,
+                            ABS(temp1_double-temp2_double));
                     }
                     nfound++;
                 }
-                mem1+=sizeof(double);
-                mem2+=sizeof(double);
-                if (options->n && nfound>=options->count)
-                    return 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++;
+                    }
+
+            } 
+            /* one is NaN, assume difference */
+            else if ( isnan1==1 || isnan2==1)
+            {
+                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++;
+
+            }
+            mem1+=sizeof(double);
+            mem2+=sizeof(double);
+            if (options->n && nfound>=options->count)
+                return nfound;
+        } /* i */
     }
+
+ /*-------------------------------------------------------------------------
+  * no -d and -p
+  *-------------------------------------------------------------------------
+  */
     else
     {
 
+
+
         for ( i = 0; i < nelmts; i++)
         {
             memcpy(&temp1_double, mem1, sizeof(double));
             memcpy(&temp2_double, mem2, sizeof(double));
 
+
             if (equal_double(temp1_double,temp2_double,options)==FALSE)
             {
                 if ( print_data(options) )
@@ -3145,14 +3358,22 @@ hsize_t diff_double(unsigned char *mem1,
             mem2+=sizeof(double);
             if (options->n && nfound>=options->count)
                 return nfound;
+
         } /* nelmts */
 
+
+
+
+
     }
 
     return nfound;
 }
 
 
+
+
+
 /*-------------------------------------------------------------------------
  * Function: diff_ldouble
  *
@@ -3163,19 +3384,19 @@ hsize_t diff_double(unsigned char *mem1,
  *-------------------------------------------------------------------------
  */
 #if H5_SIZEOF_LONG_DOUBLE !=0
- 
+
 hsize_t diff_ldouble(unsigned char *mem1,
-                    unsigned char *mem2,
-                    hsize_t       nelmts,
-                    hsize_t       hyper_start,
-                    int           rank,
-                    hsize_t       *dims,
-                    hsize_t       *acc,
-                    hsize_t       *pos,
-                    diff_opt_t    *options,
-                    const char    *obj1,
-                    const char    *obj2,
-                    int           *ph)
+                   unsigned char *mem2,
+                   hsize_t       nelmts,
+                   hsize_t       hyper_start,
+                   int           rank,
+                   hsize_t       *dims,
+                   hsize_t       *acc,
+                   hsize_t       *pos,
+                   diff_opt_t    *options,
+                   const char    *obj1,
+                   const char    *obj2,
+                   int           *ph)
 
 {
     hsize_t     nfound=0;          /* number of differences found */
@@ -3184,79 +3405,141 @@ hsize_t diff_ldouble(unsigned char *mem1,
     hsize_t     i;
     double      per;
     int         both_zero;
+    int         isnan1=0;
+    int         isnan2=0;
 
 
-    /* -d and !-p */
+ /*-------------------------------------------------------------------------
+  * -d and !-p
+  *-------------------------------------------------------------------------
+  */
+
     if (options->d && !options->p)
     {
-
         for ( i = 0; i < nelmts; i++)
         {
             memcpy(&temp1_double, mem1, sizeof(long double));
             memcpy(&temp2_double, mem2, sizeof(long double));
 
-            if (ABS(temp1_double-temp2_double) > options->delta)
+           /*-------------------------------------------------------------------------
+            * detect NaNs
+            *-------------------------------------------------------------------------
+            */
+            if ( options->do_nans )
+            {
+                isnan1 = my_isnan(FLT_LDOUBLE,&temp1_double);
+                isnan2 = my_isnan(FLT_LDOUBLE,&temp2_double);
+            }
+
+            /* both not NaN, do the comparison */
+            if ( isnan1==0 && isnan2==0)
+            {
+                if (ABS(temp1_double-temp2_double) > options->delta)
+                {
+                    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++;
+                }
+            } 
+            /* one is NaN, assume difference */
+            else if ( isnan1==1 || isnan2==1)
             {
                 if ( print_data(options) )
                 {
                     print_pos(ph,0,hyper_start+i,acc,pos,rank,dims,obj1,obj2);
                     parallel_print(SPACES);
-                    parallel_print(LD_FORMAT,temp1_double,temp2_double,ABS(temp1_double-temp2_double));
+                    parallel_print(F_FORMAT,temp1_double,temp2_double,ABS(temp1_double-temp2_double));
                 }
                 nfound++;
+
             }
             mem1+=sizeof(long double);
             mem2+=sizeof(long 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(long double));
             memcpy(&temp2_double, mem2, sizeof(long double));
 
-            PER(temp1_double,temp2_double);
-
-            if (not_comparable && !both_zero) /* not comparable */
+           /*-------------------------------------------------------------------------
+            * detect NaNs
+            *-------------------------------------------------------------------------
+            */
+            if ( options->do_nans )
             {
-                if ( print_data(options) )
-                {
-                    print_pos(ph,1,hyper_start+i,acc,pos,rank,dims,obj1,obj2);
-                    parallel_print(SPACES);
-                    parallel_print(LD_FORMAT_P_NOTCOMP,temp1_double,temp2_double,
-                        ABS(temp1_double-temp2_double));
-                }
-                nfound++;
+                isnan1 = my_isnan(FLT_LDOUBLE,&temp1_double);
+                isnan2 = my_isnan(FLT_LDOUBLE,&temp2_double);
             }
+            /* both not NaN, do the comparison */
+            if ( isnan1==0 && isnan2==0)
+            {
 
-            else
+                PER(temp1_double,temp2_double);
 
-                if ( per > options->percent )
+                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(LD_FORMAT_P,temp1_double,temp2_double,
-                            ABS(temp1_double-temp2_double),
-                            ABS(1-temp2_double/temp1_double));
+                        parallel_print(F_FORMAT_P_NOTCOMP,temp1_double,temp2_double,
+                            ABS(temp1_double-temp2_double));
                     }
                     nfound++;
                 }
-                mem1+=sizeof(long double);
-                mem2+=sizeof(long double);
-                if (options->n && nfound>=options->count)
-                    return 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++;
+                    }
+            } 
+            /* one is NaN, assume difference */
+            else if ( isnan1==1 || isnan2==1)
+            {
+                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++;
+
+            }
+            mem1+=sizeof(long double);
+            mem2+=sizeof(long double);
+            if (options->n && nfound>=options->count)
+                return nfound;
+        } /* i */
     }
 
-    /* -d and -p */
+ /*-------------------------------------------------------------------------
+  * -d and -p
+  *-------------------------------------------------------------------------
+  */
     else if ( options->d && options->p)
     {
 
@@ -3265,55 +3548,91 @@ hsize_t diff_ldouble(unsigned char *mem1,
             memcpy(&temp1_double, mem1, sizeof(long double));
             memcpy(&temp2_double, mem2, sizeof(long double));
 
-            PER(temp1_double,temp2_double);
-
-            if (not_comparable && !both_zero) /* not comparable */
+            /*-------------------------------------------------------------------------
+            * detect NaNs
+            *-------------------------------------------------------------------------
+            */
+            if ( options->do_nans )
             {
-                if ( print_data(options) )
-                {
-                    print_pos(ph,1,hyper_start+i,acc,pos,rank,dims,obj1,obj2);
-                    parallel_print(SPACES);
-                    parallel_print(LD_FORMAT_P_NOTCOMP,temp1_double,temp2_double,
-                        ABS(temp1_double-temp2_double));
-                }
-                nfound++;
+                isnan1 = my_isnan(FLT_LDOUBLE,&temp1_double);
+                isnan2 = my_isnan(FLT_LDOUBLE,&temp2_double);
             }
 
-            else
+            /* both not NaN, do the comparison */
+            if ( isnan1==0 && isnan2==0)
+            {
+
+                PER(temp1_double,temp2_double);
 
-                if ( per > options->percent && ABS(temp1_double-temp2_double) > options->delta )
+                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(LD_FORMAT_P,temp1_double,temp2_double,
-                            ABS(temp1_double-temp2_double),
-                            ABS(1-temp2_double/temp1_double));
+                        parallel_print(F_FORMAT_P_NOTCOMP,temp1_double,temp2_double,
+                            ABS(temp1_double-temp2_double));
                     }
                     nfound++;
                 }
-                mem1+=sizeof(long double);
-                mem2+=sizeof(long double);
-                if (options->n && nfound>=options->count)
-                    return 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++;
+                    }
+
+            } 
+            /* one is NaN, assume difference */
+            else if ( isnan1==1 || isnan2==1)
+            {
+                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++;
+
+            }
+            mem1+=sizeof(long double);
+            mem2+=sizeof(long double);
+            if (options->n && nfound>=options->count)
+                return nfound;
+        } /* i */
     }
+
+ /*-------------------------------------------------------------------------
+  * no -d and -p
+  *-------------------------------------------------------------------------
+  */
     else
     {
 
+
+
         for ( i = 0; i < nelmts; i++)
         {
             memcpy(&temp1_double, mem1, sizeof(long double));
             memcpy(&temp2_double, mem2, sizeof(long double));
 
+
             if (equal_ldouble(temp1_double,temp2_double,options)==FALSE)
             {
                 if ( print_data(options) )
                 {
                     print_pos(ph,0,hyper_start+i,acc,pos,rank,dims,obj1,obj2);
                     parallel_print(SPACES);
-                    parallel_print(LD_FORMAT,temp1_double,temp2_double,ABS(temp1_double-temp2_double));
+                    parallel_print(F_FORMAT,temp1_double,temp2_double,ABS(temp1_double-temp2_double));
                 }
                 nfound++;
             }
@@ -3322,15 +3641,24 @@ hsize_t diff_ldouble(unsigned char *mem1,
             mem2+=sizeof(long double);
             if (options->n && nfound>=options->count)
                 return nfound;
+
         } /* nelmts */
 
+
+
+
+
     }
 
     return nfound;
 }
-
 #endif /* H5_SIZEOF_LONG_DOUBLE */
 
+
+
+
+
+
 /*-------------------------------------------------------------------------
  * Function: diff_schar
  *
@@ -5209,12 +5537,7 @@ hbool_t equal_double(double value, double expected, diff_opt_t *options)
         if ( (isnan1 && !isnan2) || ( !isnan1 && isnan2 ) )
         {
             return FALSE;
-        }
-        
-        /*-------------------------------------------------------------------------
-        * both are not NaNs, compare
-        *-------------------------------------------------------------------------
-        */
+        }      
     }
 
     BOTH_ZERO(value,expected)
@@ -5275,13 +5598,7 @@ hbool_t equal_ldouble(long double value, long double expected, diff_opt_t *optio
         if ( (isnan1 && !isnan2) || ( !isnan1 && isnan2 ) )
         {
             return FALSE;
-        }
-        
-        /*-------------------------------------------------------------------------
-        * both are not NaNs, compare
-        *-------------------------------------------------------------------------
-        */
-        
+        }       
     }
 
     BOTH_ZERO(value,expected)
@@ -5345,13 +5662,7 @@ hbool_t equal_float(float value, float expected, diff_opt_t *options)
         if ( (isnan1 && !isnan2) || ( !isnan1 && isnan2 ) )
         {
             return FALSE;
-        }
-        
-        /*-------------------------------------------------------------------------
-        * both are not NaNs, compare
-        *-------------------------------------------------------------------------
-        */
-        
+        }       
     }
 
     BOTH_ZERO(value,expected)