[svn-r11245] Purpose:

Code cleanup Description: Trim trailing whitespace, which is making 'diff'ing the two branches difficult. Solution: Ran this script in each directory: foreach f (*.[ch] *.cpp) sed 's/[[:blank:]]*$//' $f > sed.out && mv sed.out $f end Platforms tested: FreeBSD 4.11 (sleipnir) Too minor to require h5committest
author: Quincey Koziol <koziol@hdfgroup.org> 2005-08-13 20:53:35 (GMT)
committer: Quincey Koziol <koziol@hdfgroup.org> 2005-08-13 20:53:35 (GMT)
commit: 6b45f5172ccb4311e0be9ae15da3758abb6b0e67 (patch)
tree: 5a7a112fe7a8a98c6fecb45b513789d15962eb3d /fortran
parent: 6562465a2c2a58cfbc2f47bf60bb538f7a783933 (diff)
download: hdf5-6b45f5172ccb4311e0be9ae15da3758abb6b0e67.zip
hdf5-6b45f5172ccb4311e0be9ae15da3758abb6b0e67.tar.gz
hdf5-6b45f5172ccb4311e0be9ae15da3758abb6b0e67.tar.bz2
19 files changed, 1205 insertions, 1205 deletions
diff --git a/fortran/src/H5Af.c b/fortran/src/H5Af.c
index 1541626..f19e206 100644
--- a/fortran/src/H5Af.c
+++ b/fortran/src/H5Af.c
@@ -19,9 +19,9 @@
 
 /*----------------------------------------------------------------------------
  * Name:        h5acreate_c
- * Purpose:     Call H5Acreate to create an attribute 
- * Inputs:      obj_id - object identifier 
- *              name - name of the attribute     
+ * Purpose:     Call H5Acreate to create an attribute
+ * Inputs:      obj_id - object identifier
+ *              name - name of the attribute
  *              namelen - name length
  *              type_id - datatype identifier
  *              space_id - dataspace identifier
@@ -53,13 +53,13 @@ nh5acreate_c (hid_t_f *obj_id, _fcd name, size_t_f *namelen, hid_t_f *type_id, h
 done:
     if(c_name) HDfree(c_name);
     return ret_value;
-}      
+}
 
 /*----------------------------------------------------------------------------
  * Name:        h5aopen_name _c
- * Purpose:     Call H5Aopen_name to open an attribute 
- * Inputs:      obj_id - object identifier 
- *              name - name of the attribute     
+ * Purpose:     Call H5Aopen_name to open an attribute
+ * Inputs:      obj_id - object identifier
+ *              name - name of the attribute
  *              namelen - name length
  * Outputs:     attr_id - dataset identifier
  * Returns:     0 on success, -1 on failure
@@ -88,12 +88,12 @@ nh5aopen_name_c (hid_t_f *obj_id, _fcd name, size_t_f *namelen, hid_t_f *attr_id
 done:
     if(c_name) HDfree(c_name);
     return ret_value;
-}      
+}
 
 /*----------------------------------------------------------------------------
  * Name:        h5awritec_c
  * Purpose:     Call h5awrite_c to write a character  attribute
- * Inputs:      attr_id - dataset identifier 
+ * Inputs:      attr_id - dataset identifier
  *              mem_type_id - memory datatype identifier
  *              buf      - character data buffer
  *              dims     - array to store dimensions sizes of buf; used only
@@ -115,8 +115,8 @@ nh5awritec_c (hid_t_f *attr_id, hid_t_f *mem_type_id, _fcd buf, void *dims)
 
 /*----------------------------------------------------------------------------
  * Name:        h5awrite_c
- * Purpose:     Call H5Awrite to write a attribute 
- * Inputs:      attr_id - attribute identifier 
+ * Purpose:     Call H5Awrite to write a attribute
+ * Inputs:      attr_id - attribute identifier
  *              mem_type_id - memory datatype identifier
  *              buf      - data buffer
  *              dims     - array to store dimensions sizes of buf; used only
@@ -125,7 +125,7 @@ nh5awritec_c (hid_t_f *attr_id, hid_t_f *mem_type_id, _fcd buf, void *dims)
  * Programmer:  Elena Pourmal
  *              Thursday, August 12, 1999
  * Modifications: dims parameter added
- *                April 4, 2001 
+ *                April 4, 2001
  *---------------------------------------------------------------------------*/
 int_f
 nh5awrite_c (hid_t_f *attr_id, hid_t_f *mem_type_id, void *buf, void UNUSED *dims)
@@ -140,12 +140,12 @@ nh5awrite_c (hid_t_f *attr_id, hid_t_f *mem_type_id, void *buf, void UNUSED *dim
 
 done:
      return ret_value;
-}      
+}
 
 /*----------------------------------------------------------------------------
  * Name:        h5areadc_c
  * Purpose:     Call h5aread_c to read character  attribute
- * Inputs:      dset_id - dataset identifier 
+ * Inputs:      dset_id - dataset identifier
  *              mem_type_id - memory datatype identifier
  *              dims     - array to store dimensions sizes of buf; used only
  *                         by Fortran routine.
@@ -167,8 +167,8 @@ nh5areadc_c (hid_t_f *attr_id, hid_t_f *mem_type_id, _fcd buf, void *dims)
 
 /*----------------------------------------------------------------------------
  * Name:        h5aread_c
- * Purpose:     Call H5Aread to read an attribute 
- * Inputs:      dset_id - dataset identifier 
+ * Purpose:     Call H5Aread to read an attribute
+ * Inputs:      dset_id - dataset identifier
  *              mem_type_id - memory datatype identifier
  *              dims     - array to store dimensions sizes of buf; used only
  *                         by Fortran routine.
@@ -196,7 +196,7 @@ done:
 
 /*----------------------------------------------------------------------------
  * Name:        h5aclose_c
- * Purpose:     Call H5Aclose to close an attribute 
+ * Purpose:     Call H5Aclose to close an attribute
  * Inputs:      attr_id - identifier of an attribute to be closed
  * Returns:     0 on success, -1 on failure
  * Programmer:  Elena Pourmal
@@ -204,7 +204,7 @@ done:
  * Modifications:
  *---------------------------------------------------------------------------*/
 
-int_f 
+int_f
 nh5aclose_c ( hid_t_f *attr_id )
 {
     int_f ret_value=0;          /* Return value */
@@ -218,9 +218,9 @@ done:
 
 /*----------------------------------------------------------------------------
  * Name:        h5adelete_c
- * Purpose:     Call H5Adelete to delete an attribute 
- * Inputs:      obj_id - object identifier 
- *              name - name of the attribute     
+ * Purpose:     Call H5Adelete to delete an attribute
+ * Inputs:      obj_id - object identifier
+ *              name - name of the attribute
  *              namelen - name length
  * Returns:     0 on success, -1 on failure
  * Programmer:  Elena Pourmal
@@ -248,13 +248,13 @@ nh5adelete_c (hid_t_f *obj_id, _fcd name, size_t_f *namelen)
 done:
     if(c_name) HDfree(c_name);
     return ret_value;
-}      
+}
 
 
 /*----------------------------------------------------------------------------
  * Name:        h5aopen_idx_c
- * Purpose:     Call H5Aopen_idx to open an attribute 
- * Inputs:      obj_id - object identifier 
+ * Purpose:     Call H5Aopen_idx to open an attribute
+ * Inputs:      obj_id - object identifier
  *              idx    - attribute index ( zero based)
  * Outputs:     attr_id - attribute identifier
  * Returns:     0 on success, -1 on failure
@@ -275,13 +275,13 @@ nh5aopen_idx_c (hid_t_f *obj_id, int_f *idx, hid_t_f *attr_id)
 
 done:
      return ret_value;
-}      
+}
 
 
 /*----------------------------------------------------------------------------
  * Name:        h5aget_space_c
- * Purpose:     Call H5Aget_space to get attribute's dataspace 
- * Inputs:      attr_id - attribute identifier 
+ * Purpose:     Call H5Aget_space to get attribute's dataspace
+ * Inputs:      attr_id - attribute identifier
  * Outputs:     space_id - dataspace identifier
  * Returns:     0 on success, -1 on failure
  * Programmer:  Elena Pourmal
@@ -301,12 +301,12 @@ nh5aget_space_c (hid_t_f *attr_id, hid_t_f *space_id)
 
 done:
      return ret_value;
-}      
+}
 
 /*----------------------------------------------------------------------------
  * Name:        h5aget_type_c
- * Purpose:     Call H5Aget_space to get attribute's datatype 
- * Inputs:      attr_id - attribute identifier 
+ * Purpose:     Call H5Aget_space to get attribute's datatype
+ * Inputs:      attr_id - attribute identifier
  * Outputs:     type_id - datatype identifier
  * Returns:     0 on success, -1 on failure
  * Programmer:  Elena Pourmal
@@ -326,14 +326,14 @@ nh5aget_type_c (hid_t_f *attr_id, hid_t_f *type_id)
 
 done:
      return ret_value;
-}      
+}
 
 /*----------------------------------------------------------------------------
  * Name:        h5aget_num_attrs_c
- * Purpose:     Call H5Aget_num_attrs to determine number of 
- *              attributes of an object 
- * Inputs:      obj_id - object identifier 
- *              attr_num - number of attributes 
+ * Purpose:     Call H5Aget_num_attrs to determine number of
+ *              attributes of an object
+ * Inputs:      obj_id - object identifier
+ *              attr_num - number of attributes
  * Returns:     0 on success, -1 on failure
  * Programmer:  Elena Pourmal
  *              Thursday, August 12, 1999
@@ -352,13 +352,13 @@ nh5aget_num_attrs_c (hid_t_f *obj_id, int_f *attr_num)
 
 done:
      return ret_value;
-}      
+}
 
 /*----------------------------------------------------------------------------
  * Name:        h5aget_name_c
- * Purpose:     Call H5Aget_name to get attribute's name 
- * Inputs:      attr_id - attribute identifier 
- *              bufsize -size of the buffer 
+ * Purpose:     Call H5Aget_name to get attribute's name
+ * Inputs:      attr_id - attribute identifier
+ *              bufsize -size of the buffer
  * Outputs:     buf - buffer to hold the name
  * Returns:     0 on success, -1 on failure
  * Programmer:  Elena Pourmal
@@ -376,7 +376,7 @@ nh5aget_name_c(hid_t_f *attr_id, size_t_f *bufsize, _fcd buf)
       */
      if ((c_buf = HDmalloc((size_t)*bufsize +1)) == NULL)
          HGOTO_DONE(FAIL);
- 
+
      /*
       * Call H5Aget_name function
       */
diff --git a/fortran/src/H5Df.c b/fortran/src/H5Df.c
index d8abc88..68ff852 100644
--- a/fortran/src/H5Df.c
+++ b/fortran/src/H5Df.c
@@ -18,9 +18,9 @@
 
 /*----------------------------------------------------------------------------
  * Name:        h5dcreate_c
- * Purpose:     Call H5Dcreate to create a dataset 
- * Inputs:      loc_id - file or group identifier 
- *              name - name of the dataset     
+ * Purpose:     Call H5Dcreate to create a dataset
+ * Inputs:      loc_id - file or group identifier
+ *              name - name of the dataset
  *              namelen - name length
  *              type_id - datatype identifier
  *              space_id - dataspace identifier
@@ -42,7 +42,7 @@ nh5dcreate_c (hid_t_f *loc_id, _fcd name, int_f *namelen, hid_t_f *type_id, hid_
      hid_t c_space_id;
      hid_t c_dset_id;
      hid_t c_crt_prp;
-     
+
      /*
       * Define creation property
       */
@@ -52,7 +52,7 @@ nh5dcreate_c (hid_t_f *loc_id, _fcd name, int_f *namelen, hid_t_f *type_id, hid_
       * Convert FORTRAN name to C name
       */
      c_namelen = *namelen;
-     c_name = (char *)HD5f2cstring(name, c_namelen); 
+     c_name = (char *)HD5f2cstring(name, c_namelen);
      if (c_name == NULL) return ret_value;
 
      /*
@@ -69,13 +69,13 @@ nh5dcreate_c (hid_t_f *loc_id, _fcd name, int_f *namelen, hid_t_f *type_id, hid_
 DONE:
      HDfree(c_name);
      return ret_value;
-}      
+}
 
 /*----------------------------------------------------------------------------
  * Name:        h5dopen_c
- * Purpose:     Call H5Dopen to open a dataset 
- * Inputs:      loc_id - file or group identifier 
- *              name - name of the dataset     
+ * Purpose:     Call H5Dopen to open a dataset
+ * Inputs:      loc_id - file or group identifier
+ *              name - name of the dataset
  *              namelen - name length
  * Outputs:     dset_id - dataset identifier
  * Returns:     0 on success, -1 on failure
@@ -99,7 +99,7 @@ nh5dopen_c (hid_t_f *loc_id, _fcd name, int_f *namelen, hid_t_f *dset_id)
       * Convert FORTRAN name to C name
       */
      c_namelen = *namelen;
-     c_name = (char *)HD5f2cstring(name, c_namelen); 
+     c_name = (char *)HD5f2cstring(name, c_namelen);
      if (c_name == NULL) return ret_value;
 
      /*
@@ -115,12 +115,12 @@ nh5dopen_c (hid_t_f *loc_id, _fcd name, int_f *namelen, hid_t_f *dset_id)
 DONE:
      HDfree(c_name);
      return ret_value;
-}      
+}
 
 /*----------------------------------------------------------------------------
  * Name:        h5dwritec_c
- * Purpose:     Call h5dwrite_c to write a dataset of characters 
- * Inputs:      dset_id - dataset identifier 
+ * Purpose:     Call h5dwrite_c to write a dataset of characters
+ * Inputs:      dset_id - dataset identifier
  *              mem_type_id - memory datatype identifier
  *              mem_space_id - memory dataspace identifier
  *              file_space_id - memory dataspace identifier
@@ -136,7 +136,7 @@ int_f
 nh5dwritec_c (hid_t_f *dset_id, hid_t_f *mem_type_id, hid_t_f *mem_space_id, hid_t_f *file_space_id, hid_t_f *xfer_prp, _fcd buf, hsize_t_f *dims)
 {
      int ret_value = -1;
-     
+
      /*
       * Call h5dwrite_c  function.
       */
@@ -147,8 +147,8 @@ nh5dwritec_c (hid_t_f *dset_id, hid_t_f *mem_type_id, hid_t_f *mem_space_id, hid
 
 /*----------------------------------------------------------------------------
  * Name:        h5dwrite_c
- * Purpose:     Call H5Dwrite to write a dataset 
- * Inputs:      dset_id - dataset identifier 
+ * Purpose:     Call H5Dwrite to write a dataset
+ * Inputs:      dset_id - dataset identifier
  *              mem_type_id - memory datatype identifier
  *              mem_space_id - memory dataspace identifier
  *              file_space_id - memory dataspace identifier
@@ -175,7 +175,7 @@ nh5dwrite_c (hid_t_f *dset_id, hid_t_f *mem_type_id, hid_t_f *mem_space_id, hid_
       * Define transfer property
       */
      c_xfer_prp = (hid_t)*xfer_prp;
-     
+
      /*
       * Call H5Dwrite function.
       */
@@ -188,19 +188,19 @@ nh5dwrite_c (hid_t_f *dset_id, hid_t_f *mem_type_id, hid_t_f *mem_space_id, hid_
      if (ret < 0) return ret_value;
      ret_value = 0;
      return ret_value;
-}      
+}
 
 
 /*----------------------------------------------------------------------------
  * Name:        h5dwrite_ref_obj_c
  * Purpose:     Call H5Dwrite to write a dataset  of object references
- * Inputs:      dset_id - dataset identifier 
+ * Inputs:      dset_id - dataset identifier
  *              mem_type_id - memory datatype identifier
  *              mem_space_id - memory dataspace identifier
  *              file_space_id - memory dataspace identifier
  *              xfer_pr  - identifier of transfer property list
  *              buf      - data buffer with references to the objects.
- *              n - number of references to be stored.   
+ *              n - number of references to be stored.
  * Returns:     0 on success,e-1 on failure
  * Programmer:  Elena Pourmal
  *              Tuesday, May 14, 2002
@@ -233,9 +233,9 @@ nh5dwrite_ref_obj_c (hid_t_f *dset_id, hid_t_f *mem_type_id, hid_t_f *mem_space_
     if ( buf_c != NULL ) {
         for (i = 0; i < n; i++)
              HDmemcpy(&buf_c[i], &buf[i], sizeof(haddr_t));
-    }  
+    }
     else return ret_value;
-    
+
     /*
      * Call H5Dwrite function.
      */
@@ -253,13 +253,13 @@ nh5dwrite_ref_obj_c (hid_t_f *dset_id, hid_t_f *mem_type_id, hid_t_f *mem_space_
 /*----------------------------------------------------------------------------
  * Name:        h5dwrite_ref_reg_c
  * Purpose:     Call H5Dwrite to write a dataset of dataset region references
- * Inputs:      dset_id - dataset identifier 
+ * Inputs:      dset_id - dataset identifier
  *              mem_type_id - memory datatype identifier
  *              mem_space_id - memory dataspace identifier
  *              file_space_id - memory dataspace identifier
  *              xfer_pr  - identifier of transfer property list
  *              buf      - data buffer with references to the objects.
- *              n - number of references to be stored.   
+ *              n - number of references to be stored.
  * Returns:     0 on success, -1 on failure
  * Programmer:  Elena Pourmal
  *              Tuesday, May 14, 2002
@@ -284,7 +284,7 @@ nh5dwrite_ref_reg_c (hid_t_f *dset_id, hid_t_f *mem_type_id, hid_t_f *mem_space_
       * Define transfer property
       */
      c_xfer_prp = (hid_t)*xfer_prp;
-     
+
      /*
       * Allocate temporary buffer and copy references from Fortran.
       */
@@ -294,10 +294,10 @@ nh5dwrite_ref_reg_c (hid_t_f *dset_id, hid_t_f *mem_type_id, hid_t_f *mem_space_
            HDmemcpy(&buf_c[i], buf, H5R_DSET_REG_REF_BUF_SIZE);
            buf = buf + REF_REG_BUF_LEN_F;
       }
-      }  
+      }
       else return ret_value;
-        
-     
+
+
      /*
       * Call H5Dwrite function.
       */
@@ -310,14 +310,14 @@ nh5dwrite_ref_reg_c (hid_t_f *dset_id, hid_t_f *mem_type_id, hid_t_f *mem_space_
      if (ret < 0) return ret_value;
      ret_value = 0;
      return ret_value;
-}      
+}
 
 
 
 /*----------------------------------------------------------------------------
  * Name:        h5dreadc_c
- * Purpose:     Call h5dread_c to read a dataset of characters 
- * Inputs:      dset_id - dataset identifier 
+ * Purpose:     Call h5dread_c to read a dataset of characters
+ * Inputs:      dset_id - dataset identifier
  *              mem_type_id - memory datatype identifier
  *              mem_space_id - memory dataspace identifier
  *              file_space_id - memory dataspace identifier
@@ -333,7 +333,7 @@ int_f
 nh5dreadc_c (hid_t_f *dset_id, hid_t_f *mem_type_id, hid_t_f *mem_space_id, hid_t_f *file_space_id, hid_t_f *xfer_prp, _fcd buf, hsize_t_f *dims)
 {
      int ret_value = -1;
-     
+
      /*
       * Call h5dread_c  function.
       */
@@ -344,8 +344,8 @@ nh5dreadc_c (hid_t_f *dset_id, hid_t_f *mem_type_id, hid_t_f *mem_space_id, hid_
 
 /*----------------------------------------------------------------------------
  * Name:        h5dread_c
- * Purpose:     Call H5Draed to read a dataset 
- * Inputs:      dset_id - dataset identifier 
+ * Purpose:     Call H5Draed to read a dataset
+ * Inputs:      dset_id - dataset identifier
  *              mem_type_id - memory datatype identifier
  *              mem_space_id - memory dataspace identifier
  *              file_space_id - memory dataspace identifier
@@ -372,7 +372,7 @@ nh5dread_c (hid_t_f *dset_id, hid_t_f *mem_type_id, hid_t_f *mem_space_id, hid_t
       * Define transfer property
       */
      c_xfer_prp = (hid_t)*xfer_prp;
-     
+
      /*
       * Call H5Dread function.
       */
@@ -390,13 +390,13 @@ nh5dread_c (hid_t_f *dset_id, hid_t_f *mem_type_id, hid_t_f *mem_space_id, hid_t
 /*----------------------------------------------------------------------------
  * Name:        h5dread_ref_obj_c
  * Purpose:     Call H5Dread to read a dataset  of object references
- * Inputs:      dset_id - dataset identifier 
+ * Inputs:      dset_id - dataset identifier
  *              mem_type_id - memory datatype identifier
  *              mem_space_id - memory dataspace identifier
  *              file_space_id - memory dataspace identifier
  *              xfer_pr  - identifier of transfer property list
  *              buf      - data buffer to store references to the objects.
- *              n - number of references to be stored.   
+ *              n - number of references to be stored.
  * Returns:     0 on success, -1 on failure
  * Programmer:  Elena Pourmal
  *              Wednesday, May 15, 2002
@@ -420,7 +420,7 @@ nh5dread_ref_obj_c (hid_t_f *dset_id, hid_t_f *mem_type_id, hid_t_f *mem_space_i
      * Define transfer property
      */
     c_xfer_prp = (hid_t)*xfer_prp;
-    
+
     /*
      * Allocate temporary buffer.
      */
@@ -440,7 +440,7 @@ nh5dread_ref_obj_c (hid_t_f *dset_id, hid_t_f *mem_type_id, hid_t_f *mem_space_i
               HDmemcpy(&buf[i], &buf_c[i], sizeof(haddr_t));
         }
         if ( buf_c != NULL ) HDfree(buf_c);
-    } 
+    }
     if (ret < 0) return ret_value;
     ret_value = 0;
     return ret_value;
@@ -449,13 +449,13 @@ nh5dread_ref_obj_c (hid_t_f *dset_id, hid_t_f *mem_type_id, hid_t_f *mem_space_i
 /*----------------------------------------------------------------------------
  * Name:        h5dread_ref_reg_c
  * Purpose:     Call H5Dread to read a dataset of dataset region references
- * Inputs:      dset_id - dataset identifier 
+ * Inputs:      dset_id - dataset identifier
  *              mem_type_id - memory datatype identifier
  *              mem_space_id - memory dataspace identifier
  *              file_space_id - memory dataspace identifier
  *              xfer_pr  - identifier of transfer property list
  *              buf      - data buffer to store references to the objects.
- *              n - number of references to be stored.   
+ *              n - number of references to be stored.
  * Returns:     0 on success, -1 on failure
  * Programmer:  Elena Pourmal
  *              Wednesday, May 15, 2002
@@ -479,7 +479,7 @@ nh5dread_ref_reg_c (hid_t_f *dset_id, hid_t_f *mem_type_id, hid_t_f *mem_space_i
       * Define transfer property
       */
      c_xfer_prp = (hid_t)*xfer_prp;
-     
+
      /*
       * Allocate temporary buffer.
       */
@@ -497,20 +497,20 @@ nh5dread_ref_reg_c (hid_t_f *dset_id, hid_t_f *mem_type_id, hid_t_f *mem_space_i
             for (i = 0; i < n; i++) {
                HDmemcpy(buf, &buf_c[i], H5R_DSET_REG_REF_BUF_SIZE);
                buf = buf + REF_REG_BUF_LEN_F;
-            }  
+            }
          }
          if ( buf_c != NULL ) HDfree(buf_c);
-     } 
+     }
      if (ret < 0) return ret_value;
      ret_value = 0;
      return ret_value;
-}      
+}
 
 
 
 /*----------------------------------------------------------------------------
  * Name:        h5dclose_c
- * Purpose:     Call H5Dclose to close a dataset 
+ * Purpose:     Call H5Dclose to close a dataset
  * Inputs:      dset_id - identifier of the dataset to be closed
  * Returns:     0 on success, -1 on failure
  * Programmer:  Elena Pourmal
@@ -530,7 +530,7 @@ nh5dclose_c ( hid_t_f *dset_id )
 
 /*----------------------------------------------------------------------------
  * Name:        h5dget_space_c
- * Purpose:     Call H5Dget_space to obtain dataspace of a dataset 
+ * Purpose:     Call H5Dget_space to obtain dataspace of a dataset
  * Inputs:      dset_id - identifier of the dataset
  * Outputs:     space_id - identifier of the dataset's dataspace
  * Returns:     0 on success, -1 on failure
@@ -539,14 +539,14 @@ nh5dclose_c ( hid_t_f *dset_id )
  * Modifications:
  *---------------------------------------------------------------------------*/
 
-int_f 
+int_f
 nh5dget_space_c ( hid_t_f *dset_id , hid_t_f *space_id)
 {
   int ret_value = -1;
   hid_t c_dset_id;
   hid_t c_space_id;
-  
-  c_dset_id = (hid_t)*dset_id; 
+
+  c_dset_id = (hid_t)*dset_id;
   c_space_id = H5Dget_space(c_dset_id);
   if(c_space_id < 0 ) return ret_value;
   ret_value = 0;
@@ -556,7 +556,7 @@ nh5dget_space_c ( hid_t_f *dset_id , hid_t_f *space_id)
 
 /*----------------------------------------------------------------------------
  * Name:        h5dget_type_c
- * Purpose:     Call H5Dget_type to obtain datatype of a dataset 
+ * Purpose:     Call H5Dget_type to obtain datatype of a dataset
  * Inputs:      dset_id - identifier of the dataset
  * Outputs:     type_id - identifier of the dataset's datatype
  * Returns:     0 on success, -1 on failure
@@ -565,13 +565,13 @@ nh5dget_space_c ( hid_t_f *dset_id , hid_t_f *space_id)
  * Modifications:
  *---------------------------------------------------------------------------*/
 
-int_f 
+int_f
 nh5dget_type_c ( hid_t_f *dset_id , hid_t_f *type_id)
 {
   int ret_value = -1;
   hid_t c_dset_id;
   hid_t c_type_id;
-  
+
   c_dset_id = (hid_t)*dset_id;
   c_type_id = H5Dget_type(c_dset_id);
 
@@ -585,7 +585,7 @@ nh5dget_type_c ( hid_t_f *dset_id , hid_t_f *type_id)
 /*----------------------------------------------------------------------------
  * Name:        h5dget_create_plist_c
  * Purpose:     Call H5Dget_create_plist to obtain creation property list
- *              of a dataset 
+ *              of a dataset
  * Inputs:      dset_id - identifier of the dataset
  * Outputs:     plist_id - identifier of he dataset creation property list
  * Returns:     0 on success, -1 on failure
@@ -594,13 +594,13 @@ nh5dget_type_c ( hid_t_f *dset_id , hid_t_f *type_id)
  * Modifications:
  *---------------------------------------------------------------------------*/
 
-int_f 
+int_f
 nh5dget_create_plist_c ( hid_t_f *dset_id , hid_t_f *plist_id)
 {
   int ret_value = -1;
   hid_t c_dset_id;
   hid_t c_plist_id;
-  
+
   c_dset_id = (hid_t)*dset_id;
   c_plist_id = H5Dget_create_plist(c_dset_id);
 
@@ -614,16 +614,16 @@ nh5dget_create_plist_c ( hid_t_f *dset_id , hid_t_f *plist_id)
 
 /*----------------------------------------------------------------------------
  * Name:        h5dextend_c
- * Purpose:     Call H5Dextend to extend dataset with unlimited dimensions 
- * Inputs:      dset_id - identifier of the dataset 
- * Outputs:     dims - array with the dimension sizes 
+ * Purpose:     Call H5Dextend to extend dataset with unlimited dimensions
+ * Inputs:      dset_id - identifier of the dataset
+ * Outputs:     dims - array with the dimension sizes
  * Returns:     0 on success, -1 on failure
  * Programmer:  Elena Pourmal
  *              Thursday, August 19, 1999
  * Modifications:
  *---------------------------------------------------------------------------*/
 
-int_f 
+int_f
 nh5dextend_c ( hid_t_f *dset_id , hsize_t_f *dims)
 {
   int ret_value = -1;
@@ -647,9 +647,9 @@ nh5dextend_c ( hid_t_f *dset_id , hsize_t_f *dims)
   /*
    * Reverse dimensions due to C-FORTRAN storage order.
    */
-  for (i=0; i < rank; i++) 
+  for (i=0; i < rank; i++)
       c_dims[i] = dims[rank - i - 1];
-  
+
   status = H5Dextend(c_dset_id, c_dims);
 
   if ( status >= 0  ) ret_value = 0;
@@ -659,9 +659,9 @@ nh5dextend_c ( hid_t_f *dset_id , hsize_t_f *dims)
 
 /*----------------------------------------------------------------------------
  * Name:        nh5dget_storage_size_c
- * Purpose:     Call H5Dget_storage_size to return the amount of storage 
+ * Purpose:     Call H5Dget_storage_size to return the amount of storage
  *              required for a dataset
- * Inputs:      dset_id - identifier of the dataset 
+ * Inputs:      dset_id - identifier of the dataset
  * Outputs:     size    - the amount of storage required for a dataset
  * Returns:     0 on success, -1 on failure
  * Programmer:  Elena Pourmal
@@ -669,7 +669,7 @@ nh5dextend_c ( hid_t_f *dset_id , hsize_t_f *dims)
  * Modifications:
  *---------------------------------------------------------------------------*/
 
-int_f 
+int_f
 nh5dget_storage_size_c ( hid_t_f *dset_id , hsize_t_f *size)
 {
   int ret_value = -1;
@@ -687,9 +687,9 @@ nh5dget_storage_size_c ( hid_t_f *dset_id , hsize_t_f *size)
 /*----------------------------------------------------------------------------
  * Name:        nh5dvlen_get_max_len_c
  * Purpose:     Get the maximum size of the VL dataset element
- * Inputs:      dset_id - identifier of the dataset 
+ * Inputs:      dset_id - identifier of the dataset
  *              type_id - datatype identifier
- *              space_id - dataspace identifier 
+ *              space_id - dataspace identifier
  * Outputs:     len      - maximum length of the VL dataset element
  * Returns:     0 on success, -1 on failure
  * Programmer:  Elena Pourmal
@@ -697,7 +697,7 @@ nh5dget_storage_size_c ( hid_t_f *dset_id , hsize_t_f *size)
  * Modifications:
  *---------------------------------------------------------------------------*/
 
-int_f 
+int_f
 nh5dvlen_get_max_len_c ( hid_t_f *dset_id ,  hid_t_f *type_id, hid_t_f *space_id, size_t_f *len)
 {
   int ret_value = -1;
@@ -714,20 +714,20 @@ nh5dvlen_get_max_len_c ( hid_t_f *dset_id ,  hid_t_f *type_id, hid_t_f *space_id
   c_type_id = (hid_t)*type_id;
   c_space_id = (hid_t)*space_id;
 
-  num_elem = H5Sget_select_npoints(c_space_id);  
+  num_elem = H5Sget_select_npoints(c_space_id);
   if( num_elem < 0) return ret_value;
 
-  c_buf = (hvl_t *)malloc(sizeof(hvl_t)*(size_t)num_elem); 
+  c_buf = (hvl_t *)malloc(sizeof(hvl_t)*(size_t)num_elem);
   if (c_buf == NULL) return ret_value;
   status = H5Dread(c_dset_id, c_type_id, H5S_ALL, c_space_id, H5P_DEFAULT, c_buf);
   if(status < 0) goto DONE;
-  
+
   c_len = 0;
-  for (i=0; i < num_elem; i++) c_len = H5_MAX(c_len, c_buf[i].len);  
+  for (i=0; i < num_elem; i++) c_len = H5_MAX(c_len, c_buf[i].len);
   *len = (size_t_f)c_len;
   H5Dvlen_reclaim(c_type_id, c_space_id, H5P_DEFAULT, c_buf);
   ret_value = 0;
-  
+
 DONE:
 
   free(c_buf);
@@ -735,11 +735,11 @@ DONE:
 }
 /*----------------------------------------------------------------------------
  * Name:        nh5dwrite_vl_integer_c
- * Purpose:     Write variable length dataset 
- * Inputs:      dset_id - identifier of the dataset 
+ * Purpose:     Write variable length dataset
+ * Inputs:      dset_id - identifier of the dataset
  *              mem_type_id - datatype identifier
- *              mem_space_id - dataspace identifier 
- *              file_space_id - file dataspace identifier 
+ *              mem_space_id - dataspace identifier
+ *              file_space_id - file dataspace identifier
  *              xfer          - file transfer property
  *              buf           - data buffer
  *              dims          - one-demnsional array of size 2
@@ -752,7 +752,7 @@ DONE:
  * Modifications:
  *---------------------------------------------------------------------------*/
 
-int_f 
+int_f
 nh5dwrite_vl_integer_c ( hid_t_f *dset_id ,  hid_t_f *mem_type_id, hid_t_f *mem_space_id, hid_t_f *file_space_id, hid_t_f *xfer_prp, int_f *buf, hsize_t_f *dims, size_t_f *len)
 {
   int ret_value = -1;
@@ -768,7 +768,7 @@ nh5dwrite_vl_integer_c ( hid_t_f *dset_id ,  hid_t_f *mem_type_id, hid_t_f *mem_
   hvl_t *c_buf;
   hsize_t i;
   hsize_t num_elem;
-  
+
   max_len = (size_t)dims[0];
   num_elem = dims[1];
 
@@ -778,14 +778,14 @@ nh5dwrite_vl_integer_c ( hid_t_f *dset_id ,  hid_t_f *mem_type_id, hid_t_f *mem_
   c_file_space_id = (hid_t)*file_space_id;
   c_xfer_prp      = (hid_t)*xfer_prp;
 
-  c_buf = (hvl_t *)malloc((size_t)num_elem * sizeof(hvl_t)); 
+  c_buf = (hvl_t *)malloc((size_t)num_elem * sizeof(hvl_t));
   if (c_buf == NULL) return ret_value;
-  tmp = (int_f *)buf; 
+  tmp = (int_f *)buf;
   for (i=0; i < num_elem; i++) {
-       c_buf[i].len = (size_t)len[i];  
+       c_buf[i].len = (size_t)len[i];
        c_buf[i].p   = tmp;
        tmp = tmp + max_len;
- } 
+ }
   /*
    * Call H5Dwrite function.
    */
@@ -800,11 +800,11 @@ DONE:
 
 /*----------------------------------------------------------------------------
  * Name:        nh5dread_vl_integer_c
- * Purpose:     Read variable length dataset 
- * Inputs:      dset_id - identifier of the dataset 
+ * Purpose:     Read variable length dataset
+ * Inputs:      dset_id - identifier of the dataset
  *              mem_type_id - datatype identifier
- *              mem_space_id - dataspace identifier 
- *              file_space_id - file dataspace identifier 
+ *              mem_space_id - dataspace identifier
+ *              file_space_id - file dataspace identifier
  *              xfer          - file transfer property
  *              dims          - one-demnsional array of size 2
  *                              dims[0] = MAXLENGTH
@@ -817,7 +817,7 @@ DONE:
  * Modifications:
  *---------------------------------------------------------------------------*/
 
-int_f 
+int_f
 nh5dread_vl_integer_c ( hid_t_f *dset_id ,  hid_t_f *mem_type_id, hid_t_f *mem_space_id, hid_t_f *file_space_id, hid_t_f *xfer_prp, int_f *buf, hsize_t_f *dims, size_t_f *len)
 {
   int ret_value = -1;
@@ -832,7 +832,7 @@ nh5dread_vl_integer_c ( hid_t_f *dset_id ,  hid_t_f *mem_type_id, hid_t_f *mem_s
   hvl_t *c_buf;
   size_t i;
   hssize_t num_elem;
-  
+
   c_dset_id       = (hid_t)*dset_id;
   c_mem_type_id   = (hid_t)*mem_type_id;
   c_mem_space_id  = (hid_t)*mem_space_id;
@@ -840,10 +840,10 @@ nh5dread_vl_integer_c ( hid_t_f *dset_id ,  hid_t_f *mem_type_id, hid_t_f *mem_s
   c_xfer_prp      = (hid_t)*xfer_prp;
 
   max_len = (size_t)dims[0];
-  num_elem = H5Sget_select_npoints(c_mem_space_id);  
+  num_elem = H5Sget_select_npoints(c_mem_space_id);
   if(num_elem != dims[1]) return ret_value;
 
-  c_buf = (hvl_t *)malloc((size_t)num_elem * sizeof(hvl_t)); 
+  c_buf = (hvl_t *)malloc((size_t)num_elem * sizeof(hvl_t));
   if (c_buf == NULL) return ret_value;
   /*
    * Call H5Dread function.
@@ -851,7 +851,7 @@ nh5dread_vl_integer_c ( hid_t_f *dset_id ,  hid_t_f *mem_type_id, hid_t_f *mem_s
    status = H5Dread(c_dset_id, c_mem_type_id, c_mem_space_id, c_file_space_id, c_xfer_prp, c_buf);
  if ( status < 0 ) goto DONE;
   for (i=0; i < num_elem; i++) {
-       len[i] = (size_t_f)c_buf[i].len;  
+       len[i] = (size_t_f)c_buf[i].len;
        memcpy(&buf[i*max_len], c_buf[i].p, c_buf[i].len*sizeof(int_f));
   }
   H5Dvlen_reclaim(c_mem_type_id, c_mem_space_id, H5P_DEFAULT, c_buf);
@@ -864,13 +864,13 @@ DONE:
 /*----------------------------------------------------------------------------
  * Name:        nh5dwrite_vl_string_c
  * Purpose:     Write variable length strings from Fortran program
- * Inputs:      dset_id - identifier of the dataset 
+ * Inputs:      dset_id - identifier of the dataset
  *              mem_type_id - datatype identifier
- *              mem_space_id - dataspace identifier 
- *              file_space_id - file dataspace identifier 
+ *              mem_space_id - dataspace identifier
+ *              file_space_id - file dataspace identifier
  *              xfer          - file transfer property
  *              buf           - data buffer
- *              dims          - one-demnsional array of size 2 
+ *              dims          - one-demnsional array of size 2
  *                              dims[0] = number of strings of size max_len
  *              len           - array of strings lengths
  * Returns:     0 on success, -1 on failure
@@ -879,7 +879,7 @@ DONE:
  * Modifications:
  *---------------------------------------------------------------------------*/
 
-int_f 
+int_f
 nh5dwrite_vl_string_c( hid_t_f *dset_id ,  hid_t_f *mem_type_id, hid_t_f *mem_space_id, hid_t_f *file_space_id, hid_t_f *xfer_prp, _fcd buf, hsize_t_f *dims, size_t_f *len)
 {
   int ret_value = -1;
@@ -895,7 +895,7 @@ nh5dwrite_vl_string_c( hid_t_f *dset_id ,  hid_t_f *mem_type_id, hid_t_f *mem_sp
   char **c_buf;
   hsize_t i;
   hsize_t num_elem;
-  
+
   max_len = (size_t)dims[0];
   num_elem = dims[1];
 
@@ -908,7 +908,7 @@ nh5dwrite_vl_string_c( hid_t_f *dset_id ,  hid_t_f *mem_type_id, hid_t_f *mem_sp
   /*
    * Allocate arra of character pointers
    */
-  c_buf = (char **)malloc((size_t)num_elem * sizeof(char *)); 
+  c_buf = (char **)malloc((size_t)num_elem * sizeof(char *));
   if (c_buf == NULL) return ret_value;
 
   /* Copy data to long C string */
@@ -923,7 +923,7 @@ nh5dwrite_vl_string_c( hid_t_f *dset_id ,  hid_t_f *mem_type_id, hid_t_f *mem_sp
    for (i=0; i < num_elem; i++) {
         c_buf[i] = (char *) malloc((size_t)len[i]+1);
         memcpy(c_buf[i], tmp_p, (size_t)len[i]);
-        c_buf[i][len[i]] = '\0'; 
+        c_buf[i][len[i]] = '\0';
         tmp_p = tmp_p + max_len;
    }
 
@@ -943,12 +943,12 @@ DONE:
 /*----------------------------------------------------------------------------
  * Name:        nh5dread_vl_string_c
  * Purpose:     Read variable length strings from Fortran program
- * Inputs:      dset_id - identifier of the dataset 
+ * Inputs:      dset_id - identifier of the dataset
  *              mem_type_id - datatype identifier
- *              mem_space_id - dataspace identifier 
- *              file_space_id - file dataspace identifier 
+ *              mem_space_id - dataspace identifier
+ *              file_space_id - file dataspace identifier
  *              xfer          - file transfer property
- *              dims          - one-demnsional array of size 2 
+ *              dims          - one-demnsional array of size 2
  *                              dims[0] = number of strings of size max_len
  * Output:      buf           - data buffer
  *              len           - array of strings lengths
@@ -958,7 +958,7 @@ DONE:
  * Modifications:
  *---------------------------------------------------------------------------*/
 
-int_f 
+int_f
 nh5dread_vl_string_c( hid_t_f *dset_id ,  hid_t_f *mem_type_id, hid_t_f *mem_space_id, hid_t_f *file_space_id, hid_t_f *xfer_prp, _fcd buf, hsize_t_f *dims, size_t_f *len)
 {
   int ret_value = -1;
@@ -974,7 +974,7 @@ nh5dread_vl_string_c( hid_t_f *dset_id ,  hid_t_f *mem_type_id, hid_t_f *mem_spa
   char **c_buf;
   hsize_t i;
   hsize_t num_elem;
-  
+
   max_len = (size_t)dims[0];
   num_elem = dims[1];
 
@@ -987,7 +987,7 @@ nh5dread_vl_string_c( hid_t_f *dset_id ,  hid_t_f *mem_type_id, hid_t_f *mem_spa
   /*
    * Allocate array of character pointers
    */
-  c_buf = (char **)malloc((size_t)num_elem * sizeof(char *)); 
+  c_buf = (char **)malloc((size_t)num_elem * sizeof(char *));
   if (c_buf == NULL) return ret_value;
 
   /*
@@ -1017,11 +1017,11 @@ nh5dread_vl_string_c( hid_t_f *dset_id ,  hid_t_f *mem_type_id, hid_t_f *mem_spa
 
 /*----------------------------------------------------------------------------
  * Name:        nh5dwrite_vl_real_c
- * Purpose:     Write variable length dataset 
- * Inputs:      dset_id - identifier of the dataset 
+ * Purpose:     Write variable length dataset
+ * Inputs:      dset_id - identifier of the dataset
  *              mem_type_id - datatype identifier
- *              mem_space_id - dataspace identifier 
- *              file_space_id - file dataspace identifier 
+ *              mem_space_id - dataspace identifier
+ *              file_space_id - file dataspace identifier
  *              xfer          - file transfer property
  *              buf           - data buffer
  *              dims          - one-demnsional array of size 2
@@ -1034,7 +1034,7 @@ nh5dread_vl_string_c( hid_t_f *dset_id ,  hid_t_f *mem_type_id, hid_t_f *mem_spa
  * Modifications:
  *---------------------------------------------------------------------------*/
 
-int_f 
+int_f
 nh5dwrite_vl_real_c ( hid_t_f *dset_id ,  hid_t_f *mem_type_id, hid_t_f *mem_space_id, hid_t_f *file_space_id, hid_t_f *xfer_prp, real_f *buf, hsize_t_f *dims, size_t_f *len)
 {
   int ret_value = -1;
@@ -1050,7 +1050,7 @@ nh5dwrite_vl_real_c ( hid_t_f *dset_id ,  hid_t_f *mem_type_id, hid_t_f *mem_spa
   hvl_t *c_buf;
   hsize_t i;
   hsize_t num_elem;
-  
+
   max_len = (size_t)dims[0];
   num_elem = dims[1];
 
@@ -1060,14 +1060,14 @@ nh5dwrite_vl_real_c ( hid_t_f *dset_id ,  hid_t_f *mem_type_id, hid_t_f *mem_spa
   c_file_space_id = (hid_t)*file_space_id;
   c_xfer_prp      = (hid_t)*xfer_prp;
 
-  c_buf = (hvl_t *)malloc((size_t)num_elem * sizeof(hvl_t)); 
+  c_buf = (hvl_t *)malloc((size_t)num_elem * sizeof(hvl_t));
   if (c_buf == NULL) return ret_value;
-  tmp = (real_f *)buf; 
+  tmp = (real_f *)buf;
   for (i=0; i < num_elem; i++) {
-       c_buf[i].len = (size_t)len[i];  
+       c_buf[i].len = (size_t)len[i];
        c_buf[i].p   = tmp;
        tmp = tmp + max_len;
- } 
+ }
   /*
    * Call H5Dwrite function.
    */
@@ -1082,11 +1082,11 @@ DONE:
 
 /*----------------------------------------------------------------------------
  * Name:        nh5dread_vl_real_c
- * Purpose:     Read variable length dataset 
- * Inputs:      dset_id - identifier of the dataset 
+ * Purpose:     Read variable length dataset
+ * Inputs:      dset_id - identifier of the dataset
  *              mem_type_id - datatype identifier
- *              mem_space_id - dataspace identifier 
- *              file_space_id - file dataspace identifier 
+ *              mem_space_id - dataspace identifier
+ *              file_space_id - file dataspace identifier
  *              xfer          - file transfer property
  *              dims          - one-demnsional array of size 2
  *                              dims[0] = MAXLENGTH
@@ -1099,7 +1099,7 @@ DONE:
  * Modifications:
  *---------------------------------------------------------------------------*/
 
-int_f 
+int_f
 nh5dread_vl_real_c ( hid_t_f *dset_id ,  hid_t_f *mem_type_id, hid_t_f *mem_space_id, hid_t_f *file_space_id, hid_t_f *xfer_prp, real_f *buf, hsize_t_f *dims, size_t_f *len)
 {
   int ret_value = -1;
@@ -1114,7 +1114,7 @@ nh5dread_vl_real_c ( hid_t_f *dset_id ,  hid_t_f *mem_type_id, hid_t_f *mem_spac
   hvl_t *c_buf;
   size_t i;
   hssize_t num_elem;
-  
+
   c_dset_id       = (hid_t)*dset_id;
   c_mem_type_id   = (hid_t)*mem_type_id;
   c_mem_space_id  = (hid_t)*mem_space_id;
@@ -1122,10 +1122,10 @@ nh5dread_vl_real_c ( hid_t_f *dset_id ,  hid_t_f *mem_type_id, hid_t_f *mem_spac
   c_xfer_prp      = (hid_t)*xfer_prp;
 
   max_len = (size_t)dims[0];
-  num_elem = H5Sget_select_npoints(c_mem_space_id);  
+  num_elem = H5Sget_select_npoints(c_mem_space_id);
   if(num_elem != dims[1]) return ret_value;
 
-  c_buf = (hvl_t *)malloc((size_t)num_elem * sizeof(hvl_t)); 
+  c_buf = (hvl_t *)malloc((size_t)num_elem * sizeof(hvl_t));
   if (c_buf == NULL) return ret_value;
   /*
    * Call H5Dread function.
@@ -1133,10 +1133,10 @@ nh5dread_vl_real_c ( hid_t_f *dset_id ,  hid_t_f *mem_type_id, hid_t_f *mem_spac
    status = H5Dread(c_dset_id, c_mem_type_id, c_mem_space_id, c_file_space_id, c_xfer_prp, c_buf);
  if ( status <0  )  goto DONE;
   for (i=0; i < num_elem; i++) {
-       len[i] = (size_t_f)c_buf[i].len;  
+       len[i] = (size_t_f)c_buf[i].len;
        memcpy(&buf[i*max_len], c_buf[i].p, c_buf[i].len*sizeof(real_f));
   }
-  
+
   H5Dvlen_reclaim(c_mem_type_id, c_mem_space_id, H5P_DEFAULT, c_buf);
   ret_value = 0;
 DONE:
@@ -1161,7 +1161,7 @@ int_f
 nh5dfillc_c (_fcd fill_value, hid_t_f *fill_type_id, hid_t_f *space_id, _fcd buf, hid_t_f *mem_type_id)
 {
      int ret_value = -1;
-     
+
      /*
       * Call h5dfill_c  function.
       */
@@ -1195,7 +1195,7 @@ nh5dfill_c (void * fill_value, hid_t_f *fill_type_id, hid_t_f *space_id, void *
      c_fill_type_id = (hid_t)*fill_type_id;
      c_mem_type_id = (hid_t)*mem_type_id;
      c_space_id = (hid_t)*space_id;
-     
+
      /*
       * Call H5Dfill function.
       */
@@ -1204,7 +1204,7 @@ nh5dfill_c (void * fill_value, hid_t_f *fill_type_id, hid_t_f *space_id, void *
      if (ret < 0) return ret_value;
      ret_value = 0;
      return ret_value;
-}      
+}
 
 /*----------------------------------------------------------------------------
  * Name:        h5dget_space_status_c
@@ -1226,7 +1226,7 @@ nh5dget_space_status_c ( hid_t_f *dset_id, int_f *flag)
      H5D_space_status_t c_flag;
 
      c_dset_id = (hid_t)*dset_id;
-     
+
      /*
       * Call H5Dget_space_status
       */
@@ -1236,5 +1236,5 @@ nh5dget_space_status_c ( hid_t_f *dset_id, int_f *flag)
      *flag = (int_f)c_flag;
      ret_value = 0;
      return ret_value;
-}      
+}
 
diff --git a/fortran/src/H5Ef.c b/fortran/src/H5Ef.c
index 6bd6d74..3c47ee2 100644
--- a/fortran/src/H5Ef.c
+++ b/fortran/src/H5Ef.c
@@ -20,15 +20,15 @@
 /*----------------------------------------------------------------------------
  * Name:        h5eclear_c
  * Purpose:     Call H5Eclear to clear the error stack for the current thread
- * Inputs:      
- * Outputs:     
+ * Inputs:
+ * Outputs:
  * Returns:     0 on success, -1 on failure
  * Programmer:  Xiangyang Su
  *              Wednesday, March 29, 2000
  * Modifications:
  *---------------------------------------------------------------------------*/
 
-int_f 
+int_f
 nh5eclear_c( )
 {
   int ret_val = -1;
@@ -37,18 +37,18 @@ nh5eclear_c( )
   /*
    * Call H5Eclear function.
    */
-  status = H5Eclear_stack(H5E_DEFAULT); 
+  status = H5Eclear_stack(H5E_DEFAULT);
   if(status < 0) return ret_val;
   ret_val = 0;
   return ret_val;
-}   
+}
 
 /*----------------------------------------------------------------------------
  * Name:        h5eprint_c1
  * Purpose:     Call H5Eprint to print the error stack in a default manner.
  * Inputs:      name - file name
  *              namelen - length of name
- * Outputs:     
+ * Outputs:
  * Returns:     0 on success, -1 on failure
  * Programmer:  Xiangyang Su
  *              Wednesday, March 29, 2000
@@ -76,17 +76,17 @@ nh5eprint_c1(_fcd name, int_f* namelen)
   fclose(file);
 
 DONE:
-  HDfree(c_name); 
+  HDfree(c_name);
   return ret_val;
-}  
+}
 
 
 /*----------------------------------------------------------------------------
  * Name:        h5eprint_c2
  * Purpose:     Call H5Eprint to print the error stack to stderr
  *              in a default manner.
- * Inputs:     
- * Outputs:     
+ * Inputs:
+ * Outputs:
  * Returns:     0 on success, -1 on failure
  * Programmer:  Xiangyang Su
  *              Wednesday, March 29, 2000
@@ -104,11 +104,11 @@ nh5eprint_c2()
   status = H5Eprint_stack(H5E_DEFAULT, NULL);
   if(status >= 0) ret_val = 0;
   return ret_val;
-}  
+}
 
 /*----------------------------------------------------------------------------
  * Name:        h5eget_major_c
- * Purpose:     Call H5Eget_major to get a character string 
+ * Purpose:     Call H5Eget_major to get a character string
  *              describing an error specified by a major error number.
  * Inputs:      error_no - Major error number
  * Outputs:     name - character string describing the error
@@ -133,16 +133,16 @@ nh5eget_major_c(int_f* error_no, _fcd name, size_t_f* namelen)
    * Call H5Eget_major function.
    */
   H5Eget_msg(c_error_no, NULL, c_name, c_namelen);
-  HD5packFstring((char*)c_name, _fcdtocp(name), c_namelen); 
-  
+  HD5packFstring((char*)c_name, _fcdtocp(name), c_namelen);
+
   if(!strcmp(c_name, "Invalid major error number")) return ret_val;
   ret_val = 0;
   return ret_val;
-}  
+}
 
 /*----------------------------------------------------------------------------
  * Name:        h5eget_minor_c
- * Purpose:     Call H5Eget_minor to get a character string 
+ * Purpose:     Call H5Eget_minor to get a character string
  *              describing an error specified by a minor error number.
  * Inputs:      error_no - Major error number
  * Outputs:     name - character string describing the error
@@ -167,18 +167,18 @@ nh5eget_minor_c(int_f* error_no, _fcd name, size_t_f* namelen)
    * Call H5Eget_minor function.
    */
   H5Eget_msg(c_error_no, NULL, c_name, c_namelen);
-  HD5packFstring((char*)c_name, _fcdtocp(name), c_namelen); 
-  
+  HD5packFstring((char*)c_name, _fcdtocp(name), c_namelen);
+
   if(!strcmp(c_name, "Invalid minor error number")) return ret_val;
   ret_val = 0;
   return ret_val;
-}  
+}
 
 /*----------------------------------------------------------------------------
  * Name:        h5eset_auto_c
  * Purpose:     Call H5Eset_auto to turn automatic error printing on or off.
  * Inputs:      printflag - flag to turn automatic error printing on or off.
- * Outputs:    
+ * Outputs:
  * Returns:     0 on success, -1 on failure
  * Programmer:  Elena Pourmal
  *              Friday, November 17, 2000
diff --git a/fortran/src/H5FDmpiof.c b/fortran/src/H5FDmpiof.c
index 1a8aa13..6803674 100644
--- a/fortran/src/H5FDmpiof.c
+++ b/fortran/src/H5FDmpiof.c
@@ -15,12 +15,12 @@
 /* This files contains C stubs for Parallel Fortran APIs */
 
 #include "H5f90.h"
-#include <mpi.h> 
+#include <mpi.h>
 #include "H5public.h"
 
 
 /* Support for C to Fortran translation in MPI */
-#ifndef H5_HAVE_MPI_MULTI_LANG_Comm 
+#ifndef H5_HAVE_MPI_MULTI_LANG_Comm
 #define MPI_Comm_c2f(comm) (int_f)(comm)
 #define MPI_Comm_f2c(comm) (MPI_Comm)(comm)
 #endif /*MPI Comm*/
@@ -31,14 +31,14 @@
 
 /*----------------------------------------------------------------------------
  * Name:        h5pset_fapl_mpio_c
- * Purpose:     Call H5Pset_fapl_mpio to set mode for parallel I/O and the user 
- *              supplied communicator and info object 
+ * Purpose:     Call H5Pset_fapl_mpio to set mode for parallel I/O and the user
+ *              supplied communicator and info object
  * Inputs:      prp_id - property list identifier
- *              comm   - MPI communicator 
- *              info   - MPI info object 
+ *              comm   - MPI communicator
+ *              info   - MPI info object
  * Returns:     0 on success, -1 on failure
- * Programmer:  Elena Pourmal 
- *              Thursday, October 26, 2000 
+ * Programmer:  Elena Pourmal
+ *              Thursday, October 26, 2000
  * Modifications:
  *---------------------------------------------------------------------------*/
 int_f
@@ -48,8 +48,8 @@ nh5pset_fapl_mpio_c(hid_t_f *prp_id, int_f* comm, int_f* info)
      hid_t c_prp_id;
      herr_t ret;
      MPI_Comm c_comm;
-     MPI_Info c_info; 
-     c_comm = MPI_Comm_f2c(*comm); 
+     MPI_Info c_info;
+     c_comm = MPI_Comm_f2c(*comm);
      c_info = MPI_Info_f2c(*info);
 
      /*
@@ -60,17 +60,17 @@ nh5pset_fapl_mpio_c(hid_t_f *prp_id, int_f* comm, int_f* info)
      if (ret < 0) return ret_value;
      ret_value = 0;
      return ret_value;
-} 
+}
 
 /*----------------------------------------------------------------------------
  * Name:        h5pget_fapl_mpio_c
- * Purpose:     Call H5Pget_fapl_mpio to retrieve communicator and info object 
+ * Purpose:     Call H5Pget_fapl_mpio to retrieve communicator and info object
  * Inputs:      prp_id - property list identifier
- *              comm   - buffer to return MPI communicator 
- *              info   - buffer to return MPI info object 
+ *              comm   - buffer to return MPI communicator
+ *              info   - buffer to return MPI info object
  * Returns:     0 on success, -1 on failure
- * Programmer:  Elena Pourmal 
- *              Thursday, October 26, 2000 
+ * Programmer:  Elena Pourmal
+ *              Thursday, October 26, 2000
  * Modifications:
  *---------------------------------------------------------------------------*/
 int_f
@@ -80,7 +80,7 @@ nh5pget_fapl_mpio_c(hid_t_f *prp_id, int_f* comm, int_f* info)
      hid_t c_prp_id;
      herr_t ret;
      MPI_Comm c_comm;
-     MPI_Info c_info; 
+     MPI_Info c_info;
 
      /*
       * Call H5Pget_mpi function.
@@ -92,16 +92,16 @@ nh5pget_fapl_mpio_c(hid_t_f *prp_id, int_f* comm, int_f* info)
      *info = (int_f) MPI_Info_c2f(c_info);
      ret_value = 0;
      return ret_value;
-} 
+}
 /*----------------------------------------------------------------------------
  * Name:        h5pset_dxpl_mpio_c
- * Purpose:     Call H5Pset_dxpl_mpio to set transfer mode of the dataset 
- *              trasfer property list 
+ * Purpose:     Call H5Pset_dxpl_mpio to set transfer mode of the dataset
+ *              trasfer property list
  * Inputs:      prp_id - property list identifier
  *              data_xfer_mode - transfer mode
  * Returns:     0 on success, -1 on failure
- * Programmer:  Elena Pourmal 
- *              Thursday, October 26, 2000 
+ * Programmer:  Elena Pourmal
+ *              Thursday, October 26, 2000
  * Modifications:
  *---------------------------------------------------------------------------*/
 int_f
@@ -134,17 +134,17 @@ nh5pset_dxpl_mpio_c(hid_t_f *prp_id, int_f* data_xfer_mode)
      if (ret < 0) return ret_value;
      ret_value = 0;
      return ret_value;
-} 
+}
 
 /*----------------------------------------------------------------------------
  * Name:        h5pget_dxpl_mpio_c
- * Purpose:     Call H5Pget_dxpl_mpio to get transfer mode of the dataset 
- *              trasfer property list 
+ * Purpose:     Call H5Pget_dxpl_mpio to get transfer mode of the dataset
+ *              trasfer property list
  * Inputs:      prp_id - property list identifier
  *              data_xfer_mode  - buffer to retrieve transfer mode
  * Returns:     0 on success, -1 on failure
- * Programmer:  Elena Pourmal 
- *              Thursday, June 15, 2000 
+ * Programmer:  Elena Pourmal
+ *              Thursday, June 15, 2000
  * Modifications:
  *---------------------------------------------------------------------------*/
 int_f
@@ -161,7 +161,7 @@ nh5pget_dxpl_mpio_c(hid_t_f *prp_id, int_f* data_xfer_mode)
      c_prp_id = *prp_id;
      ret = H5Pget_dxpl_mpio(c_prp_id, &c_data_xfer_mode);
      if (ret < 0) return ret_value;
-     *data_xfer_mode = (int_f)c_data_xfer_mode; 
+     *data_xfer_mode = (int_f)c_data_xfer_mode;
 /*
      switch (c_data_xfer_mode) {
 
@@ -179,17 +179,17 @@ nh5pget_dxpl_mpio_c(hid_t_f *prp_id, int_f* data_xfer_mode)
 */
      ret_value = 0;
      return ret_value;
-} 
+}
 
 /*----------------------------------------------------------------------------
  * Name:        h5pset_fapl_mpiposix_c
- * Purpose:     Call H5Pset_fapl_mpiposix to set mode for parallel I/O and the user 
- *              supplied communicator 
+ * Purpose:     Call H5Pset_fapl_mpiposix to set mode for parallel I/O and the user
+ *              supplied communicator
  * Inputs:      prp_id - property list identifier
- *              comm   - MPI communicator 
+ *              comm   - MPI communicator
  *              flag   - flag to use GPFS hints
  * Returns:     0 on success, -1 on failure
- * Programmer:  Elena Pourmal 
+ * Programmer:  Elena Pourmal
  *              Tuesday, May 6, 2003
  * Modifications:
  *---------------------------------------------------------------------------*/
@@ -201,7 +201,7 @@ nh5pset_fapl_mpiposix_c(hid_t_f *prp_id, int_f* comm, int_f* flag)
      herr_t ret;
      hbool_t c_flag;
      MPI_Comm c_comm;
-     c_comm = MPI_Comm_f2c(*comm); 
+     c_comm = MPI_Comm_f2c(*comm);
      c_flag  = (hbool_t)*flag;
      /*
       * Call H5Pset_fapl_mpiposix function.
@@ -211,17 +211,17 @@ nh5pset_fapl_mpiposix_c(hid_t_f *prp_id, int_f* comm, int_f* flag)
      if (ret < 0) return ret_value;
      ret_value = 0;
      return ret_value;
-} 
+}
 
 /*----------------------------------------------------------------------------
  * Name:        h5pget_fapl_mpiposix_c
- * Purpose:     Call H5Pget_fapl_mpiposix to retrieve communicator and info object 
+ * Purpose:     Call H5Pget_fapl_mpiposix to retrieve communicator and info object
  * Inputs:      prp_id - property list identifier
- * Outputs:     comm   - buffer to return MPI communicator 
+ * Outputs:     comm   - buffer to return MPI communicator
  *              flag - flag to use GPFS hints
  * Returns:     0 on success, -1 on failure
- * Programmer:  Elena Pourmal 
- *              Tuesday, May 6, 2003 
+ * Programmer:  Elena Pourmal
+ *              Tuesday, May 6, 2003
  * Modifications:
  *---------------------------------------------------------------------------*/
 int_f
@@ -243,4 +243,4 @@ nh5pget_fapl_mpiposix_c(hid_t_f *prp_id, int_f* comm, int_f* flag)
      *flag = (int_f) c_flag;
      ret_value = 0;
      return ret_value;
-} 
+}
diff --git a/fortran/src/H5Ff.c b/fortran/src/H5Ff.c
index cc3fb36..4b21b45 100644
--- a/fortran/src/H5Ff.c
+++ b/fortran/src/H5Ff.c
@@ -20,11 +20,11 @@
 /*----------------------------------------------------------------------------
  * Name:        h5fcreate_c
  * Purpose:     Call H5Fcreate to create the file
- * Inputs:      name - name of the file     
+ * Inputs:      name - name of the file
  *              namelen - name length
  *              access_flags - file access  flags
  *              crt_pr  - identifier of creation property list
- *              acc_prp - identifier of access property list 
+ *              acc_prp - identifier of access property list
  * Outputs:     file_id - file identifier
  * Returns:     0 on success, -1 on failure
  * Programmer:  Elena Pourmal
@@ -65,7 +65,7 @@ nh5fcreate_c(_fcd name, int_f *namelen, int_f *access_flags, hid_t_f* crt_prp, h
       * Convert FORTRAN name to C name
       */
      c_namelen = *namelen;
-     c_name = (char *)HD5f2cstring(name, (size_t)c_namelen); 
+     c_name = (char *)HD5f2cstring(name, (size_t)c_namelen);
      if (c_name == NULL) return ret_value;
 
      /*
@@ -78,15 +78,15 @@ nh5fcreate_c(_fcd name, int_f *namelen, int_f *access_flags, hid_t_f* crt_prp, h
      HDfree(c_name);
      ret_value = 0;
      return ret_value;
-} 
-     
+}
+
 /*----------------------------------------------------------------------------
  * Name:        h5fflush_c
  * Purpose:     Call H5Fflush to flush the object
  * Inputs:      object_id - identifier of either a file, a dataset,
- *                          a group, an attribute or a named data type       
+ *                          a group, an attribute or a named data type
  *              scope - integer to specify the flushing action, either
- *                      H5F_SCOPE_GLOBAL or H5F_SCOPE_LOCAL 
+ *                      H5F_SCOPE_GLOBAL or H5F_SCOPE_LOCAL
  * Returns:     0 on success, -1 on failure
  * Programmer:  Xiangyang Su
  *              Friday, November 5, 1999
@@ -112,17 +112,17 @@ nh5fflush_c (hid_t_f *object_id, int_f *scope)
      if (status >= 0)  ret_value = 0;
 
      return ret_value;
-}      
+}
 
 
 /*----------------------------------------------------------------------------
  * Name:        h5fmount_c
  * Purpose:     Call H5Fmount to mount the file
  * Inputs:      loc_id - Identifier for file or group
- *              dsetname - name of dataset    
+ *              dsetname - name of dataset
  *              namelen - dsetname length
  *              file_id - file identifier for the file to be mounted
- *              acc_prp - identifier of access property list 
+ *              acc_prp - identifier of access property list
  * Returns:     0 on success, -1 on failure
  * Programmer:  Xiangyang Su
  *              Monday, October 25, 1999
@@ -153,7 +153,7 @@ nh5fmount_c (hid_t_f *loc_id, _fcd dsetname, int_f *namelen, hid_t_f *file_id, h
       * Convert FORTRAN name to C name
       */
      c_namelen = *namelen;
-     c_name = (char *)HD5f2cstring(dsetname, (size_t)c_namelen); 
+     c_name = (char *)HD5f2cstring(dsetname, (size_t)c_namelen);
      if (c_name == NULL) return ret_value;
 
      /*
@@ -165,13 +165,13 @@ nh5fmount_c (hid_t_f *loc_id, _fcd dsetname, int_f *namelen, hid_t_f *file_id, h
 
      HDfree(c_name);
      return ret_value;
-}      
+}
 
 /*----------------------------------------------------------------------------
  * Name:        h5funmount_c
  * Purpose:     Call H5Funmount to unmount the file
  * Inputs:      loc_id - Identifier for file or group
- *              dsetname - name of dataset    
+ *              dsetname - name of dataset
  *              namelen - dsetname length
  * Returns:     0 on success, -1 on failure
  * Programmer:  Xiangyang Su
@@ -193,7 +193,7 @@ nh5funmount_c (hid_t_f *loc_id, _fcd dsetname, int_f *namelen)
       * Convert FORTRAN name to C name
       */
      c_namelen = *namelen;
-     c_name = (char *)HD5f2cstring(dsetname, (size_t)c_namelen); 
+     c_name = (char *)HD5f2cstring(dsetname, (size_t)c_namelen);
      if (c_name == NULL) return ret_value;
 
      /*
@@ -205,17 +205,17 @@ nh5funmount_c (hid_t_f *loc_id, _fcd dsetname, int_f *namelen)
 
      HDfree(c_name);
      return ret_value;
-}      
+}
 
 
 
 /*----------------------------------------------------------------------------
  * Name:        h5fopen_c
  * Purpose:     Call H5Fopen to open the file
- * Inputs:      name - name of the file     
+ * Inputs:      name - name of the file
  *              namelen - name length
  *              access_flags - file access  flags
- *              acc_prp - identifier of access property list 
+ *              acc_prp - identifier of access property list
  * Outputs:     file_id - file identifier
  * Returns:     0 on success, -1 on failure
  * Programmer:  Elena Pourmal
@@ -249,7 +249,7 @@ nh5fopen_c (_fcd name, int_f *namelen, int_f *access_flags, hid_t_f *acc_prp, hi
       * Convert FORTRAN name to C name
       */
      c_namelen = *namelen;
-     c_name = (char *)HD5f2cstring(name, (size_t)c_namelen); 
+     c_name = (char *)HD5f2cstring(name, (size_t)c_namelen);
      if (c_name == NULL) return ret_value;
 
      /*
@@ -263,7 +263,7 @@ nh5fopen_c (_fcd name, int_f *namelen, int_f *access_flags, hid_t_f *acc_prp, hi
      HDfree(c_name);
      ret_value = 0;
      return ret_value;
-}      
+}
 
 /*----------------------------------------------------------------------------
  * Name:        h5freopen_c
@@ -289,7 +289,7 @@ nh5freopen_c (hid_t_f *file_id1, hid_t_f *file_id2)
 
      ret_value = 0;
      return ret_value;
-}      
+}
 
 /*----------------------------------------------------------------------------
  * Name:        h5fget_create_plist_c
@@ -315,7 +315,7 @@ nh5fget_create_plist_c (hid_t_f *file_id, hid_t_f *prop_id)
 
      ret_value = 0;
      return ret_value;
-}      
+}
 
 /*----------------------------------------------------------------------------
  * Name:        h5fget_access_plist_c
@@ -341,15 +341,15 @@ nh5fget_access_plist_c (hid_t_f *file_id, hid_t_f *access_id)
 
      ret_value = 0;
      return ret_value;
-}      
-      
+}
+
 /*----------------------------------------------------------------------------
  * Name:        h5fis_hdf5_c
  * Purpose:     Call H5Fis_hdf5 to determone if the file is an HDF5 file
- * Inputs:      name - name of the file     
+ * Inputs:      name - name of the file
  *              namelen - name length
  * Outputs:     flag - 0 if file is not HDF5 file , positive if a file
- *                     is an HDF5 file, and negative on failure. 
+ *                     is an HDF5 file, and negative on failure.
  * Returns:     0 on success, -1 on failure
  * Programmer:  Elena Pourmal
  *              Tuesday, August 3, 1999
@@ -367,7 +367,7 @@ nh5fis_hdf5_c (_fcd name, int_f *namelen, int_f *flag)
       * Convert FORTRAN name to C name
       */
      c_namelen = *namelen;
-     c_name = (char *)HD5f2cstring(name, (size_t)c_namelen); 
+     c_name = (char *)HD5f2cstring(name, (size_t)c_namelen);
      if (c_name == NULL) return ret_value;
 
      /*
@@ -379,7 +379,7 @@ nh5fis_hdf5_c (_fcd name, int_f *namelen, int_f *flag)
 
      HDfree(c_name);
      return ret_value;
-}      
+}
 /*----------------------------------------------------------------------------
  * Name:        h5fclose_c
  * Purpose:     Call H5Fclose to close the file
@@ -390,7 +390,7 @@ nh5fis_hdf5_c (_fcd name, int_f *namelen, int_f *flag)
  * Modifications:
  *---------------------------------------------------------------------------*/
 
-int_f 
+int_f
 nh5fclose_c ( hid_t_f *file_id )
 {
   int ret_value = 0;
@@ -405,21 +405,21 @@ nh5fclose_c ( hid_t_f *file_id )
  * Purpose:     Call H5Fget_obj_count to get number of open objects within a file
  * Inputs:      file_id - identifier of the file to be closed
  *              obj_type - type of the object
- * Returns:     obj_count - number of objects 
+ * Returns:     obj_count - number of objects
  *              0 on success, -1 on failure
  * Programmer:  Elena Pourmal
  *              Monday, September 30, 2002
  * Modifications:
  *---------------------------------------------------------------------------*/
 
-int_f 
+int_f
 nh5fget_obj_count_c ( hid_t_f *file_id , int_f *obj_type, int_f * obj_count)
 {
   int ret_value = 0;
   hid_t c_file_id;
   unsigned c_obj_type;
   int c_obj_count;
-  
+
 
   c_file_id = (hid_t)*file_id;
   c_obj_type = (unsigned) *obj_type;
@@ -439,7 +439,7 @@ nh5fget_obj_count_c ( hid_t_f *file_id , int_f *obj_type, int_f * obj_count)
  * Modifications:
  *---------------------------------------------------------------------------*/
 
-int_f 
+int_f
 nh5fget_obj_ids_c ( hid_t_f *file_id , int_f *obj_type, int_f *max_objs, hid_t_f *obj_ids)
 {
   int ret_value = 0;
@@ -464,7 +464,7 @@ nh5fget_obj_ids_c ( hid_t_f *file_id , int_f *obj_type, int_f *max_objs, hid_t_f
  * Modifications:
  *---------------------------------------------------------------------------*/
 
-int_f 
+int_f
 nh5fget_freespace_c ( hid_t_f *file_id , hssize_t_f *free_space)
 {
   int ret_value = 0;
@@ -479,9 +479,9 @@ nh5fget_freespace_c ( hid_t_f *file_id , hssize_t_f *free_space)
 
 /*----------------------------------------------------------------------------
  * Name:        h5fget_name_c
- * Purpose:     Call H5Fget_name to get file's name 
- * Inputs:      obj_id - object identifier 
- *              buflen -size of the buffer 
+ * Purpose:     Call H5Fget_name to get file's name
+ * Inputs:      obj_id - object identifier
+ *              buflen -size of the buffer
  * Outputs:     buf - buffer to hold the name
  *              size - size of the file's name
  * Returns:     0 on success, -1 on failure
@@ -501,7 +501,7 @@ nh5fget_name_c(hid_t_f *obj_id, size_t_f *size, _fcd buf, size_t_f *buflen)
       */
      if ((c_buf = HDmalloc((size_t)*buflen +1)) == NULL)
          HGOTO_DONE(FAIL);
- 
+
      /*
       * Call H5Aget_name function
       */
@@ -522,7 +522,7 @@ done:
 /*----------------------------------------------------------------------------
  * Name:        h5fget_filesize_c
  * Purpose:     Call H5Fget_filesize to get file size
- * Inputs:      file_id - file identifier 
+ * Inputs:      file_id - file identifier
  * Outputs:     size - size of the file
  * Returns:     0 on success, -1 on failure
  * Programmer:  Elena Pourmal
diff --git a/fortran/src/H5Gf.c b/fortran/src/H5Gf.c
index 42f5658..fdce19f 100644
--- a/fortran/src/H5Gf.c
+++ b/fortran/src/H5Gf.c
@@ -18,9 +18,9 @@
 
 /*----------------------------------------------------------------------------
  * Name:        h5gcreate_c
- * Purpose:     Call H5Gcreate to create a group 
- * Inputs:      loc_id - file or group identifier 
- *              name - name of the group     
+ * Purpose:     Call H5Gcreate to create a group
+ * Inputs:      loc_id - file or group identifier
+ *              name - name of the group
  *              namelen - name length
  *              size_hint - length of names in the group
  * Outputs:     grp_id - group identifier
@@ -43,16 +43,16 @@ nh5gcreate_c (hid_t_f *loc_id, _fcd name, int_f *namelen, size_t_f *size_hint,
       * Convert FORTRAN name to C name
       */
      c_namelen = *namelen;
-     c_name = (char *)HD5f2cstring(name, c_namelen); 
+     c_name = (char *)HD5f2cstring(name, c_namelen);
      if (c_name == NULL) return ret_value;
      /*
       * Call H5Gcreate function.
       */
      c_loc_id = *loc_id;
-     if ( *size_hint == OBJECT_NAMELEN_DEFAULT_F ) 
+     if ( *size_hint == OBJECT_NAMELEN_DEFAULT_F )
      c_grp_id = H5Gcreate(c_loc_id, c_name, 0);
      else {
-          c_size_hint = (size_t)*size_hint; 
+          c_size_hint = (size_t)*size_hint;
           c_grp_id = H5Gcreate(c_loc_id, c_name, c_size_hint);
      }
      if (c_grp_id < 0) goto DONE;
@@ -62,13 +62,13 @@ nh5gcreate_c (hid_t_f *loc_id, _fcd name, int_f *namelen, size_t_f *size_hint,
 DONE:
      HDfree(c_name);
      return ret_value;
-}      
+}
 
 /*----------------------------------------------------------------------------
  * Name:        h5gopen_c
- * Purpose:     Call H5Gopen to open a dataset 
- * Inputs:      loc_id - file or group identifier 
- *              name - name of the group     
+ * Purpose:     Call H5Gopen to open a dataset
+ * Inputs:      loc_id - file or group identifier
+ *              name - name of the group
  *              namelen - name length
  * Outputs:     grp_id - group identifier
  * Returns:     0 on success, -1 on failure
@@ -89,7 +89,7 @@ nh5gopen_c (hid_t_f *loc_id, _fcd name, int_f *namelen, hid_t_f *grp_id)
       * Convert FORTRAN name to C name
       */
      c_namelen = *namelen;
-     c_name = (char *)HD5f2cstring(name, c_namelen); 
+     c_name = (char *)HD5f2cstring(name, c_namelen);
      if (c_name == NULL) return ret_value;
 
      /*
@@ -105,27 +105,27 @@ nh5gopen_c (hid_t_f *loc_id, _fcd name, int_f *namelen, hid_t_f *grp_id)
 DONE:
      HDfree(c_name);
      return ret_value;
-}      
+}
 
 /*----------------------------------------------------------------------------
  * Name:        h5gget_obj_info_idx_c
  * Purpose:     Call H5Gget_obj_info to return name and the type of group
- *              member 
- * Inputs:      loc_id - file or group identifier 
- *              name - name of the group     
+ *              member
+ * Inputs:      loc_id - file or group identifier
+ *              name - name of the group
  *              namelen - name length
  *              idx - index of the group member
  * Outputs:     obj_name - buffer to store member's name
  *              obj_namelen - length of the buffer
- *              obj_type - type of the object 
+ *              obj_type - type of the object
  * Returns:     0 on success, -1 on failure
  * Programmer:  Elena Pourmal
  *              Wednesday, August 5, 1999
  * Modifications:
  *---------------------------------------------------------------------------*/
 int_f
-nh5gget_obj_info_idx_c 
-(hid_t_f *loc_id, _fcd name, int_f *namelen, int_f *idx, _fcd obj_name, int_f *obj_namelen, int_f *obj_type) 
+nh5gget_obj_info_idx_c
+(hid_t_f *loc_id, _fcd name, int_f *namelen, int_f *idx, _fcd obj_name, int_f *obj_namelen, int_f *obj_type)
 {
      int ret_value = -1;
      hid_t c_loc_id = (hid_t)*loc_id;
@@ -142,13 +142,13 @@ nh5gget_obj_info_idx_c
       */
      c_namelen = *namelen;
      c_obj_namelen = *obj_namelen;
-     c_name = (char *)HD5f2cstring(name, c_namelen); 
+     c_name = (char *)HD5f2cstring(name, c_namelen);
      if (c_name == NULL) return ret_value;
 
      /*
       * Allocate buffer to hold name of the object
       */
-     if (c_obj_namelen) c_obj_name = (char *)HDmalloc(c_obj_namelen + 1); 
+     if (c_obj_namelen) c_obj_name = (char *)HDmalloc(c_obj_namelen + 1);
      if (c_obj_name == NULL) { HDfree(c_name);
                                return ret_value;
                              }
@@ -175,15 +175,15 @@ DONE:
      HDfree(c_obj_name);
      HDfree(c_name);
      return ret_value;
-}      
+}
 
 /*----------------------------------------------------------------------------
  * Name:        h5gn_members_c
- * Purpose:     Call H5Gn_members to find number of objects in the group 
- * Inputs:      loc_id - file or group identifier 
- *              name - name of the group     
+ * Purpose:     Call H5Gn_members to find number of objects in the group
+ * Inputs:      loc_id - file or group identifier
+ *              name - name of the group
  *              namelen - name length
- * Outputs:     nmemebers - number of members 
+ * Outputs:     nmemebers - number of members
  * Returns:     0 on success, -1 on failure
  * Programmer:  Elena Pourmal
  *              Wednesday, August 5, 1999
@@ -196,14 +196,14 @@ nh5gn_members_c (hid_t_f *loc_id, _fcd name, int_f *namelen, int_f *nmembers)
      hid_t c_loc_id=(hid_t)*loc_id;
      char *c_name;
      int c_namelen;
-     hsize_t c_nmembers; 
+     hsize_t c_nmembers;
      hid_t gid = (-1);
 
      /*
       * Convert FORTRAN name to C name
       */
      c_namelen = *namelen;
-     c_name = (char *)HD5f2cstring(name, c_namelen); 
+     c_name = (char *)HD5f2cstring(name, c_namelen);
      if (c_name == NULL) return ret_value;
 
      /* Get a temporary group ID for the group to query */
@@ -221,10 +221,10 @@ DONE:
 
      HDfree(c_name);
      return ret_value;
-}      
+}
 /*----------------------------------------------------------------------------
  * Name:        h5gclose_c
- * Purpose:     Call H5Gclose to close the group 
+ * Purpose:     Call H5Gclose to close the group
  * Inputs:      grp_id - identifier of the group to be closed
  * Returns:     0 on success, -1 on failure
  * Programmer:  Elena Pourmal
@@ -232,12 +232,12 @@ DONE:
  * Modifications:
  *---------------------------------------------------------------------------*/
 
-int_f 
+int_f
 nh5gclose_c ( hid_t_f *grp_id )
 {
   int ret_value = 0;
   hid_t c_grp_id;
-  
+
   c_grp_id = (hid_t)*grp_id;
   if ( H5Gclose(c_grp_id) < 0  ) ret_value = -1;
   return ret_value;
@@ -246,8 +246,8 @@ nh5gclose_c ( hid_t_f *grp_id )
 
 /*----------------------------------------------------------------------------
  * Name:        h5glink_c
- * Purpose:     Call H5Glink to link the specified type 
- * Inputs:      loc_id - identifier of file or group 
+ * Purpose:     Call H5Glink to link the specified type
+ * Inputs:      loc_id - identifier of file or group
  *              link_type - link type
  *              current_name - name of the existing object for hard link,
  *                             anything for the soft link
@@ -278,7 +278,7 @@ nh5glink_c(hid_t_f *loc_id, int_f *link_type, _fcd current_name, int_f *current_
   if (c_current_name == NULL) return ret_value;
 
   c_new_name = (char *)HD5f2cstring(new_name, c_new_namelen);
-  if(c_new_name == NULL) { HDfree(c_current_name); 
+  if(c_new_name == NULL) { HDfree(c_current_name);
                            return ret_value;
                          }
   /*
@@ -299,8 +299,8 @@ DONE:
 
 /*----------------------------------------------------------------------------
  * Name:        h5glink2_c
- * Purpose:     Call H5Glink2 to link the specified type 
- * Inputs:      cur_loc_id - identifier of file or group 
+ * Purpose:     Call H5Glink2 to link the specified type
+ * Inputs:      cur_loc_id - identifier of file or group
  *              cur_name - name of the existing object for hard link releative
  *                         to cur_loc_id location,
  *                         anything for the soft link
@@ -313,7 +313,7 @@ DONE:
  * Returns:     0 on success, -1 on failure
  * Programmer:  Elena Pourmal
  *              Wednesday, September 25, 2002
- * Modifications: 
+ * Modifications:
  *---------------------------------------------------------------------------*/
 
 int_f
@@ -357,8 +357,8 @@ DONE:
 
 /*----------------------------------------------------------------------------
  * Name:        h5gunlink_c
- * Purpose:     Call H5Gunlink to remove  the specified name 
- * Inputs:      loc_id - identifier of file or group             
+ * Purpose:     Call H5Gunlink to remove  the specified name
+ * Inputs:      loc_id - identifier of file or group
  *              name - name of the object to unlink
  * Returns:     0 on success, -1 on failure
  * Programmer:  Mingshi Chen
@@ -396,8 +396,8 @@ DONE:
 /*----------------------------------------------------------------------------
  * Name:        h5gmove_c
  * Purpose:     Call H5Gmove to rename an object within an HDF5 file
- * Inputs:      loc_id - identifier of file or group 
- *              src_name - name of the original object 
+ * Inputs:      loc_id - identifier of file or group
+ *              src_name - name of the original object
  *              src_namelen - original name lenghth
  *              dst_name - new name for the object
  *              dst_namelen - new name lenghth
@@ -424,7 +424,7 @@ nh5gmove_c(hid_t_f *loc_id, _fcd src_name, int_f *src_namelen, _fcd dst_name, in
   if(c_src_name == NULL) return ret_value;
 
   c_dst_name = (char *)HD5f2cstring(dst_name, c_dst_namelen);
-  if(c_dst_name == NULL) { HDfree(c_src_name); 
+  if(c_dst_name == NULL) { HDfree(c_src_name);
                            return ret_value;
                          }
   /*
@@ -445,7 +445,7 @@ DONE:
 /*----------------------------------------------------------------------------
  * Name:        h5gmove2_c
  * Purpose:     Call H5Gmove2 to rename an object within an HDF5 file
- * Inputs:      src_loc_id - identifier of file or group 
+ * Inputs:      src_loc_id - identifier of file or group
  *              src_name - name of the original object relative to src_loc_id
  *              src_namelen - original name lenghth
  *              dst_loc_id - new location identifier
@@ -454,7 +454,7 @@ DONE:
  * Returns:     0 on success, -1 on failure
  * Programmer:  Elena Pourmal
  *              Wednesday, September 25, 2002
- * Modifications: 
+ * Modifications:
  *---------------------------------------------------------------------------*/
 
 int_f
@@ -475,7 +475,7 @@ nh5gmove2_c(hid_t_f *src_loc_id, _fcd src_name, int_f *src_namelen, hid_t_f *dst
   if(c_src_name == NULL) return ret_value;
 
   c_dst_name = (char *)HD5f2cstring(dst_name, c_dst_namelen);
-  if(c_dst_name == NULL) { HDfree(c_src_name); 
+  if(c_dst_name == NULL) { HDfree(c_src_name);
                            return ret_value;
                          }
   /*
@@ -497,8 +497,8 @@ DONE:
 /*----------------------------------------------------------------------------
  * Name:        h5gget_linkval_c
  * Purpose:     Call H5Gget_linkval to return the name of object
- * Inputs:      loc_id - identifier of file or group 
- *              name - name of the object that symbolic link points to 
+ * Inputs:      loc_id - identifier of file or group
+ *              name - name of the object that symbolic link points to
  *              namelen - the name lenghth
  *              size - lenghth of retrurned value
  * Outputs:     value - name to be returned
@@ -530,10 +530,10 @@ nh5gget_linkval_c(hid_t_f *loc_id, _fcd name, int_f *namelen, size_t_f *size, _f
    */
   if(*size) c_value = (char *)HDmalloc((size_t)*size);
   if(c_value == NULL) {
-                     HDfree(c_name); 
+                     HDfree(c_name);
                      return ret_value;
                      }
-  
+
   /*
    *  Call H5Gget_linkval function
    */
@@ -542,7 +542,7 @@ nh5gget_linkval_c(hid_t_f *loc_id, _fcd name, int_f *namelen, size_t_f *size, _f
   c_loc_id = (hid_t)*loc_id;
   c_ret_value = H5Gget_linkval(c_loc_id, c_name, c_size, c_value);
   if(c_ret_value < 0) goto DONE;
-                       
+
 
   /*
    *  Convert C name to FORTRAN and place it in the given buffer
@@ -559,8 +559,8 @@ DONE:
 /*----------------------------------------------------------------------------
  * Name:        h5gset_comment_c
  * Purpose:     Call H5Gset_comment to set comments for the specified object
- * Inputs:      loc_id - identifier of file or group 
- *              name - name of object whose comment is to be set or reset 
+ * Inputs:      loc_id - identifier of file or group
+ *              name - name of object whose comment is to be set or reset
  *              namelen - the name lenghth
  *              comment - the new comment
  *              commentlen - new comment lenghth
@@ -608,8 +608,8 @@ DONE:
 /*----------------------------------------------------------------------------
  * Name:        h5gget_comment_c
  * Purpose:     Call H5Gget_comment to retrieve comments for the specified object
- * Inputs:      loc_id - identifier of file or group 
- *              name - name of object whose comment is to be set or reset 
+ * Inputs:      loc_id - identifier of file or group
+ *              name - name of object whose comment is to be set or reset
  *              namelen - the name lenghth
  *              bufsize - at most bufsize characters
  *              comment - the new comment
@@ -629,7 +629,7 @@ nh5gget_comment_c(hid_t_f *loc_id, _fcd name, int_f *namelen, size_t_f *bufsize,
   char *c_comment = NULL;
   size_t c_bufsize;
   herr_t c_ret_value;
-  
+
   /*
    *  Convert Fortran name to C name
    */
@@ -646,7 +646,7 @@ nh5gget_comment_c(hid_t_f *loc_id, _fcd name, int_f *namelen, size_t_f *bufsize,
                         HDfree(c_name);
                         return ret_value;
                         }
-  
+
   /*
    *  Call H5Gget_comment function
    */
diff --git a/fortran/src/H5If.c b/fortran/src/H5If.c
index e739508..6931066 100644
--- a/fortran/src/H5If.c
+++ b/fortran/src/H5If.c
@@ -19,9 +19,9 @@
 
 /*----------------------------------------------------------------------------
  * Name:        h5iget_type_c
- * Purpose:     Call H5Iget_type to get the type of an object 
- * Inputs:      obj_id - object identifier 
- * Outputs:     type - object type 
+ * Purpose:     Call H5Iget_type to get the type of an object
+ * Inputs:      obj_id - object identifier
+ * Outputs:     type - object type
  * Returns:     0 on success, -1 on failure
  * Programmer:  Xiangyang Su
  *              Thursday, March 24, 2000
@@ -46,9 +46,9 @@ nh5iget_type_c (hid_t_f *obj_id, int_f *type)
 }
 /*----------------------------------------------------------------------------
  * Name:        h5iget_name_c
- * Purpose:     Call H5Iget_name to get object's name 
- * Inputs:      obj_id - object identifier 
- *              buf_size - size of the buffer 
+ * Purpose:     Call H5Iget_name to get object's name
+ * Inputs:      obj_id - object identifier
+ *              buf_size - size of the buffer
  * Outputs:     buf - buffer to hold the name
  * Returns:     length of the name on success, -1 on failure
  * Programmer:  Elena Pourmal
@@ -69,8 +69,8 @@ nh5iget_name_c(hid_t_f *obj_id, _fcd buf, size_t_f *buf_size, size_t_f *name_siz
       */
      c_buf_size = (size_t)*buf_size;
      c_buf = (char *)HDmalloc(c_buf_size +1);
-     if (c_buf == NULL) return ret_value; 
- 
+     if (c_buf == NULL) return ret_value;
+
      /*
       * Call H5IAget_name function
       */
@@ -93,7 +93,7 @@ DONE:
 /*----------------------------------------------------------------------------
  * Name:        h5iinc_ref_c
  * Purpose:     Call H5Iinc_ref to increment object's reference count
- * Inputs:      obj_id - object identifier 
+ * Inputs:      obj_id - object identifier
  * Outputs:     ref_count - Reference count of ID
  * Returns:     current reference count on success, -1 on failure
  * Programmer:  Quincey Koziol
@@ -122,7 +122,7 @@ done:
 /*----------------------------------------------------------------------------
  * Name:        h5idec_ref_c
  * Purpose:     Call H5Idec_ref to decrement object's reference count
- * Inputs:      obj_id - object identifier 
+ * Inputs:      obj_id - object identifier
  * Outputs:     ref_count - Reference count of ID
  * Returns:     current reference count on success, -1 on failure
  * Programmer:  Quincey Koziol
@@ -151,7 +151,7 @@ done:
 /*----------------------------------------------------------------------------
  * Name:        h5iget_ref_c
  * Purpose:     Call H5Iget_ref to retrieve object's reference count
- * Inputs:      obj_id - object identifier 
+ * Inputs:      obj_id - object identifier
  * Outputs:     ref_count - Reference count of ID
  * Returns:     current reference count on success, -1 on failure
  * Programmer:  Quincey Koziol
@@ -180,7 +180,7 @@ done:
 /*----------------------------------------------------------------------------
  * Name:        h5iget_file_id_c
  * Purpose:     Call H5Iget_file_id to obtain file identifier from object identifier
- * Inputs:      obj_id - object identifier 
+ * Inputs:      obj_id - object identifier
  * Outputs:     file_id - file identifier
  * Returns:     0 on success, -1 on failure
  * Programmer:  Elena Pourmal
diff --git a/fortran/src/H5Pf.c b/fortran/src/H5Pf.c
index 2b6e8be..91508c0 100644
--- a/fortran/src/H5Pf.c
+++ b/fortran/src/H5Pf.c
@@ -19,24 +19,24 @@
 
 /*----------------------------------------------------------------------------
  * Name:        h5pcreate_c
- * Purpose:     Call H5Pcreate to create a property list 
+ * Purpose:     Call H5Pcreate to create a property list
  * Inputs:      class - property list class identifier
- * Outputs:     prp_id - identifier of the created property list 
+ * Outputs:     prp_id - identifier of the created property list
  * Returns:     0 on success, -1 on failure
  * Programmer:  Elena Pourmal
  *              Wednesday, October 9, 2002
  * Modifications:
  *---------------------------------------------------------------------------*/
 
-int_f 
+int_f
 nh5pcreate_c ( hid_t_f *class, hid_t_f *prp_id )
 {
   hid_t c_class;
   int ret_value = 0;
   hid_t c_prp_id;
-  
+
   c_class = (hid_t)*class;
-  c_prp_id = H5Pcreate(c_class); 
+  c_prp_id = H5Pcreate(c_class);
 
   if ( c_prp_id  < 0  ) ret_value = -1;
   *prp_id = (hid_t_f)c_prp_id;
@@ -45,7 +45,7 @@ nh5pcreate_c ( hid_t_f *class, hid_t_f *prp_id )
 
 /*----------------------------------------------------------------------------
  * Name:        h5pclose_c
- * Purpose:     Call H5Pclose to close property lis 
+ * Purpose:     Call H5Pclose to close property lis
  * Inputs:      prp_id - identifier of the property list to be closed
  * Returns:     0 on success, -1 on failure
  * Programmer:  Elena Pourmal
@@ -53,7 +53,7 @@ nh5pcreate_c ( hid_t_f *class, hid_t_f *prp_id )
  * Modifications:
  *---------------------------------------------------------------------------*/
 
-int_f 
+int_f
 nh5pclose_c ( hid_t_f *prp_id )
 {
   int ret_value = 0;
@@ -66,16 +66,16 @@ nh5pclose_c ( hid_t_f *prp_id )
 
 /*----------------------------------------------------------------------------
  * Name:        h5pcopy_c
- * Purpose:     Call H5Pcopy to copy property list 
- * Inputs:      prp_id - identifier of the property list to be copied 
- * Outputs:     new_prp_id - identifier of the new property list 
+ * Purpose:     Call H5Pcopy to copy property list
+ * Inputs:      prp_id - identifier of the property list to be copied
+ * Outputs:     new_prp_id - identifier of the new property list
  * Returns:     0 on success, -1 on failure
  * Programmer:  Elena Pourmal
  *              Saturday, August 14, 1999
  * Modifications:
  *---------------------------------------------------------------------------*/
 
-int_f 
+int_f
 nh5pcopy_c ( hid_t_f *prp_id , hid_t_f *new_prp_id)
 {
   int ret_value = 0;
@@ -83,7 +83,7 @@ nh5pcopy_c ( hid_t_f *prp_id , hid_t_f *new_prp_id)
   hid_t c_new_prp_id;
 
   c_prp_id = *prp_id;
-  c_new_prp_id = H5Pcopy(c_prp_id); 
+  c_new_prp_id = H5Pcopy(c_prp_id);
   if ( c_new_prp_id < 0  ) ret_value = -1;
   *new_prp_id = (hid_t_f)c_new_prp_id;
   return ret_value;
@@ -91,7 +91,7 @@ nh5pcopy_c ( hid_t_f *prp_id , hid_t_f *new_prp_id)
 
 /*----------------------------------------------------------------------------
  * Name:        h5pequal_c
- * Purpose:     Call H5Pequal to check if two property lists are equal 
+ * Purpose:     Call H5Pequal to check if two property lists are equal
  * Inputs:      plist1_id - property list identifier
  *              plist2_id - property list identifier
  * Outputs:     c_flag    - flag to indicate that lists are eqaul
@@ -101,7 +101,7 @@ nh5pcopy_c ( hid_t_f *prp_id , hid_t_f *new_prp_id)
  * Modifications:
  *---------------------------------------------------------------------------*/
 
-int_f 
+int_f
 nh5pequal_c ( hid_t_f *plist1_id , hid_t_f *plist2_id, int_f * c_flag)
 {
   int ret_value = 0;
@@ -111,7 +111,7 @@ nh5pequal_c ( hid_t_f *plist1_id , hid_t_f *plist2_id, int_f * c_flag)
 
   c_plist1_id = (hid_t)*plist1_id;
   c_plist2_id = (hid_t)*plist2_id;
-  c_c_flag = H5Pequal(c_plist1_id, c_plist2_id); 
+  c_c_flag = H5Pequal(c_plist1_id, c_plist2_id);
   if ( c_c_flag < 0  ) ret_value = -1;
   *c_flag = (int_f)c_c_flag;
   return ret_value;
@@ -121,9 +121,9 @@ nh5pequal_c ( hid_t_f *plist1_id , hid_t_f *plist2_id, int_f * c_flag)
 /*----------------------------------------------------------------------------
  * Name:        h5pget_class_c
  * Purpose:     Call H5Pget_class to determine property list class
- * Inputs:      prp_id - identifier of the dataspace 
+ * Inputs:      prp_id - identifier of the dataspace
  * Outputs:     classtype - class type; possible values are:
- *              H5P_NO_CLASS_F       -1 
+ *              H5P_NO_CLASS_F       -1
  *              H5P_FILE_CREATE_F     0
  *              H5P_FILE_ACCESS_F     1
  *              H5P_DATASET_CREATE_F  2
@@ -135,17 +135,17 @@ nh5pequal_c ( hid_t_f *plist1_id , hid_t_f *plist2_id, int_f * c_flag)
  * Modifications:
  *---------------------------------------------------------------------------*/
 
-int_f 
+int_f
 nh5pget_class_c ( hid_t_f *prp_id , int_f *classtype)
 {
   int ret_value = 0;
   hid_t c_prp_id;
-  hid_t c_classtype; 
+  hid_t c_classtype;
 
   c_prp_id = *prp_id;
   c_classtype = H5Pget_class(c_prp_id);
   if (c_classtype == H5P_NO_CLASS ) {
-      *classtype = H5P_NO_CLASS; 
+      *classtype = H5P_NO_CLASS;
        ret_value = -1;
        return ret_value;
   }
@@ -156,17 +156,17 @@ nh5pget_class_c ( hid_t_f *prp_id , int_f *classtype)
 
 /*----------------------------------------------------------------------------
  * Name:        h5pset_preserve_c
- * Purpose:     Call H5Pset_preserve to set  transfer property for compound 
+ * Purpose:     Call H5Pset_preserve to set  transfer property for compound
  *              datatype
- * Inputs:      prp_id - property list identifier 
- *              flag - TRUE/FALSE flag 
+ * Inputs:      prp_id - property list identifier
+ *              flag - TRUE/FALSE flag
  * Returns:     0 on success, -1 on failure
  * Programmer:  Elena Pourmal
- *              Thursday, February 17, 2000 
+ *              Thursday, February 17, 2000
  * Modifications:
  *---------------------------------------------------------------------------*/
 
-int_f 
+int_f
 nh5pset_preserve_c ( hid_t_f *prp_id , int_f *flag)
 {
   int ret_value = 0;
@@ -184,22 +184,22 @@ nh5pset_preserve_c ( hid_t_f *prp_id , int_f *flag)
 
 /*----------------------------------------------------------------------------
  * Name:        h5pget_preserve_c
- * Purpose:     Call H5Pget_preserve to set  transfer property for compound 
+ * Purpose:     Call H5Pget_preserve to set  transfer property for compound
  *              datatype
- * Inputs:      prp_id - property list identifier 
- * Outputs:     flag - TRUE/FALSE flag 
+ * Inputs:      prp_id - property list identifier
+ * Outputs:     flag - TRUE/FALSE flag
  * Returns:     0 on success, -1 on failure
  * Programmer:  Elena Pourmal
- *              Thursday, February 17, 2000 
+ *              Thursday, February 17, 2000
  * Modifications:
  *---------------------------------------------------------------------------*/
 
-int_f 
+int_f
 nh5pget_preserve_c ( hid_t_f *prp_id , int_f *flag)
 {
   int ret_value = 0;
   hid_t c_prp_id;
-  int c_flag; 
+  int c_flag;
 
   c_prp_id = (hid_t)*prp_id;
   c_flag = H5Pget_preserve(c_prp_id);
@@ -210,16 +210,16 @@ nh5pget_preserve_c ( hid_t_f *prp_id , int_f *flag)
 
 /*----------------------------------------------------------------------------
  * Name:        h5pset_deflate_c
- * Purpose:     Call H5Pset_deflate to set deflate level 
- * Inputs:      prp_id - property list identifier 
- *              level - level of deflation 
+ * Purpose:     Call H5Pset_deflate to set deflate level
+ * Inputs:      prp_id - property list identifier
+ *              level - level of deflation
  * Returns:     0 on success, -1 on failure
  * Programmer:  Elena Pourmal
  *              Saturday, August 14, 1999
  * Modifications:
  *---------------------------------------------------------------------------*/
 
-int_f 
+int_f
 nh5pset_deflate_c ( hid_t_f *prp_id , int_f *level)
 {
   int ret_value = 0;
@@ -239,17 +239,17 @@ nh5pset_deflate_c ( hid_t_f *prp_id , int_f *level)
 /*----------------------------------------------------------------------------
  * Name:        h5pset_chunk_c
  * Purpose:     Call H5Pset_chunk to set the sizes of chunks for a chunked
- *              layout dataset 
- * Inputs:      prp_id - property list identifier 
- *              rank - number of dimensions of each chunk 
- *              dims - array of the size of each chunk 
+ *              layout dataset
+ * Inputs:      prp_id - property list identifier
+ *              rank - number of dimensions of each chunk
+ *              dims - array of the size of each chunk
  * Returns:     0 on success, -1 on failure
  *              Saturday, August 14, 1999
  * Programmer:  Elena Pourmal
  * Modifications:
  *---------------------------------------------------------------------------*/
 
-int_f 
+int_f
 nh5pset_chunk_c ( hid_t_f *prp_id, int_f *rank, hsize_t_f *dims )
 {
   int ret_value = -1;
@@ -278,23 +278,23 @@ nh5pset_chunk_c ( hid_t_f *prp_id, int_f *rank, hsize_t_f *dims )
 DONE:
   HDfree (c_dims);
   return ret_value;
-}  
+}
 
 
 /*----------------------------------------------------------------------------
  * Name:        h5pget_chunk_c
  * Purpose:     Call H5Pget_chunk to get the sizes of chunks for a chunked
  *              layout dataset  for at list max_rank number of dimensions
- * Inputs:      prp_id - property list identifier 
- *              max rank - maximum number of dimensions to return  
- *              dims - array of the size of each chunk 
+ * Inputs:      prp_id - property list identifier
+ *              max rank - maximum number of dimensions to return
+ *              dims - array of the size of each chunk
  * Returns:     number of chunk's dimnesion on success, -1 on failure
  *              Saturday, August 14, 1999
  * Programmer:  Elena Pourmal
  * Modifications:
  *---------------------------------------------------------------------------*/
 
-int_f 
+int_f
 nh5pget_chunk_c ( hid_t_f *prp_id, int_f *max_rank, hsize_t_f *dims )
 {
   int ret_value = -1;
@@ -321,16 +321,16 @@ nh5pget_chunk_c ( hid_t_f *prp_id, int_f *max_rank, hsize_t_f *dims )
   if (rank < 0) return ret_value;
   ret_value = (int_f)rank;
   return ret_value;
-}  
+}
 
 
 
 /*----------------------------------------------------------------------------
  * Name:        h5pset_fill_valuec_c
  * Purpose:     Call h5pset_fill_value_c to a character fill value
- * Inputs:      prp_id - property list identifier 
+ * Inputs:      prp_id - property list identifier
  *              type_id - datatype identifier (fill value is of type type_id)
- *              fillvalue  - character value 
+ *              fillvalue  - character value
  * Returns:     0 on success, -1 on failure
  *              Saturday, August 14, 1999
  * Programmer:  Elena Pourmal
@@ -340,7 +340,7 @@ int_f
 nh5pset_fill_valuec_c (hid_t_f *prp_id, hid_t_f *type_id, _fcd fillvalue)
 {
      int ret_value = -1;
-     
+
      /*
       * Call h5pset_fill_value_c  function.
       */
@@ -351,10 +351,10 @@ nh5pset_fill_valuec_c (hid_t_f *prp_id, hid_t_f *type_id, _fcd fillvalue)
 
 /*----------------------------------------------------------------------------
  * Name:        h5pset_fill_value_c
- * Purpose:     Call H5Pset_fill_value to set a fillvalue for a dataset 
- * Inputs:      prp_id - property list identifier 
+ * Purpose:     Call H5Pset_fill_value to set a fillvalue for a dataset
+ * Inputs:      prp_id - property list identifier
  *              type_id - datatype identifier (fill value is of type type_id)
- *              fillvalue - fillvalue 
+ *              fillvalue - fillvalue
  * Returns:     0 on success, -1 on failure
  * Programmer:  Elena Pourmal
  *              Saturday, August 14, 1999
@@ -378,15 +378,15 @@ nh5pset_fill_value_c (hid_t_f *prp_id, hid_t_f *type_id, void *fillvalue)
      if (ret < 0) return ret_value;
      ret_value = 0;
      return ret_value;
-}      
+}
 
 
 /*----------------------------------------------------------------------------
  * Name:        h5pget_fill_valuec_c
  * Purpose:     Call h5pget_fill_value_c to a character fill value
- * Inputs:      prp_id - property list identifier 
+ * Inputs:      prp_id - property list identifier
  *              type_id - datatype identifier (fill value is of type type_id)
- *              fillvalue  - character value 
+ *              fillvalue  - character value
  * Returns:     0 on success, -1 on failure
  *              Saturday, August 14, 1999
  * Programmer:  Elena Pourmal
@@ -396,7 +396,7 @@ int_f
 nh5pget_fill_valuec_c (hid_t_f *prp_id, hid_t_f *type_id, _fcd fillvalue)
 {
      int ret_value = -1;
-     
+
      /*
       * Call h5pget_fill_value_c  function.
       */
@@ -407,10 +407,10 @@ nh5pget_fill_valuec_c (hid_t_f *prp_id, hid_t_f *type_id, _fcd fillvalue)
 
 /*----------------------------------------------------------------------------
  * Name:        h5pget_fill_value_c
- * Purpose:     Call H5Pget_fill_value to set a fillvalue for a dataset 
- * Inputs:      prp_id - property list identifier 
+ * Purpose:     Call H5Pget_fill_value to set a fillvalue for a dataset
+ * Inputs:      prp_id - property list identifier
  *              type_id - datatype identifier (fill value is of type type_id)
- *              fillvalue - fillvalue 
+ *              fillvalue - fillvalue
  * Returns:     0 on success, -1 on failure
  * Programmer:  Elena Pourmal
  *              Saturday, August 14, 1999
@@ -434,13 +434,13 @@ nh5pget_fill_value_c (hid_t_f *prp_id, hid_t_f *type_id, void *fillvalue)
      if (ret < 0) return ret_value;
      ret_value = 0;
      return ret_value;
-}      
+}
 
 /*----------------------------------------------------------------------------
  * Name:        h5pget_version_c
  * Purpose:     Call H5Pget_version to get the version information
- *              of various objects for a file creation property list  
- * Inputs:      prp_id - property list identifier 
+ *              of various objects for a file creation property list
+ * Inputs:      prp_id - property list identifier
  * Outputs:     boot - array to put boot block version number
  *              freelist - array to put global freelist version number
  *              stab - array to put symbol table version number
@@ -475,13 +475,13 @@ nh5pget_version_c (hid_t_f *prp_id, int_f * boot,int_f * freelist, int_f * stab,
      ret_value = 0;
 
      return ret_value;
-}      
+}
 
 /*----------------------------------------------------------------------------
  * Name:        h5pget_userblock_c
- * Purpose:     Call H5Pget_userblock to get the size of a user block in 
+ * Purpose:     Call H5Pget_userblock to get the size of a user block in
  *              a file creation property list
- * Inputs:      prp_id - property list identifier 
+ * Inputs:      prp_id - property list identifier
  * Outputs      size - Size of the user-block in bytes
  * Returns:     0 on success, -1 on failure
  * Programmer:  Xiangyang Su
@@ -507,13 +507,13 @@ nh5pget_userblock_c (hid_t_f *prp_id, hsize_t_f * size)
      ret_value = 0;
 
      return ret_value;
-}      
+}
 
 /*----------------------------------------------------------------------------
  * Name:        h5pset_userblock_c
- * Purpose:     Call H5Pset_userblock to set the size of a user block in 
+ * Purpose:     Call H5Pset_userblock to set the size of a user block in
  *              a file creation property list
- * Inputs:      prp_id - property list identifier 
+ * Inputs:      prp_id - property list identifier
  *              size - Size of the user-block in bytes
  * Returns:     0 on success, -1 on failure
  * Programmer:  Xiangyang Su
@@ -538,13 +538,13 @@ nh5pset_userblock_c (hid_t_f *prp_id, hsize_t_f * size)
      if (ret < 0) return ret_value;
      ret_value = 0;
      return ret_value;
-}      
+}
 
 /*----------------------------------------------------------------------------
  * Name:        h5pget_sizes_c
- * Purpose:     Call H5Pget_sizes to get the size of the offsets 
- *              and lengths used in an HDF5 file 
- * Inputs:      prp_id - property list identifier 
+ * Purpose:     Call H5Pget_sizes to get the size of the offsets
+ *              and lengths used in an HDF5 file
+ * Inputs:      prp_id - property list identifier
  * Outputs      sizeof_addr - Size of an object offset in bytes
  *              sizeof_size - Size of an object length in bytes
  * Returns:     0 on success, -1 on failure
@@ -573,12 +573,12 @@ nh5pget_sizes_c (hid_t_f *prp_id, size_t_f * sizeof_addr, size_t_f * sizeof_size
      ret_value = 0;
 
      return ret_value;
-}      
+}
 
 /*----------------------------------------------------------------------------
  * Name:        h5pset_sizes_c
  * Purpose:     Call H5Pset_sizes to set the size of the offsets
- * Inputs:      prp_id - property list identifier 
+ * Inputs:      prp_id - property list identifier
  *              sizeof_addr - Size of an object offset in bytes
  *              sizeof_size - Size of an object length in bytes
  * Returns:     0 on success, -1 on failure
@@ -605,15 +605,15 @@ nh5pset_sizes_c (hid_t_f *prp_id, size_t_f * sizeof_addr, size_t_f * sizeof_size
      if (ret < 0) return ret_value;
      ret_value = 0;
      return ret_value;
-}      
+}
 
 /*----------------------------------------------------------------------------
  * Name:        h5pset_sym_k_c
- * Purpose:     Call H5Pset_sym_k to set the size of parameters used 
- *              to control the symbol table node 
+ * Purpose:     Call H5Pset_sym_k to set the size of parameters used
+ *              to control the symbol table node
  * Inputs:      prp_id - property list identifier
  *              ik - Symbol table tree rank
- *              lk - Symbol table node size 
+ *              lk - Symbol table node size
  * Returns:     0 on success, -1 on failure
  * Programmer:  Xiangyang Su
  *              Friday, February 25, 2000
@@ -639,15 +639,15 @@ nh5pset_sym_k_c (hid_t_f *prp_id, int_f* ik, int_f* lk)
      if (ret < 0) return ret_value;
      ret_value = 0;
      return ret_value;
-}      
+}
 
 /*----------------------------------------------------------------------------
  * Name:        h5pget_sym_k_c
- * Purpose:     Call H5Pget_sym_k to get the size of parameters used 
- *              to control the symbol table node 
+ * Purpose:     Call H5Pget_sym_k to get the size of parameters used
+ *              to control the symbol table node
  * Inputs:      prp_id - property list identifier
  * Outputs:     ik - Symbol table tree rank
- *              lk - Symbol table node size 
+ *              lk - Symbol table node size
  * Returns:     0 on success, -1 on failure
  * Programmer:  Xiangyang Su
  *              Friday, February 25, 2000
@@ -672,7 +672,7 @@ nh5pget_sym_k_c (hid_t_f *prp_id, int_f* ik, int_f* lk)
      if (ret < 0) return ret_value;
      ret_value = 0;
      return ret_value;
-} 
+}
 
 /*----------------------------------------------------------------------------
  * Name:        h5pset_istore_k_c
@@ -703,12 +703,12 @@ nh5pset_istore_k_c (hid_t_f *prp_id, int_f* ik)
      if (ret < 0) return ret_value;
      ret_value = 0;
      return ret_value;
-}      
+}
 
 /*----------------------------------------------------------------------------
  * Name:        h5pget_istore_k_c
- * Purpose:     Call H5Pget_istore_k to get the size of parameters used 
- *              to control the B-trees for indexing chunked datasets  
+ * Purpose:     Call H5Pget_istore_k to get the size of parameters used
+ *              to control the B-trees for indexing chunked datasets
  * Inputs:      prp_id - property list identifier
  * Outputs:     ik - Symbol table tree rank
  * Returns:     0 on success, -1 on failure
@@ -733,11 +733,11 @@ nh5pget_istore_k_c (hid_t_f *prp_id, int_f* ik)
      if (ret < 0) return ret_value;
      ret_value = 0;
      return ret_value;
-} 
+}
 
 /*----------------------------------------------------------------------------
  * Name:        h5pget_driver_c
- * Purpose:     Call H5Pget_driver to get low-level file driver identifier 
+ * Purpose:     Call H5Pget_driver to get low-level file driver identifier
  * Inputs:      prp_id - property list identifier
  * Outputs:     driver - low-level file driver identifier
  * Returns:     0 on success, -1 on failure
@@ -762,11 +762,11 @@ nh5pget_driver_c (hid_t_f *prp_id, hid_t_f* driver)
 
 DONE:
      return ret_value;
-} 
+}
 
 /*----------------------------------------------------------------------------
  * Name:        h5pset_fapl_stdio_c
- * Purpose:     Call H5Pset_stdio to set the low level file driver to 
+ * Purpose:     Call H5Pset_stdio to set the low level file driver to
  *              use the functions declared in the stdio.h
  * Inputs:      prp_id - property list identifier
  * Returns:     0 on success, -1 on failure
@@ -784,15 +784,15 @@ nh5pset_fapl_stdio_c (hid_t_f *prp_id)
       * Call H5Pset_fapl_stdio function.
       */
      c_prp_id = (hid_t)*prp_id;
-     ret = H5Pset_fapl_stdio(c_prp_id); 
+     ret = H5Pset_fapl_stdio(c_prp_id);
      if (ret < 0) return ret_value;
      ret_value = 0;
      return ret_value;
-} 
+}
 #ifdef NO_SUCH_F90_FUNCTION
 /*----------------------------------------------------------------------------
  * Name:        h5pget_fapl_stdio_c
- * Purpose:     Call H5Pget_fapl_stdio to determine whther the low level file driver 
+ * Purpose:     Call H5Pget_fapl_stdio to determine whther the low level file driver
  *              uses the functions declared in the stdio.h
  * Inputs:      prp_id - property list identifier
  * Outputs:     io - value indicates whether the file driver uses
@@ -812,7 +812,7 @@ nh5pget_fapl_stdio_c (hid_t_f *prp_id, int_f* io)
       * Call H5Pget_fapl_stdio function.
       */
      c_prp_id = *prp_id;
-     ret = H5Pget_fapl_stdio(c_prp_id); 
+     ret = H5Pget_fapl_stdio(c_prp_id);
      if (ret < 0) return ret_value;
      *io = (int_f)ret;
      ret_value = 0;
@@ -823,7 +823,7 @@ nh5pget_fapl_stdio_c (hid_t_f *prp_id, int_f* io)
 
 /*----------------------------------------------------------------------------
  * Name:        h5pset_fapl_sec2_c
- * Purpose:     Call H5Pset_fapl_sec2 to set the low level file driver to 
+ * Purpose:     Call H5Pset_fapl_sec2 to set the low level file driver to
  *              use the functions declared in the  unistd.h
  * Inputs:      prp_id - property list identifier
  * Returns:     0 on success, -1 on failure
@@ -841,16 +841,16 @@ nh5pset_fapl_sec2_c (hid_t_f *prp_id)
       * Call H5Pset_fapl_sec2 function.
       */
      c_prp_id = (hid_t)*prp_id;
-     ret = H5Pset_fapl_sec2(c_prp_id); 
+     ret = H5Pset_fapl_sec2(c_prp_id);
      if (ret < 0) return ret_value;
      ret_value = 0;
      return ret_value;
-} 
+}
 
 #ifdef NO_SUCH_F90_FUNCTION
 /*----------------------------------------------------------------------------
  * Name:        h5pget_fapl_sec2_c
- * Purpose:     Call H5Pget_fapl_stdio to determine whther the low level file driver 
+ * Purpose:     Call H5Pget_fapl_stdio to determine whther the low level file driver
  *              uses the functions declared in the  unistd.h
  * Inputs:      prp_id - property list identifier
  * Outputs:     sec2 - value indicates whether the file driver uses
@@ -870,7 +870,7 @@ nh5pget_fapl_sec2_c (hid_t_f *prp_id, int_f* sec2)
       * Call H5Pget_fapl_sec2 function.
       */
      c_prp_id = (hid_t)*prp_id;
-     ret = H5Pget_fapl_sec2(c_prp_id); 
+     ret = H5Pget_fapl_sec2(c_prp_id);
      if (ret < 0) return ret_value;
      *sec2 = (int_f)ret;
      ret_value = 0;
@@ -907,7 +907,7 @@ nh5pset_alignment_c (hid_t_f *prp_id, hsize_t_f* threshold, hsize_t_f* alignment
      if (ret < 0) return ret_value;
      ret_value = 0;
      return ret_value;
-} 
+}
 
 /*----------------------------------------------------------------------------
  * Name:        h5pget_alignment_c
@@ -936,10 +936,10 @@ nh5pget_alignment_c (hid_t_f *prp_id, hsize_t_f* threshold, hsize_t_f* alignment
      if (ret < 0) return ret_value;
      *threshold = (hsize_t_f)c_threshold;
      *alignment = (hsize_t_f)c_alignment;
-     
+
      ret_value = 0;
      return ret_value;
-} 
+}
 
 /*----------------------------------------------------------------------------
  * Name:        h5pset_fapl_core_c
@@ -947,8 +947,8 @@ nh5pget_alignment_c (hid_t_f *prp_id, hsize_t_f* threshold, hsize_t_f* alignment
  *              to use malloc() and free()
  * Inputs:      prp_id - property list identifier
  *              increment - File block size in bytes
- *              flag - Boolean flag indicating whether to write the 
- *              file contents to disk when the file is closed. 
+ *              flag - Boolean flag indicating whether to write the
+ *              file contents to disk when the file is closed.
  * Returns:     0 on success, -1 on failure
  * Programmer:  Elena Pourmal
  *              March 9, 2001
@@ -964,12 +964,12 @@ nh5pset_fapl_core_c (hid_t_f *prp_id, size_t_f* increment, int_f *flag)
      hbool_t c_backing_store;
      c_increment = (size_t)*increment;
      c_backing_store = (hbool_t)*flag;
-     
+
      /*
       * Call H5Pset_fapl_core function.
       */
      c_prp_id = (hid_t)*prp_id;
-     ret = H5Pset_fapl_core(c_prp_id, c_increment, c_backing_store); 
+     ret = H5Pset_fapl_core(c_prp_id, c_increment, c_backing_store);
      if (ret < 0) return ret_value;
      ret_value = 0;
      return ret_value;
@@ -977,7 +977,7 @@ nh5pset_fapl_core_c (hid_t_f *prp_id, size_t_f* increment, int_f *flag)
 
 /*----------------------------------------------------------------------------
  * Name:        h5pget_fapl_core_c
- * Purpose:     Call H5Pget_fapl_core to determine whether the file access 
+ * Purpose:     Call H5Pget_fapl_core to determine whether the file access
  *              property list is set to the core drive
  * Inputs:      prp_id - property list identifier
  * Outputs      increment - File block size in bytes
@@ -993,23 +993,23 @@ nh5pget_fapl_core_c (hid_t_f *prp_id, size_t_f* increment, int_f *flag)
      hid_t c_prp_id;
      herr_t ret = -1;
      size_t c_increment = 0;
-     hbool_t c_backing_store; 
-     *flag = 0; 
+     hbool_t c_backing_store;
+     *flag = 0;
      /*
       * Call H5Pset_fapl_core function.
       */
      c_prp_id = (hid_t)*prp_id;
-     ret = H5Pget_fapl_core(c_prp_id, &c_increment, &c_backing_store); 
+     ret = H5Pget_fapl_core(c_prp_id, &c_increment, &c_backing_store);
      if (ret < 0) return ret_value;
      *increment = (size_t_f)c_increment;
      if(c_backing_store  > 0) *flag = 1;
      ret_value = 0;
      return ret_value;
-} 
+}
 
 /*----------------------------------------------------------------------------
  * Name:        h5pset_fapl_family_c
- * Purpose:     Call H5Pset_fapl_family to set the file access properties list 
+ * Purpose:     Call H5Pset_fapl_family to set the file access properties list
  *              to the family driver
  * Inputs:      prp_id - property list identifier
  *              memb_size -  Logical size, in bytes, of each family member.
@@ -1034,15 +1034,15 @@ nh5pset_fapl_family_c(hid_t_f *prp_id, hsize_t_f* memb_size, hid_t_f* memb_plist
       * Call H5Pset_fapl_family function.
       */
      c_prp_id = (hid_t)*prp_id;
-     ret = H5Pset_fapl_family(c_prp_id, c_memb_size, c_memb_plist); 
+     ret = H5Pset_fapl_family(c_prp_id, c_memb_size, c_memb_plist);
      if (ret < 0) return ret_value;
      ret_value = 0;
      return ret_value;
-} 
+}
 
 /*----------------------------------------------------------------------------
  * Name:        h5pget_fapl_family_c
- * Purpose:     Call H5Pget_fapl_family to determine whether the file access 
+ * Purpose:     Call H5Pget_fapl_family to determine whether the file access
  *              property list is set to the family driver
  * Inputs:      prp_id - property list identifier
  *              memb_size -  Logical size, in bytes, of each family member.
@@ -1065,18 +1065,18 @@ nh5pget_fapl_family_c(hid_t_f *prp_id, hsize_t_f* memb_size, hid_t_f* memb_plist
       * Call H5Pget_fapl_family function.
       */
      c_prp_id = (hid_t)*prp_id;
-     ret = H5Pget_fapl_family(c_prp_id, &c_memb_size, &c_memb_plist); 
+     ret = H5Pget_fapl_family(c_prp_id, &c_memb_size, &c_memb_plist);
      if (ret < 0) return ret_value;
      *memb_size = (hsize_t_f)c_memb_size;
      *memb_plist = (hid_t_f)c_memb_plist;
-    
+
      ret_value = 0;
      return ret_value;
-} 
+}
 
 /*----------------------------------------------------------------------------
  * Name:        h5pset_cache_c
- * Purpose:     Call H5Pset_cache to set he number of elements in 
+ * Purpose:     Call H5Pset_cache to set he number of elements in
  *              the meta data cache and the total number of bytes in
  *              the raw data chunk cache
  * Inputs:      prp_id - property list identifier
@@ -1113,17 +1113,17 @@ nh5pset_cache_c(hid_t_f *prp_id, int_f* mdc_nelmts, size_t_f* rdcc_nelmts,  size
      if (ret < 0) return ret_value;
      ret_value = 0;
      return ret_value;
-} 
+}
 
 /*----------------------------------------------------------------------------
  * Name:        h5pget_cache_c
- * Purpose:     Call H5Pget_cache to get he number of elements in 
+ * Purpose:     Call H5Pget_cache to get he number of elements in
  *              the meta data cache and the total number of bytes in
  *              the raw data chunk cache
  * Inputs:      prp_id - property list identifier
  * Outputs:     mdc_nelmts - Number of elements (objects) in the
  *                           meta data cache
- *              rdcc_nelmts - Number of elements in the raw data chunk 
+ *              rdcc_nelmts - Number of elements in the raw data chunk
  *              rdcc_nbytes - Total size of the raw data chunk cache, in bytes
  *              rdcc_w0 - Preemption policy
  * Returns:     0 on success, -1 on failure
@@ -1131,7 +1131,7 @@ nh5pset_cache_c(hid_t_f *prp_id, int_f* mdc_nelmts, size_t_f* rdcc_nelmts,  size
  *              Friday, February 25, 2000
  * Modifications: Changed type of the rdcc_w0 parameter to be real_f instead of double
  *                Changed type of the rdcc_nelmts parameter to be int_f.
- *                                                          EIP  October 10, 2003      
+ *                                                          EIP  October 10, 2003
  *---------------------------------------------------------------------------*/
 int_f
 nh5pget_cache_c(hid_t_f *prp_id, int_f* mdc_nelmts, size_t_f* rdcc_nelmts, size_t_f* rdcc_nbytes , real_f* rdcc_w0)
@@ -1140,9 +1140,9 @@ nh5pget_cache_c(hid_t_f *prp_id, int_f* mdc_nelmts, size_t_f* rdcc_nelmts, size_
      hid_t c_prp_id;
      herr_t ret;
      int c_mdc_nelmts;
-     size_t c_rdcc_nelmts; 
+     size_t c_rdcc_nelmts;
      size_t c_rdcc_nbytes;
-     double c_rdcc_w0; 
+     double c_rdcc_w0;
      /*
       * Call H5Pget_cache function.
       */
@@ -1153,21 +1153,21 @@ nh5pget_cache_c(hid_t_f *prp_id, int_f* mdc_nelmts, size_t_f* rdcc_nelmts, size_
      *rdcc_nelmts = (size_t_f)c_rdcc_nelmts;
      *rdcc_nbytes = (size_t_f)c_rdcc_nbytes;
      *rdcc_w0 = (real_f)c_rdcc_w0;
-    
+
      ret_value = 0;
      return ret_value;
-} 
+}
 
 /*----------------------------------------------------------------------------
  * Name:        h5pset_fapl_split_c
- * Purpose:     Call H5Pset_fapl_split to set he low-level driver to split meta data 
+ * Purpose:     Call H5Pset_fapl_split to set he low-level driver to split meta data
  *              from raw data
  * Inputs:      prp_id - property list identifier
  *              meta_len - Length of meta_ext
- *              meta_ext - Name of the extension for the metafile filename.                 
+ *              meta_ext - Name of the extension for the metafile filename.
  *              meta_plist - Identifier of the meta file access property list
  *              raw_len - Length of raw _ext
- *              raw_ext - Name of the extension for the raw file filename.                 
+ *              raw_ext - Name of the extension for the raw file filename.
  *              raw_plist - Identifier of the raw  file access property list
  * Returns:     0 on success, -1 on failure
  * Programmer:  Elena Pourmal
@@ -1180,14 +1180,14 @@ nh5pset_fapl_split_c(hid_t_f *prp_id, int_f* meta_len, _fcd meta_ext, hid_t_f* m
      int ret_value = -1;
      hid_t c_prp_id;
      hid_t c_meta_plist;
-     hid_t c_raw_plist; 
+     hid_t c_raw_plist;
      herr_t ret = -1;
      char* c_meta_ext;
      char* c_raw_ext;
 
-     c_meta_ext = (char *)HD5f2cstring(meta_ext, (int)*meta_len); 
+     c_meta_ext = (char *)HD5f2cstring(meta_ext, (int)*meta_len);
      if (c_meta_ext == NULL) return ret_value;
-     c_raw_ext = (char *)HD5f2cstring(raw_ext, (int)*raw_len); 
+     c_raw_ext = (char *)HD5f2cstring(raw_ext, (int)*raw_len);
      if (c_raw_ext == NULL) { HDfree(c_meta_ext);
                               return ret_value;
                             }
@@ -1197,7 +1197,7 @@ nh5pset_fapl_split_c(hid_t_f *prp_id, int_f* meta_len, _fcd meta_ext, hid_t_f* m
       */
      c_prp_id = (hid_t)*prp_id;
      c_meta_plist = (hid_t)*meta_plist;
-     c_raw_plist = (hid_t)*raw_plist; 
+     c_raw_plist = (hid_t)*raw_plist;
      ret = H5Pset_fapl_split(c_prp_id, c_meta_ext, c_meta_plist, c_raw_ext, c_raw_plist );
 
      if (ret < 0) goto DONE;
@@ -1213,16 +1213,16 @@ DONE:
 #ifdef NO_SUCH_F90_FUNCTION
 /*----------------------------------------------------------------------------
  * Name:        h5pget_fapl_split_c
- * Purpose:     Call H5Pget_fapl_split to determine whether the file access 
+ * Purpose:     Call H5Pget_fapl_split to determine whether the file access
  *              property list is set to the split driver
  * Inputs:      prp_id - property list identifier
  *              meta_ext_size - Number of characters of the meta file extension
  *                              to be copied to the meta_ext buffer
  *              raw_ext_size - Number of characters of the raw file extension
  *                              to be copied to the raw_ext buffer
- *Outputs:      meta_ext - Name of the extension for the metafile filename.                 
+ *Outputs:      meta_ext - Name of the extension for the metafile filename.
  *              meta_plist - Identifier of the meta file access property list
- *              raw_ext - Name of the extension for the raw file filename.                 
+ *              raw_ext - Name of the extension for the raw file filename.
  *              raw_plist - Identifier of the raw  file access property list
  * Returns:     0 on success, -1 on failure
  * Programmer:  Elena Pourmal
@@ -1235,9 +1235,9 @@ nh5pget_fapl_split_c(hid_t_f *prp_id, size_t_f* meta_ext_size , _fcd meta_ext, h
      int ret_value = -1;
      hid_t c_prp_id;
      herr_t ret = -1;
-     size_t c_meta_ext_size, c_raw_ext_size; 
+     size_t c_meta_ext_size, c_raw_ext_size;
      hid_t c_meta_plist = -1;
-     hid_t c_raw_plist = -1; 
+     hid_t c_raw_plist = -1;
 
      char* c_meta_ext = NULL;
      char* c_raw_ext  = NULL;
@@ -1252,25 +1252,25 @@ nh5pget_fapl_split_c(hid_t_f *prp_id, size_t_f* meta_ext_size , _fcd meta_ext, h
       * Call H5Pget_fapl_split function.
       */
      c_prp_id = *prp_id;
-     ret = H5Pget_fapl_split(c_prp_id, c_meta_ext_size, c_meta_ext,&c_meta_plist, c_raw_ext_size, c_raw_ext, &c_raw_plist ); 
+     ret = H5Pget_fapl_split(c_prp_id, c_meta_ext_size, c_meta_ext,&c_meta_plist, c_raw_ext_size, c_raw_ext, &c_raw_plist );
 
      if (ret < 0) return ret_value;
      *meta_plist = c_meta_plist;
      *raw_plist = c_raw_plist;
-     HD5packFstring(c_meta_ext, _fcdtocp(meta_ext), strlen(c_meta_ext));  
-     HD5packFstring(c_raw_ext, _fcdtocp(raw_ext), strlen(c_raw_ext));  
-    
+     HD5packFstring(c_meta_ext, _fcdtocp(meta_ext), strlen(c_meta_ext));
+     HD5packFstring(c_raw_ext, _fcdtocp(raw_ext), strlen(c_raw_ext));
+
      ret_value = 0;
      return ret_value;
-} 
+}
 #endif /*NO_SUCH_F90_FUNCTION*/
 
 /*----------------------------------------------------------------------------
  * Name:        h5pset_gc_references_c
- * Purpose:     Call H5Pset_gc_references to set garbage 
+ * Purpose:     Call H5Pset_gc_references to set garbage
  *              collecting references flag
  * Inputs:      prp_id - property list identifier
- *              gc_reference - flag for garbage collecting references 
+ *              gc_reference - flag for garbage collecting references
  *                             for the file
  * Returns:     0 on success, -1 on failure
  * Programmer:  Xiangyang Su
@@ -1295,14 +1295,14 @@ nh5pset_gc_references_c (hid_t_f *prp_id, int_f* gc_references)
      if (ret < 0) return ret_value;
      ret_value = 0;
      return ret_value;
-}      
+}
 
 /*----------------------------------------------------------------------------
  * Name:        h5pget_gc_references_c
- * Purpose:     Call H5Pget_gc_references to set garbage 
+ * Purpose:     Call H5Pget_gc_references to set garbage
  *              collecting references flag
  * Inputs:      prp_id - property list identifier
- * Outputs      gc_reference - flag for garbage collecting references 
+ * Outputs      gc_reference - flag for garbage collecting references
  *                             for the file
  * Returns:     0 on success, -1 on failure
  * Programmer:  Xiangyang Su
@@ -1355,7 +1355,7 @@ nh5pset_layout_c (hid_t_f *prp_id, int_f* layout)
      if (ret < 0) return ret_value;
      ret_value = 0;
      return ret_value;
-}      
+}
 
 /*----------------------------------------------------------------------------
  * Name:        h5pget_layout_c
@@ -1388,7 +1388,7 @@ nh5pget_layout_c (hid_t_f *prp_id, int_f* layout)
 /*----------------------------------------------------------------------------
  * Name:        h5pset_filter_c
  * Purpose:     Call H5Pset_filter to add a filter to the filter pipeline.
- * Inputs:      prp_id - property list identifier 
+ * Inputs:      prp_id - property list identifier
  *              filter - Filter to be added to the pipeline.
  *              flags - Bit vector specifying certain general
  *                      properties of the filter.
@@ -1410,7 +1410,7 @@ nh5pset_filter_c (hid_t_f *prp_id, int_f* filter, int_f* flags, size_t_f* cd_nel
      H5Z_filter_t c_filter;
      unsigned int * c_cd_values;
      unsigned i;
-     
+
      c_filter = (H5Z_filter_t)*filter;
      c_flags = (unsigned)*flags;
      c_cd_nelmts = (size_t)*cd_nelmts;
@@ -1465,17 +1465,17 @@ nh5pget_nfilters_c (hid_t_f *prp_id, int_f* nfilters)
 
 /*----------------------------------------------------------------------------
  * Name:        h5pget_filter_c
- * Purpose:     Call H5Pget_filter to get information about a filter 
+ * Purpose:     Call H5Pget_filter to get information about a filter
  *              in a pipeline
  * Inputs:      prp_id - property list identifier
- *              filter_number - Sequence number within the filter 
- *                              pipeline of the filter for which 
+ *              filter_number - Sequence number within the filter
+ *                              pipeline of the filter for which
  *                              information is sought.
  *              namelen - Anticipated number of characters in name.
- *Outputs:      flags - Bit vector specifying certain general 
+ *Outputs:      flags - Bit vector specifying certain general
  *                      properties of the filter.
  *              cd_nelmts - Number of elements in cd_value
- *              cd_values - Auxiliary data for the filter. 
+ *              cd_values - Auxiliary data for the filter.
  *              name - Name of the filter
  *              filter_id - filter identification number
  * Returns:     0 on success, -1 on failure
@@ -1506,8 +1506,8 @@ nh5pget_filter_c(hid_t_f *prp_id, int_f* filter_number, int_f* flags, size_t_f*
      if (!c_cd_values) {HDfree(c_name);
                         return ret_value;
                        }
-                        
- 
+
+
      /*
       * Call H5Pget_filter function.
       */
@@ -1520,29 +1520,29 @@ nh5pget_filter_c(hid_t_f *prp_id, int_f* filter_number, int_f* flags, size_t_f*
      *filter_id = (int_f)c_filter;
      *cd_nelmts = (size_t_f)c_cd_nelmts;
      *flags = (int_f)c_flags;
-     HD5packFstring(c_name, _fcdtocp(name), (int)strlen(c_name)); 
- 
+     HD5packFstring(c_name, _fcdtocp(name), (int)strlen(c_name));
+
      for (i = 0; i < c_cd_nelmts_in; i++)
           cd_values[i] = (int_f)c_cd_values[i];
-    
+
      ret_value = 0;
 
 DONE:
      HDfree(c_name);
      HDfree(c_cd_values);
      return ret_value;
-} 
+}
 
 /*----------------------------------------------------------------------------
  * Name:        h5pset_external_c
  * Purpose:     Call H5Pset_external to add an external file to the
  *              list of external files.
- * Inputs:      prp_id - property list identifier 
+ * Inputs:      prp_id - property list identifier
  *              name - Name of an external file
  *              namelen - length of name
  *              offset - Offset, in bytes, from the beginning of the file
- *                       to the location in the file where the data starts. 
- *              bytes - Number of bytes reserved in the file for the data. 
+ *                       to the location in the file where the data starts.
+ *              bytes - Number of bytes reserved in the file for the data.
  * Returns:     0 on success, -1 on failure
  * Programmer:  Xiangyang Su
  *              Wednesday, February 23, 2000
@@ -1560,10 +1560,10 @@ nh5pset_external_c (hid_t_f *prp_id, _fcd name, int_f* namelen, int_f* offset, h
      off_t c_offset;
      c_bytes = (hsize_t) *bytes;
      c_offset = (off_t) *offset;
-     
-     
+
+
      c_namelen = (int)*namelen;
-     c_name = (char *)HD5f2cstring(name, c_namelen); 
+     c_name = (char *)HD5f2cstring(name, c_namelen);
      if (c_name == NULL) return ret_value;
 
      /*
@@ -1610,14 +1610,14 @@ nh5pget_external_count_c (hid_t_f *prp_id, int_f* count)
 
 /*----------------------------------------------------------------------------
  * Name:        h5pget_external_c
- * Purpose:     Call H5Pget_external to get nformation about an external file. 
- * Inputs:      prp_id - property list identifier 
+ * Purpose:     Call H5Pget_external to get nformation about an external file.
+ * Inputs:      prp_id - property list identifier
  *              name_size - length of name
- *              idx - External file index. 
+ *              idx - External file index.
  *Outputs:      name - Name of an external file
  *              offset - Offset, in bytes, from the beginning of the file
- *                       to the location in the file where the data starts. 
- *              bytes - Number of bytes reserved in the file for the data. 
+ *                       to the location in the file where the data starts.
+ *              bytes - Number of bytes reserved in the file for the data.
  * Returns:     0 on success, -1 on failure
  * Programmer:  Xiangyang Su
  *              Wednesday, February 23, 2000
@@ -1641,35 +1641,35 @@ nh5pget_external_c(hid_t_f *prp_id, int_f *idx, size_t_f* name_size, _fcd name,
       */
      if(c_namelen) c_name = (char*) HDmalloc(c_namelen + 1);
      if (c_name == NULL) return ret_value;
- 
+
      /*
       * Call H5Pget_external function.
       */
      c_prp_id = (hid_t)*prp_id;
-     c_idx = (unsigned)*idx; 
+     c_idx = (unsigned)*idx;
      status = H5Pget_external(c_prp_id, c_idx, c_namelen, c_name, &c_offset, &size );
 
      if (status < 0) goto DONE;
 
      *offset = (int_f)c_offset;
      *bytes = (hsize_t_f)size;
-     HD5packFstring(c_name, _fcdtocp(name), (int)strlen(c_name)); 
+     HD5packFstring(c_name, _fcdtocp(name), (int)strlen(c_name));
      ret_value = 0;
 
-DONE:    
+DONE:
      HDfree(c_name);
      return ret_value;
-} 
+}
 
 /*----------------------------------------------------------------------------
  * Name:        h5pset_btree_ratios_c
- * Purpose:     Call H5Pset_btree_ratios to set B-tree split ratios for B-tree split ratios for a dataset transfer property list. a 
- *              dataset transfer property list. 
+ * Purpose:     Call H5Pset_btree_ratios to set B-tree split ratios for B-tree split ratios for a dataset transfer property list. a
+ *              dataset transfer property list.
  * Inputs:      prp_id - property list identifier
- *              left - The B-tree split ratio for left-most nodes. 
- *              middle - The B-tree split ratio for all other nodes 
- *              right - The B-tree split ratio for right-most nodes 
- *                      and lone nodes. 
+ *              left - The B-tree split ratio for left-most nodes.
+ *              middle - The B-tree split ratio for all other nodes
+ *              right - The B-tree split ratio for right-most nodes
+ *                      and lone nodes.
  * Returns:     0 on success, -1 on failure
  * Programmer:  Xiangyang Su
  *              Friday, February 25, 2000
@@ -1696,17 +1696,17 @@ nh5pset_btree_ratios_c(hid_t_f *prp_id, real_f* left, real_f* middle, real_f* ri
      if (ret < 0) return ret_value;
      ret_value = 0;
      return ret_value;
-} 
+}
 
 /*----------------------------------------------------------------------------
  * Name:        h5pget_btree_ratios_c
- * Purpose:     Call H5Pget_btree_ratios to Gets B-tree split ratios 
- *              for a dataset transfer property list. 
+ * Purpose:     Call H5Pget_btree_ratios to Gets B-tree split ratios
+ *              for a dataset transfer property list.
  * Inputs:      prp_id - property list identifier
- *              left - The B-tree split ratio for left-most nodes. 
- *              middle - The B-tree split ratio for all other nodes 
- *              right - The B-tree split ratio for right-most nodes 
- *                      and lone nodes. 
+ *              left - The B-tree split ratio for left-most nodes.
+ *              middle - The B-tree split ratio for all other nodes
+ *              right - The B-tree split ratio for right-most nodes
+ *                      and lone nodes.
  * Returns:     0 on success, -1 on failure
  * Programmer:  Xiangyang Su
  *              Friday, February 25, 2000
@@ -1731,11 +1731,11 @@ nh5pget_btree_ratios_c(hid_t_f *prp_id, real_f* left, real_f* middle, real_f* ri
      if (ret < 0) return ret_value;
      ret_value = 0;
      return ret_value;
-} 
+}
 /*----------------------------------------------------------------------------
  * Name:        h5pget_fclose_degree_c
  * Purpose:     Call H5Pget_fclose_degree to determine file close behavior
- * Inputs:      fapl_id - file access identifier 
+ * Inputs:      fapl_id - file access identifier
  * Outputs:
  *              degree  - possible values are:
  *              		H5F_CLOSE_DEFAULT
@@ -1748,16 +1748,16 @@ nh5pget_btree_ratios_c(hid_t_f *prp_id, real_f* left, real_f* middle, real_f* ri
  * Modifications:
  *---------------------------------------------------------------------------*/
 
-int_f 
+int_f
 nh5pget_fclose_degree_c ( hid_t_f *fapl_id , int_f *degree)
 {
   int ret_value = -1;
   hid_t c_fapl_id;
-  H5F_close_degree_t c_degree; 
+  H5F_close_degree_t c_degree;
 
   c_fapl_id = (hid_t)*fapl_id;
   if( H5Pget_fclose_degree(c_fapl_id, &c_degree) < 0) return ret_value;
-  
+
   *degree = (int_f)c_degree;
   ret_value = 0;
   return ret_value;
@@ -1766,7 +1766,7 @@ nh5pget_fclose_degree_c ( hid_t_f *fapl_id , int_f *degree)
 /*----------------------------------------------------------------------------
  * Name:        h5pset_fclose_degree_c
  * Purpose:     Call H5Pset_fclose_degree to set file close behavior
- * Inputs:      fapl_id - file access identifier 
+ * Inputs:      fapl_id - file access identifier
  *              degree  - possible values are:
  *              		H5F_CLOSE_DEFAULT
  *              		H5F_CLOSE_WEAK
@@ -1778,34 +1778,34 @@ nh5pget_fclose_degree_c ( hid_t_f *fapl_id , int_f *degree)
  * Modifications:
  *---------------------------------------------------------------------------*/
 
-int_f 
+int_f
 nh5pset_fclose_degree_c ( hid_t_f *fapl_id , int_f *degree)
 {
   int ret_value = -1;
   hid_t c_fapl_id;
-  H5F_close_degree_t c_degree; 
+  H5F_close_degree_t c_degree;
 
   c_fapl_id = (hid_t)*fapl_id;
   c_degree = (H5F_close_degree_t)*degree;
   if( H5Pset_fclose_degree(c_fapl_id, c_degree) < 0) return ret_value;
-  
+
   ret_value = 0;
   return ret_value;
 }
 
 /*----------------------------------------------------------------------------
  * Name:        h5pset_buffer_c
- * Purpose:     Call H5Pset_buffer to set size of conversion buffer 
+ * Purpose:     Call H5Pset_buffer to set size of conversion buffer
  * Inputs:      prp_id - t`dataset trasfer property list identifier
  *              size   - size of the buffer
- * Outputs:     NONE 
+ * Outputs:     NONE
  * Returns:     0 on success, -1 on failure
  * Programmer:  Elena Pourmal
  *              Wednesday, October 2, 2002
  * Modifications:
  *---------------------------------------------------------------------------*/
 
-int_f 
+int_f
 nh5pset_buffer_c ( hid_t_f *prp_id , hsize_t_f *size)
 {
   int ret_value = 0;
@@ -1820,16 +1820,16 @@ nh5pset_buffer_c ( hid_t_f *prp_id , hsize_t_f *size)
 
 /*----------------------------------------------------------------------------
  * Name:        h5pget_buffer_c
- * Purpose:     Call H5Pget_buffer to get size of conversion buffer 
+ * Purpose:     Call H5Pget_buffer to get size of conversion buffer
  * Inputs:      prp_id - t`dataset trasfer property list identifier
- * Outputs:     size - size of conversion buffer 
+ * Outputs:     size - size of conversion buffer
  * Returns:     0 on success, -1 on failure
  * Programmer:  Elena Pourmal
  *              Wednesday, October 2, 2002
  * Modifications:
  *---------------------------------------------------------------------------*/
 
-int_f 
+int_f
 nh5pget_buffer_c ( hid_t_f *prp_id , hsize_t_f *size)
 {
   int ret_value = -1;
@@ -1854,7 +1854,7 @@ nh5pget_buffer_c ( hid_t_f *prp_id , hsize_t_f *size)
  * Modifications:
  *---------------------------------------------------------------------------*/
 
-int_f 
+int_f
 nh5pfill_value_defined_c ( hid_t_f *prp_id , int_f *flag)
 {
   int ret_value = -1;
@@ -1869,7 +1869,7 @@ nh5pfill_value_defined_c ( hid_t_f *prp_id , int_f *flag)
 }
 /*----------------------------------------------------------------------------
  * Name:        h5pget_alloc_time_c
- * Purpose:     Call H5Pget_alloc_time to get space allocation 
+ * Purpose:     Call H5Pget_alloc_time to get space allocation
  *              time for dataset during creation
  * Inputs:      prp_id - dataset creation property list identifier
  * Outputs:     flag - allocation time flag
@@ -1879,7 +1879,7 @@ nh5pfill_value_defined_c ( hid_t_f *prp_id , int_f *flag)
  * Modifications:
  *---------------------------------------------------------------------------*/
 
-int_f 
+int_f
 nh5pget_alloc_time_c ( hid_t_f *prp_id , int_f *flag)
 {
   int ret_value = -1;
@@ -1894,7 +1894,7 @@ nh5pget_alloc_time_c ( hid_t_f *prp_id , int_f *flag)
 }
 /*----------------------------------------------------------------------------
  * Name:        h5pset_alloc_time_c
- * Purpose:     Call H5Pset_alloc_time to get space allocation 
+ * Purpose:     Call H5Pset_alloc_time to get space allocation
  *              time for dataset during creation
  * Inputs:      prp_id - dataset creation property list identifier
  *              flag - allocation time flag
@@ -1904,7 +1904,7 @@ nh5pget_alloc_time_c ( hid_t_f *prp_id , int_f *flag)
  * Modifications:
  *---------------------------------------------------------------------------*/
 
-int_f 
+int_f
 nh5pset_alloc_time_c ( hid_t_f *prp_id , int_f *flag)
 {
   int ret_value = -1;
@@ -1929,7 +1929,7 @@ nh5pset_alloc_time_c ( hid_t_f *prp_id , int_f *flag)
  * Modifications:
  *---------------------------------------------------------------------------*/
 
-int_f 
+int_f
 nh5pget_fill_time_c ( hid_t_f *prp_id , int_f *flag)
 {
   int ret_value = -1;
@@ -1954,7 +1954,7 @@ nh5pget_fill_time_c ( hid_t_f *prp_id , int_f *flag)
  * Modifications:
  *---------------------------------------------------------------------------*/
 
-int_f 
+int_f
 nh5pset_fill_time_c ( hid_t_f *prp_id , int_f *flag)
 {
   int ret_value = -1;
@@ -1972,14 +1972,14 @@ nh5pset_fill_time_c ( hid_t_f *prp_id , int_f *flag)
  * Purpose:     Call H5Pset_meta_block_size to set size of  metadata block
  * Inputs:      prp_id - file access  property list identifier
  *              size   - size of the metadata block
- * Outputs:     NONE 
+ * Outputs:     NONE
  * Returns:     0 on success, -1 on failure
  * Programmer:  Elena Pourmal
  *              Monday, October 7, 2002
  * Modifications:
  *---------------------------------------------------------------------------*/
 
-int_f 
+int_f
 nh5pset_meta_block_size_c ( hid_t_f *prp_id , hsize_t_f *size)
 {
   int ret_value = 0;
@@ -1995,7 +1995,7 @@ nh5pset_meta_block_size_c ( hid_t_f *prp_id , hsize_t_f *size)
  * Name:        h5pget_meta_block_size_c
  * Purpose:     Call H5Pget_meta_block_size to get size of  metadata block
  * Inputs:      prp_id - file access  property list identifier
- * Outputs:     
+ * Outputs:
  *              size   - size of the metadata block
  * Returns:     0 on success, -1 on failure
  * Programmer:  Elena Pourmal
@@ -2003,7 +2003,7 @@ nh5pset_meta_block_size_c ( hid_t_f *prp_id , hsize_t_f *size)
  * Modifications:
  *---------------------------------------------------------------------------*/
 
-int_f 
+int_f
 nh5pget_meta_block_size_c ( hid_t_f *prp_id , hsize_t_f *size)
 {
   int ret_value = 0;
@@ -2020,14 +2020,14 @@ nh5pget_meta_block_size_c ( hid_t_f *prp_id , hsize_t_f *size)
  * Purpose:     Call H5Pset_sieve_buf_size to set size of datasieve buffer
  * Inputs:      prp_id - file access  property list identifier
  *              size   - size of the buffer
- * Outputs:     NONE 
+ * Outputs:     NONE
  * Returns:     0 on success, -1 on failure
  * Programmer:  Elena Pourmal
  *              Monday, October 7, 2002
  * Modifications:
  *---------------------------------------------------------------------------*/
 
-int_f 
+int_f
 nh5pset_sieve_buf_size_c ( hid_t_f *prp_id , size_t_f *size)
 {
   int ret_value = 0;
@@ -2043,7 +2043,7 @@ nh5pset_sieve_buf_size_c ( hid_t_f *prp_id , size_t_f *size)
  * Name:        h5pget_sieve_buf_size_c
  * Purpose:     Call H5Pget_sieve_buf_size to get size of datasieve buffer
  * Inputs:      prp_id - file access  property list identifier
- * Outputs:     
+ * Outputs:
  *              size   - size of the buffer
  * Returns:     0 on success, -1 on failure
  * Programmer:  Elena Pourmal
@@ -2051,7 +2051,7 @@ nh5pset_sieve_buf_size_c ( hid_t_f *prp_id , size_t_f *size)
  * Modifications:
  *---------------------------------------------------------------------------*/
 
-int_f 
+int_f
 nh5pget_sieve_buf_size_c ( hid_t_f *prp_id , size_t_f *size)
 {
   int ret_value = 0;
@@ -2068,14 +2068,14 @@ nh5pget_sieve_buf_size_c ( hid_t_f *prp_id , size_t_f *size)
  * Purpose:     Call H5Pset_small_data_block_size to set size of raw small data block
  * Inputs:      prp_id - file access  property list identifier
  *              size   - size of the block
- * Outputs:     NONE 
+ * Outputs:     NONE
  * Returns:     0 on success, -1 on failure
  * Programmer:  Elena Pourmal
  *              Monday, October 7, 2002
  * Modifications:
  *---------------------------------------------------------------------------*/
 
-int_f 
+int_f
 nh5pset_small_data_block_size_c ( hid_t_f *prp_id , hsize_t_f *size)
 {
   int ret_value = 0;
@@ -2091,7 +2091,7 @@ nh5pset_small_data_block_size_c ( hid_t_f *prp_id , hsize_t_f *size)
  * Name:        h5pget_small_data_block_size_c
  * Purpose:     Call H5Pget_small_data_block_size to get size of raw small data block
  * Inputs:      prp_id - file access  property list identifier
- * Outputs:     
+ * Outputs:
  *              size   - size of the block
  * Returns:     0 on success, -1 on failure
  * Programmer:  Elena Pourmal
@@ -2099,7 +2099,7 @@ nh5pset_small_data_block_size_c ( hid_t_f *prp_id , hsize_t_f *size)
  * Modifications:
  *---------------------------------------------------------------------------*/
 
-int_f 
+int_f
 nh5pget_small_data_block_size_c ( hid_t_f *prp_id , hsize_t_f *size)
 {
   int ret_value = 0;
@@ -2116,14 +2116,14 @@ nh5pget_small_data_block_size_c ( hid_t_f *prp_id , hsize_t_f *size)
  * Purpose:     Call H5Pset_hyper_vector_size to set size of the hyper vector
  * Inputs:      prp_id - dataset transfer property list identifier
  *              size   - size of the vector
- * Outputs:     NONE 
+ * Outputs:     NONE
  * Returns:     0 on success, -1 on failure
  * Programmer:  Elena Pourmal
  *              Monday, October 7, 2002
  * Modifications:
  *---------------------------------------------------------------------------*/
 
-int_f 
+int_f
 nh5pset_hyper_vector_size_c ( hid_t_f *prp_id , size_t_f *size)
 {
   int ret_value = 0;
@@ -2139,7 +2139,7 @@ nh5pset_hyper_vector_size_c ( hid_t_f *prp_id , size_t_f *size)
  * Name:        h5pget_hyper_vector_size_c
  * Purpose:     Call H5Pget_hyper_vector_size to get size of the hyper vector
  * Inputs:      prp_id - dataset transfer property list identifier
- * Outputs:     
+ * Outputs:
  *              size   - size of the vector
  * Returns:     0 on success, -1 on failure
  * Programmer:  Elena Pourmal
@@ -2147,7 +2147,7 @@ nh5pset_hyper_vector_size_c ( hid_t_f *prp_id , size_t_f *size)
  * Modifications:
  *---------------------------------------------------------------------------*/
 
-int_f 
+int_f
 nh5pget_hyper_vector_size_c ( hid_t_f *prp_id , size_t_f *size)
 {
   int ret_value = 0;
@@ -2156,7 +2156,7 @@ nh5pget_hyper_vector_size_c ( hid_t_f *prp_id , size_t_f *size)
 
   c_prp_id = (hid_t)*prp_id;
   if ( H5Pget_hyper_vector_size(c_prp_id, &c_size) < 0  ) ret_value = -1;
-  *size = (size_t_f)c_size; 
+  *size = (size_t_f)c_size;
   return ret_value;
 }
 /*----------------------------------------------------------------------------
@@ -2179,7 +2179,7 @@ nh5pcreate_class_c(hid_t_f *parent, _fcd name, int_f *name_len, hid_t_f *class)
      hid_t c_class;
      char* c_name;
 
-     c_name = (char *)HD5f2cstring(name, (int)*name_len); 
+     c_name = (char *)HD5f2cstring(name, (int)*name_len);
      if (c_name == NULL) goto DONE;
      c_parent = (hid_t)*parent;
 
@@ -2198,11 +2198,11 @@ DONE:
 
 /*----------------------------------------------------------------------------
  * Name:        h5pregisterc_c
- * Purpose:     Call h5pregister_c to registers a permanent property 
+ * Purpose:     Call h5pregister_c to registers a permanent property
  * Inputs:      class - property list class identifier
  *              name   - name of the new property
  *              name_len - length of the "name" buffer
- *              size - property size 
+ *              size - property size
  *              value - property value of character type
  * Returns:     0 on success, -1 on failure
  * Programmer:  Elena Pourmal
@@ -2213,7 +2213,7 @@ int_f
 nh5pregisterc_c(hid_t_f *class, _fcd name, int_f *name_len, size_t_f *size, _fcd value, int_f *value_len)
 {
      int ret_value = -1;
-     
+
      /*
       * Call h5pregister_c function
       */
@@ -2223,12 +2223,12 @@ nh5pregisterc_c(hid_t_f *class, _fcd name, int_f *name_len, size_t_f *size, _fcd
 
 /*----------------------------------------------------------------------------
  * Name:        h5pregister_c
- * Purpose:     Call H5Pregister to registers a permanent property 
+ * Purpose:     Call H5Pregister to registers a permanent property
  * Inputs:      class - property list class identifier
  *              name   - name of the new property
  *              name_len - length of the "name" buffer
- *              size - property size 
- *              value - property value 
+ *              size - property size
+ *              value - property value
  * Returns:     0 on success, -1 on failure
  * Programmer:  Elena Pourmal
  *              October 11, 2002
@@ -2242,7 +2242,7 @@ nh5pregister_c(hid_t_f *class, _fcd name, int_f *name_len, size_t_f *size, void
      char* c_name;
      size_t c_size;
 
-     c_name = (char *)HD5f2cstring(name, (int)*name_len); 
+     c_name = (char *)HD5f2cstring(name, (int)*name_len);
      if (c_name == NULL) goto DONE;
      c_size = (size_t)*size;
      c_class = (hid_t)*class;
@@ -2259,11 +2259,11 @@ DONE:
 }
 /*----------------------------------------------------------------------------
  * Name:        h5pinsertc_c
- * Purpose:     Call h5pinsert_c to register a temporary property 
+ * Purpose:     Call h5pinsert_c to register a temporary property
  * Inputs:      plist - property list identifier
  *              name   - name of the new property
  *              name_len - length of the "name" buffer
- *              size - property size 
+ *              size - property size
  *              value - property value of character type
  * Returns:     0 on success, -1 on failure
  * Programmer:  Elena Pourmal
@@ -2274,7 +2274,7 @@ int_f
 nh5pinsertc_c(hid_t_f *plist, _fcd name, int_f *name_len, size_t_f *size, _fcd value, int_f *value_len)
 {
      int_f ret_value = -1;
-     
+
      /*
       * Call h5pinsert_c function
       */
@@ -2288,8 +2288,8 @@ nh5pinsertc_c(hid_t_f *plist, _fcd name, int_f *name_len, size_t_f *size, _fcd v
  * Inputs:      plist - property list class identifier
  *              name   - name of the new property
  *              name_len - length of the "name" buffer
- *              size - property size 
- *              value - property value 
+ *              size - property size
+ *              value - property value
  * Returns:     0 on success, -1 on failure
  * Programmer:  Elena Pourmal
  *              October 11, 2002
@@ -2303,7 +2303,7 @@ nh5pinsert_c(hid_t_f *plist, _fcd name, int_f *name_len, size_t_f *size, void *v
      char* c_name;
      size_t c_size;
 
-     c_name = (char *)HD5f2cstring(name, (int)*name_len); 
+     c_name = (char *)HD5f2cstring(name, (int)*name_len);
      if (c_name == NULL) goto DONE;
      c_size = (size_t)*size;
      c_plist = (hid_t)*plist;
@@ -2321,7 +2321,7 @@ DONE:
 
 /*----------------------------------------------------------------------------
  * Name:        h5pexist_c
- * Purpose:     Call H5Pexist to querie whether a property name exists 
+ * Purpose:     Call H5Pexist to querie whether a property name exists
  *              in a property list or class
  * Inputs:      plist - property list or property class identifier
  *              name   - name of the new property
@@ -2339,7 +2339,7 @@ nh5pexist_c(hid_t_f *class, _fcd name, int_f *name_len)
      char* c_name;
      htri_t status;
 
-     c_name = (char *)HD5f2cstring(name, (int)*name_len); 
+     c_name = (char *)HD5f2cstring(name, (int)*name_len);
      if (c_name == NULL) goto DONE;
 
      c_class = (hid_t)*class;
@@ -2355,8 +2355,8 @@ DONE:
 }
 /*----------------------------------------------------------------------------
  * Name:        h5pisa_class_c
- * Purpose:     Call H5Pisa_class to querie whether a property is a  
- *              member of a class 
+ * Purpose:     Call H5Pisa_class to querie whether a property is a
+ *              member of a class
  * Inputs:      plist - property list identifier
  *              class - property class identifier
  * Returns:     nonnegative on success, -1 on failure
@@ -2402,7 +2402,7 @@ nh5pget_size_c(hid_t_f *plist, _fcd name, int_f *name_len, size_t_f *size)
      char* c_name;
      size_t c_size;
 
-     c_name = (char *)HD5f2cstring(name, (int)*name_len); 
+     c_name = (char *)HD5f2cstring(name, (int)*name_len);
      if (c_name == NULL) goto DONE;
 
      c_plist = (hid_t)*plist;
@@ -2447,7 +2447,7 @@ nh5pget_nprops_c(hid_t_f *plist, size_t_f *nprops)
 }
 /*----------------------------------------------------------------------------
  * Name:        h5pget_class_parent_c
- * Purpose:     Call H5Pget_class_parent to get the parent class of 
+ * Purpose:     Call H5Pget_class_parent to get the parent class of
  *              a genereic property class
  * Inputs:      prp_id - property list to query
  * Outputs:     parent_id - parent classs identifier
@@ -2477,7 +2477,7 @@ nh5pget_class_parent_c(hid_t_f *prp_id, hid_t_f *parent_id)
 }
 /*----------------------------------------------------------------------------
  * Name:        h5pcopy_prop_c
- * Purpose:     Call H5Pcopy_prop to copy a property from one list or 
+ * Purpose:     Call H5Pcopy_prop to copy a property from one list or
  *              class to another
  * Inputs:      dst_id - identifier of destination property list
  *              src_id - identifier of source property list
@@ -2495,7 +2495,7 @@ nh5pcopy_prop_c(hid_t_f *dst_id, hid_t_f *src_id, _fcd name, int_f *name_len)
      hid_t c_dst_id, c_src_id;
      char* c_name;
 
-     c_name = (char *)HD5f2cstring(name, (int)*name_len); 
+     c_name = (char *)HD5f2cstring(name, (int)*name_len);
      if (c_name == NULL) goto DONE;
 
      c_dst_id = (hid_t)*dst_id;
@@ -2528,7 +2528,7 @@ nh5premove_c(hid_t_f *plid, _fcd name, int_f *name_len)
      hid_t c_plid;
      char* c_name;
 
-     c_name = (char *)HD5f2cstring(name, (int)*name_len); 
+     c_name = (char *)HD5f2cstring(name, (int)*name_len);
      if (c_name == NULL) goto DONE;
 
      c_plid = (hid_t)*plid;
@@ -2560,7 +2560,7 @@ nh5punregister_c(hid_t_f *class, _fcd name, int_f *name_len)
      hid_t c_class;
      char* c_name;
 
-     c_name = (char *)HD5f2cstring(name, (int)*name_len); 
+     c_name = (char *)HD5f2cstring(name, (int)*name_len);
      if (c_name == NULL) goto DONE;
 
      c_class = (hid_t)*class;
@@ -2599,7 +2599,7 @@ nh5pclose_class_c(hid_t_f *class)
 }
 /*----------------------------------------------------------------------------
  * Name:        h5pget_class_name_c
- * Purpose:     Call H5Pget_class_name to get property class name 
+ * Purpose:     Call H5Pget_class_name to get property class name
  * Inputs:      class - identifier of property class
  *              name   - ibuffer to retrieve name in
  *              name_len - length of the "name" buffer
@@ -2620,7 +2620,7 @@ nh5pget_class_name_c(hid_t_f *class, _fcd name, int_f *name_len)
      /*
       * Call H5Pget_class_name function.
       */
-     c_name = H5Pget_class_name(c_class); 
+     c_name = H5Pget_class_name(c_class);
      if( c_name == NULL) goto DONE;
 
      HD5packFstring(c_name, _fcdtocp(name), (int)*name_len);
@@ -2646,7 +2646,7 @@ int_f
 nh5psetc_c(hid_t_f *plist, _fcd name, int_f *name_len, _fcd value, int_f *value_len)
 {
      int_f ret_value = -1;
-     
+
      /*
       * Call h5pset_c function
       */
@@ -2660,7 +2660,7 @@ nh5psetc_c(hid_t_f *plist, _fcd name, int_f *name_len, _fcd value, int_f *value_
  * Inputs:      plist - property list class identifier
  *              name   - name of the new property
  *              name_len - length of the "name" buffer
- *              value - property value 
+ *              value - property value
  * Returns:     0 on success, -1 on failure
  * Programmer:  Elena Pourmal
  *              October 11, 2002
@@ -2673,7 +2673,7 @@ nh5pset_c(hid_t_f *plist, _fcd name, int_f *name_len, void *value)
      hid_t c_plist;
      char* c_name;
 
-     c_name = (char *)HD5f2cstring(name, (int)*name_len); 
+     c_name = (char *)HD5f2cstring(name, (int)*name_len);
      if (c_name == NULL) goto DONE;
      c_plist = (hid_t)*plist;
 
@@ -2703,7 +2703,7 @@ int_f
 nh5pgetc_c(hid_t_f *plist, _fcd name, int_f *name_len, _fcd value, int_f *value_len)
 {
      int_f ret_value = -1;
-     
+
      /*
       * Call h5pget_c function
       */
@@ -2717,7 +2717,7 @@ nh5pgetc_c(hid_t_f *plist, _fcd name, int_f *name_len, _fcd value, int_f *value_
  * Inputs:      plist - property list class identifier
  *              name   - name of the new property
  *              name_len - length of the "name" buffer
- * Output:      value - property value 
+ * Output:      value - property value
  * Returns:     0 on success, -1 on failure
  * Programmer:  Elena Pourmal
  *              October 11, 2002
@@ -2730,7 +2730,7 @@ nh5pget_c(hid_t_f *plist, _fcd name, int_f *name_len, void *value)
      hid_t c_plist;
      char* c_name;
 
-     c_name = (char *)HD5f2cstring(name, (int)*name_len); 
+     c_name = (char *)HD5f2cstring(name, (int)*name_len);
      if (c_name == NULL) goto DONE;
      c_plist = (hid_t)*plist;
 
@@ -2746,8 +2746,8 @@ DONE:
 }
 /*----------------------------------------------------------------------------
  * Name:        h5pset_shuffle_c
- * Purpose:     Call H5Pset_shuffle 
- * Inputs:      prp_id - property list identifier 
+ * Purpose:     Call H5Pset_shuffle
+ * Inputs:      prp_id - property list identifier
  *              type_size - size of the datatype in bytes
  * Returns:     0 on success, -1 on failure
  * Programmer:  Elena Pourmal
@@ -2755,7 +2755,7 @@ DONE:
  * Modifications:
  *---------------------------------------------------------------------------*/
 
-int_f 
+int_f
 nh5pset_shuffle_c ( hid_t_f *prp_id )
 {
   int_f ret_value = 0;
@@ -2770,14 +2770,14 @@ nh5pset_shuffle_c ( hid_t_f *prp_id )
 /*----------------------------------------------------------------------------
  * Name:        h5pset_fletcher32_c
  * Purpose:     Call H5Pset_fletcher32 to enable EDC
- * Inputs:      prp_id - dataset creation property list identifier 
+ * Inputs:      prp_id - dataset creation property list identifier
  * Returns:     0 on success, -1 on failure
  * Programmer:  Elena Pourmal
  *              Thursday, March 13, 2003
  * Modifications:
  *---------------------------------------------------------------------------*/
 
-int_f 
+int_f
 nh5pset_fletcher32_c ( hid_t_f *prp_id )
 {
   int_f ret_value = 0;
@@ -2793,7 +2793,7 @@ nh5pset_fletcher32_c ( hid_t_f *prp_id )
 /*----------------------------------------------------------------------------
  * Name:        h5pset_edc_check_c
  * Purpose:     Call H5Pset_edc_check to enable EDC
- * Inputs:      prp_id - dataset transfer property list identifier 
+ * Inputs:      prp_id - dataset transfer property list identifier
  *              flag   - EDC flag
  * Returns:     0 on success, -1 on failure
  * Programmer:  Elena Pourmal
@@ -2801,7 +2801,7 @@ nh5pset_fletcher32_c ( hid_t_f *prp_id )
  * Modifications:
  *---------------------------------------------------------------------------*/
 
-int_f 
+int_f
 nh5pset_edc_check_c ( hid_t_f *prp_id, int_f *flag )
 {
   int_f ret_value = 0;
@@ -2819,7 +2819,7 @@ nh5pset_edc_check_c ( hid_t_f *prp_id, int_f *flag )
 /*----------------------------------------------------------------------------
  * Name:        h5pget_edc_check_c
  * Purpose:     Call H5Pget_edc_check to query EDC
- * Inputs:      prp_id - dataset transfer property list identifier 
+ * Inputs:      prp_id - dataset transfer property list identifier
  * Outouts:     flag   - EDC flag
  * Returns:     0 on success, -1 on failure
  * Programmer:  Elena Pourmal
@@ -2827,7 +2827,7 @@ nh5pset_edc_check_c ( hid_t_f *prp_id, int_f *flag )
  * Modifications:
  *---------------------------------------------------------------------------*/
 
-int_f 
+int_f
 nh5pget_edc_check_c ( hid_t_f *prp_id, int_f *flag )
 {
   int_f ret_value = 0;
@@ -2843,7 +2843,7 @@ nh5pget_edc_check_c ( hid_t_f *prp_id, int_f *flag )
 /*----------------------------------------------------------------------------
  * Name:        h5pset_family_offset_c
  * Purpose:     Call H5Pset_family_offset to set and offset for family driver
- * Inputs:      prp_id - property list identifier 
+ * Inputs:      prp_id - property list identifier
  *              offset - offset in bytes
  * Returns:     0 on success, -1 on failure
  * Programmer:  Elena Pourmal
@@ -2851,7 +2851,7 @@ nh5pget_edc_check_c ( hid_t_f *prp_id, int_f *flag )
  * Modifications:
  *---------------------------------------------------------------------------*/
 
-int_f 
+int_f
 nh5pset_family_offset_c ( hid_t_f *prp_id , hsize_t_f *offset)
 {
   int_f ret_value = 0;
@@ -2869,9 +2869,9 @@ nh5pset_family_offset_c ( hid_t_f *prp_id , hsize_t_f *offset)
 /*----------------------------------------------------------------------------
  * Name:        h5pset_fapl_multi_c
  * Purpose:     Call H5Pset_fapl_multi to set multi file dirver
- * Inputs:      prp_id - file_creation property list identifier 
+ * Inputs:      prp_id - file_creation property list identifier
  *              mem_map - memory mapping array
- *              memb_fapl - property list for each memory usage type 
+ *              memb_fapl - property list for each memory usage type
  *              memb_name - array with members names
  *              len - array with the lenght of each name
  *              lenmax - lenght of the name a sdeclared in Fortran
@@ -2882,7 +2882,7 @@ nh5pset_family_offset_c ( hid_t_f *prp_id , hsize_t_f *offset)
  * Modifications:
  *---------------------------------------------------------------------------*/
 
-int_f 
+int_f
 /*nh5pset_fapl_multi_c ( hid_t_f *prp_id , int_f *memb_map, hid_t_f *memb_fapl, _fcd memb_name, int_f *len, int_f *lenmax, haddr_t_f *memb_addr, int_f *flag) */
 nh5pset_fapl_multi_c ( hid_t_f *prp_id , int_f *memb_map, hid_t_f *memb_fapl, _fcd memb_name, int_f *len, int_f *lenmax, real_f *memb_addr, int_f *flag)
 {
@@ -2890,9 +2890,9 @@ nh5pset_fapl_multi_c ( hid_t_f *prp_id , int_f *memb_map, hid_t_f *memb_fapl, _f
   hid_t c_prp_id;
   H5FD_mem_t c_memb_map[H5FD_MEM_NTYPES];
   hid_t c_memb_fapl[H5FD_MEM_NTYPES];
-  char *c_memb_name[H5FD_MEM_NTYPES]; 
-  haddr_t c_memb_addr[H5FD_MEM_NTYPES]; 
-  hbool_t relax; 
+  char *c_memb_name[H5FD_MEM_NTYPES];
+  haddr_t c_memb_addr[H5FD_MEM_NTYPES];
+  hbool_t relax;
   herr_t status;
   char *tmp, *tmp_p, *tmp_pp;
   int i;
@@ -2910,7 +2910,7 @@ nh5pset_fapl_multi_c ( hid_t_f *prp_id , int_f *memb_map, hid_t_f *memb_fapl, _f
  */
 
   tmp = (char *)HD5f2cstring(memb_name, c_lenmax*(H5FD_MEM_NTYPES));
-  if (tmp ==NULL) return ret_value; 
+  if (tmp ==NULL) return ret_value;
   tmp_p = tmp;
   for (i=0; i < H5FD_MEM_NTYPES; i++) {
        c_memb_name[i] = malloc((size_t)len[i] + 1);
@@ -2921,11 +2921,11 @@ nh5pset_fapl_multi_c ( hid_t_f *prp_id , int_f *memb_map, hid_t_f *memb_fapl, _f
 /*       printf(" %d \n", len[i]);
        printf("name %s \n", c_memb_name[i]);
 */
- } 
+ }
 /*
  * Take care of othe arguments
  */
- 
+
   c_prp_id = (hid_t)*prp_id;
   for (i=0; i < H5FD_MEM_NTYPES; i++) {
        c_memb_map[i] = (H5FD_mem_t)memb_map[i];
@@ -2933,9 +2933,9 @@ nh5pset_fapl_multi_c ( hid_t_f *prp_id , int_f *memb_map, hid_t_f *memb_fapl, _f
        c_memb_fapl[i] = (hid_t)memb_fapl[i];
        /*printf("fapl %d \n", c_memb_fapl[i]); */
        if(memb_addr[i] < 0) c_memb_addr[i] = HADDR_UNDEF;
-       else c_memb_addr[i] = (haddr_t)(((float)memb_addr[i])*(HADDR_MAX)); 
+       else c_memb_addr[i] = (haddr_t)(((float)memb_addr[i])*(HADDR_MAX));
        /*printf("address %Ld \n", c_memb_addr[i]); */
-  }     
+  }
 /*
  * Call  H5Pset_fapl_multi function
  */
@@ -2953,19 +2953,19 @@ DONE:
 /*----------------------------------------------------------------------------
  * Name:        h5pset_fapl_multi_sc
  * Purpose:     Call H5Pset_fapl_multi to set multi file dirver
- * Inputs:      prp_id - file_creation property list identifier 
+ * Inputs:      prp_id - file_creation property list identifier
  * Returns:     0 on success, -1 on failure
  * Programmer:  Elena Pourmal
  *              March 31 2003
  * Modifications:
  *---------------------------------------------------------------------------*/
 
-int_f 
+int_f
 nh5pset_fapl_multi_sc ( hid_t_f *prp_id , int_f *flag)
 {
   int_f ret_value = -1;
   hid_t c_prp_id;
-  hbool_t relax; 
+  hbool_t relax;
   herr_t status;
 
   relax = (hbool_t)*flag;
@@ -2982,10 +2982,10 @@ nh5pset_fapl_multi_sc ( hid_t_f *prp_id , int_f *flag)
 /*----------------------------------------------------------------------------
  * Name:        h5pget_fapl_multi_c
  * Purpose:     Call H5Pget_fapl_multi to set multi file dirver
- * Inputs:      prp_id - file_creation property list identifier 
+ * Inputs:      prp_id - file_creation property list identifier
  *              lenmax - lenght of the name a sdeclared in Fortran
  * Outputs:     memb_map - memory mapping array
- *              memb_fapl - property list for each memory usage type 
+ *              memb_fapl - property list for each memory usage type
  *              memb_name - array with members names
  *              len - array with the lenght of each name
  *              flag - flag allowing partila access when one of the files is missing
@@ -2995,16 +2995,16 @@ nh5pset_fapl_multi_sc ( hid_t_f *prp_id , int_f *flag)
  * Modifications:
  *---------------------------------------------------------------------------*/
 
-int_f 
+int_f
 nh5pget_fapl_multi_c ( hid_t_f *prp_id , int_f *memb_map, hid_t_f *memb_fapl, _fcd memb_name, int_f *len, int_f *lenmax, real_f *memb_addr, int_f *flag, int_f *maxlen_out)
 {
   int_f ret_value = -1;
   hid_t c_prp_id;
   H5FD_mem_t c_memb_map[H5FD_MEM_NTYPES];
   hid_t c_memb_fapl[H5FD_MEM_NTYPES];
-  char *c_memb_name[H5FD_MEM_NTYPES]; 
+  char *c_memb_name[H5FD_MEM_NTYPES];
   haddr_t c_memb_addr[H5FD_MEM_NTYPES];
-  hbool_t relax; 
+  hbool_t relax;
   herr_t status;
   char *tmp, *tmp_p;
   int i;
@@ -3018,7 +3018,7 @@ nh5pget_fapl_multi_c ( hid_t_f *prp_id , int_f *memb_map, hid_t_f *memb_fapl, _f
  */
 
   status = H5Pget_fapl_multi(c_prp_id, c_memb_map, c_memb_fapl, c_memb_name, c_memb_addr, &relax);
-  if ( status < 0  ) return ret_value; 
+  if ( status < 0  ) return ret_value;
 
 /*
  * Take care of names array
@@ -3032,13 +3032,13 @@ nh5pget_fapl_multi_c ( hid_t_f *prp_id , int_f *memb_map, hid_t_f *memb_fapl, _f
        len[i] = (int_f)strlen(c_memb_name[i]);
        length = H5_MAX(length, strlen(c_memb_name[i]));
        tmp_p = tmp_p + c_lenmax;
- } 
+ }
 HD5packFstring(tmp, _fcdtocp(memb_name), (int)(c_lenmax*H5FD_MEM_NTYPES));
 
 /*
  * Take care of other arguments
  */
- 
+
   for (i=0; i < H5FD_MEM_NTYPES; i++) {
        memb_map[i] = (int_f)c_memb_map[i];
        memb_fapl[i] = (hid_t_f)c_memb_fapl[i];
@@ -3048,8 +3048,8 @@ HD5packFstring(tmp, _fcdtocp(memb_name), (int)(c_lenmax*H5FD_MEM_NTYPES));
        if(c_memb_addr[i] == HADDR_UNDEF) memb_addr[i] = -1;
        else memb_addr[i] = (real_f) ((long)c_memb_addr[i]/HADDR_MAX);
 #endif /*WIN32*/
-  }     
-  *flag = (int_f)relax; 
+  }
+  *flag = (int_f)relax;
   *maxlen_out = (int_f)length;
   ret_value = 0;
   free(tmp);
@@ -3060,7 +3060,7 @@ HD5packFstring(tmp, _fcdtocp(memb_name), (int)(c_lenmax*H5FD_MEM_NTYPES));
 /*----------------------------------------------------------------------------
  * Name:        h5pset_szip_c
  * Purpose:     Call H5Pset_szip to set szip compression
- * Inputs:      prp_id - dataset creation property list identifier 
+ * Inputs:      prp_id - dataset creation property list identifier
  *              options_mask
  *              pixels_per_block -szip compression parameters
  * Returns:     0 on success, -1 on failure
@@ -3069,7 +3069,7 @@ HD5packFstring(tmp, _fcdtocp(memb_name), (int)(c_lenmax*H5FD_MEM_NTYPES));
  * Modifications:
  *---------------------------------------------------------------------------*/
 
-int_f 
+int_f
 nh5pset_szip_c ( hid_t_f *prp_id , int_f *options_mask, int_f *pixels_per_block)
 {
   int_f ret_value = -1;
@@ -3093,7 +3093,7 @@ nh5pset_szip_c ( hid_t_f *prp_id , int_f *options_mask, int_f *pixels_per_block)
 /*----------------------------------------------------------------------------
  * Name:        h5pall_filters_avail_c
  * Purpose:     Call H5Pall_filters_avail
- * Inputs:      prp_id - dataset creation property list identifier 
+ * Inputs:      prp_id - dataset creation property list identifier
  * Outputs:     status - logical flag
  * Returns:     0 on success, -1 on failure
  * Programmer:  Elena Pourmal
@@ -3101,13 +3101,13 @@ nh5pset_szip_c ( hid_t_f *prp_id , int_f *options_mask, int_f *pixels_per_block)
  * Modifications:
  *---------------------------------------------------------------------------*/
 
-int_f 
+int_f
 nh5pall_filters_avail_c ( hid_t_f *prp_id , int_f *status)
 {
   int_f ret_value = -1;
   hid_t c_prp_id;
   htri_t c_status;
-  
+
 
   c_prp_id = (hid_t)*prp_id;
 /*
@@ -3123,15 +3123,15 @@ nh5pall_filters_avail_c ( hid_t_f *prp_id , int_f *status)
 }
 /*----------------------------------------------------------------------------
  * Name:        h5pget_filter_by_id_c
- * Purpose:     Call H5Pget_filter_by_id to get information about a filter 
+ * Purpose:     Call H5Pget_filter_by_id to get information about a filter
  *              in a pipeline
  * Inputs:      prp_id - property list identifier
  *              filter_id - filter id
  *              namelen - Anticipated number of characters in name.
- *Outputs:      flags - Bit vector specifying certain general 
+ *Outputs:      flags - Bit vector specifying certain general
  *                      properties of the filter.
  *              cd_nelmts - Number of elements in cd_value
- *              cd_values - Auxiliary data for the filter. 
+ *              cd_values - Auxiliary data for the filter.
  *              name - Name of the filter
  * Returns:     0 on success, -1 on failure
  * Programmer:  Elena POurmal
@@ -3161,8 +3161,8 @@ nh5pget_filter_by_id_c(hid_t_f *prp_id, int_f* filter_id, int_f* flags, size_t_f
      if (!c_cd_values) {HDfree(c_name);
                         return ret_value;
                        }
-                        
- 
+
+
      /*
       * Call H5Pget_filter function.
       */
@@ -3173,23 +3173,23 @@ nh5pget_filter_by_id_c(hid_t_f *prp_id, int_f* filter_id, int_f* flags, size_t_f
 
      *cd_nelmts = (size_t_f)c_cd_nelmts;
      *flags = (int_f)c_flags;
-     HD5packFstring(c_name, _fcdtocp(name), (int)strlen(c_name)); 
- 
+     HD5packFstring(c_name, _fcdtocp(name), (int)strlen(c_name));
+
      for (i = 0; i < c_cd_nelmts_in; i++)
           cd_values[i] = (int_f)c_cd_values[i];
-    
+
      ret_value = 0;
 
 DONE:
      HDfree(c_name);
      HDfree(c_cd_values);
      return ret_value;
-} 
+}
 
 /*----------------------------------------------------------------------------
  * Name:        h5pmodify_filter_c
  * Purpose:     Call H5Pmodify_filter to modify a filter
- * Inputs:      prp_id - property list identifier 
+ * Inputs:      prp_id - property list identifier
  *              filter - Filter to be modified
  *              flags - Bit vector specifying certain general
  *                      properties of the filter.
@@ -3211,7 +3211,7 @@ nh5pmodify_filter_c (hid_t_f *prp_id, int_f* filter, int_f* flags, size_t_f* cd_
      H5Z_filter_t c_filter;
      unsigned int * c_cd_values;
      unsigned i;
-     
+
      c_filter = (H5Z_filter_t)*filter;
      c_flags = (unsigned)*flags;
      c_cd_nelmts = (size_t)*cd_nelmts;
@@ -3237,7 +3237,7 @@ DONE:
 /*----------------------------------------------------------------------------
  * Name:        h5premove_filter_c
  * Purpose:     Call H5Premove_filter to delete one or more filters
- * Inputs:      prp_id - property list identifier 
+ * Inputs:      prp_id - property list identifier
  *              filter - Filter to be deleted
  * Returns:     0 on success, -1 on failure
  * Programmer:  Quincey Koziol
@@ -3250,7 +3250,7 @@ nh5premove_filter_c (hid_t_f *prp_id, int_f* filter)
      int_f ret_value = -1;
      hid_t c_prp_id;
      H5Z_filter_t c_filter;
-     
+
      c_filter = (H5Z_filter_t)*filter;
      c_prp_id = (hid_t)*prp_id;
 
diff --git a/fortran/src/H5Rf.c b/fortran/src/H5Rf.c
index 843c2ea..808bb90 100644
--- a/fortran/src/H5Rf.c
+++ b/fortran/src/H5Rf.c
@@ -19,10 +19,10 @@
 /*----------------------------------------------------------------------------
  * Name:        h5rcreate_object_c
  * Purpose:     Call H5Rcreate to create a reference to an object
- * Inputs:      loc_id - file or group identifier 
- *              name - name of the dataset     
+ * Inputs:      loc_id - file or group identifier
+ *              name - name of the dataset
  *              namelen - name length
- * Outputs:     ref  - reference to the object 
+ * Outputs:     ref  - reference to the object
  * Returns:     0 on success, -1 on failure
  * Programmer:  Elena Pourmal
  *              Wednesday, December 1, 1999
@@ -42,7 +42,7 @@ nh5rcreate_object_c (haddr_t_f *ref, hid_t_f *loc_id, _fcd name, int_f *namelen)
       * Convert FORTRAN name to C name
       */
      c_namelen = *namelen;
-     c_name = (char *)HD5f2cstring(name, c_namelen); 
+     c_name = (char *)HD5f2cstring(name, c_namelen);
      if (c_name == NULL) return ret_value;
 
      /*
@@ -56,19 +56,19 @@ nh5rcreate_object_c (haddr_t_f *ref, hid_t_f *loc_id, _fcd name, int_f *namelen)
          *ref=(haddr_t_f)ref_c;
          ret_value = 0;
      }
-       
+
      return ret_value;
-}      
+}
 
 /*----------------------------------------------------------------------------
  * Name:        h5rcreate_region_c
  * Purpose:     Call H5Rcreate to create a reference to dataset region
- *              region 
- * Inputs:      loc_id - file or group identifier 
- *              name - name of the dataset     
+ *              region
+ * Inputs:      loc_id - file or group identifier
+ *              name - name of the dataset
  *              namelen - name length
  *              space_id - dataset space identifier
- * Outputs:     ref  - reference to the dataset region 
+ * Outputs:     ref  - reference to the dataset region
  * Returns:     0 on success, -1 on failure
  * Programmer:  Elena Pourmal
  *              Wednesday, December 1, 1999
@@ -89,7 +89,7 @@ nh5rcreate_region_c (int_f *ref, hid_t_f *loc_id, _fcd name, int_f *namelen, hid
       * Convert FORTRAN name to C name
       */
      c_namelen = *namelen;
-     c_name = (char *)HD5f2cstring(name, c_namelen); 
+     c_name = (char *)HD5f2cstring(name, c_namelen);
      if (c_name == NULL) return ret_value;
 
      /*
@@ -105,14 +105,14 @@ nh5rcreate_region_c (int_f *ref, hid_t_f *loc_id, _fcd name, int_f *namelen, hid
          ret_value = 0;
      }
      return ret_value;
-}      
+}
 
 /*----------------------------------------------------------------------------
  * Name:        h5rdereference_region_c
  * Purpose:     Call H5Rdereference to dereference to dataset region
- * Inputs:      dset_id - dataset identifier 
- *              ref - reference to the dataset region 
- * Outputs:     obj_id - dereferenced dataset identifier 
+ * Inputs:      dset_id - dataset identifier
+ *              ref - reference to the dataset region
+ * Outputs:     obj_id - dereferenced dataset identifier
  * Returns:     0 on success, -1 on failure
  * Programmer:  Elena Pourmal
  *              Wednesday, December 1, 1999
@@ -135,17 +135,17 @@ nh5rdereference_region_c (hid_t_f *dset_id, int_f *ref, hid_t_f *obj_id)
      c_obj_id = H5Rdereference(c_dset_id, H5R_DATASET_REGION, &ref_c);
      if(c_obj_id < 0) return ret_value;
      *obj_id = (hid_t_f)c_obj_id;
-     ret_value = 0;     
+     ret_value = 0;
      return ret_value;
-}      
+}
 
 
 /*----------------------------------------------------------------------------
  * Name:        h5rdereference_object_c
- * Purpose:     Call H5Rdereference to dereference an object 
- * Inputs:      dset_id - dataset identifier 
- *              ref - reference to an object 
- * Outputs:     obj_id - dereferenced  object identifier 
+ * Purpose:     Call H5Rdereference to dereference an object
+ * Inputs:      dset_id - dataset identifier
+ *              ref - reference to an object
+ * Outputs:     obj_id - dereferenced  object identifier
  * Returns:     0 on success, -1 on failure
  * Programmer:  Elena Pourmal
  *              Wednesday, December 1, 1999
@@ -168,16 +168,16 @@ nh5rdereference_object_c (hid_t_f *dset_id, haddr_t_f *ref, hid_t_f *obj_id)
      c_obj_id = H5Rdereference(c_dset_id, H5R_OBJECT, &ref_c);
      if(c_obj_id < 0) return ret_value;
      *obj_id = (hid_t_f)c_obj_id;
-     ret_value = 0;     
+     ret_value = 0;
      return ret_value;
 }
 
 /*----------------------------------------------------------------------------
  * Name:        h5rget_region_region_object_c
- * Purpose:     Call H5Rget_region to dereference dataspace region 
- * Inputs:      dset_id - dataset identifier 
- *              ref - reference to the dataset region 
- * Outputs:     space_id - dereferenced  dataset dataspace identifier 
+ * Purpose:     Call H5Rget_region to dereference dataspace region
+ * Inputs:      dset_id - dataset identifier
+ *              ref - reference to the dataset region
+ * Outputs:     space_id - dereferenced  dataset dataspace identifier
  * Returns:     0 on success, -1 on failure
  * Programmer:  Elena Pourmal
  *              Wednesday, December 1, 1999
@@ -200,17 +200,17 @@ nh5rget_region_region_c (hid_t_f *dset_id, int_f *ref, hid_t_f *space_id)
      c_space_id = H5Rget_region(c_dset_id, H5R_DATASET_REGION, &ref_c);
      if(c_space_id < 0) return ret_value;
      *space_id = (hid_t_f)c_space_id;
-     ret_value = 0;     
+     ret_value = 0;
      return ret_value;
 }
 
 /*----------------------------------------------------------------------------
  * Name:        h5rget_object_type_obj_c
- * Purpose:     Call H5Rget_object_type to retrieve the type of the object reference points 
- *              to 
- * Inputs:      dset_id - dataset identifier 
- *              ref - reference to the dataset region 
- * Outputs:     obj_type - type of dereferenced object 
+ * Purpose:     Call H5Rget_object_type to retrieve the type of the object reference points
+ *              to
+ * Inputs:      dset_id - dataset identifier
+ *              ref - reference to the dataset region
+ * Outputs:     obj_type - type of dereferenced object
  * Returns:     0 on success, -1 on failure
  * Programmer:  Elena Pourmal
  *              Wednesday, December 1, 1999
@@ -233,6 +233,6 @@ nh5rget_object_type_obj_c (hid_t_f *dset_id, haddr_t_f *ref, int_f *obj_type)
      c_obj_type = H5Rget_obj_type(c_dset_id, H5R_OBJECT, &ref_c);
      if(c_obj_type < 0) return ret_value;
      *obj_type = (int_f)c_obj_type;
-     ret_value = 0;     
+     ret_value = 0;
      return ret_value;
 }
diff --git a/fortran/src/H5Sf.c b/fortran/src/H5Sf.c
index df93eae..a7f2b1b 100644
--- a/fortran/src/H5Sf.c
+++ b/fortran/src/H5Sf.c
@@ -16,7 +16,7 @@
 
 /*----------------------------------------------------------------------------
  * Name:        h5screate_simple_c
- * Purpose:     Call H5Screate_simple to create a dataspace 
+ * Purpose:     Call H5Screate_simple to create a dataspace
  * Inputs:      rank - number of dimensions of dataspace
  *              dims - array of the size of each dimension
                 maxdims - an array of the maximum size of each dimension
@@ -27,7 +27,7 @@
  * Modifications:
  *---------------------------------------------------------------------------*/
 
-int_f 
+int_f
 nh5screate_simple_c ( int_f *rank, hsize_t_f *dims, hsize_t_f *maxdims, hid_t_f *space_id )
 {
   int ret_value = -1;
@@ -46,7 +46,7 @@ nh5screate_simple_c ( int_f *rank, hsize_t_f *dims, hsize_t_f *maxdims, hid_t_f
    */
   for (i = 0; i < *rank ; i++) {
        c_dims[i] =  dims[*rank - i - 1];
-       c_maxdims[i] = maxdims[*rank - i - 1]; 
+       c_maxdims[i] = maxdims[*rank - i - 1];
   }
 
   c_space_id = H5Screate_simple(*rank, c_dims, c_maxdims);
@@ -57,13 +57,13 @@ nh5screate_simple_c ( int_f *rank, hsize_t_f *dims, hsize_t_f *maxdims, hid_t_f
   HDfree (c_dims);
   HDfree (c_maxdims);
   return ret_value;
-}  
+}
 
 
 
 /*----------------------------------------------------------------------------
  * Name:        h5sclose_c
- * Purpose:     Call H5Sclose to close the dataspace 
+ * Purpose:     Call H5Sclose to close the dataspace
  * Inputs:      space_id - identifier of the dataspace to be closed
  * Returns:     0 on success, -1 on failure
  * Programmer:  Elena Pourmal
@@ -71,12 +71,12 @@ nh5screate_simple_c ( int_f *rank, hsize_t_f *dims, hsize_t_f *maxdims, hid_t_f
  * Modifications:
  *---------------------------------------------------------------------------*/
 
-int_f 
+int_f
 nh5sclose_c ( hid_t_f *space_id )
 {
   int ret_value = 0;
   hid_t c_space_id;
-  
+
   c_space_id = *space_id;
   if ( H5Sclose(c_space_id) < 0  ) ret_value = -1;
   return ret_value;
@@ -85,7 +85,7 @@ nh5sclose_c ( hid_t_f *space_id )
 
 /*----------------------------------------------------------------------------
  * Name:        h5screate_c
- * Purpose:     Call H5Screate to create a dataspace 
+ * Purpose:     Call H5Screate to create a dataspace
  * Inputs:      classtype - type of the dataspace class
  * Outputs:     space_id - identifier of the created dataspace
  * Returns:     0 on success, -1 on failure
@@ -94,14 +94,14 @@ nh5sclose_c ( hid_t_f *space_id )
  * Modifications:
  *---------------------------------------------------------------------------*/
 
-int_f 
+int_f
 nh5screate_c ( int_f *classtype, hid_t_f *space_id )
 {
   H5S_class_t c_classtype;
   int ret_value = 0;
   hid_t c_space_id;
   c_classtype = (H5S_class_t) *classtype;
-  c_space_id = H5Screate(c_classtype); 
+  c_space_id = H5Screate(c_classtype);
 
   if ( c_space_id  < 0  ) ret_value = -1;
   *space_id = (hid_t_f) c_space_id;
@@ -110,8 +110,8 @@ nh5screate_c ( int_f *classtype, hid_t_f *space_id )
 
 /*----------------------------------------------------------------------------
  * Name:        h5scopy_c
- * Purpose:     Call H5Scopy to copy dataspace 
- * Inputs:      space_id - identifier of the dataspace to be copied 
+ * Purpose:     Call H5Scopy to copy dataspace
+ * Inputs:      space_id - identifier of the dataspace to be copied
  * Outputs:     new_space_id - identifier of the new datspace
  * Returns:     0 on success, -1 on failure
  * Programmer:  Elena Pourmal
@@ -119,7 +119,7 @@ nh5screate_c ( int_f *classtype, hid_t_f *space_id )
  * Modifications:
  *---------------------------------------------------------------------------*/
 
-int_f 
+int_f
 nh5scopy_c( hid_t_f *space_id , hid_t_f *new_space_id)
 {
   int ret_value = 0;
@@ -127,7 +127,7 @@ nh5scopy_c( hid_t_f *space_id , hid_t_f *new_space_id)
   hid_t c_space_id;
 
   c_space_id = *space_id;
-  c_new_space_id = H5Scopy(c_space_id); 
+  c_new_space_id = H5Scopy(c_space_id);
   if ( c_new_space_id < 0  ) ret_value = -1;
 
   *new_space_id = (hid_t_f)c_new_space_id;
@@ -136,11 +136,11 @@ nh5scopy_c( hid_t_f *space_id , hid_t_f *new_space_id)
 
 /*----------------------------------------------------------------------------
  * Name:        h5sget_select_hyper_nblocks_c
- * Purpose:     Call H5SH5Sget_select_hyper_nblocks to 
- *              get the the number of hyperslab blocks in 
- *              the current dataspace selection if successful 
+ * Purpose:     Call H5SH5Sget_select_hyper_nblocks to
+ *              get the the number of hyperslab blocks in
+ *              the current dataspace selection if successful
  * Inputs:      space_id - identifier of the dataspace
- * Outputs:     num_blocks -  number of hyperslab blocks in 
+ * Outputs:     num_blocks -  number of hyperslab blocks in
  *              the current dataspace selection
  * Returns:     0 on success, -1 on failure
  * Programmer:  Xiangyang Su
@@ -148,7 +148,7 @@ nh5scopy_c( hid_t_f *space_id , hid_t_f *new_space_id)
  * Modifications:
  *---------------------------------------------------------------------------*/
 
-int_f 
+int_f
 nh5sget_select_hyper_nblocks_c( hid_t_f *space_id , hssize_t_f * num_blocks)
 {
   int ret_value = 0;
@@ -165,11 +165,11 @@ nh5sget_select_hyper_nblocks_c( hid_t_f *space_id , hssize_t_f * num_blocks)
 
 /*----------------------------------------------------------------------------
  * Name:        h5sget_select_elem_npoints_c
- * Purpose:     Call H5Sget_select_elem_npoints to 
- *              get the the number of element points in 
- *              the current dataspace selection if successful 
+ * Purpose:     Call H5Sget_select_elem_npoints to
+ *              get the the number of element points in
+ *              the current dataspace selection if successful
  * Inputs:      space_id - identifier of the dataspace
- * Outputs:     num_points -  number of element points in 
+ * Outputs:     num_points -  number of element points in
  *              the current dataspace selection
  * Returns:     0 on success, -1 on failure
  * Programmer:  Xiangyang Su
@@ -177,7 +177,7 @@ nh5sget_select_hyper_nblocks_c( hid_t_f *space_id , hssize_t_f * num_blocks)
  * Modifications:
  *---------------------------------------------------------------------------*/
 
-int_f 
+int_f
 nh5sget_select_elem_npoints_c( hid_t_f *space_id , hssize_t_f * num_points)
 {
   int ret_value = 0;
@@ -194,26 +194,26 @@ nh5sget_select_elem_npoints_c( hid_t_f *space_id , hssize_t_f * num_points)
 
 /*----------------------------------------------------------------------------
  * Name:        h5sget_select_hyper_blocklist_c
- * Purpose:     Call H5Sget_select_hyper_blocklist to 
- *              get a list of the hyperslab blocks currently selected  
+ * Purpose:     Call H5Sget_select_hyper_blocklist to
+ *              get a list of the hyperslab blocks currently selected
  *              Starting with the startblock-th block in the
  *              list of blocks, num_blocks blocks are put into the user's
- *              buffer. If the user's buffer fills up before numblocks 
+ *              buffer. If the user's buffer fills up before numblocks
  *              blocks are inserted, the buffer
- *              will contain only as many blocks as fit. 
+ *              will contain only as many blocks as fit.
  * Inputs:      space_id - identifier of the dataspace
  *              startblock - Hyperslab block to start with
- *              num_blocks -  number of hyperslab blocks in 
+ *              num_blocks -  number of hyperslab blocks in
  *                            the current dataspace selection
- * Outputs:     buf - List of hyperslab blocks selected 
+ * Outputs:     buf - List of hyperslab blocks selected
  * Returns:     0 on success, -1 on failure
  * Programmer:  Xiangyang Su
  *              Monday, November 15, 1999
  * Modifications:
  *---------------------------------------------------------------------------*/
 
-int_f 
-nh5sget_select_hyper_blocklist_c( hid_t_f *space_id ,hsize_t_f * startblock, 
+int_f
+nh5sget_select_hyper_blocklist_c( hid_t_f *space_id ,hsize_t_f * startblock,
                                   hsize_t_f * num_blocks, hsize_t_f * buf)
 {
   int ret_value = -1;
@@ -234,7 +234,7 @@ nh5sget_select_hyper_blocklist_c( hid_t_f *space_id ,hsize_t_f * startblock,
   c_buf = (hsize_t*)malloc(sizeof(hsize_t)*(size_t)(c_num_blocks*2*rank));
   if (!c_buf) return ret_value;
 
-  ret_value = H5Sget_select_hyper_blocklist(c_space_id, c_startblock, 
+  ret_value = H5Sget_select_hyper_blocklist(c_space_id, c_startblock,
                                             c_num_blocks, c_buf);
   for(i = 0; i < c_num_blocks*2*rank; i++)
   {
@@ -247,20 +247,20 @@ nh5sget_select_hyper_blocklist_c( hid_t_f *space_id ,hsize_t_f * startblock,
 
 /*----------------------------------------------------------------------------
  * Name:        h5sget_select_bounds_c
- * Purpose:     Call H5Sget_select_bounds to retrieve the coordinates 
- *              of the bounding box containing the current selection 
+ * Purpose:     Call H5Sget_select_bounds to retrieve the coordinates
+ *              of the bounding box containing the current selection
  *              and places them into user-supplied buffers
  * Inputs:      space_id - identifier of the dataspace
  * Outputs:     start -  Starting coordinates of the bounding box
  *              end -  Ending coordinates of the bounding box,
- *                     i.e., the coordinates of the diagonally opposite corne 
+ *                     i.e., the coordinates of the diagonally opposite corne
  * Returns:     0 on success, -1 on failure
  * Programmer:  Xiangyang Su
  *              Wednesday, November 17, 1999
  * Modifications:
  *---------------------------------------------------------------------------*/
 
-int_f 
+int_f
 nh5sget_select_bounds_c( hid_t_f *space_id , hsize_t_f * start, hsize_t_f * end)
 {
   int ret_value = -1;
@@ -295,25 +295,25 @@ nh5sget_select_bounds_c( hid_t_f *space_id , hsize_t_f * start, hsize_t_f * end)
 /*----------------------------------------------------------------------------
  * Name:        h5sget_select_elem_pointlist_c
  * Purpose:     Call  H5Sget_select_elem_pointlist
- *              get a list of  element points in the  
- *              current dataspace selectin. 
+ *              get a list of  element points in the
+ *              current dataspace selectin.
  *              Starting with the startpoint-th point in the
  *              list of points, numpoints points are put into the user's
- *              buffer. If the user's buffer fills up before numpoints 
+ *              buffer. If the user's buffer fills up before numpoints
  *              points are inserted, the buffer
- *              will contain only as many points as fit. 
+ *              will contain only as many points as fit.
  * Inputs:      space_id - identifier of the dataspace
  *              startpoint - Element point to start with
- *              numpoints -  Number of element points to get 
- * Outputs:     buf - List of element points selected 
+ *              numpoints -  Number of element points to get
+ * Outputs:     buf - List of element points selected
  * Returns:     0 on success, -1 on failure
  * Programmer:  Xiangyang Su
  *              Wednesday, November 17, 1999
  * Modifications:
  *---------------------------------------------------------------------------*/
 
-int_f 
-nh5sget_select_elem_pointlist_c( hid_t_f *space_id ,hsize_t_f * startpoint, 
+int_f
+nh5sget_select_elem_pointlist_c( hid_t_f *space_id ,hsize_t_f * startpoint,
                                   hsize_t_f * numpoints, hsize_t_f * buf)
 {
   int ret_value = -1;
@@ -328,17 +328,17 @@ nh5sget_select_elem_pointlist_c( hid_t_f *space_id ,hsize_t_f * startpoint,
   rank = H5Sget_simple_extent_ndims(c_space_id);
   if (rank < 0 ) return ret_value;
 
-  c_startpoint = (hsize_t)*startpoint; 
+  c_startpoint = (hsize_t)*startpoint;
   c_buf = (hsize_t*)malloc(sizeof(hsize_t)*(size_t)(c_num_points*rank));
   if (!c_buf) return ret_value;
-  ret_value = H5Sget_select_elem_pointlist(c_space_id, c_startpoint, 
+  ret_value = H5Sget_select_elem_pointlist(c_space_id, c_startpoint,
                                             c_num_points, c_buf);
   for (i = c_num_points*rank-1; i >= 0; i--) {
       buf[i] = (hsize_t_f)(c_buf[i]+1);
   }
 
   if (ret_value  >= 0  ) ret_value = 0;
- 
+
   HDfree(c_buf);
 
   return ret_value;
@@ -348,15 +348,15 @@ nh5sget_select_elem_pointlist_c( hid_t_f *space_id ,hsize_t_f * startpoint,
 
 /*----------------------------------------------------------------------------
  * Name:        h5sselect_all_c
- * Purpose:     Call H5Sselect_all to select entire dataspace 
- * Inputs:      space_id - identifier of the dataspace 
+ * Purpose:     Call H5Sselect_all to select entire dataspace
+ * Inputs:      space_id - identifier of the dataspace
  * Returns:     0 on success, -1 on failure
  * Programmer:  Elena Pourmal
  *              Tuesday, August 10, 1999
  * Modifications:
  *---------------------------------------------------------------------------*/
 
-int_f 
+int_f
 nh5sselect_all_c ( hid_t_f *space_id )
 {
   int ret_value = 0;
@@ -369,15 +369,15 @@ nh5sselect_all_c ( hid_t_f *space_id )
 
 /*----------------------------------------------------------------------------
  * Name:        h5sselect_none_c
- * Purpose:     Call H5Sselect_none to reset the selection region 
- * Inputs:      space_id - identifier of the dataspace 
+ * Purpose:     Call H5Sselect_none to reset the selection region
+ * Inputs:      space_id - identifier of the dataspace
  * Returns:     0 on success, -1 on failure
  * Programmer:  Elena Pourmal
  *              Tuesday, August 10, 1999
  * Modifications:
  *---------------------------------------------------------------------------*/
 
-int_f 
+int_f
 nh5sselect_none_c ( hid_t_f *space_id )
 {
   int ret_value = 0;
@@ -391,8 +391,8 @@ nh5sselect_none_c ( hid_t_f *space_id )
 /*----------------------------------------------------------------------------
  * Name:        h5sselect_valid_c
  * Purpose:     Call H5Sselect_valid to verify that selection
- *              is within dataspace extent.  
- * Inputs:      space_id - identifier of the dataspace 
+ *              is within dataspace extent.
+ * Inputs:      space_id - identifier of the dataspace
  * Outputs:     flag - 0 if not valid selection, 1 if is valid selection,
  *              and negative on failure.
  * Returns:     0 on success, -1 on failure
@@ -401,7 +401,7 @@ nh5sselect_none_c ( hid_t_f *space_id )
  * Modifications:
  *---------------------------------------------------------------------------*/
 
-int_f 
+int_f
 nh5sselect_valid_c ( hid_t_f *space_id , int_f *flag )
 {
   int ret_value = 0;
@@ -418,16 +418,16 @@ nh5sselect_valid_c ( hid_t_f *space_id , int_f *flag )
 /*----------------------------------------------------------------------------
  * Name:        h5sget_simple_extent_npoints_c
  * Purpose:     Call H5Sget_simple_extent_npoints to determine the number
- *              of elements in a dataspace 
- * Inputs:      space_id - identifier of the dataspace 
- * Outputs:     npoints - number of points in a dataspace 
+ *              of elements in a dataspace
+ * Inputs:      space_id - identifier of the dataspace
+ * Outputs:     npoints - number of points in a dataspace
  * Returns:     0 on success, -1 on failure
  * Programmer:  Elena Pourmal
  *              Wednesday, August 11, 1999
  * Modifications:
  *---------------------------------------------------------------------------*/
 
-int_f 
+int_f
 nh5sget_simple_extent_npoints_c ( hid_t_f *space_id , hsize_t_f *npoints )
 {
   int ret_value = 0;
@@ -444,16 +444,16 @@ nh5sget_simple_extent_npoints_c ( hid_t_f *space_id , hsize_t_f *npoints )
 /*----------------------------------------------------------------------------
  * Name:        h5sget_select_npoints_c
  * Purpose:     Call H5Sget_select_npoints to determine the number
- *              of elements in a dataspace selection 
- * Inputs:      space_id - identifier of the dataspace 
- * Outputs:     npoints - number of points in a dataspace selection 
+ *              of elements in a dataspace selection
+ * Inputs:      space_id - identifier of the dataspace
+ * Outputs:     npoints - number of points in a dataspace selection
  * Returns:     0 on success, -1 on failure
  * Programmer:  Elena Pourmal
  *              Wednesday, August 11, 1999
  * Modifications:
  *---------------------------------------------------------------------------*/
 
-int_f 
+int_f
 nh5sget_select_npoints_c ( hid_t_f *space_id , hssize_t_f *npoints )
 {
   int ret_value = 0;
@@ -470,21 +470,21 @@ nh5sget_select_npoints_c ( hid_t_f *space_id , hssize_t_f *npoints )
 /*----------------------------------------------------------------------------
  * Name:        h5sget_simple_extent_ndims_c
  * Purpose:     Call H5Sget_simple_extent_ndims to determine the number
- *              dimensions 
- * Inputs:      space_id - identifier of the dataspace 
- * Outputs:     rank - number of dataspace dimensions 
+ *              dimensions
+ * Inputs:      space_id - identifier of the dataspace
+ * Outputs:     rank - number of dataspace dimensions
  * Returns:     0 on success, -1 on failure
  * Programmer:  Elena Pourmal
  *              Wednesday, August 11, 1999
  * Modifications:
  *---------------------------------------------------------------------------*/
 
-int_f 
+int_f
 nh5sget_simple_extent_ndims_c ( hid_t_f *space_id , int_f *ndims )
 {
   int ret_value = 0;
   hid_t c_space_id;
-  int c_ndims; 
+  int c_ndims;
 
   c_space_id = *space_id;
   c_ndims = H5Sget_simple_extent_ndims(c_space_id);
@@ -496,22 +496,22 @@ nh5sget_simple_extent_ndims_c ( hid_t_f *space_id , int_f *ndims )
 /*----------------------------------------------------------------------------
  * Name:        h5sget_simple_extent_type_c
  * Purpose:     Call H5Sget_simple_extent_type to determine the class type
- *              of a dataspace 
- * Inputs:      space_id - identifier of the dataspace 
+ *              of a dataspace
+ * Inputs:      space_id - identifier of the dataspace
  * Outputs:     classtype - class type; possible values are:
- *              H5S_SCALAR_F (0), H5S_SIMPLE_F (1), H5S_NULL_F (2) 
+ *              H5S_SCALAR_F (0), H5S_SIMPLE_F (1), H5S_NULL_F (2)
  * Returns:     0 on success, -1 on failure
  * Programmer:  Elena Pourmal
  *              Wednesday, August 11, 1999
  * Modifications:
  *---------------------------------------------------------------------------*/
 
-int_f 
+int_f
 nh5sget_simple_extent_type_c ( hid_t_f *space_id , int_f *classtype)
 {
   int ret_value = 0;
   hid_t c_space_id;
-  H5S_class_t c_classtype; 
+  H5S_class_t c_classtype;
 
   c_space_id = *space_id;
   c_classtype = H5Sget_simple_extent_type(c_space_id);
@@ -527,17 +527,17 @@ nh5sget_simple_extent_type_c ( hid_t_f *space_id , int_f *classtype)
 
 /*----------------------------------------------------------------------------
  * Name:        h5soffset_simple_c
- * Purpose:     Call H5Soffset_simple to set the offset of a simple 
- *              dataspace 
- * Inputs:      space_id - identifier of the dataspace 
- *              offset - offset array 
+ * Purpose:     Call H5Soffset_simple to set the offset of a simple
+ *              dataspace
+ * Inputs:      space_id - identifier of the dataspace
+ *              offset - offset array
  * Returns:     0 on success, -1 on failure
  * Programmer:  Elena Pourmal
  *              Wednesday, August 11, 1999
  * Modifications:
  *---------------------------------------------------------------------------*/
 
-int_f 
+int_f
 nh5soffset_simple_c ( hid_t_f *space_id , hssize_t_f *offset)
 {
   int ret_value = -1;
@@ -568,10 +568,10 @@ nh5soffset_simple_c ( hid_t_f *space_id , hssize_t_f *offset)
 /*----------------------------------------------------------------------------
  * Name:        h5sset_extent_simple_c
  * Purpose:     Call H5Sset_extent_simple to set or reset size of
- *              existing  dataspace 
- * Inputs:      space_id - identifier of the dataspace 
+ *              existing  dataspace
+ * Inputs:      space_id - identifier of the dataspace
  *              rank - dataspace rank
- *              current_size - array with the new dimension sizes 
+ *              current_size - array with the new dimension sizes
  *              maximum_size - aray with maximum sizes of dimensions
  * Returns:     0 on success, -1 on failure
  * Programmer:  Elena Pourmal
@@ -579,7 +579,7 @@ nh5soffset_simple_c ( hid_t_f *space_id , hssize_t_f *offset)
  * Modifications:
  *---------------------------------------------------------------------------*/
 
-int_f 
+int_f
 nh5sset_extent_simple_c ( hid_t_f *space_id , int_f *rank, hsize_t_f *current_size, hsize_t_f *maximum_size)
 {
   int ret_value = -1;
@@ -603,7 +603,7 @@ nh5sset_extent_simple_c ( hid_t_f *space_id , int_f *rank, hsize_t_f *current_si
       c_current_size[i] = (hsize_t)current_size[*rank - i - 1];
       c_maximum_size[i] = (hsize_t)maximum_size[*rank - i - 1];
   }
-  
+
   c_space_id = *space_id;
   c_rank = *rank;
   status = H5Sset_extent_simple(c_space_id, c_rank, c_current_size, c_maximum_size);
@@ -615,10 +615,10 @@ nh5sset_extent_simple_c ( hid_t_f *space_id , int_f *rank, hsize_t_f *current_si
 
 /*----------------------------------------------------------------------------
  * Name:        h5sget_simple_extent_dims_c
- * Purpose:     Call H5Sget_simple_extent_dims to retrieve sizes of an 
- *              existing  dataspace 
- * Inputs:      space_id - identifier of the dataspace 
- * Outputs:     dims - array with the dimension sizes 
+ * Purpose:     Call H5Sget_simple_extent_dims to retrieve sizes of an
+ *              existing  dataspace
+ * Inputs:      space_id - identifier of the dataspace
+ * Outputs:     dims - array with the dimension sizes
  *              maxdims - aray with maximum sizes of dimensions
  * Returns:     number of dataspace dimensions (rank) on success, -1 on failure
  * Programmer:  Elena Pourmal
@@ -626,7 +626,7 @@ nh5sset_extent_simple_c ( hid_t_f *space_id , int_f *rank, hsize_t_f *current_si
  * Modifications:
  *---------------------------------------------------------------------------*/
 
-int_f 
+int_f
 nh5sget_simple_extent_dims_c ( hid_t_f *space_id , hsize_t_f *dims, hsize_t_f *maxdims)
 {
   int ret_value = -1;
@@ -664,9 +664,9 @@ nh5sget_simple_extent_dims_c ( hid_t_f *space_id , hsize_t_f *dims, hsize_t_f *m
 
 /*----------------------------------------------------------------------------
  * Name:        h5sis_simple_c
- * Purpose:     Call H5Sis_simple to detrmine if the dataspace 
- *              is simple.  
- * Inputs:      space_id - identifier of the dataspace 
+ * Purpose:     Call H5Sis_simple to detrmine if the dataspace
+ *              is simple.
+ * Inputs:      space_id - identifier of the dataspace
  * Outputs:     flag - 0 if not simple, 1 if is simple,
  *              and negative on failure.
  * Returns:     0 on success, -1 on failure
@@ -675,7 +675,7 @@ nh5sget_simple_extent_dims_c ( hid_t_f *space_id , hsize_t_f *dims, hsize_t_f *m
  * Modifications:
  *---------------------------------------------------------------------------*/
 
-int_f 
+int_f
 nh5sis_simple_c ( hid_t_f *space_id , int_f *flag )
 {
   int ret_value = 0;
@@ -692,8 +692,8 @@ nh5sis_simple_c ( hid_t_f *space_id , int_f *flag )
 
 /*----------------------------------------------------------------------------
  * Name:        h5sextent_copy_c
- * Purpose:     Call H5Sextent_copy to copy an extent of dataspace 
- * Inputs:      dest_space_id - identifier of the destination dataspace 
+ * Purpose:     Call H5Sextent_copy to copy an extent of dataspace
+ * Inputs:      dest_space_id - identifier of the destination dataspace
  *              source_space_id - identifier of the source dataspace
  * Returns:     0 on success, -1 on failure
  * Programmer:  Elena Pourmal
@@ -701,7 +701,7 @@ nh5sis_simple_c ( hid_t_f *space_id , int_f *flag )
  * Modifications:
  *---------------------------------------------------------------------------*/
 
-int_f 
+int_f
 nh5sextent_copy_c ( hid_t_f *dest_space_id , hid_t_f *source_space_id)
 {
   int ret_value = 0;
@@ -710,22 +710,22 @@ nh5sextent_copy_c ( hid_t_f *dest_space_id , hid_t_f *source_space_id)
 
   c_dest_space_id = *dest_space_id;
   c_source_space_id = *source_space_id;
-  status = H5Sextent_copy(c_dest_space_id, c_source_space_id); 
+  status = H5Sextent_copy(c_dest_space_id, c_source_space_id);
   if ( status < 0  ) ret_value = -1;
   return ret_value;
 }
 
 /*----------------------------------------------------------------------------
  * Name:        h5sset_extent_none_c
- * Purpose:     Call H5Sset_extent_none to remove extent from a dataspace 
- * Inputs:      space_id - dataspace identifier 
+ * Purpose:     Call H5Sset_extent_none to remove extent from a dataspace
+ * Inputs:      space_id - dataspace identifier
  * Returns:     0 on success, -1 on failure
  * Programmer:  Elena Pourmal
  *              Wednesday, August 11, 1999
  * Modifications:
  *---------------------------------------------------------------------------*/
 
-int_f 
+int_f
 nh5sset_extent_none_c ( hid_t_f *space_id )
 {
   int ret_value = 0;
@@ -733,19 +733,19 @@ nh5sset_extent_none_c ( hid_t_f *space_id )
   herr_t status;
 
   c_space_id = *space_id;
-  status = H5Sset_extent_none(c_space_id); 
+  status = H5Sset_extent_none(c_space_id);
   if ( status < 0  ) ret_value = -1;
   return ret_value;
 }
 
 /*----------------------------------------------------------------------------
  * Name:        h5sselect_hyperslab_c
- * Purpose:     Call H5Sselect_hyperslab to select a hyperslab 
- * Inputs:      space_id - identifier of the dataspace 
+ * Purpose:     Call H5Sselect_hyperslab to select a hyperslab
+ * Inputs:      space_id - identifier of the dataspace
  *              operator - defines how the new selection is combined
- *              with the previous one; current values are 
- *              H5S_SELECT_SET_F (0) and H5S_SELECT_OR_F (1) 
- *              start - offset of start of hyperslab 
+ *              with the previous one; current values are
+ *              H5S_SELECT_SET_F (0) and H5S_SELECT_OR_F (1)
+ *              start - offset of start of hyperslab
  *              count - number of blocks included in the hyperslab
  *              stride - hyperslab stride (interval between blocks)
  *              block - size of block in the hyperslab
@@ -755,7 +755,7 @@ nh5sset_extent_none_c ( hid_t_f *space_id )
  * Modifications:
  *---------------------------------------------------------------------------*/
 
-int_f 
+int_f
 nh5sselect_hyperslab_c ( hid_t_f *space_id , int_f *op, hsize_t_f *start, hsize_t_f *count, hsize_t_f *stride, hsize_t_f *block)
 {
   int ret_value = -1;
@@ -763,7 +763,7 @@ nh5sselect_hyperslab_c ( hid_t_f *space_id , int_f *op, hsize_t_f *start, hsize_
   hsize_t *c_start = NULL;
   hsize_t *c_count = NULL;
   hsize_t *c_stride = NULL;
-  hsize_t *c_block = NULL; 
+  hsize_t *c_block = NULL;
 
   H5S_seloper_t c_op;
   herr_t  status;
@@ -816,10 +816,10 @@ DONE:
 #ifdef NEW_HYPERSLAB_API
 /*----------------------------------------------------------------------------
  * Name:        h5scombine_hyperslab_c
- * Purpose:     Call H5Scombine_hyperslab 
- * Inputs:      space_id - identifier of the dataspace 
+ * Purpose:     Call H5Scombine_hyperslab
+ * Inputs:      space_id - identifier of the dataspace
  *              operator - defines how the new selection is combined
- *              start - offset of start of hyperslab 
+ *              start - offset of start of hyperslab
  *              count - number of blocks included in the hyperslab
  *              stride - hyperslab stride (interval between blocks)
  *              block - size of block in the hyperslab
@@ -830,7 +830,7 @@ DONE:
  * Modifications:
  *---------------------------------------------------------------------------*/
 
-int_f 
+int_f
 nh5scombine_hyperslab_c ( hid_t_f *space_id , int_f *op, hsize_t_f *start, hsize_t_f *count, hsize_t_f *stride, hsize_t_f *block, hid_t_f *hyper_id)
 {
   int ret_value = -1;
@@ -839,7 +839,7 @@ nh5scombine_hyperslab_c ( hid_t_f *space_id , int_f *op, hsize_t_f *start, hsize
   hsize_t *c_start = NULL;
   hsize_t *c_count = NULL;
   hsize_t *c_stride = NULL;
-  hsize_t *c_block = NULL; 
+  hsize_t *c_block = NULL;
 
   H5S_seloper_t c_op;
   herr_t  status;
@@ -890,9 +890,9 @@ DONE:
 /*----------------------------------------------------------------------------
  * Name:        h5scombine_select_c
  * Purpose:     Call H5Scombine_ select
- * Inputs:      space1_id - identifier of the first dataspace 
+ * Inputs:      space1_id - identifier of the first dataspace
  *              operator - defines how the new selection is combined
- *              space2_id - identifier of the second dataspace 
+ *              space2_id - identifier of the second dataspace
  * Outputs:     ds_id   - identifier for the new dataspace
  * Returns:     0 on success, -1 on failure
  * Programmer:  Elena Pourmal
@@ -900,7 +900,7 @@ DONE:
  * Modifications:
  *---------------------------------------------------------------------------*/
 
-int_f 
+int_f
 nh5scombine_select_c ( hid_t_f *space1_id , int_f *op, hid_t_f *space2_id, hid_t_f *ds_id)
 {
   int ret_value = -1;
@@ -924,14 +924,14 @@ nh5scombine_select_c ( hid_t_f *space1_id , int_f *op, hid_t_f *space2_id, hid_t
  * Purpose:     Call H5Sselect_ select
  * Inputs:      space1_id - identifier of the first dataspace  to modify
  *              operator - defines how the new selection is combined
- *              space2_id - identifier of the second dataspace 
+ *              space2_id - identifier of the second dataspace
  * Returns:     0 on success, -1 on failure
  * Programmer:  Elena Pourmal
  *              Monday, October 7, 2002
  * Modifications:
  *---------------------------------------------------------------------------*/
 
-int_f 
+int_f
 nh5sselect_select_c ( hid_t_f *space1_id , int_f *op, hid_t_f *space2_id)
 {
   int ret_value = -1;
@@ -951,7 +951,7 @@ nh5sselect_select_c ( hid_t_f *space1_id , int_f *op, hid_t_f *space2_id)
 /*----------------------------------------------------------------------------
  * Name:        h5sget_select_type_c
  * Purpose:     Call H5Sget_select_type
- * Inputs:      space_id - identifier of the dataspace 
+ * Inputs:      space_id - identifier of the dataspace
  * Outputs:     type - type of selection
  * Returns:     0 on success, -1 on failure
  * Programmer:  Elena Pourmal
@@ -959,7 +959,7 @@ nh5sselect_select_c ( hid_t_f *space1_id , int_f *op, hid_t_f *space2_id)
  * Modifications:
  *---------------------------------------------------------------------------*/
 
-int_f 
+int_f
 nh5sget_select_type_c ( hid_t_f *space_id , int_f *type)
 {
   int ret_value = -1;
@@ -977,20 +977,20 @@ nh5sget_select_type_c ( hid_t_f *space_id , int_f *type)
 
 /*----------------------------------------------------------------------------
  * Name:        h5sselect_elements_c
- * Purpose:     Call H5Sselect_elements to select elements of a dataspace 
- * Inputs:      space_id - identifier of the dataspace 
+ * Purpose:     Call H5Sselect_elements to select elements of a dataspace
+ * Inputs:      space_id - identifier of the dataspace
  *              operator - defines how the new selection is combined
- *              with the previous one; current values are 
- *              H5S_SELECT_SET_F (0) 
- *              nelements - number of elements in the selection 
- *              coord - arrays with the elements coordinates 
+ *              with the previous one; current values are
+ *              H5S_SELECT_SET_F (0)
+ *              nelements - number of elements in the selection
+ *              coord - arrays with the elements coordinates
  * Returns:     0 on success, -1 on failure
  * Programmer:  Elena Pourmal
  *              Wednesday, August 11, 1999
  * Modifications:
  *---------------------------------------------------------------------------*/
 
-int_f 
+int_f
 nh5sselect_elements_c ( hid_t_f *space_id , int_f *op, size_t_f *nelements,  hsize_t_f *coord)
 {
   int ret_value = -1;
@@ -1021,7 +1021,7 @@ nh5sselect_elements_c ( hid_t_f *space_id , int_f *op, size_t_f *nelements,  hsi
   c_nelements = *nelements;
   status = H5Sselect_elements(c_space_id, c_op, c_nelements, (const hsize_t **)c_coord);
   if ( status >= 0  ) ret_value = 0;
-  HDfree(c_coord); 
+  HDfree(c_coord);
   return ret_value;
 }
 
diff --git a/fortran/src/H5Tf.c b/fortran/src/H5Tf.c
index cd1ccd0..a4ac7bd 100644
--- a/fortran/src/H5Tf.c
+++ b/fortran/src/H5Tf.c
@@ -19,9 +19,9 @@
 
 /*----------------------------------------------------------------------------
  * Name:        h5topen_c
- * Purpose:     Call H5Topen to open a datatype 
- * Inputs:      loc_id - file or group identifier 
- *              name - name of the datatype within file or  group     
+ * Purpose:     Call H5Topen to open a datatype
+ * Inputs:      loc_id - file or group identifier
+ *              name - name of the datatype within file or  group
  *              namelen - name length
  * Outputs:     type_id - dataset identifier
  * Returns:     0 on success, -1 on failure
@@ -42,7 +42,7 @@ nh5topen_c (hid_t_f *loc_id, _fcd name, int_f *namelen, hid_t_f *type_id)
       * Convert FORTRAN name to C name
       */
      c_namelen = *namelen;
-     c_name = (char *)HD5f2cstring(name, c_namelen); 
+     c_name = (char *)HD5f2cstring(name, c_namelen);
      if (c_name == NULL) return ret_value;
 
      /*
@@ -56,14 +56,14 @@ nh5topen_c (hid_t_f *loc_id, _fcd name, int_f *namelen, hid_t_f *type_id)
      HDfree(c_name);
      ret_value = 0;
      return ret_value;
-}      
+}
 
 
 /*----------------------------------------------------------------------------
  * Name:        h5tcommit_c
- * Purpose:     Call H5Tcommit to commit a datatype 
- * Inputs:      loc_id - file or group identifier 
- *              name - name of the datatype within file or  group     
+ * Purpose:     Call H5Tcommit to commit a datatype
+ * Inputs:      loc_id - file or group identifier
+ *              name - name of the datatype within file or  group
  *              namelen - name length
  *              type_id - dataset identifier
  * Returns:     0 on success, -1 on failure
@@ -85,7 +85,7 @@ nh5tcommit_c (hid_t_f *loc_id, _fcd name, int_f *namelen, hid_t_f *type_id)
       * Convert FORTRAN name to C name
       */
      c_namelen = *namelen;
-     c_name = (char *)HD5f2cstring(name, c_namelen); 
+     c_name = (char *)HD5f2cstring(name, c_namelen);
      if (c_name == NULL) return ret_value;
 
      /*
@@ -98,11 +98,11 @@ nh5tcommit_c (hid_t_f *loc_id, _fcd name, int_f *namelen, hid_t_f *type_id)
      if (status < 0) return ret_value;
      ret_value = 0;
      return ret_value;
-}      
+}
 
 /*----------------------------------------------------------------------------
  * Name:        h5tclose_c
- * Purpose:     Call H5Tclose to close the datatype 
+ * Purpose:     Call H5Tclose to close the datatype
  * Inputs:      type_id - identifier of the datatype to be closed
  * Returns:     0 on success, -1 on failure
  * Programmer:  Elena Pourmal
@@ -110,7 +110,7 @@ nh5tcommit_c (hid_t_f *loc_id, _fcd name, int_f *namelen, hid_t_f *type_id)
  * Modifications:
  *---------------------------------------------------------------------------*/
 
-int_f 
+int_f
 nh5tclose_c ( hid_t_f *type_id )
 {
   int ret_value = 0;
@@ -125,7 +125,7 @@ nh5tclose_c ( hid_t_f *type_id )
 /*----------------------------------------------------------------------------
  * Name:        h5tcopy_c
  * Purpose:     Call H5Tcopy to copy a datatype
- * Inputs:      type_id - identifier of the datatype to be copied 
+ * Inputs:      type_id - identifier of the datatype to be copied
  * Outputs:     new_type_id - identifier of the new datatype
  * Returns:     0 on success, -1 on failure
  * Programmer:  Elena Pourmal
@@ -133,7 +133,7 @@ nh5tclose_c ( hid_t_f *type_id )
  * Modifications:
  *---------------------------------------------------------------------------*/
 
-int_f 
+int_f
 nh5tcopy_c ( hid_t_f *type_id , hid_t_f *new_type_id)
 {
   int ret_value = 0;
@@ -141,7 +141,7 @@ nh5tcopy_c ( hid_t_f *type_id , hid_t_f *new_type_id)
   hid_t c_new_type_id;
 
   c_type_id = *type_id;
-  c_new_type_id = H5Tcopy(c_type_id); 
+  c_new_type_id = H5Tcopy(c_type_id);
   if ( c_new_type_id < 0  ) ret_value = -1;
   *new_type_id = (hid_t_f)c_new_type_id;
   return ret_value;
@@ -150,16 +150,16 @@ nh5tcopy_c ( hid_t_f *type_id , hid_t_f *new_type_id)
 /*----------------------------------------------------------------------------
  * Name:        h5tequal_c
  * Purpose:     Call H5Tequal to copy a datatype
- * Inputs:      type1_id - datatype identifier 
- *              type2_id - datatype identifier 
- * Outputs:     c_flag - flag; indicates if two datatypes are equal or not. 
+ * Inputs:      type1_id - datatype identifier
+ *              type2_id - datatype identifier
+ * Outputs:     c_flag - flag; indicates if two datatypes are equal or not.
  * Returns:     0 on success, -1 on failure
  * Programmer:  Elena Pourmal
- *              Tuesday, February 22, 2000 
+ *              Tuesday, February 22, 2000
  * Modifications:
  *---------------------------------------------------------------------------*/
 
-int_f 
+int_f
 nh5tequal_c ( hid_t_f *type1_id , hid_t_f *type2_id, int_f *c_flag)
 {
   int ret_value = -1;
@@ -168,9 +168,9 @@ nh5tequal_c ( hid_t_f *type1_id , hid_t_f *type2_id, int_f *c_flag)
 
   c_type1_id = *type1_id;
   c_type2_id = *type2_id;
-  status = H5Tequal(c_type1_id, c_type2_id); 
-  if ( status < 0  ) return ret_value; 
-  *c_flag = (int_f)status; 
+  status = H5Tequal(c_type1_id, c_type2_id);
+  if ( status < 0  ) return ret_value;
+  *c_flag = (int_f)status;
   ret_value = 0;
   return ret_value;
 }
@@ -179,7 +179,7 @@ nh5tequal_c ( hid_t_f *type1_id , hid_t_f *type2_id, int_f *c_flag)
 /*----------------------------------------------------------------------------
  * Name:        h5tget_class_c
  * Purpose:     Call H5Tget_class to determine the datatype class
- * Inputs:      type_id - identifier of the dataspace 
+ * Inputs:      type_id - identifier of the dataspace
  * Outputs:     classtype - class type; possible values are:
  *              H5T_NO_CLASS_F (-1)
  *              H5T_INTEGER_F (0)
@@ -197,18 +197,18 @@ nh5tequal_c ( hid_t_f *type1_id , hid_t_f *type2_id, int_f *c_flag)
  * Modifications:
  *---------------------------------------------------------------------------*/
 
-int_f 
+int_f
 nh5tget_class_c ( hid_t_f *type_id , int_f *classtype)
 {
   int ret_value = 0;
   hid_t c_type_id;
-  H5T_class_t c_classtype; 
+  H5T_class_t c_classtype;
 
   c_type_id = *type_id;
   c_classtype = H5Tget_class(c_type_id);
   if (c_classtype == H5T_NO_CLASS ) {
       /* *classtype = H5T_NO_CLASS_F; */
-      *classtype = (int_f)H5T_NO_CLASS; 
+      *classtype = (int_f)H5T_NO_CLASS;
        ret_value = -1;
        return ret_value;
   }
@@ -229,8 +229,8 @@ nh5tget_class_c ( hid_t_f *type_id , int_f *classtype)
 
 /*----------------------------------------------------------------------------
  * Name:        h5tget_order_c
- * Purpose:     Call H5Tget_order to determine byte order 
- * Inputs:      type_id - identifier of the dataspace 
+ * Purpose:     Call H5Tget_order to determine byte order
+ * Inputs:      type_id - identifier of the dataspace
  * Outputs:     order; possible values are:
  *              H5T_ORDER_LE_F (0)
  *              H5T_ORDER_BE_F (1)
@@ -241,12 +241,12 @@ nh5tget_class_c ( hid_t_f *type_id , int_f *classtype)
  * Modifications:
  *---------------------------------------------------------------------------*/
 
-int_f 
+int_f
 nh5tget_order_c ( hid_t_f *type_id , int_f *order)
 {
   int ret_value = -1;
   hid_t c_type_id;
-  H5T_order_t c_order; 
+  H5T_order_t c_order;
 
   c_type_id = *type_id;
   c_order = H5Tget_order(c_type_id);
@@ -264,8 +264,8 @@ nh5tget_order_c ( hid_t_f *type_id , int_f *order)
 
 /*----------------------------------------------------------------------------
  * Name:        h5tset_order_c
- * Purpose:     Call H5Tset_order to set byte order 
- * Inputs:      type_id - identifier of the dataspace 
+ * Purpose:     Call H5Tset_order to set byte order
+ * Inputs:      type_id - identifier of the dataspace
  *              order; possible values are:
  *              H5T_ORDER_LE_F (0)
  *              H5T_ORDER_BE_F (1)
@@ -276,12 +276,12 @@ nh5tget_order_c ( hid_t_f *type_id , int_f *order)
  * Modifications:
  *---------------------------------------------------------------------------*/
 
-int_f 
+int_f
 nh5tset_order_c ( hid_t_f *type_id , int_f *order)
 {
   int ret_value = 0;
   hid_t c_type_id;
-  H5T_order_t c_order; 
+  H5T_order_t c_order;
   herr_t status;
   c_order = (H5T_order_t)*order;
 /*
@@ -297,47 +297,47 @@ nh5tset_order_c ( hid_t_f *type_id , int_f *order)
 
 /*----------------------------------------------------------------------------
  * Name:        h5tget_size_c
- * Purpose:     Call H5Tget_size to get size of the datatype 
- * Inputs:      type_id - identifier of the dataspace 
- * Outputs:     size (in bytes) 
+ * Purpose:     Call H5Tget_size to get size of the datatype
+ * Inputs:      type_id - identifier of the dataspace
+ * Outputs:     size (in bytes)
  * Returns:     0 on success, -1 on failure
  * Programmer:  Elena Pourmal
  *              Saturday, August 14, 1999
  * Modifications:
  *---------------------------------------------------------------------------*/
 
-int_f 
+int_f
 nh5tget_size_c ( hid_t_f *type_id , size_t_f *size)
 {
   int ret_value = -1;
   hid_t c_type_id;
-  size_t c_size; 
+  size_t c_size;
 
   c_type_id = *type_id;
   c_size = H5Tget_size(c_type_id);
   if ( c_size == 0  ) return ret_value;
   *size = (size_t_f)c_size ;
-  ret_value = 0; 
+  ret_value = 0;
   return ret_value;
 }
 
 /*----------------------------------------------------------------------------
  * Name:        h5tset_size_c
- * Purpose:     Call H5Tget_size to get size of the datatype 
- * Inputs:      type_id - identifier of the dataspace 
- * Outputs:     size (in bytes) 
+ * Purpose:     Call H5Tget_size to get size of the datatype
+ * Inputs:      type_id - identifier of the dataspace
+ * Outputs:     size (in bytes)
  * Returns:     0 on success, -1 on failure
  * Programmer:  Elena Pourmal
  *              Saturday, August 14, 1999
  * Modifications:
  *---------------------------------------------------------------------------*/
 
-int_f 
+int_f
 nh5tset_size_c ( hid_t_f *type_id , size_t_f *size)
 {
   int ret_value = -1;
   hid_t c_type_id;
-  size_t c_size; 
+  size_t c_size;
   herr_t status;
 
   c_size = (size_t)*size;
@@ -350,134 +350,134 @@ nh5tset_size_c ( hid_t_f *type_id , size_t_f *size)
 
 /*----------------------------------------------------------------------------
  * Name:        h5tget_precision_c
- * Purpose:     Call H5Tget_precision to get precision of the datatype 
- * Inputs:      type_id - identifier of the dataspace 
- * Outputs:     precision -  number of significant bits 
+ * Purpose:     Call H5Tget_precision to get precision of the datatype
+ * Inputs:      type_id - identifier of the dataspace
+ * Outputs:     precision -  number of significant bits
  * Returns:     0 on success, -1 on failure
  * Programmer:  XIANGYANG SU
  *              Tuesday, January 25, 2000
  * Modifications:
  *---------------------------------------------------------------------------*/
 
-int_f 
+int_f
 nh5tget_precision_c ( hid_t_f *type_id , size_t_f *precision)
 {
   int ret_value = -1;
   hid_t c_type_id;
-  size_t c_precision; 
+  size_t c_precision;
 
   c_type_id = *type_id;
   c_precision = H5Tget_precision(c_type_id);
   if ( c_precision == 0  ) return ret_value;
   *precision = (size_t_f)c_precision ;
-  ret_value = 0; 
+  ret_value = 0;
   return ret_value;
 }
 
 /*----------------------------------------------------------------------------
  * Name:        h5tset_precision_c
- * Purpose:     Call H5Tset_precision to set precision of the datatype 
- * Inputs:      type_id - identifier of the dataspace 
- *              precision -  number of significant bits 
+ * Purpose:     Call H5Tset_precision to set precision of the datatype
+ * Inputs:      type_id - identifier of the dataspace
+ *              precision -  number of significant bits
  * Returns:     0 on success, -1 on failure
  * Programmer:  XIANGYANG SU
  *              Tuesday, January 25, 2000
  * Modifications:
  *---------------------------------------------------------------------------*/
 
-int_f 
+int_f
 nh5tset_precision_c ( hid_t_f *type_id , size_t_f *precision)
 {
   int ret_value = -1;
   hid_t c_type_id;
-  size_t c_precision; 
+  size_t c_precision;
   herr_t status;
 
   c_type_id = *type_id;
   c_precision = (size_t)*precision;
   status = H5Tset_precision(c_type_id, c_precision);
   if ( status < 0 ) return ret_value;
-  ret_value = 0; 
+  ret_value = 0;
   return ret_value;
 }
 
 /*----------------------------------------------------------------------------
  * Name:        h5tget_offset_c
- * Purpose:     Call H5Tget_offset to get bit offset of the first 
- *              significant bit of the datatype 
- * Inputs:      type_id - identifier of the dataspace 
- * Outputs:     offset - bit offset of the first significant bit  
+ * Purpose:     Call H5Tget_offset to get bit offset of the first
+ *              significant bit of the datatype
+ * Inputs:      type_id - identifier of the dataspace
+ * Outputs:     offset - bit offset of the first significant bit
  * Returns:     0 on success, -1 on failure
  * Programmer:  XIANGYANG SU
  *              Tuesday, January 25, 2000
  * Modifications:
  *---------------------------------------------------------------------------*/
 
-int_f 
+int_f
 nh5tget_offset_c ( hid_t_f *type_id , size_t_f *offset)
 {
   int ret_value = -1;
   hid_t c_type_id;
-  size_t c_offset; 
+  size_t c_offset;
 
   c_type_id = *type_id;
   c_offset = H5Tget_offset(c_type_id);
   if ( c_offset == 0  ) return ret_value;
 
   *offset = (size_t_f)c_offset ;
-  ret_value = 0; 
+  ret_value = 0;
   return ret_value;
 }
 
 /*----------------------------------------------------------------------------
  * Name:        h5tset_offset_c
- * Purpose:     Call H5Tset_offset to set bit offset of the first 
- *              significant bit of the datatype 
- * Inputs:      type_id - identifier of the dataspace 
- *              offset - bit offset of the first significant bit  
+ * Purpose:     Call H5Tset_offset to set bit offset of the first
+ *              significant bit of the datatype
+ * Inputs:      type_id - identifier of the dataspace
+ *              offset - bit offset of the first significant bit
  * Returns:     0 on success, -1 on failure
  * Programmer:  XIANGYANG SU
  *              Tuesday, January 25, 2000
  * Modifications:
  *---------------------------------------------------------------------------*/
 
-int_f 
+int_f
 nh5tset_offset_c ( hid_t_f *type_id , size_t_f *offset)
 {
   int ret_value = -1;
   hid_t c_type_id;
-  size_t c_offset; 
+  size_t c_offset;
   herr_t status;
 
   c_offset = (size_t)*offset;
   c_type_id = *type_id;
   status = H5Tset_offset(c_type_id, c_offset);
   if ( status < 0 ) return ret_value;
-  ret_value = 0; 
+  ret_value = 0;
   return ret_value;
 }
 
 /*----------------------------------------------------------------------------
  * Name:        h5tget_pad_c
  * Purpose:     Call H5Tget_pad to get the padding type of the least and
- *              most-significant bit padding 
- *              
- * Inputs:      type_id - identifier of the dataspace 
+ *              most-significant bit padding
+ *
+ * Inputs:      type_id - identifier of the dataspace
  * Outputs:     lsbpad - padding type of the least significant bit
- *              msbpad - padding type of the least significant bit  
+ *              msbpad - padding type of the least significant bit
  * Returns:     0 on success, -1 on failure
  * Programmer:  XIANGYANG SU
  *              Wednesday, January 26, 2000
  * Modifications:
  *---------------------------------------------------------------------------*/
 
-int_f 
+int_f
 nh5tget_pad_c ( hid_t_f *type_id , int_f * lsbpad, int_f * msbpad)
 {
   int ret_value = -1;
   hid_t c_type_id;
   herr_t status;
-  H5T_pad_t c_lsb, c_msb; 
+  H5T_pad_t c_lsb, c_msb;
 
   c_type_id = *type_id;
   status = H5Tget_pad(c_type_id, &c_lsb, &c_msb);
@@ -485,85 +485,85 @@ nh5tget_pad_c ( hid_t_f *type_id , int_f * lsbpad, int_f * msbpad)
 
   *lsbpad = (int_f) c_lsb;
   *msbpad = (int_f) c_msb;
-  ret_value = 0; 
+  ret_value = 0;
   return ret_value;
 }
 
 /*----------------------------------------------------------------------------
  * Name:        h5tset_pad_c
- * Inputs:      type_id - identifier of the dataspace 
+ * Inputs:      type_id - identifier of the dataspace
  * Purpose:     Call H5Tset_pad to set the padding type of the least and
- *              most-significant bit padding 
- *              
- * Inputs:      type_id - identifier of the dataspace 
+ *              most-significant bit padding
+ *
+ * Inputs:      type_id - identifier of the dataspace
  *              lsbpad - padding type of the least significant bit
- *              msbpad - padding type of the least significant bit  
+ *              msbpad - padding type of the least significant bit
  * Returns:     0 on success, -1 on failure
  * Programmer:  XIANGYANG SU
  *              Wednesday, January 26, 2000
  * Modifications:
  *---------------------------------------------------------------------------*/
 
-int_f 
+int_f
 nh5tset_pad_c ( hid_t_f *type_id, int_f * lsbpad, int_f* msbpad )
 {
   int ret_value = -1;
   hid_t c_type_id;
   herr_t status;
-  H5T_pad_t c_lsb, c_msb; 
+  H5T_pad_t c_lsb, c_msb;
 
   c_type_id = *type_id;
   c_lsb = (H5T_pad_t)*lsbpad;
   c_msb = (H5T_pad_t)*msbpad;
   status = H5Tset_pad(c_type_id, c_lsb, c_msb);
   if ( status < 0 ) return ret_value;
-  ret_value = 0; 
+  ret_value = 0;
   return ret_value;
 }
 
 /*----------------------------------------------------------------------------
  * Name:        h5tget_sign_c
- * Purpose:     Call H5Tget_sign to get sign type for an integer type 
- * Inputs:      type_id - identifier of the dataspace 
- * Outputs:     sign - sign type for an integer type  
+ * Purpose:     Call H5Tget_sign to get sign type for an integer type
+ * Inputs:      type_id - identifier of the dataspace
+ * Outputs:     sign - sign type for an integer type
  * Returns:     0 on success, -1 on failure
  * Programmer:  XIANGYANG SU
  *              Wednesday, January 26, 2000
  * Modifications:
  *---------------------------------------------------------------------------*/
 
-int_f 
+int_f
 nh5tget_sign_c ( hid_t_f *type_id , int_f *sign)
 {
   int ret_value = -1;
   hid_t c_type_id;
-  H5T_sign_t c_sign; 
+  H5T_sign_t c_sign;
 
   c_type_id = *type_id;
   c_sign = H5Tget_sign(c_type_id);
   if ( c_sign == -1  ) return ret_value;
   *sign = (int_f)c_sign ;
-  ret_value = 0; 
+  ret_value = 0;
   return ret_value;
 }
 
 /*----------------------------------------------------------------------------
  * Name:        h5tset_sign_c
- * Purpose:     Call H5Tset_sign to set sign type for an integer type 
- * Inputs:      type_id - identifier of the dataspace 
- *              sign - sign type for an integer typ   
+ * Purpose:     Call H5Tset_sign to set sign type for an integer type
+ * Inputs:      type_id - identifier of the dataspace
+ *              sign - sign type for an integer typ
  * Returns:     0 on success, -1 on failure
  * Programmer:  XIANGYANG SU
  *              Wednesday, January 26, 2000
  * Modifications:
  *---------------------------------------------------------------------------*/
 
-int_f 
+int_f
 nh5tset_sign_c ( hid_t_f *type_id , int_f* sign)
 {
   int ret_value = -1;
   hid_t c_type_id;
-  H5T_sign_t c_sign; 
+  H5T_sign_t c_sign;
   herr_t status;
 
   c_type_id = *type_id;
@@ -571,15 +571,15 @@ nh5tset_sign_c ( hid_t_f *type_id , int_f* sign)
   status = H5Tset_sign(c_type_id, c_sign);
   if ( status < 0 ) return ret_value;
 
-  ret_value = 0; 
+  ret_value = 0;
   return ret_value;
 }
 
 /*----------------------------------------------------------------------------
  * Name:        h5tget_fields_c
- * Purpose:     Call H5Tget_fields to get floating point datatype 
+ * Purpose:     Call H5Tget_fields to get floating point datatype
  *              bit field information
- * Inputs:      type_id - identifier of the dataspace 
+ * Inputs:      type_id - identifier of the dataspace
  * Outputs:     epos -  exponent bit-position
  *              esize - size of exponent in bits
  *              mpos -  mantissa bit-position
@@ -590,13 +590,13 @@ nh5tset_sign_c ( hid_t_f *type_id , int_f* sign)
  * Modifications:
  *---------------------------------------------------------------------------*/
 
-int_f 
+int_f
 nh5tget_fields_c ( hid_t_f *type_id , size_t_f *spos, size_t_f *epos, size_t_f* esize, size_t_f* mpos, size_t_f* msize)
 {
   int ret_value = -1;
   hid_t c_type_id;
   herr_t status;
-  size_t  c_spos, c_epos, c_esize, c_mpos, c_msize; 
+  size_t  c_spos, c_epos, c_esize, c_mpos, c_msize;
 
   c_type_id = *type_id;
   status = H5Tget_fields(c_type_id, &c_spos, &c_epos, &c_esize, &c_mpos, &c_msize);
@@ -606,15 +606,15 @@ nh5tget_fields_c ( hid_t_f *type_id , size_t_f *spos, size_t_f *epos, size_t_f*
   *esize = (size_t_f) c_esize;
   *mpos = (size_t_f) c_mpos;
   *msize = (size_t_f) c_msize;
-  ret_value = 0; 
+  ret_value = 0;
   return ret_value;
 }
 
 /*----------------------------------------------------------------------------
  * Name:        h5tset_fields_c
- * Purpose:     Call H5Tset_fields to set floating point datatype 
+ * Purpose:     Call H5Tset_fields to set floating point datatype
  *              bit field information
- * Inputs:      type_id - identifier of the dataspace 
+ * Inputs:      type_id - identifier of the dataspace
  *              epos -  exponent bit-position
  *              esize - size of exponent in bits
  *              mpos -  mantissa bit-position
@@ -625,13 +625,13 @@ nh5tget_fields_c ( hid_t_f *type_id , size_t_f *spos, size_t_f *epos, size_t_f*
  * Modifications:
  *---------------------------------------------------------------------------*/
 
-int_f 
+int_f
 nh5tset_fields_c ( hid_t_f *type_id, size_t_f *spos, size_t_f *epos, size_t_f* esize, size_t_f* mpos, size_t_f* msize)
 {
   int ret_value = -1;
   hid_t c_type_id;
   herr_t status;
-  size_t  c_spos, c_epos, c_esize, c_mpos, c_msize; 
+  size_t  c_spos, c_epos, c_esize, c_mpos, c_msize;
 
   c_spos = (size_t)*spos;
   c_epos = (size_t)*epos;
@@ -642,15 +642,15 @@ nh5tset_fields_c ( hid_t_f *type_id, size_t_f *spos, size_t_f *epos, size_t_f* e
   status = H5Tset_fields(c_type_id, c_spos, c_epos, c_esize, c_mpos, c_msize);
   if ( status < 0 ) return ret_value;
 
-  ret_value = 0; 
+  ret_value = 0;
   return ret_value;
 }
 
 /*----------------------------------------------------------------------------
  * Name:        h5tget_ebias_c
- * Purpose:     Call H5Tget_ebias to get  exponent bias of a 
- *              floating-point type of the datatype 
- * Inputs:      type_id - identifier of the dataspace 
+ * Purpose:     Call H5Tget_ebias to get  exponent bias of a
+ *              floating-point type of the datatype
+ * Inputs:      type_id - identifier of the dataspace
  * Outputs:     ebias - exponent bias of a floating-point type of the datatype
  * Returns:     0 on success, -1 on failure
  * Programmer:  Xiangyang Su
@@ -658,40 +658,40 @@ nh5tset_fields_c ( hid_t_f *type_id, size_t_f *spos, size_t_f *epos, size_t_f* e
  * Modifications:
  *---------------------------------------------------------------------------*/
 
-int_f 
+int_f
 nh5tget_ebias_c ( hid_t_f *type_id , size_t_f *ebias)
 {
   int ret_value = -1;
   hid_t c_type_id;
-  size_t c_ebias; 
+  size_t c_ebias;
 
   c_type_id = *type_id;
   c_ebias = H5Tget_ebias(c_type_id);
   if ( c_ebias == 0  ) return ret_value;
 
   *ebias = (size_t_f)c_ebias;
-  ret_value = 0; 
+  ret_value = 0;
   return ret_value;
 }
 
 /*----------------------------------------------------------------------------
  * Name:        h5tset_ebias_c
  * Purpose:     Call H5Tset_ebias to set exponent bias of a
- *              floating-point type of the datatype  
- * Inputs:      type_id - identifier of the dataspace 
- *              ebias - exponent bias of a floating-point type of the datatyp 
+ *              floating-point type of the datatype
+ * Inputs:      type_id - identifier of the dataspace
+ *              ebias - exponent bias of a floating-point type of the datatyp
  * Returns:     0 on success, -1 on failure
  * Programmer:  Xiangyang Su
  *              Friday, January 27, 2000
  * Modifications:
  *---------------------------------------------------------------------------*/
 
-int_f 
+int_f
 nh5tset_ebias_c ( hid_t_f *type_id , size_t_f *ebias)
 {
   int ret_value = -1;
   hid_t c_type_id;
-  size_t c_ebias; 
+  size_t c_ebias;
   herr_t status;
 
   c_type_id = *type_id;
@@ -706,8 +706,8 @@ nh5tset_ebias_c ( hid_t_f *type_id , size_t_f *ebias)
 /*----------------------------------------------------------------------------
  * Name:        h5tget_norm_c
  * Purpose:     Call H5Tget_norm to get mantissa normalization
- *              of a floating-point datatype  
- * Inputs:      type_id - identifier of the dataspace 
+ *              of a floating-point datatype
+ * Inputs:      type_id - identifier of the dataspace
  * Outputs:     norm - mantissa normalization of a floating-point type
  * Returns:     0 on success, -1 on failure
  * Programmer:  Xiangyang Su
@@ -715,27 +715,27 @@ nh5tset_ebias_c ( hid_t_f *type_id , size_t_f *ebias)
  * Modifications:
  *---------------------------------------------------------------------------*/
 
-int_f 
+int_f
 nh5tget_norm_c ( hid_t_f *type_id , int_f *norm)
 {
   int ret_value = -1;
   hid_t c_type_id;
-  H5T_norm_t  c_norm; 
+  H5T_norm_t  c_norm;
 
   c_type_id = *type_id;
   c_norm = H5Tget_norm(c_type_id);
   if ( c_norm == 0  ) return ret_value;
 
   *norm = (int_f)c_norm;
-  ret_value = 0; 
+  ret_value = 0;
   return ret_value;
 }
 
 /*----------------------------------------------------------------------------
  * Name:        h5tset_norm_c
- * Purpose:     Call H5Tset_norm to set mantissa normalization of 
- *              floating-point type of the datatype  
- * Inputs:      type_id - identifier of the dataspace 
+ * Purpose:     Call H5Tset_norm to set mantissa normalization of
+ *              floating-point type of the datatype
+ * Inputs:      type_id - identifier of the dataspace
  *              norm -  mantissa normalization of a floating-point type
  * Returns:     0 on success, -1 on failure
  * Programmer:  Xiangyang Su
@@ -743,12 +743,12 @@ nh5tget_norm_c ( hid_t_f *type_id , int_f *norm)
  * Modifications:
  *---------------------------------------------------------------------------*/
 
-int_f 
+int_f
 nh5tset_norm_c ( hid_t_f *type_id , int_f *norm)
 {
   int ret_value = -1;
   hid_t c_type_id;
-  H5T_norm_t  c_norm; 
+  H5T_norm_t  c_norm;
   herr_t status;
 
   c_type_id = *type_id;
@@ -764,8 +764,8 @@ nh5tset_norm_c ( hid_t_f *type_id , int_f *norm)
  * Name:        h5tget_inpad_c
  * Purpose:     Call H5Tget_inpad to get the padding type for
  *              unused bits in floating-point datatypes
- *              
- * Inputs:      type_id - identifier of the dataspace 
+ *
+ * Inputs:      type_id - identifier of the dataspace
  * Outputs:     padtype - padding type for
  *                        unused bits in floating-point datatype
  * Returns:     0 on success, -1 on failure
@@ -774,29 +774,29 @@ nh5tset_norm_c ( hid_t_f *type_id , int_f *norm)
  * Modifications:
  *---------------------------------------------------------------------------*/
 
-int_f 
+int_f
 nh5tget_inpad_c ( hid_t_f *type_id , int_f * padtype)
 {
   int ret_value = -1;
   hid_t c_type_id;
-  H5T_pad_t c_padtype; 
+  H5T_pad_t c_padtype;
 
   c_type_id = *type_id;
   c_padtype = H5Tget_inpad(c_type_id);
   if ( c_padtype == H5T_PAD_ERROR  ) return ret_value;
 
   *padtype = (int_f) c_padtype;
-  ret_value = 0; 
+  ret_value = 0;
   return ret_value;
 }
 
 /*----------------------------------------------------------------------------
  * Name:        h5tset_inpad_c
- * Inputs:      type_id - identifier of the dataspace 
- * Purpose:     Call H5Tset_inpad to set the padding type 
+ * Inputs:      type_id - identifier of the dataspace
+ * Purpose:     Call H5Tset_inpad to set the padding type
  *              unused bits in floating-point datatype
- *              
- * Inputs:      type_id - identifier of the dataspace 
+ *
+ * Inputs:      type_id - identifier of the dataspace
  *              padtype - padding type for unused bits
  *                        in floating-point datatypes
  * Returns:     0 on success, -1 on failure
@@ -805,29 +805,29 @@ nh5tget_inpad_c ( hid_t_f *type_id , int_f * padtype)
  * Modifications:
  *---------------------------------------------------------------------------*/
 
-int_f 
+int_f
 nh5tset_inpad_c ( hid_t_f *type_id, int_f * padtype)
 {
   int ret_value = -1;
   hid_t c_type_id;
   herr_t status;
-  H5T_pad_t c_padtype; 
+  H5T_pad_t c_padtype;
 
   c_type_id = *type_id;
   c_padtype = (H5T_pad_t)*padtype;
   status = H5Tset_inpad(c_type_id, c_padtype);
   if ( status < 0 ) return ret_value;
 
-  ret_value = 0; 
+  ret_value = 0;
   return ret_value;
 }
 
 /*----------------------------------------------------------------------------
  * Name:        h5tget_cset_c
- * Purpose:     Call H5Tget_cset to get character set 
+ * Purpose:     Call H5Tget_cset to get character set
  *              type of a string datatype
- *              
- * Inputs:      type_id - identifier of the dataspace 
+ *
+ * Inputs:      type_id - identifier of the dataspace
  * Outputs:     cset - character set type of a string datatype
  * Returns:     0 on success, -1 on failure
  * Programmer:  XIANGYANG SU
@@ -835,29 +835,29 @@ nh5tset_inpad_c ( hid_t_f *type_id, int_f * padtype)
  * Modifications:
  *---------------------------------------------------------------------------*/
 
-int_f 
+int_f
 nh5tget_cset_c ( hid_t_f *type_id , int_f * cset)
 {
   int ret_value = -1;
   hid_t c_type_id;
-  H5T_cset_t  c_cset; 
+  H5T_cset_t  c_cset;
 
   c_type_id = *type_id;
   c_cset = H5Tget_cset(c_type_id);
   if ( c_cset == H5T_CSET_ERROR  ) return ret_value;
 
   *cset = (int_f) c_cset;
-  ret_value = 0; 
+  ret_value = 0;
   return ret_value;
 }
 
 /*----------------------------------------------------------------------------
  * Name:        h5tset_cset_c
- * Inputs:      type_id - identifier of the dataspace 
+ * Inputs:      type_id - identifier of the dataspace
  * Purpose:     Call H5Tset_cset to set character set
  *              type of a string datatype
- *              
- * Inputs:      type_id - identifier of the dataspace 
+ *
+ * Inputs:      type_id - identifier of the dataspace
  *              cset -  character set type of a string datatype
  * Returns:     0 on success, -1 on failure
  * Programmer:  XIANGYANG SU
@@ -865,20 +865,20 @@ nh5tget_cset_c ( hid_t_f *type_id , int_f * cset)
  * Modifications:
  *---------------------------------------------------------------------------*/
 
-int_f 
+int_f
 nh5tset_cset_c ( hid_t_f *type_id, int_f * cset)
 {
   int ret_value = -1;
   hid_t c_type_id;
   herr_t status;
-  H5T_cset_t c_cset; 
+  H5T_cset_t c_cset;
 
   c_type_id = *type_id;
   c_cset = (H5T_cset_t)*cset;
   status = H5Tset_cset(c_type_id, c_cset);
 
   if ( status < 0 ) return ret_value;
-  ret_value = 0; 
+  ret_value = 0;
   return ret_value;
 }
 
@@ -886,7 +886,7 @@ nh5tset_cset_c ( hid_t_f *type_id, int_f * cset)
  * Name:        h5tget_strpad_c
  * Purpose:     Call H5Tget_strpad to get string padding method
  *              for a string datatype
- * Inputs:      type_id - identifier of the dataspace 
+ * Inputs:      type_id - identifier of the dataspace
  * Outputs:     strpad - string padding method for a string datatype
  * Returns:     0 on success, -1 on failure
  * Programmer:  XIANGYANG SU
@@ -894,29 +894,29 @@ nh5tset_cset_c ( hid_t_f *type_id, int_f * cset)
  * Modifications:
  *---------------------------------------------------------------------------*/
 
-int_f 
+int_f
 nh5tget_strpad_c ( hid_t_f *type_id , int_f * strpad)
 {
   int ret_value = -1;
   hid_t c_type_id;
-  H5T_str_t  c_strpad; 
+  H5T_str_t  c_strpad;
 
   c_type_id = *type_id;
   c_strpad = H5Tget_strpad(c_type_id);
   if ( c_strpad == H5T_STR_ERROR  ) return ret_value;
 
   *strpad = (int_f) c_strpad;
-  ret_value = 0; 
+  ret_value = 0;
   return ret_value;
 }
 
 /*----------------------------------------------------------------------------
  * Name:        h5tset_strpad_c
- * Inputs:      type_id - identifier of the dataspace 
+ * Inputs:      type_id - identifier of the dataspace
  * Purpose:     Call H5Tset_strpad to set string padding method
  *              for a string datatype
- *              
- * Inputs:      type_id - identifier of the dataspace 
+ *
+ * Inputs:      type_id - identifier of the dataspace
  *              strpad - string padding method for a string datatype
  * Returns:     0 on success, -1 on failure
  * Programmer:  XIANGYANG SU
@@ -924,28 +924,28 @@ nh5tget_strpad_c ( hid_t_f *type_id , int_f * strpad)
  * Modifications:
  *---------------------------------------------------------------------------*/
 
-int_f 
+int_f
 nh5tset_strpad_c ( hid_t_f *type_id, int_f * strpad)
 {
   int ret_value = -1;
   hid_t c_type_id;
   herr_t status;
-  H5T_str_t c_strpad; 
+  H5T_str_t c_strpad;
 
   c_type_id = *type_id;
   c_strpad = (H5T_str_t)*strpad;
   status = H5Tset_strpad(c_type_id, c_strpad);
   if ( status < 0 ) return ret_value;
 
-  ret_value = 0; 
+  ret_value = 0;
   return ret_value;
 }
 
 /*----------------------------------------------------------------------------
  * Name:        h5tget_nmembers_c
- * Purpose:     Call H5Tget_nmembers to get number of fields 
+ * Purpose:     Call H5Tget_nmembers to get number of fields
  *              in a compound datatype
- * Inputs:      type_id - identifier of the dataspace 
+ * Inputs:      type_id - identifier of the dataspace
  * Outputs:     num_members - number of fields in a compound datatype
  * Returns:     0 on success, -1 on failure
  * Programmer:  XIANGYANG SU
@@ -953,7 +953,7 @@ nh5tset_strpad_c ( hid_t_f *type_id, int_f * strpad)
  * Modifications:
  *---------------------------------------------------------------------------*/
 
-int_f 
+int_f
 nh5tget_nmembers_c ( hid_t_f *type_id , int_f * num_members)
 {
   int ret_value = -1;
@@ -963,16 +963,16 @@ nh5tget_nmembers_c ( hid_t_f *type_id , int_f * num_members)
   *num_members = (int_f)H5Tget_nmembers(c_type_id);
   if (*num_members < 0  ) return ret_value;
 
-  ret_value = 0; 
+  ret_value = 0;
   return ret_value;
 }
 
 /*----------------------------------------------------------------------------
  * Name:        h5tget_member_name_c
- * Purpose:     Call H5Tget_member_name to get name  
+ * Purpose:     Call H5Tget_member_name to get name
  *              of a compound datatype
- * Inputs:      type_id - identifier of the dataspace 
- * Outputs:     member_name - name of a field of a compound datatype  
+ * Inputs:      type_id - identifier of the dataspace
+ * Outputs:     member_name - name of a field of a compound datatype
  * Returns:     0 on success, -1 on failure
  * Programmer:  XIANGYANG SU
  *              Thursday, February 3, 2000
@@ -980,7 +980,7 @@ nh5tget_nmembers_c ( hid_t_f *type_id , int_f * num_members)
  * Added namelen parameter to return length of the name to Fortran user
  *---------------------------------------------------------------------------*/
 
-int_f 
+int_f
 nh5tget_member_name_c ( hid_t_f *type_id ,int_f* idx, _fcd member_name, int_f *namelen)
 {
   int ret_value = -1;
@@ -993,18 +993,18 @@ nh5tget_member_name_c ( hid_t_f *type_id ,int_f* idx, _fcd member_name, int_f *n
   c_name = H5Tget_member_name(c_type_id, c_index);
   if (c_name == NULL ) return ret_value;
 
-  HD5packFstring(c_name, _fcdtocp(member_name), (int)strlen(c_name));  
+  HD5packFstring(c_name, _fcdtocp(member_name), (int)strlen(c_name));
   *namelen = (int_f)strlen(c_name);
   HDfree(c_name);
-  ret_value = 0; 
+  ret_value = 0;
   return ret_value;
 }
 /*----------------------------------------------------------------------------
  * Name:        h5tget_member_index_c
  * Purpose:     Call H5Tget_member_index to get an index of
  *              the specified datatype filed or member.
- * Inputs:      type_id - datatype identifier  
- *              name - name of the datatype within file or  group     
+ * Inputs:      type_id - datatype identifier
+ *              name - name of the datatype within file or  group
  *              namelen - name length
  * Outputs:     index - 0-based index
  * Returns:     0 on success, -1 on failure
@@ -1025,7 +1025,7 @@ nh5tget_member_index_c (hid_t_f *type_id, _fcd name, int_f *namelen, int_f *idx)
       * Convert FORTRAN name to C name
       */
      c_namelen = *namelen;
-     c_name = (char *)HD5f2cstring(name, c_namelen); 
+     c_name = (char *)HD5f2cstring(name, c_namelen);
      if (c_name == NULL) return ret_value;
 
      /*
@@ -1040,25 +1040,25 @@ DONE:
      HDfree(c_name);
      ret_value = 0;
      return ret_value;
-}      
+}
 
 
 /*----------------------------------------------------------------------------
  * Name:        h5tget_member_offset_c
  * Purpose:     Call H5Tget_member_offset to get byte offset of the
- *              beginning of a field within a compound datatype with 
+ *              beginning of a field within a compound datatype with
  *              respect to the beginning of the compound data type datum
- * Inputs:      type_id - identifier of the dataspace 
+ * Inputs:      type_id - identifier of the dataspace
  *              member_no - Number of the field whose offset is requested
  * Outputs:     offset - byte offset of the the beginning of the field of
- *                       a compound datatype  
+ *                       a compound datatype
  * Returns:     always 0
  * Programmer:  XIANGYANG SU
  *              Thursday, February 3, 2000
  * Modifications:
  *---------------------------------------------------------------------------*/
 
-int_f 
+int_f
 nh5tget_member_offset_c ( hid_t_f *type_id ,int_f* member_no, size_t_f * offset)
 {
   int ret_value = -1;
@@ -1070,23 +1070,23 @@ nh5tget_member_offset_c ( hid_t_f *type_id ,int_f* member_no, size_t_f * offset)
   c_member_no = *member_no;
   c_offset = H5Tget_member_offset(c_type_id, c_member_no);
   *offset = (size_t_f)c_offset;
-  ret_value = 0; 
+  ret_value = 0;
   return ret_value;
 }
 
 /*----------------------------------------------------------------------------
  * Name:        h5tget_array_dims_c
- * Purpose:     Call H5Tget_array_dims to get  
+ * Purpose:     Call H5Tget_array_dims to get
  *              dimensions of array datatype
  * Inputs:      type_id - identifier of the array datatype
  * Outputs:     dims -  dimensions(sizes of dimensions) of the array
  * Returns:     0 on success, -1 on failure
  * Programmer:  Elena Pourmal
  *              Thursday, November 16, 2000
- * Modifications: 
+ * Modifications:
  *---------------------------------------------------------------------------*/
 
-int_f 
+int_f
 nh5tget_array_dims_c ( hid_t_f *type_id , hsize_t_f * dims)
 {
   int ret_value = -1;
@@ -1112,7 +1112,7 @@ nh5tget_array_dims_c ( hid_t_f *type_id , hsize_t_f * dims)
       dims[rank-i-1] = (hsize_t_f)c_dims[i];
   }
 
-  ret_value = 0; 
+  ret_value = 0;
   HDfree(c_dims);
 
   return ret_value;
@@ -1120,17 +1120,17 @@ nh5tget_array_dims_c ( hid_t_f *type_id , hsize_t_f * dims)
 
 /*----------------------------------------------------------------------------
  * Name:        h5tget_array_ndims_c
- * Purpose:     Call H5Tget_array_ndims to get number 
+ * Purpose:     Call H5Tget_array_ndims to get number
  *              of dimensions of array datatype
  * Inputs:      type_id - identifier of the array datatype
  * Outputs:     ndims -  number of dimensions of the array
  * Returns:     0 on success, -1 on failure
  * Programmer:  Elena Pourmal
  *              Thursday, November 16, 2000
- * Modifications: 
+ * Modifications:
  *---------------------------------------------------------------------------*/
 
-int_f 
+int_f
 nh5tget_array_ndims_c ( hid_t_f *type_id , int_f * ndims)
 {
   int ret_value = -1;
@@ -1142,23 +1142,23 @@ nh5tget_array_ndims_c ( hid_t_f *type_id , int_f * ndims)
   if (c_ndims < 0) return ret_value;
 
   *ndims = (int_f)c_ndims;
-  ret_value = 0; 
+  ret_value = 0;
   return ret_value;
 }
 
 /*----------------------------------------------------------------------------
  * Name:        h5tget_super_c
- * Purpose:     Call H5Tget_super to get base datatype from which 
- *              datatype was derived 
+ * Purpose:     Call H5Tget_super to get base datatype from which
+ *              datatype was derived
  * Inputs:      type_id - identifier of the array datatype
- * Outputs:     base_type_id - base datatype identifier 
+ * Outputs:     base_type_id - base datatype identifier
  * Returns:     0 on success, -1 on failure
  * Programmer:  Elena Pourmal
  *              Thursday, November 16, 2000
- * Modifications: 
+ * Modifications:
  *---------------------------------------------------------------------------*/
 
-int_f 
+int_f
 nh5tget_super_c ( hid_t_f *type_id , hid_t_f *base_type_id)
 {
   int ret_value = -1;
@@ -1170,7 +1170,7 @@ nh5tget_super_c ( hid_t_f *type_id , hid_t_f *base_type_id)
   if (c_base_type_id < 0) return ret_value;
 
   *base_type_id = (hid_t_f)c_base_type_id;
-  ret_value = 0; 
+  ret_value = 0;
   return ret_value;
 }
 
@@ -1179,7 +1179,7 @@ nh5tget_super_c ( hid_t_f *type_id , hid_t_f *base_type_id)
  * Name:        h5tget_member_type_c
  * Purpose:     Call H5Tget_member_type to get the identifier of a copy of
  *              the datatype of the field
- * Inputs:      type_id - identifier of the datatype 
+ * Inputs:      type_id - identifier of the datatype
  *              field_idx - Field index (0-based) of the field type to retrieve
  * Outputs:     datatype - identifier of a copy of the datatype of the field
  * Returns:     0 on success, -1 on failure
@@ -1188,7 +1188,7 @@ nh5tget_super_c ( hid_t_f *type_id , hid_t_f *base_type_id)
  * Modifications:
  *---------------------------------------------------------------------------*/
 
-int_f 
+int_f
 nh5tget_member_type_c ( hid_t_f *type_id ,int_f* field_idx, hid_t_f * datatype)
 {
   int ret_value = -1;
@@ -1200,23 +1200,23 @@ nh5tget_member_type_c ( hid_t_f *type_id ,int_f* field_idx, hid_t_f * datatype)
   *datatype = (hid_t_f)H5Tget_member_type(c_type_id, c_field_idx);
   if(*datatype < 0) return ret_value;
 
-  ret_value = 0; 
+  ret_value = 0;
   return ret_value;
 }
 
 
 /*----------------------------------------------------------------------------
  * Name:        h5tcreate_c
- * Purpose:     Call H5Tcreate to create a datatype 
- * Inputs:      class - class type 
- *              size - size of the class memeber 
+ * Purpose:     Call H5Tcreate to create a datatype
+ * Inputs:      class - class type
+ *              size - size of the class memeber
  * Returns:     0 on success, -1 on failure
- * Programmer:  Elena Pourmal 
+ * Programmer:  Elena Pourmal
  *              Thursday, February 17, 2000
  * Modifications:
  *---------------------------------------------------------------------------*/
 
-int_f 
+int_f
 nh5tcreate_c(int_f *class, size_t_f *size, hid_t_f *type_id)
 {
   int ret_value = -1;
@@ -1229,14 +1229,14 @@ nh5tcreate_c(int_f *class, size_t_f *size, hid_t_f *type_id)
   *type_id = (hid_t_f)H5Tcreate(c_class, c_size);
   if(*type_id < 0) return ret_value;
 
-  ret_value = 0; 
+  ret_value = 0;
   return ret_value;
 }
 
 /*----------------------------------------------------------------------------
  * Name:        h5tinsert_c
  * Purpose:     Call H5Tinsert to adds another member to the compound datatype
- * Inputs:      type_id - identifier of the datatype 
+ * Inputs:      type_id - identifier of the datatype
  *              name  - Name of the field to insert
  *              namelen - length of the name
  *              offset - Offset in memory structure of the field to insert
@@ -1247,7 +1247,7 @@ nh5tcreate_c(int_f *class, size_t_f *size, hid_t_f *type_id)
  * Modifications:
  *---------------------------------------------------------------------------*/
 
-int_f 
+int_f
 nh5tinsert_c(hid_t_f *type_id, _fcd name, int_f* namelen, size_t_f *offset, hid_t_f * field_id)
 {
   int ret_value = -1;
@@ -1260,7 +1260,7 @@ nh5tinsert_c(hid_t_f *type_id, _fcd name, int_f* namelen, size_t_f *offset, hid_
 
   c_offset =(size_t) *offset;
   c_namelen = *namelen;
-  c_name = (char *)HD5f2cstring(name, c_namelen); 
+  c_name = (char *)HD5f2cstring(name, c_namelen);
   if (c_name == NULL) return ret_value;
 
   c_type_id = *type_id;
@@ -1268,17 +1268,17 @@ nh5tinsert_c(hid_t_f *type_id, _fcd name, int_f* namelen, size_t_f *offset, hid_
   error = H5Tinsert(c_type_id, c_name, c_offset, c_field_id);
   HDfree(c_name);
   if(error < 0) return ret_value;
-  ret_value = 0; 
+  ret_value = 0;
   return ret_value;
 }
 
 
 /*----------------------------------------------------------------------------
  * Name:        h5tpack_c
- * Purpose:     Call H5Tpack tor ecursively remove padding from 
- *              within a compound datatype to make it more efficient 
+ * Purpose:     Call H5Tpack tor ecursively remove padding from
+ *              within a compound datatype to make it more efficient
  *              (space-wise) to store that data
- * Inputs:      type_id - identifier of the datatype 
+ * Inputs:      type_id - identifier of the datatype
  * Returns:     0 on success, -1 on failure
  * Programmer:  XIANGYANG SU
  *              Thursday, February 3, 2000
@@ -1298,7 +1298,7 @@ nh5tpack_c(hid_t_f * type_id)
 
   ret_value = 0;
   return ret_value;
-} 
+}
 
 /*----------------------------------------------------------------------------
  * Name:        h5tarray_create_c
@@ -1308,9 +1308,9 @@ nh5tpack_c(hid_t_f * type_id)
  *              dims - Size of new member array
  *              type_id - identifier of the array datatype
  * Returns:     0 on success, -1 on failure
- * Programmer:  Elena Pourmal 
+ * Programmer:  Elena Pourmal
  *              Thursday, November 16, 2000
- * Modifications: 
+ * Modifications:
  *---------------------------------------------------------------------------*/
 int_f
 nh5tarray_create_c(hid_t_f * base_id, int_f *rank, hsize_t_f* dims, hid_t_f* type_id)
@@ -1332,7 +1332,7 @@ nh5tarray_create_c(hid_t_f * base_id, int_f *rank, hsize_t_f* dims, hid_t_f* typ
   for (i = 0; i < *rank ; i++) {
      c_dims[i] =  (hsize_t)dims[*rank - i - 1];
   }
-  
+
   c_base_id = (hid_t)*base_id;
   c_rank = (int)*rank;
   c_type_id = H5Tarray_create(c_base_id, c_rank, c_dims, NULL);
@@ -1353,8 +1353,8 @@ nh5tarray_create_c(hid_t_f * base_id, int_f *rank, hsize_t_f* dims, hid_t_f* typ
 /*----------------------------------------------------------------------------
  * Name:        h5tenum_create_c
  * Purpose:     Call H5Tenum_create to create a new enumeration datatype
- * Inputs:      parent_id - Datatype identifier for the base datatype 
- * Outputs:     new_type_id - datatype identifier for the new 
+ * Inputs:      parent_id - Datatype identifier for the base datatype
+ * Outputs:     new_type_id - datatype identifier for the new
  *                            enumeration datatype
  * Returns:     0 on success, -1 on failure
  * Programmer:  Xiangyang Su
@@ -1362,7 +1362,7 @@ nh5tarray_create_c(hid_t_f * base_id, int_f *rank, hsize_t_f* dims, hid_t_f* typ
  * Modifications:
  *---------------------------------------------------------------------------*/
 
-int_f 
+int_f
 nh5tenum_create_c ( hid_t_f *parent_id , hid_t_f *new_type_id)
 {
   int ret_value = 0;
@@ -1370,7 +1370,7 @@ nh5tenum_create_c ( hid_t_f *parent_id , hid_t_f *new_type_id)
   hid_t c_new_type_id;
 
   c_parent_id = *parent_id;
-  c_new_type_id = H5Tenum_create(c_parent_id); 
+  c_new_type_id = H5Tenum_create(c_parent_id);
   if ( c_new_type_id < 0  ) ret_value = -1;
 
   *new_type_id = (hid_t_f)c_new_type_id;
@@ -1380,7 +1380,7 @@ nh5tenum_create_c ( hid_t_f *parent_id , hid_t_f *new_type_id)
 /*----------------------------------------------------------------------------
  * Name:        h5tenum_insert_c
  * Purpose:     Call H5Tenum_insert to insert a new enumeration datatype member.
- * Inputs:      type_id - identifier of the datatype 
+ * Inputs:      type_id - identifier of the datatype
  *              name  - Name of  the new member
  *              namelen - length of the name
  *              value - value of the new member
@@ -1390,7 +1390,7 @@ nh5tenum_create_c ( hid_t_f *parent_id , hid_t_f *new_type_id)
  * Modifications:
  *---------------------------------------------------------------------------*/
 
-int_f 
+int_f
 nh5tenum_insert_c(hid_t_f *type_id, _fcd name, int_f* namelen, int_f* value)
 {
   int ret_value = -1;
@@ -1401,16 +1401,16 @@ nh5tenum_insert_c(hid_t_f *type_id, _fcd name, int_f* namelen, int_f* value)
   herr_t error;
 
   c_namelen = *namelen;
-  c_name = (char *)HD5f2cstring(name, c_namelen); 
+  c_name = (char *)HD5f2cstring(name, c_namelen);
   if (c_name == NULL) return ret_value;
- 
+
   c_type_id = (hid_t)*type_id;
   c_value = (int)*value;
   error = H5Tenum_insert(c_type_id, c_name, &c_value);
   HDfree(c_name);
   if(error < 0) return ret_value;
 
-  ret_value = 0; 
+  ret_value = 0;
   return ret_value;
 }
 
@@ -1419,7 +1419,7 @@ nh5tenum_insert_c(hid_t_f *type_id, _fcd name, int_f* namelen, int_f* value)
  * Name:        h5tenum_nameof_c
  * Purpose:     Call H5Tenum_nameof to find the symbol name that corresponds to
  *              the specified value of the enumeration datatype type
- * Inputs:      type_id - identifier of the datatype 
+ * Inputs:      type_id - identifier of the datatype
  *              namelen - length of the name
  *              value - value of the enumeration datatype
  * Output:      name  - Name of  the enumeration datatype
@@ -1429,7 +1429,7 @@ nh5tenum_insert_c(hid_t_f *type_id, _fcd name, int_f* namelen, int_f* value)
  * Modifications:
  *---------------------------------------------------------------------------*/
 
-int_f 
+int_f
 nh5tenum_nameof_c(hid_t_f *type_id, int_f* value, _fcd name, size_t_f* namelen)
 {
   int ret_value = -1;
@@ -1443,11 +1443,11 @@ nh5tenum_nameof_c(hid_t_f *type_id, int_f* value, _fcd name, size_t_f* namelen)
   c_name = (char *)malloc(sizeof(char)*c_namelen);
   c_type_id = (hid_t)*type_id;
   error = H5Tenum_nameof(c_type_id, &c_value, c_name, c_namelen);
-  HD5packFstring(c_name, _fcdtocp(name), (int)strlen(c_name));  
+  HD5packFstring(c_name, _fcdtocp(name), (int)strlen(c_name));
   HDfree(c_name);
 
   if(error < 0) return ret_value;
-  ret_value = 0; 
+  ret_value = 0;
   return ret_value;
 }
 
@@ -1455,9 +1455,9 @@ nh5tenum_nameof_c(hid_t_f *type_id, int_f* value, _fcd name, size_t_f* namelen)
  * Name:        h5tenum_valueof_c
  * Purpose:     Call H5Tenum_valueof to find the value of that corresponds to
  *              the specified name of the enumeration datatype type
- * Inputs:      type_id - identifier of the datatype 
+ * Inputs:      type_id - identifier of the datatype
  *              name - Name of  the enumeration datatype
- *              namelen - length of name 
+ *              namelen - length of name
  * Output:      value  - value of the enumeration datatype
  * Returns:     0 on success, -1 on failure
  * Programmer:  XIANGYANG SU
@@ -1465,7 +1465,7 @@ nh5tenum_nameof_c(hid_t_f *type_id, int_f* value, _fcd name, size_t_f* namelen)
  * Modifications:
  *---------------------------------------------------------------------------*/
 
-int_f 
+int_f
 nh5tenum_valueof_c(hid_t_f *type_id, _fcd name, int_f* namelen, int_f* value)
 {
   int ret_value = -1;
@@ -1474,7 +1474,7 @@ nh5tenum_valueof_c(hid_t_f *type_id, _fcd name, int_f* namelen, int_f* value)
   int c_namelen;
   herr_t error;
   c_namelen = *namelen;
-  c_name = (char *)HD5f2cstring(name, c_namelen); 
+  c_name = (char *)HD5f2cstring(name, c_namelen);
   if (c_name == NULL) return ret_value;
 
   c_type_id = *type_id;
@@ -1482,16 +1482,16 @@ nh5tenum_valueof_c(hid_t_f *type_id, _fcd name, int_f* namelen, int_f* value)
   HDfree(c_name);
 
   if(error < 0) return ret_value;
-  ret_value = 0; 
+  ret_value = 0;
   return ret_value;
 }
 
 
 /*----------------------------------------------------------------------------
  * Name:        h5tget_member_value_c
- * Purpose:     Call H5Tget_member_value to get the value of an 
+ * Purpose:     Call H5Tget_member_value to get the value of an
  *              enumeration datatype member
- * Inputs:      type_id - identifier of the datatype 
+ * Inputs:      type_id - identifier of the datatype
  *              member_no - Number of the enumeration datatype member.
  * Output:      value  - value of the enumeration datatype
  * Returns:     0 on success, -1 on failure
@@ -1500,7 +1500,7 @@ nh5tenum_valueof_c(hid_t_f *type_id, _fcd name, int_f* namelen, int_f* value)
  * Modifications:
  *---------------------------------------------------------------------------*/
 
-int_f 
+int_f
 nh5tget_member_value_c(hid_t_f *type_id, int_f* member_no, int_f* value)
 {
   int ret_value = -1;
@@ -1515,16 +1515,16 @@ nh5tget_member_value_c(hid_t_f *type_id, int_f* member_no, int_f* value)
   if(error < 0) return ret_value;
 
   *value = (int_f)c_value;
-  ret_value = 0; 
+  ret_value = 0;
   return ret_value;
 }
 
 /*----------------------------------------------------------------------------
  * Name:        h5tset_tag_c
- * Inputs:      type_id - identifier of the dataspace 
+ * Inputs:      type_id - identifier of the dataspace
  * Purpose:     Call H5Tset_tag to set an opaque datatype tag
- * Inputs:      type_id - identifier of the dataspace 
- *              tag -  Unique ASCII string with which the opaque 
+ * Inputs:      type_id - identifier of the dataspace
+ *              tag -  Unique ASCII string with which the opaque
  *                     datatype is to be tagged
  *              namelen - length of tag
  * Returns:     0 on success, -1 on failure
@@ -1541,23 +1541,23 @@ nh5tset_tag_c(hid_t_f* type_id, _fcd tag, int_f* namelen)
   char* c_tag;
   int c_namelen;
 
-  c_namelen = *namelen; 
-  c_tag = (char *)HD5f2cstring(tag, c_namelen); 
+  c_namelen = *namelen;
+  c_tag = (char *)HD5f2cstring(tag, c_namelen);
 
   c_type_id = *type_id;
   status = H5Tset_tag(c_type_id, c_tag);
   HDfree(c_tag);
   if ( status < 0 ) return ret_value;
 
-  ret_value = 0; 
+  ret_value = 0;
   return ret_value;
-}    
+}
 
 /*----------------------------------------------------------------------------
  * Name:        h5tget_tag_c
  * Purpose:     Call H5Tset_tag to set an opaque datatype tag
  * Inputs:      type_id - identifier of the datatype
- * Outputs:     tag -  Unique ASCII string with which the opaque 
+ * Outputs:     tag -  Unique ASCII string with which the opaque
  *                     datatype is to be tagged
  *              taglen - length of tag
  * Returns:     0 on success, -1 on failure
@@ -1576,10 +1576,10 @@ nh5tget_tag_c(hid_t_f* type_id, _fcd tag, int_f* taglen)
   c_tag = H5Tget_tag(c_type_id);
   if (c_tag == NULL ) return ret_value;
 
-  HD5packFstring(c_tag, _fcdtocp(tag), (int)strlen(c_tag));  
+  HD5packFstring(c_tag, _fcdtocp(tag), (int)strlen(c_tag));
   *taglen = (int_f)HDstrlen(c_tag);
   HDfree(c_tag);
-  ret_value = 0; 
+  ret_value = 0;
   return ret_value;
 }
 /*----------------------------------------------------------------------------
@@ -1603,14 +1603,14 @@ nh5tvlen_create_c(hid_t_f* type_id, hid_t_f *vltype_id)
   c_vltype_id = H5Tvlen_create(c_type_id);
   if (c_vltype_id < 0 ) return ret_value;
   *vltype_id = (hid_t_f)c_vltype_id;
-  ret_value = 0; 
+  ret_value = 0;
   return ret_value;
 }
 /*----------------------------------------------------------------------------
  * Name:        h5tis_variable_str_c
  * Purpose:     Call H5Tis_variable_str to detrmine if the datatype
  *              is a variable string.
- * Inputs:      type_id - identifier of the dataspace 
+ * Inputs:      type_id - identifier of the dataspace
  * Outputs:     flag - 0 if not VL str, 1 if is not
  *              and negative on failure.
  * Returns:     0 on success, -1 on failure
@@ -1619,7 +1619,7 @@ nh5tvlen_create_c(hid_t_f* type_id, hid_t_f *vltype_id)
  * Modifications:
  *---------------------------------------------------------------------------*/
 
-int_f 
+int_f
 nh5tis_variable_str_c ( hid_t_f *type_id , int_f *flag )
 {
   int ret_value = 0;
@@ -1636,7 +1636,7 @@ nh5tis_variable_str_c ( hid_t_f *type_id , int_f *flag )
  * Name:        h5tget_member_class_c
  * Purpose:     Call H5Tget_member_class to detrmine ithe class of the compound
  *		datatype member
- * Inputs:      type_id - identifier of the dataspace 
+ * Inputs:      type_id - identifier of the dataspace
  *              member_no - member's index
  * Outputs:     class - member's class
  *              and negative on failure.
@@ -1646,7 +1646,7 @@ nh5tis_variable_str_c ( hid_t_f *type_id , int_f *flag )
  * Modifications:
  *---------------------------------------------------------------------------*/
 
-int_f 
+int_f
 nh5tget_member_class_c ( hid_t_f *type_id ,  int_f *member_no, int_f *class )
 {
   int ret_value = 0;
diff --git a/fortran/src/H5Zf.c b/fortran/src/H5Zf.c
index 8c2b6b6..6436de5 100644
--- a/fortran/src/H5Zf.c
+++ b/fortran/src/H5Zf.c
@@ -54,7 +54,7 @@ nh5zunregister_c (int_f *filter)
  * Modifications:
  *---------------------------------------------------------------------------*/
 
-int_f 
+int_f
 nh5zfilter_avail_c ( int_f *filter , int_f *flag )
 {
   int ret_value = 0;
@@ -80,7 +80,7 @@ nh5zfilter_avail_c ( int_f *filter , int_f *flag )
  * Modifications:
  *---------------------------------------------------------------------------*/
 
-int_f 
+int_f
 nh5zget_filter_info_c ( int_f *filter , int_f *flag )
 {
   int ret_value = 0;
diff --git a/fortran/src/H5_f.c b/fortran/src/H5_f.c
index 8b244f0..745dfe4 100644
--- a/fortran/src/H5_f.c
+++ b/fortran/src/H5_f.c
@@ -19,21 +19,21 @@
 /*---------------------------------------------------------------------------
  * Name:              h5init_types_c
  * Purpose:           Initialize predefined datatypes in Fortran
- * Inputs:            types - array with the predefined Native Fortran 
+ * Inputs:            types - array with the predefined Native Fortran
  *                            type, its element and length must be the
- *                            same as the types array defined in the 
+ *                            same as the types array defined in the
  *                            H5f90global.f90
- *                    floatingtypes - array with the predefined Floating Fortran 
+ *                    floatingtypes - array with the predefined Floating Fortran
  *                                    type, its element and length must be the
- *                                    same as the floatingtypes array defined in the 
+ *                                    same as the floatingtypes array defined in the
  *                                    H5f90global.f90
- *                    integertypes - array with the predefined Integer Fortran 
+ *                    integertypes - array with the predefined Integer Fortran
  *                                   type, its element and length must be the
- *                                   same as the integertypes array defined in the 
+ *                                   same as the integertypes array defined in the
  *                                   H5f90global.f90
- * Outputs:           None 
+ * Outputs:           None
  * Returns:           0 on success, -1 on failure
- * Programmer:        Elena Pourmal  
+ * Programmer:        Elena Pourmal
  *                    Tuesday, August 3, 1999
  * Modifications:
  *---------------------------------------------------------------------------*/
@@ -112,49 +112,49 @@ nh5init_types_c( hid_t_f * types, hid_t_f * floatingtypes, hid_t_f * integertype
     if ((integertypes[13] = (hid_t_f)H5Tcopy(H5T_STD_U32LE)) < 0) return ret_value;
     if ((integertypes[14] = (hid_t_f)H5Tcopy(H5T_STD_U64BE)) < 0) return ret_value;
     if ((integertypes[15] = (hid_t_f)H5Tcopy(H5T_STD_U64LE)) < 0) return ret_value;
-/* 
- *  Define Fortran H5T_STRING type to store non-fixed size strings 
+/*
+ *  Define Fortran H5T_STRING type to store non-fixed size strings
  */
     if ((c_type_id = H5Tcopy(H5T_C_S1)) < 0) return ret_value;
-    if(H5Tset_size(c_type_id, H5T_VARIABLE) < 0) return ret_value; 
+    if(H5Tset_size(c_type_id, H5T_VARIABLE) < 0) return ret_value;
     integertypes[16] = c_type_id;
 
-    ret_value = 0; 
+    ret_value = 0;
     return ret_value;
 }
-    
+
 /*---------------------------------------------------------------------------
  * Name:              h5close_types_c
  * Purpose:           Closes predefined datatype in Fortran
- * Inputs:            types - array with the predefined Native Fortran 
+ * Inputs:            types - array with the predefined Native Fortran
  *                            type, its element and length must be the
- *                            same as the types array defined in the 
+ *                            same as the types array defined in the
  *                            H5f90global.f90
  *                    lentypes - length of the types array, which must be the
- *                               same as the length of types array defined 
+ *                               same as the length of types array defined
  *                               in the H5f90global.f90
- *                    floatingtypes - array with the predefined Floating Fortran 
+ *                    floatingtypes - array with the predefined Floating Fortran
  *                                    type, its element and length must be the
- *                                    same as the floatingtypes array defined in the 
+ *                                    same as the floatingtypes array defined in the
  *                                    H5f90global.f90
  *                    floatinglen - length of the floatingtypes array, which must be the
- *                                  same as the length of floatingtypes array defined 
+ *                                  same as the length of floatingtypes array defined
  *                                  in the H5f90global.f90
- *                    integertypes - array with the predefined Integer Fortran 
+ *                    integertypes - array with the predefined Integer Fortran
  *                                   type, its element and length must be the
- *                                   same as the integertypes array defined in the 
+ *                                   same as the integertypes array defined in the
  *                                   H5f90global.f90
  *                    integerlen - length of the floatingtypes array, which must be the
- *                                 same as the length of floatingtypes array defined 
+ *                                 same as the length of floatingtypes array defined
  *                                 in the H5f90global.f90
- * Outputs:           None 
+ * Outputs:           None
  * Returns:           0 on success, -1 on failure
- * Programmer:        Elena Pourmal  
+ * Programmer:        Elena Pourmal
  *                    Tuesday, August 3, 1999
  * Modifications:
  *---------------------------------------------------------------------------*/
 int_f
-nh5close_types_c( hid_t_f * types, int_f *lentypes, 
+nh5close_types_c( hid_t_f * types, int_f *lentypes,
                   hid_t_f * floatingtypes, int_f* floatinglen,
                   hid_t_f * integertypes,  int_f * integerlen )
 {
@@ -175,13 +175,13 @@ nh5close_types_c( hid_t_f * types, int_f *lentypes,
         c_type_id = integertypes[i];
         if ( H5Tclose(c_type_id) < 0) return ret_value;
     }
-    ret_value = 0; 
+    ret_value = 0;
     return ret_value;
-}    
+}
 /*---------------------------------------------------------------------------
  * Name:              h5init_flags_c
  * Purpose:           Initialize Fortran flags
- * Inputs:            h5d_flags    - H5D inteface flags 
+ * Inputs:            h5d_flags    - H5D inteface flags
  *                    h5f_flags    - H5F interface flags
  *                    h5fd_flags    - H5FD interface flags
  *                    h5fd_hid_flags- H5FD interface flags of type hid_t
@@ -192,18 +192,18 @@ nh5close_types_c( hid_t_f * types, int_f *lentypes,
  *                    h5s_flags    - H5S interface flags
  *                    h5t_flags    - H5T interface flags
  *                    h5z_flags    - H5Z interface flags
- * Outputs:           None 
+ * Outputs:           None
  * Returns:           0 on success, -1 on failure
- * Programmer:        Elena Pourmal  
+ * Programmer:        Elena Pourmal
  *                    Tuesday, August 3, 1999
  * Modifications:     Added Z flags. EIP,  March 12, 2003
  *                    Added more FD flags and new H5LIB flags
- *                    Added more FD flags for HDF5 file driver 
- *                                  EIP, April 9, 2005 
+ *                    Added more FD flags for HDF5 file driver
+ *                                  EIP, April 9, 2005
  *---------------------------------------------------------------------------*/
 int_f
 nh5init_flags_c( int_f *h5d_flags, int_f *h5f_flags,
-                 int_f *h5fd_flags, hid_t_f *h5fd_hid_flags, 
+                 int_f *h5fd_flags, hid_t_f *h5fd_hid_flags,
                  int_f *h5g_flags, int_f *h5i_flags,
                  hid_t_f *h5p_flags, int_f *h5r_flags, int_f *h5s_flags,
                  int_f *h5t_flags, int_f *h5z_flags)
@@ -235,7 +235,7 @@ nh5init_flags_c( int_f *h5d_flags, int_f *h5f_flags,
 /*
  *  H5F flags
  */
-      h5f_flags[0] = (int_f)H5F_ACC_RDWR; 
+      h5f_flags[0] = (int_f)H5F_ACC_RDWR;
       h5f_flags[1] = (int_f)H5F_ACC_RDONLY;
       h5f_flags[2] = (int_f)H5F_ACC_TRUNC;
       h5f_flags[3] = (int_f)H5F_ACC_EXCL;
@@ -264,7 +264,7 @@ nh5init_flags_c( int_f *h5d_flags, int_f *h5f_flags,
       h5fd_flags[6] = H5FD_MEM_DRAW;
       h5fd_flags[7] = H5FD_MEM_GHEAP;
       h5fd_flags[8] = H5FD_MEM_LHEAP;
-      h5fd_flags[9] = H5FD_MEM_OHDR; 
+      h5fd_flags[9] = H5FD_MEM_OHDR;
       h5fd_flags[10] = H5FD_MEM_NTYPES;
 
 /*
@@ -308,8 +308,8 @@ nh5init_flags_c( int_f *h5d_flags, int_f *h5f_flags,
  *  H5P flags
  */
 
-      h5p_flags[0] = H5P_FILE_CREATE; 
-      h5p_flags[1] = H5P_FILE_ACCESS; 
+      h5p_flags[0] = H5P_FILE_CREATE;
+      h5p_flags[1] = H5P_FILE_ACCESS;
       h5p_flags[2] = H5P_DATASET_CREATE;
       h5p_flags[3] = H5P_DATASET_XFER;
       h5p_flags[4] = H5P_MOUNT;
@@ -328,9 +328,9 @@ nh5init_flags_c( int_f *h5d_flags, int_f *h5f_flags,
  */
 
 
-      h5s_flags[0] = H5S_SCALAR; 
-      h5s_flags[1] = H5S_SIMPLE; 
-      h5s_flags[2] = H5S_NULL; 
+      h5s_flags[0] = H5S_SCALAR;
+      h5s_flags[1] = H5S_SIMPLE;
+      h5s_flags[2] = H5S_NULL;
       h5s_flags[3] = H5S_SELECT_SET;
       h5s_flags[4] = H5S_SELECT_OR;
       h5s_flags[5] = (int_f)H5S_UNLIMITED;
@@ -357,29 +357,29 @@ nh5init_flags_c( int_f *h5d_flags, int_f *h5f_flags,
  */
 
 
-      h5t_flags[0] = H5T_NO_CLASS; 
-      h5t_flags[1] = H5T_INTEGER; 
-      h5t_flags[2] = H5T_FLOAT;  
-      h5t_flags[3] = H5T_TIME; 
-      h5t_flags[4] = H5T_STRING; 
+      h5t_flags[0] = H5T_NO_CLASS;
+      h5t_flags[1] = H5T_INTEGER;
+      h5t_flags[2] = H5T_FLOAT;
+      h5t_flags[3] = H5T_TIME;
+      h5t_flags[4] = H5T_STRING;
       h5t_flags[5] = H5T_BITFIELD;
       h5t_flags[6] = H5T_OPAQUE;
-      h5t_flags[7] = H5T_COMPOUND; 
+      h5t_flags[7] = H5T_COMPOUND;
       h5t_flags[8] = H5T_REFERENCE;
-      h5t_flags[9] = H5T_ENUM; 
-      h5t_flags[10] = H5T_ORDER_LE; 
+      h5t_flags[9] = H5T_ENUM;
+      h5t_flags[10] = H5T_ORDER_LE;
       h5t_flags[11] = H5T_ORDER_BE;
       h5t_flags[12] = H5T_ORDER_VAX;
       h5t_flags[13] = H5T_PAD_ZERO;
       h5t_flags[14] = H5T_PAD_ONE;
       h5t_flags[15] = H5T_PAD_BACKGROUND;
-      h5t_flags[16] = H5T_PAD_ERROR;    
-      h5t_flags[17] = H5T_SGN_NONE;   
-      h5t_flags[18] = H5T_SGN_2;     
+      h5t_flags[16] = H5T_PAD_ERROR;
+      h5t_flags[17] = H5T_SGN_NONE;
+      h5t_flags[18] = H5T_SGN_2;
       h5t_flags[19] = H5T_SGN_ERROR;
       h5t_flags[20] = H5T_NORM_IMPLIED;
       h5t_flags[21] = H5T_NORM_MSBSET;
-      h5t_flags[22] = H5T_NORM_NONE; 
+      h5t_flags[22] = H5T_NORM_NONE;
       h5t_flags[23] = H5T_CSET_ASCII;
       h5t_flags[24] = H5T_CSET_UTF8;
       h5t_flags[25] = H5T_STR_NULLTERM;
@@ -407,7 +407,7 @@ nh5init_flags_c( int_f *h5d_flags, int_f *h5f_flags,
       h5z_flags[12] = H5Z_FILTER_CONFIG_DECODE_ENABLED;
       h5z_flags[13] = H5Z_FILTER_ALL;
 
-    ret_value = 0; 
+    ret_value = 0;
     return ret_value;
 }
 
@@ -419,7 +419,7 @@ nh5init1_flags_c(int_f *h5lib_flags)
     unsigned prm_2 = H5_SZIP_NN_OPTION_MASK;
     h5lib_flags[0] = (int_f)prm_1;
     h5lib_flags[1] = (int_f)prm_2;
-    ret_value = 0; 
+    ret_value = 0;
     return ret_value;
 }
 
@@ -427,8 +427,8 @@ nh5init1_flags_c(int_f *h5lib_flags)
  * Name:              h5open_c
  * Purpose:           Calls H5open call to initialize C HDF5 library
  * Returns:           0 on success, -1 on failure
- * Programmer:        Elena Pourmal  
- *                    Friday, November 17, 2000 
+ * Programmer:        Elena Pourmal
+ *                    Friday, November 17, 2000
  * Modifications:
  *---------------------------------------------------------------------------*/
 int_f
@@ -436,16 +436,16 @@ nh5open_c()
 {
 
     int ret_value = -1;
-    if (H5open() < 0) return ret_value;  
-    ret_value = 0; 
+    if (H5open() < 0) return ret_value;
+    ret_value = 0;
     return ret_value;
-}    
+}
 /*---------------------------------------------------------------------------
  * Name:              h5close_c
  * Purpose:           Calls H5close call to close C HDF5 library
  * Returns:           0 on success, -1 on failure
- * Programmer:        Elena Pourmal  
- *                    Friday, November 17, 2000 
+ * Programmer:        Elena Pourmal
+ *                    Friday, November 17, 2000
  * Modifications:
  *---------------------------------------------------------------------------*/
 int_f
@@ -453,24 +453,24 @@ nh5close_c()
 {
 
     int ret_value = -1;
-    if (H5close() < 0) return ret_value;  
-    ret_value = 0; 
+    if (H5close() < 0) return ret_value;
+    ret_value = 0;
     return ret_value;
-}    
+}
 
 
 /*---------------------------------------------------------------------------
  * Name:              h5get_libversion_c
  * Purpose:           Calls H5get_libversion function
- *		      to retrieve library version info. 
- * Inputs:            
+ *		      to retrieve library version info.
+ * Inputs:
  *                    None
- * Outputs:           
+ * Outputs:
  *                    majnum - the major version of the library
  *                    minnum - the minor version of the library
  *                    relnum - the release version of the library
  * Returns:           0 on success, -1 on failure
- * Programmer:        Elena Pourmal  
+ * Programmer:        Elena Pourmal
  *                    Tuesday, September 24, 2002
  * Modifications:
  *---------------------------------------------------------------------------*/
@@ -479,30 +479,30 @@ nh5get_libversion_c( int_f *majnum, int_f *minnum, int_f *relnum)
 {
 
     int ret_value = -1;
-    unsigned c_majnum, c_minnum, c_relnum; 
+    unsigned c_majnum, c_minnum, c_relnum;
 
     if (H5get_libversion(&c_majnum, &c_minnum, &c_relnum) < 0) return ret_value;
 
     *majnum = (int_f)c_majnum;
     *minnum = (int_f)c_minnum;
     *relnum = (int_f)c_relnum;
-    ret_value = 0; 
+    ret_value = 0;
     return ret_value;
-}    
+}
 
 
 /*---------------------------------------------------------------------------
  * Name:              h5check_version_c
  * Purpose:           Calls H5check_version function
- *		      to verify library version info. 
- * Inputs:            
+ *		      to verify library version info.
+ * Inputs:
  *                    majnum - the major version of the library
  *                    minnum - the minor version of the library
  *                    relnum - the release version of the library
- * Outputs:           
+ * Outputs:
  *                    None
  * Returns:           0 on success, aborts on failure
- * Programmer:        Elena Pourmal  
+ * Programmer:        Elena Pourmal
  *                    Tuesday, September 24, 2002
  * Modifications:
  *---------------------------------------------------------------------------*/
@@ -511,22 +511,22 @@ nh5check_version_c( int_f *majnum, int_f *minnum, int_f *relnum)
 {
 
     int ret_value = -1;
-    unsigned c_majnum, c_minnum, c_relnum; 
+    unsigned c_majnum, c_minnum, c_relnum;
     c_majnum = (unsigned) *majnum;
     c_minnum = (unsigned) *minnum;
     c_relnum = (unsigned) *relnum;
 
     H5check_version(c_majnum, c_minnum, c_relnum);
 
-    ret_value = 0; 
+    ret_value = 0;
     return ret_value;
-}    
+}
 
 /*---------------------------------------------------------------------------
  * Name:              h5garbage_collect_c
  * Purpose:           Calls H5garbage_collect to collect on all free-lists of all types
  * Returns:           0 on success, -1 on failure
- * Programmer:        Elena Pourmal  
+ * Programmer:        Elena Pourmal
  *                    Tuesday, September 24, 2002
  * Modifications:
  *---------------------------------------------------------------------------*/
@@ -535,16 +535,16 @@ nh5garbage_collect_c()
 {
 
     int ret_value = -1;
-    if (H5garbage_collect() < 0) return ret_value;  
-    ret_value = 0; 
+    if (H5garbage_collect() < 0) return ret_value;
+    ret_value = 0;
     return ret_value;
-}    
+}
 
 /*---------------------------------------------------------------------------
  * Name:              h5dont_atexit_c
  * Purpose:           Calls H5dont_atexit not to install atexit cleanup routine
  * Returns:           0 on success, -1 on failure
- * Programmer:        Elena Pourmal  
+ * Programmer:        Elena Pourmal
  *                    Tuesday, September 24, 2002
  * Modifications:
  *---------------------------------------------------------------------------*/
@@ -553,7 +553,7 @@ nh5dont_atexit_c()
 {
 
     int ret_value = -1;
-    if (H5dont_atexit() < 0) return ret_value;  
-    ret_value = 0; 
+    if (H5dont_atexit() < 0) return ret_value;
+    ret_value = 0;
     return ret_value;
-}    
+}
diff --git a/fortran/src/H5f90.h b/fortran/src/H5f90.h
index 864da1c..a9d15ae 100644
--- a/fortran/src/H5f90.h
+++ b/fortran/src/H5f90.h
@@ -14,7 +14,7 @@
 
 
 #ifndef _H5f90_H
-#define _H5f90_H 
+#define _H5f90_H
 
 #include "hdf5.h"
 #include "H5private.h"
diff --git a/fortran/src/H5f90kit.c b/fortran/src/H5f90kit.c
index a25645b..2cd9f7c 100644
--- a/fortran/src/H5f90kit.c
+++ b/fortran/src/H5f90kit.c
@@ -14,7 +14,7 @@
 
 
 #include <ctype.h>
-#include <stddef.h>                                 
+#include <stddef.h>
 #include "H5f90.h"
 
 
diff --git a/fortran/src/H5f90proto.h b/fortran/src/H5f90proto.h
index 38f6b53..5d972f9 100644
--- a/fortran/src/H5f90proto.h
+++ b/fortran/src/H5f90proto.h
@@ -236,14 +236,14 @@ H5_FCDLL int_f nh5awrite_c (hid_t_f *attr_id, hid_t_f *mem_type_id, void *buf, v
 H5_FCDLL int_f nh5areadc_c (hid_t_f *attr_id, hid_t_f *mem_type_id, _fcd buf, void *dims);
 H5_FCDLL int_f nh5aread_c (hid_t_f *attr_id, hid_t_f *mem_type_id, void *buf, void *dims);
 H5_FCDLL int_f nh5aclose_c ( hid_t_f *attr_id );
-H5_FCDLL int_f nh5adelete_c (hid_t_f *obj_id, _fcd name, size_t_f *namelen); 
+H5_FCDLL int_f nh5adelete_c (hid_t_f *obj_id, _fcd name, size_t_f *namelen);
 H5_FCDLL int_f nh5aopen_idx_c (hid_t_f *obj_id, int_f *idx, hid_t_f *attr_id);
 H5_FCDLL int_f nh5aget_space_c (hid_t_f *attr_id, hid_t_f *space_id);
 H5_FCDLL int_f nh5aget_type_c (hid_t_f *attr_id, hid_t_f *type_id);
 H5_FCDLL int_f nh5aget_num_attrs_c (hid_t_f *obj_id, int_f *attr_num);
 H5_FCDLL int_f nh5aget_name_c(hid_t_f *attr_id, size_t_f *size, _fcd buf);
 
-/* 
+/*
  * Functions form H5Tf.c file
  */
 #   define nh5topen_c         H5_FC_FUNC_(h5topen_c, H5TOPEN_C)
@@ -361,7 +361,7 @@ H5_FCDLL int_f nh5tvlen_create_c ( hid_t_f *type_id , hid_t_f *vltype_id);
 H5_FCDLL int_f nh5tis_variable_str_c ( hid_t_f *type_id , int_f *flag );
 H5_FCDLL int_f nh5tget_member_class_c ( hid_t_f *type_id ,  int_f *member_no, int_f *class );
 
-/* 
+/*
  * Functions from H5Pf.c
  */
 #   define nh5pcreate_c       H5_FC_FUNC_(h5pcreate_c, H5PCREATE_C)
@@ -463,7 +463,7 @@ H5_FCDLL int_f nh5tget_member_class_c ( hid_t_f *type_id ,  int_f *member_no, in
 #   define nh5pset_fletcher32_c           H5_FC_FUNC_(h5pset_fletcher32_c, H5PSET_FLETCHER32_C)
 #   define nh5pset_edc_check_c            H5_FC_FUNC_(h5pset_edc_check_c, H5PSET_EDC_CHECK_C)
 #   define nh5pget_edc_check_c            H5_FC_FUNC_(h5pget_edc_check_c, H5PGET_EDC_CHECK_C)
-#   define nh5pset_family_offset_c       H5_FC_FUNC_(h5pset_family_offset_c, H5PSET_FAMILY_OFFSET_C)       
+#   define nh5pset_family_offset_c       H5_FC_FUNC_(h5pset_family_offset_c, H5PSET_FAMILY_OFFSET_C)
 #   define nh5pget_fapl_multi_c          H5_FC_FUNC_(h5pget_fapl_multi_c, H5PGET_FAPL_MULTI_C)
 #   define nh5pset_fapl_multi_c          H5_FC_FUNC_(h5pset_fapl_multi_c, H5PSET_FAPL_MULTI_C)
 #   define nh5pset_fapl_multi_sc          H5_FC_FUNC_(h5pset_fapl_multi_sc, H5PSET_FAPL_MULTI_SC)
@@ -548,23 +548,23 @@ H5_FCDLL int_f nh5pget_small_data_block_size_c(hid_t_f *plist, hsize_t_f *size);
 H5_FCDLL int_f nh5pset_hyper_vector_size_c(hid_t_f *plist, size_t_f *size);
 H5_FCDLL int_f nh5pget_hyper_vector_size_c(hid_t_f *plist, size_t_f *size);
 H5_FCDLL int_f nh5pcreate_class_c(hid_t_f *parent, _fcd name, int_f *name_len, hid_t_f *class);
-H5_FCDLL int_f nh5pregister_c(hid_t_f *class, _fcd name, int_f * name_len, size_t_f *size, void *value);   
-H5_FCDLL int_f nh5pregisterc_c(hid_t_f *class, _fcd name, int_f * name_len, size_t_f *size, _fcd value, int_f *value_len); 
-H5_FCDLL int_f nh5pinsert_c(hid_t_f  *plist, _fcd name, int_f *name_len, size_t_f *size, void *value);   
-H5_FCDLL int_f nh5pinsertc_c(hid_t_f  *plist, _fcd name, int_f *name_len, size_t_f *size, _fcd value, int_f *value_len); 
-H5_FCDLL int_f nh5pset_c(hid_t_f *prp_id, _fcd name, int_f *name_len, void *value);    
-H5_FCDLL int_f nh5psetc_c(hid_t_f *prp_id, _fcd name, int_f *name_len, _fcd value, int_f *value_len);  
-H5_FCDLL int_f nh5pget_c(hid_t_f *prp_id, _fcd name, int_f *name_len, void *value);   
+H5_FCDLL int_f nh5pregister_c(hid_t_f *class, _fcd name, int_f * name_len, size_t_f *size, void *value);
+H5_FCDLL int_f nh5pregisterc_c(hid_t_f *class, _fcd name, int_f * name_len, size_t_f *size, _fcd value, int_f *value_len);
+H5_FCDLL int_f nh5pinsert_c(hid_t_f  *plist, _fcd name, int_f *name_len, size_t_f *size, void *value);
+H5_FCDLL int_f nh5pinsertc_c(hid_t_f  *plist, _fcd name, int_f *name_len, size_t_f *size, _fcd value, int_f *value_len);
+H5_FCDLL int_f nh5pset_c(hid_t_f *prp_id, _fcd name, int_f *name_len, void *value);
+H5_FCDLL int_f nh5psetc_c(hid_t_f *prp_id, _fcd name, int_f *name_len, _fcd value, int_f *value_len);
+H5_FCDLL int_f nh5pget_c(hid_t_f *prp_id, _fcd name, int_f *name_len, void *value);
 H5_FCDLL int_f nh5pgetc_c(hid_t_f *prp_id, _fcd name, int_f *name_len, _fcd value, int_f *value_len);
-H5_FCDLL int_f nh5pexist_c(hid_t_f *prp_id, _fcd name, int_f *name_len);         
-H5_FCDLL int_f nh5pget_size_c(hid_t_f *prp_id, _fcd name, int_f *name_len, size_t_f *size); 
-H5_FCDLL int_f nh5pget_nprops_c(hid_t_f *prp_id, size_t_f *nprops);  
-H5_FCDLL int_f nh5pget_class_parent_c(hid_t_f *prp_id, hid_t_f *parent_id); 
-H5_FCDLL int_f nh5pisa_class_c(hid_t_f *plist, hid_t_f *pclass);      
+H5_FCDLL int_f nh5pexist_c(hid_t_f *prp_id, _fcd name, int_f *name_len);
+H5_FCDLL int_f nh5pget_size_c(hid_t_f *prp_id, _fcd name, int_f *name_len, size_t_f *size);
+H5_FCDLL int_f nh5pget_nprops_c(hid_t_f *prp_id, size_t_f *nprops);
+H5_FCDLL int_f nh5pget_class_parent_c(hid_t_f *prp_id, hid_t_f *parent_id);
+H5_FCDLL int_f nh5pisa_class_c(hid_t_f *plist, hid_t_f *pclass);
 H5_FCDLL int_f nh5pcopy_prop_c(hid_t_f *dst_id, hid_t_f *src_id, _fcd name, int_f *name_len);
-H5_FCDLL int_f nh5premove_c(hid_t_f *plid, _fcd name, int_f *name_len);      
+H5_FCDLL int_f nh5premove_c(hid_t_f *plid, _fcd name, int_f *name_len);
 H5_FCDLL int_f nh5punregister_c(hid_t_f *class, _fcd name, int_f *name_len);
-H5_FCDLL int_f nh5pclose_class_c(hid_t_f * class);   
+H5_FCDLL int_f nh5pclose_class_c(hid_t_f * class);
 H5_FCDLL int_f nh5pget_class_name_c(hid_t_f *prp_id, _fcd name, int_f *name_len);
 H5_FCDLL int_f nh5pset_shuffle_c ( hid_t_f *prp_id);
 H5_FCDLL int_f nh5pset_fletcher32_c ( hid_t_f *prp_id );
@@ -575,11 +575,11 @@ H5_FCDLL int_f nh5pget_fapl_multi_c ( hid_t_f *prp_id , int_f *mem_map, hid_t_f
 H5_FCDLL int_f nh5pset_fapl_multi_c ( hid_t_f *prp_id , int_f *mem_map, hid_t_f *memb_fapl, _fcd memb_name, int_f *len, int_f *lenmax, real_f *memb_addr, int_f *flag);
 H5_FCDLL int_f nh5pset_fapl_multi_sc ( hid_t_f *prp_id , int_f *flag);
 H5_FCDLL int_f nh5pset_szip_c ( hid_t_f *prp_id , int_f *options_mask, int_f *pixels_per_block);
-H5_FCDLL int_f nh5pall_filters_avail_c ( hid_t_f *prp_id , int_f *status); 
+H5_FCDLL int_f nh5pall_filters_avail_c ( hid_t_f *prp_id , int_f *status);
 H5_FCDLL int_f nh5pfill_value_defined_c ( hid_t_f *prp_id , int_f *flag);
 
 /*
- * Functions frome H5Rf.c 
+ * Functions frome H5Rf.c
  */
 #   define nh5rcreate_object_c     H5_FC_FUNC_(h5rcreate_object_c, H5RCREATE_OBJECT_C)
 #   define nh5rcreate_region_c     H5_FC_FUNC_(h5rcreate_region_c, H5RCREATE_REGION_C)
@@ -614,7 +614,7 @@ H5_FCDLL int_f nh5iget_ref_c(hid_t_f *obj_id, int_f *ref_count);
 H5_FCDLL int_f nh5iget_file_id_c(hid_t_f *obj_id, hid_t_f *file_id);
 
 /*
- * Functions from H5Ef.c 
+ * Functions from H5Ef.c
  */
 #  define nh5eclear_c     H5_FC_FUNC_(h5eclear_c, H5ECLEAR_C)
 #  define nh5eprint_c1    H5_FC_FUNC_(h5eprint_c1, H5EPRINT_C1)
@@ -632,7 +632,7 @@ H5_FCDLL int_f nh5eget_minor_c(int_f* error_no, _fcd name, size_t_f* namelen);
 H5_FCDLL int_f nh5eset_auto_c(int_f* printflag);
 
 /*
- * Functions from H5f.c 
+ * Functions from H5f.c
  */
 #   define nh5open_c            H5_FC_FUNC_(h5open_c, H5OPEN_C)
 #   define nh5close_c           H5_FC_FUNC_(h5close_c, H5CLOSE_C)
@@ -654,8 +654,8 @@ H5_FCDLL int_f nh5init_flags_c( int_f *h5d_flags, int_f *h5f_flags,
                               int_f *h5fd_flags, hid_t_f *h5fd_hid_flags,
                               int_f *h5g_flags, int_f *h5i_flags,
                               hid_t_f *h5p_flags, int_f *h5r_flags, int_f *h5s_flags,
-                              int_f *h5t_flags, int_f *h5z_flags); 
-H5_FCDLL int_f nh5init1_flags_c(int_f *h5lib_flags); 
+                              int_f *h5t_flags, int_f *h5z_flags);
+H5_FCDLL int_f nh5init1_flags_c(int_f *h5lib_flags);
 H5_FCDLL int_f nh5get_libversion_c(int_f *majnum, int_f *minnum, int_f *relnum);
 H5_FCDLL int_f nh5check_version_c(int_f *majnum, int_f *minnum, int_f *relnum);
 H5_FCDLL int_f nh5garbage_collect_c(void);
diff --git a/fortran/src/H5match_types.c b/fortran/src/H5match_types.c
index 2edc813..2c11a29 100644
--- a/fortran/src/H5match_types.c
+++ b/fortran/src/H5match_types.c
@@ -221,13 +221,13 @@ int main()
 #endif
 
   /* int */
-#if defined H5_FORTRAN_HAS_NATIVE_8 
+#if defined H5_FORTRAN_HAS_NATIVE_8
       writeToFiles("INT", "int_f", 8);
-#elif defined H5_FORTRAN_HAS_NATIVE_4 
+#elif defined H5_FORTRAN_HAS_NATIVE_4
       writeToFiles("INT", "int_f", 4);
-#elif defined H5_FORTRAN_HAS_NATIVE_2 
+#elif defined H5_FORTRAN_HAS_NATIVE_2
       writeToFiles("INT", "int_f", 2);
-#elif defined H5_FORTRAN_HAS_NATIVE_1 
+#elif defined H5_FORTRAN_HAS_NATIVE_1
       writeToFiles("INT", "int_f", 1);
 #else
     /* Error: couldn't find a size for int */
diff --git a/fortran/test/t.c b/fortran/test/t.c
index 3b51add..cb71fd2 100644
--- a/fortran/test/t.c
+++ b/fortran/test/t.c
@@ -17,9 +17,9 @@
 /*----------------------------------------------------------------------------
  * Name:        h5_fixname_c
  * Purpose:     Call h5_fixname to modify file name
- * Inputs:      base_name - name of the file     
+ * Inputs:      base_name - name of the file
  *              base_namelen - name length
- *              fapl - file access property list 
+ *              fapl - file access property list
  *              full_name - buffer to return full name
  *              full_namelen - name length
  * Returns:     0 on success, -1 on failure
@@ -42,7 +42,7 @@ nh5_fixname_c(_fcd base_name, size_t_f *base_namelen, hid_t_f* fapl, _fcd full_n
      /*
       * Convert FORTRAN name to C name
       */
-     c_base_name = (char *)HD5f2cstring(base_name, (size_t)*base_namelen); 
+     c_base_name = (char *)HD5f2cstring(base_name, (size_t)*base_namelen);
      if (c_base_name == NULL) goto DONE;
      c_full_name = (char *) HDmalloc((size_t)*full_namelen + 1);
      if (c_full_name == NULL) goto DONE;
@@ -51,7 +51,7 @@ nh5_fixname_c(_fcd base_name, size_t_f *base_namelen, hid_t_f* fapl, _fcd full_n
       * Call h5_fixname function.
       */
      if (NULL != h5_fixname(c_base_name, c_fapl, c_full_name, (size_t)*full_namelen + 1)) {
-         HD5packFstring(c_full_name, _fcdtocp(full_name), (size_t)*full_namelen);         
+         HD5packFstring(c_full_name, _fcdtocp(full_name), (size_t)*full_namelen);
          ret_value = 0;
          goto DONE;
      }
@@ -59,15 +59,15 @@ nh5_fixname_c(_fcd base_name, size_t_f *base_namelen, hid_t_f* fapl, _fcd full_n
 DONE:
      if (NULL != c_base_name) HDfree(c_base_name);
      if (NULL != c_full_name) HDfree(c_full_name);
-     return ret_value; 
-} 
+     return ret_value;
+}
 
 /*----------------------------------------------------------------------------
  * Name:        h5_cleanup_c
  * Purpose:     Call h5_cleanup to clean temporary files.
- * Inputs:      base_name - name of the file     
+ * Inputs:      base_name - name of the file
  *              base_namelen - name length
- *              fapl - file access property list 
+ *              fapl - file access property list
  * Returns:     0 on success, -1 on failure
  * Programmer:  Elena Pourmal
  *              Thursday, September 19, 2002
@@ -89,7 +89,7 @@ nh5_cleanup_c(_fcd base_name, size_t_f *base_namelen, hid_t_f* fapl)
      /*
       * Convert FORTRAN name to C name
       */
-     c_base_name[0] = (char *)HD5f2cstring(base_name, (size_t)*base_namelen); 
+     c_base_name[0] = (char *)HD5f2cstring(base_name, (size_t)*base_namelen);
      if (c_base_name[0] == NULL) goto DONE;
 
      /*
@@ -100,19 +100,19 @@ nh5_cleanup_c(_fcd base_name, size_t_f *base_namelen, hid_t_f* fapl)
      goto DONE;
      }
 */
-     h5_fixname(c_base_name[0], c_fapl, filename, sizeof(filename)); 
+     h5_fixname(c_base_name[0], c_fapl, filename, sizeof(filename));
      HDremove(filename);
      ret_value =0;
 
 DONE:
      if (NULL != c_base_name[0]) HDfree(c_base_name[0]);
-     return ret_value; 
-    
-} 
+     return ret_value;
+
+}
 
 /*----------------------------------------------------------------------------
  * Name:        h5_exit_c
- * Purpose:     Call 'exit()' to terminate application.  Be careful not to 
+ * Purpose:     Call 'exit()' to terminate application.  Be careful not to
  *              overflow the exit value range since UNIX supports a very
  *              small range such as 1 byte.  Therefore, exit(256) may end
  *              up as exit(0).
diff --git a/fortran/test/t.h b/fortran/test/t.h
index d66f882..79c6d4b 100644
--- a/fortran/test/t.h
+++ b/fortran/test/t.h
@@ -26,12 +26,12 @@ char *h5_fixname(const char *base_name, hid_t fapl, char *fullname, size_t size)
 #   define nh5_cleanup_c              H5_FC_FUNC_(h5_cleanup_c, H5_CLEANUP_C)
 #   define nh5_exit_c                 H5_FC_FUNC_(h5_exit_c, H5_EXIT_C)
 
-H5_FCTESTDLL int_f nh5_fixname_c 
+H5_FCTESTDLL int_f nh5_fixname_c
 (_fcd base_name, size_t_f *base_namelen, hid_t_f *fapl, _fcd full_name, size_t_f *full_namelen);
 
-H5_FCTESTDLL int_f nh5_cleanup_c 
+H5_FCTESTDLL int_f nh5_cleanup_c
 (_fcd base_name, size_t_f *base_namelen, hid_t_f *fapl);
 
-H5_FCTESTDLL void nh5_exit_c 
+H5_FCTESTDLL void nh5_exit_c
 (int_f *status);
author	Quincey Koziol <koziol@hdfgroup.org>	2005-08-13 20:53:35 (GMT)
committer	Quincey Koziol <koziol@hdfgroup.org>	2005-08-13 20:53:35 (GMT)
commit	6b45f5172ccb4311e0be9ae15da3758abb6b0e67 (patch)
tree	5a7a112fe7a8a98c6fecb45b513789d15962eb3d /fortran
parent	6562465a2c2a58cfbc2f47bf60bb538f7a783933 (diff)
download	hdf5-6b45f5172ccb4311e0be9ae15da3758abb6b0e67.zip hdf5-6b45f5172ccb4311e0be9ae15da3758abb6b0e67.tar.gz hdf5-6b45f5172ccb4311e0be9ae15da3758abb6b0e67.tar.bz2