[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

1 files changed, 129 insertions, 129 deletions

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;
 }