[svn-r16656] #1402 (B1) h5repack does not preserve creation order indexing.

ISSUE : h5repack does not handle group creation order flags. 
ACTION: call H5P(g)(s)et_link_creation_order functions when handling groups, add new groups with these flags to the test generation program, and verify results in the test program. 
TEST: in the test program, function that compares property lists, added code to verify groups

tested: windows, linux, solaris

4 files changed, 2540 insertions, 2124 deletions

diff --git a/tools/h5repack/h5repack.h b/tools/h5repack/h5repack.h
index b63102b..cb3d75a 100644
--- a/tools/h5repack/h5repack.h
+++ b/tools/h5repack/h5repack.h
@@ -131,7 +131,7 @@ int h5repack_addlayout (const char* str, pack_opt_t *options);
 int h5repack_init      (pack_opt_t *options, int verbose);
 int h5repack_end       (pack_opt_t *options);
 int h5repack_verify    (const char *fname,pack_opt_t *options);
-int h5repack_cmpdcpl   (const char *fname1,
+int h5repack_cmp_pl   (const char *fname1,
                         const char *fname2);
 
 
diff --git a/tools/h5repack/h5repack_copy.c b/tools/h5repack/h5repack_copy.c
index 4e2e036..8ab5a35 100644
--- a/tools/h5repack/h5repack_copy.c
+++ b/tools/h5repack/h5repack_copy.c
@@ -1,17 +1,17 @@
 /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
- * Copyright by The HDF Group.                                               *
- * Copyright by the Board of Trustees of the University of Illinois.         *
- * All rights reserved.                                                      *
- *                                                                           *
- * This file is part of HDF5.  The full HDF5 copyright notice, including     *
- * terms governing use, modification, and redistribution, is contained in    *
- * the files COPYING and Copyright.html.  COPYING can be found at the root   *
- * of the source code distribution tree; Copyright.html can be found at the  *
- * root level of an installed copy of the electronic HDF5 document set and   *
- * is linked from the top-level documents page.  It can also be found at     *
- * http://hdfgroup.org/HDF5/doc/Copyright.html.  If you do not have          *
- * access to either file, you may request a copy from help@hdfgroup.org.     *
- * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
+* Copyright by The HDF Group.                                               *
+* Copyright by the Board of Trustees of the University of Illinois.         *
+* All rights reserved.                                                      *
+*                                                                           *
+* This file is part of HDF5.  The full HDF5 copyright notice, including     *
+* terms governing use, modification, and redistribution, is contained in    *
+* the files COPYING and Copyright.html.  COPYING can be found at the root   *
+* of the source code distribution tree; Copyright.html can be found at the  *
+* root level of an installed copy of the electronic HDF5 document set and   *
+* is linked from the top-level documents page.  It can also be found at     *
+* http://hdfgroup.org/HDF5/doc/Copyright.html.  If you do not have          *
+* access to either file, you may request a copy from help@hdfgroup.org.     *
+* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
 
 #include <stdlib.h>
 #include <string.h>
@@ -25,15 +25,15 @@ extern char  *progname;
 
 
 /*-------------------------------------------------------------------------
- * macros
- *-------------------------------------------------------------------------
- */
+* macros
+*-------------------------------------------------------------------------
+*/
 #define USERBLOCK_XFER_SIZE     512     /* size of buffer/# of bytes to xfer at a time when copying userblock */
 
 /*-------------------------------------------------------------------------
- * local functions
- *-------------------------------------------------------------------------
- */
+* local functions
+*-------------------------------------------------------------------------
+*/
 static void  print_dataset_info(hid_t dcpl_id,char *objname,double per, int pr);
 static int   do_copy_objects(hid_t fidin,hid_t fidout,trav_table_t *travt,pack_opt_t *options);
 static int   copy_attr(hid_t loc_in,hid_t loc_out,pack_opt_t *options);
@@ -43,28 +43,28 @@ static void  print_user_block(const char *filename, hid_t fid);
 #endif
 
 /*-------------------------------------------------------------------------
- * Function: copy_objects
- *
- * Purpose: duplicate all HDF5 objects in the file
- *
- * Return: 0, ok, -1 no
- *
- * Programmer: Pedro Vicente, pvn@ncsa.uiuc.edu
- *
- * Date: October, 23, 2003
- *
- * Modification:
- *   Peter Cao, June 13, 2007
- *   Add "-L, --latest" and other options to pack a file with the latest file format
- *
- *   Peter Cao, September 25, 2007
- *   Copy user block when repacking a file
- *
- *   Pedro Vicente, August 20, 2008
- *   Add a user block to file if requested
- *
- *-------------------------------------------------------------------------
- */
+* Function: copy_objects
+*
+* Purpose: duplicate all HDF5 objects in the file
+*
+* Return: 0, ok, -1 no
+*
+* Programmer: Pedro Vicente, pvn@ncsa.uiuc.edu
+*
+* Date: October, 23, 2003
+*
+* Modification:
+*   Peter Cao, June 13, 2007
+*   Add "-L, --latest" and other options to pack a file with the latest file format
+*
+*   Peter Cao, September 25, 2007
+*   Copy user block when repacking a file
+*
+*   Pedro Vicente, August 20, 2008
+*   Add a user block to file if requested
+*
+*-------------------------------------------------------------------------
+*/
 
 int copy_objects(const char* fnamein,
                  const char* fnameout,
@@ -90,19 +90,19 @@ int copy_objects(const char* fnamein,
     /* get user block size */
     {
         hid_t fcpl_in; /* file creation property list ID for input file */
-        
+
         if((fcpl_in = H5Fget_create_plist(fidin)) < 0) 
         {
             error_msg(progname, "failed to retrieve file creation property list\n");
             goto out;
         } 
-        
+
         if(H5Pget_userblock(fcpl_in, &ub_size) < 0) 
         {
             error_msg(progname, "failed to retrieve userblock size\n");
             goto out;
         } 
-        
+
         if(H5Pclose(fcpl_in) < 0) 
         {
             error_msg(progname, "failed to close property list\n");
@@ -147,25 +147,27 @@ int copy_objects(const char* fnamein,
                 {
                     switch(i) 
                     {
-                        case 0:
-                            mesg_type_flags[nindex] = H5O_SHMESG_SDSPACE_FLAG;
-                            break;
-
-                        case 1:
-                            mesg_type_flags[nindex] = H5O_SHMESG_DTYPE_FLAG;
-                            break;
-
-                        case 2:
-                            mesg_type_flags[nindex] = H5O_SHMESG_FILL_FLAG;
-                            break;
-
-                        case 3:
-                            mesg_type_flags[nindex] = H5O_SHMESG_PLINE_FLAG;
-                            break;
-
-                        case 4:
-                            mesg_type_flags[nindex] = H5O_SHMESG_ATTR_FLAG;
-                            break;
+                    case 0:
+                        mesg_type_flags[nindex] = H5O_SHMESG_SDSPACE_FLAG;
+                        break;
+
+                    case 1:
+                        mesg_type_flags[nindex] = H5O_SHMESG_DTYPE_FLAG;
+                        break;
+
+                    case 2:
+                        mesg_type_flags[nindex] = H5O_SHMESG_FILL_FLAG;
+                        break;
+
+                    case 3:
+                        mesg_type_flags[nindex] = H5O_SHMESG_PLINE_FLAG;
+                        break;
+
+                    case 4:
+                        mesg_type_flags[nindex] = H5O_SHMESG_ATTR_FLAG;
+                        break;
+                    default:
+                        break;
                     } /* end switch */
                     min_mesg_sizes[nindex] = (unsigned)options->msg_size[i];
 
@@ -205,8 +207,8 @@ int copy_objects(const char* fnamein,
             } /* end if */
         } /* end if */
     } /* end if */
-  
-   
+
+
 
 
 #if defined (H5REPACK_DEBUG_USER_BLOCK)  
@@ -230,30 +232,30 @@ int copy_objects(const char* fnamein,
                 error_msg(progname, "failed to set userblock size\n");
                 goto out;
             } 
-            
+
         }
-        
+
         else
         {
-            
+
             /* create a file creation property list */
             if((fcpl = H5Pcreate(H5P_FILE_CREATE)) < 0) 
             {
                 error_msg(progname, "fail to create a file creation property list\n");
                 goto out;
             }  
-            
+
             /* set user block size */
             if(H5Pset_userblock(fcpl, options->ublock_size) < 0) 
             {
                 error_msg(progname, "failed to set userblock size\n");
                 goto out;
             } 
-            
+
         }
-        
-       
-        
+
+
+
     }
 
 
@@ -262,39 +264,39 @@ int copy_objects(const char* fnamein,
     *-------------------------------------------------------------------------
     */
 
-   
+
     if (  options->alignment > 0 )
     {
         /* either use the FAPL already created or create a new one */
         if (fapl != H5P_DEFAULT)
         {
-            
+
             if (H5Pset_alignment(fapl, options->threshold, options->alignment) < 0)
             {
                 error_msg(progname, "failed to set alignment\n");
                 goto out;
             }
-            
+
         }
-        
+
         else
         {
-            
+
             /* create a file access property list */
             if ((fapl = H5Pcreate(H5P_FILE_ACCESS)) < 0) 
             {
                 error_msg(progname, "Could not create file access property list\n");
                 goto out;
             } 
-            
+
             if (H5Pset_alignment(fapl, options->threshold, options->alignment) < 0)
             {
                 error_msg(progname, "failed to set alignment\n");
                 goto out;
             }
-            
+
         }      
-        
+
     }
 
 
@@ -303,18 +305,18 @@ int copy_objects(const char* fnamein,
     *-------------------------------------------------------------------------
     */
 
-    
+
     if(options->verbose)
         printf("Making file <%s>...\n",fnameout);
-    
-    
+
+
     if((fidout = H5Fcreate(fnameout,H5F_ACC_TRUNC, fcpl, fapl)) < 0) 
     {
         error_msg(progname, "<%s>: Could not create file\n", fnameout );
         goto out;
     } 
 
-    
+
     /*-------------------------------------------------------------------------
     * write a new user block if requested
     *-------------------------------------------------------------------------
@@ -325,11 +327,11 @@ int copy_objects(const char* fnamein,
         {
             error_msg(progname, "Could not copy user block. Exiting...\n");
             goto out;
-            
+
         }
     }
 
-     /*-------------------------------------------------------------------------
+    /*-------------------------------------------------------------------------
     * get list of objects
     *-------------------------------------------------------------------------
     */
@@ -375,7 +377,7 @@ int copy_objects(const char* fnamein,
 
     H5Fclose(fidin);
     H5Fclose(fidout);
-    
+
     /* free table */
     trav_table_free(travt);
     travt = NULL;
@@ -391,7 +393,7 @@ int copy_objects(const char* fnamein,
         {
             error_msg(progname, "Could not copy user block. Exiting...\n");
             goto out;
-            
+
         }
     }
 
@@ -417,74 +419,74 @@ out:
 }
 
 /*-------------------------------------------------------------------------
- * Function: do_copy_objects
- *
- * Purpose: duplicate all HDF5 objects in the file
- *
- * Return: 0, ok, -1 no
- *
- * Programmer: Pedro Vicente, pvn@ncsa.uiuc.edu
- *
- * Date: October, 23, 2003
- *
- * Modifications: 
- *
- *  July 2004:     Introduced the extra EC or NN option for SZIP
- *
- *  December 2004: Added a check for H5Dcreate; if the dataset cannot be created
- *                  with the requested filter, use the input one
- *
- *  October 2006:  Read/write using the file type by default.
- *
- *  October 2006:  Read by hyperslabs for big datasets.
- *
- *  A threshold of H5TOOLS_MALLOCSIZE (128 MB) is the limit upon which I/O hyperslab is done
- *  i.e., if the memory needed to read a dataset is greater than this limit, 
- *  then hyperslab I/O is done instead of one operation I/O 
- *  For each dataset, the memory needed is calculated according to
- *
- *  memory needed = number of elements * size of each element
- *
- *  if the memory needed is lower than H5TOOLS_MALLOCSIZE, then the following operations 
- *  are done
- *
- *  H5Dread( input_dataset1 )
- *  H5Dread( input_dataset2 )
- *
- *  with all elements in the datasets selected. If the memory needed is greater than 
- *  H5TOOLS_MALLOCSIZE, then the following operations are done instead:
- *
- *  a strip mine is defined for each dimension k (a strip mine is defined as a 
- *  hyperslab whose size is memory manageable) according to the formula
- *
- *  (1) strip_mine_size[k ] = MIN(dimension[k ], H5TOOLS_BUFSIZE / size of memory type)
- *
- *  where H5TOOLS_BUFSIZE is a constant currently defined as 1MB. This formula assures 
- *  that for small datasets (small relative to the H5TOOLS_BUFSIZE constant), the strip 
- *  mine size k is simply defined as its dimension k, but for larger datasets the 
- *  hyperslab size is still memory manageable.
- *  a cycle is done until the number of elements in the dataset is reached. In each 
- *  iteration, two parameters are defined for the function H5Sselect_hyperslab, 
- *  the start and size of each hyperslab, according to
- *
- *  (2) hyperslab_size [k] = MIN(dimension[k] - hyperslab_offset[k], strip_mine_size [k])
- *
- *  where hyperslab_offset [k] is initially set to zero, and later incremented in 
- *  hyperslab_size[k] offsets. The reason for the operation 
- *
- *  dimension[k] - hyperslab_offset[k]
- *
- *  in (2) is that, when using the strip mine size, it assures that the "remaining" part 
- *  of the dataset that does not fill an entire strip mine is processed.
- *
- *  November 2006:  Use H5Ocopy in the copy of objects. The logic for using 
- *   H5Ocopy or not is if a change of filters or layout is requested by the user 
- *   then use read/write else use H5Ocopy. 
- *
- * May, 1, 2008: Add a printing of the compression ratio of old size / new size
- *
- *-------------------------------------------------------------------------
- */
+* Function: do_copy_objects
+*
+* Purpose: duplicate all HDF5 objects in the file
+*
+* Return: 0, ok, -1 no
+*
+* Programmer: Pedro Vicente, pvn@ncsa.uiuc.edu
+*
+* Date: October, 23, 2003
+*
+* Modifications: 
+*
+*  July 2004:     Introduced the extra EC or NN option for SZIP
+*
+*  December 2004: Added a check for H5Dcreate; if the dataset cannot be created
+*                  with the requested filter, use the input one
+*
+*  October 2006:  Read/write using the file type by default.
+*
+*  October 2006:  Read by hyperslabs for big datasets.
+*
+*  A threshold of H5TOOLS_MALLOCSIZE (128 MB) is the limit upon which I/O hyperslab is done
+*  i.e., if the memory needed to read a dataset is greater than this limit, 
+*  then hyperslab I/O is done instead of one operation I/O 
+*  For each dataset, the memory needed is calculated according to
+*
+*  memory needed = number of elements * size of each element
+*
+*  if the memory needed is lower than H5TOOLS_MALLOCSIZE, then the following operations 
+*  are done
+*
+*  H5Dread( input_dataset1 )
+*  H5Dread( input_dataset2 )
+*
+*  with all elements in the datasets selected. If the memory needed is greater than 
+*  H5TOOLS_MALLOCSIZE, then the following operations are done instead:
+*
+*  a strip mine is defined for each dimension k (a strip mine is defined as a 
+*  hyperslab whose size is memory manageable) according to the formula
+*
+*  (1) strip_mine_size[k ] = MIN(dimension[k ], H5TOOLS_BUFSIZE / size of memory type)
+*
+*  where H5TOOLS_BUFSIZE is a constant currently defined as 1MB. This formula assures 
+*  that for small datasets (small relative to the H5TOOLS_BUFSIZE constant), the strip 
+*  mine size k is simply defined as its dimension k, but for larger datasets the 
+*  hyperslab size is still memory manageable.
+*  a cycle is done until the number of elements in the dataset is reached. In each 
+*  iteration, two parameters are defined for the function H5Sselect_hyperslab, 
+*  the start and size of each hyperslab, according to
+*
+*  (2) hyperslab_size [k] = MIN(dimension[k] - hyperslab_offset[k], strip_mine_size [k])
+*
+*  where hyperslab_offset [k] is initially set to zero, and later incremented in 
+*  hyperslab_size[k] offsets. The reason for the operation 
+*
+*  dimension[k] - hyperslab_offset[k]
+*
+*  in (2) is that, when using the strip mine size, it assures that the "remaining" part 
+*  of the dataset that does not fill an entire strip mine is processed.
+*
+*  November 2006:  Use H5Ocopy in the copy of objects. The logic for using 
+*   H5Ocopy or not is if a change of filters or layout is requested by the user 
+*   then use read/write else use H5Ocopy. 
+*
+* May, 1, 2008: Add a printing of the compression ratio of old size / new size
+*
+*-------------------------------------------------------------------------
+*/
 
 int do_copy_objects(hid_t fidin,
                     hid_t fidout,
@@ -495,7 +497,8 @@ int do_copy_objects(hid_t fidin,
     hid_t    grp_out=-1;        /* group ID */
     hid_t    dset_in=-1;        /* read dataset ID */
     hid_t    dset_out=-1;       /* write dataset ID */
-    hid_t    gcpl_id=-1;        /* group creation property list */
+    hid_t    gcpl_in=-1;        /* group creation property list */
+    hid_t    gcpl_out=-1;       /* group creation property list */
     hid_t    type_in=-1;        /* named type ID */
     hid_t    type_out=-1;       /* named type ID */
     hid_t    dcpl_id=-1;        /* dataset creation property list ID */
@@ -515,6 +518,7 @@ int do_copy_objects(hid_t fidin,
     void     *sm_buf=NULL;      /* buffer for raw data */
     int      has_filter;        /* current object has a filter */
     int      req_filter;        /* there was a request for a filter */
+    unsigned crt_order_flags;   /* group creation order flag */
     unsigned i;
     unsigned u;
     int      is_ref=0;
@@ -537,510 +541,532 @@ int do_copy_objects(hid_t fidin,
         buf = NULL;
         switch ( travt->objs[i].type ) 
         {
+
+        case H5TRAV_TYPE_UNKNOWN:
+            assert(0);
+            break;
             /*-------------------------------------------------------------------------
-             * H5TRAV_TYPE_GROUP
-             *-------------------------------------------------------------------------
-             */
-            case H5TRAV_TYPE_GROUP:
-                if (options->verbose)
-                    printf(FORMAT_OBJ,"group",travt->objs[i].name );
+            * H5TRAV_TYPE_GROUP
+            *-------------------------------------------------------------------------
+            */
+        case H5TRAV_TYPE_GROUP:
 
-                /*-------------------------------------------------------------------------
-                 * the root is a special case, we get an ID for the root group
-                 * and copy its attributes using that ID
-                 *-------------------------------------------------------------------------
-                 */
-                if(HDstrcmp(travt->objs[i].name, "/") == 0) 
-                {
-                    if ((grp_out = H5Gopen2(fidout, "/", H5P_DEFAULT)) < 0)
-                        goto error;
-                }
-                else if (options->grp_compact>0 || options->grp_indexed>0) 
-                {
-                    /* Set up group creation property list */
-                    if((gcpl_id = H5Pcreate(H5P_GROUP_CREATE)) < 0)
-                        goto error;
+            if (options->verbose)
+            {
+                printf(FORMAT_OBJ,"group",travt->objs[i].name );
+            }
 
-                    if(H5Pset_link_phase_change(gcpl_id, (unsigned)options->grp_compact, (unsigned)options->grp_indexed) < 0)
-                        goto error;
+            /* open input group */
+            if ((grp_in = H5Gopen2(fidin, travt->objs[i].name, H5P_DEFAULT)) < 0)
+                goto error;
 
-                    if((grp_out = H5Gcreate2(fidout, travt->objs[i].name, H5P_DEFAULT, gcpl_id, H5P_DEFAULT)) < 0)
-                        goto error; 
-                }
-                else 
-                {
-                    if((grp_out = H5Gcreate2(fidout, travt->objs[i].name, H5P_DEFAULT, H5P_DEFAULT, H5P_DEFAULT)) < 0)
-                        goto error;
-                }
+            /* get input group creation property list */
+            if ((gcpl_in = H5Gget_create_plist(grp_in)) < 0)
+                goto error;
 
-                if((grp_in = H5Gopen2(fidin, travt->objs[i].name, H5P_DEFAULT)) < 0)
-                    goto error;
+            /* query and set the group creation properties */
+            if (H5Pget_link_creation_order(gcpl_in, &crt_order_flags) < 0)
+                goto error;
 
-                /*-------------------------------------------------------------------------
-                 * copy attrs
-                 *-------------------------------------------------------------------------
-                 */
-                if(copy_attr(grp_in,grp_out,options) < 0)
+            /* set up group creation property list */
+            if ((gcpl_out = H5Pcreate(H5P_GROUP_CREATE)) < 0)
+                goto error;
+
+            if (H5Pset_link_creation_order(gcpl_out, crt_order_flags) < 0)
+                goto error;
+
+
+            /*-------------------------------------------------------------------------
+            * the root is a special case, we get an ID for the root group
+            * and copy its attributes using that ID
+            *-------------------------------------------------------------------------
+            */
+            if(HDstrcmp(travt->objs[i].name, "/") == 0) 
+            {
+                if ((grp_out = H5Gopen2(fidout, "/", H5P_DEFAULT)) < 0)
                     goto error;
+            }
 
-                if(gcpl_id > 0) {
-                    if(H5Pclose(gcpl_id) < 0)
+            else
+            {
+
+                if (options->grp_compact>0 || options->grp_indexed>0) 
+                {
+                    if(H5Pset_link_phase_change(gcpl_out, (unsigned)options->grp_compact, (unsigned)options->grp_indexed) < 0)
                         goto error;
                 }
-                if(H5Gclose(grp_out) < 0)
-                    goto error;
-                if(H5Gclose(grp_in) < 0)
+
+                if((grp_out = H5Gcreate2(fidout, travt->objs[i].name, H5P_DEFAULT, gcpl_out, H5P_DEFAULT)) < 0)
                     goto error;
 
-                break;
+            }
+
+            /*-------------------------------------------------------------------------
+            * copy attrs
+            *-------------------------------------------------------------------------
+            */
+            if(copy_attr(grp_in,grp_out,options) < 0)
+                goto error;
+
+
+            if(H5Pclose(gcpl_out) < 0)
+                goto error;
+            if(H5Pclose(gcpl_in) < 0)
+                goto error;
+            if(H5Gclose(grp_out) < 0)
+                goto error;
+            if(H5Gclose(grp_in) < 0)
+                goto error;
+
+            break;
 
             /*-------------------------------------------------------------------------
-             * H5TRAV_TYPE_DATASET
-             *-------------------------------------------------------------------------
-             */
-            case H5TRAV_TYPE_DATASET:
+            * H5TRAV_TYPE_DATASET
+            *-------------------------------------------------------------------------
+            */
+        case H5TRAV_TYPE_DATASET:
+
+            has_filter = 0;
+            req_filter = 0;
 
-                has_filter = 0;
-                req_filter = 0;
+            /* check if global filters were requested */
+            if ( options->n_filter_g )
+                req_filter = 1;
 
-                /* check if global filters were requested */
-                if ( options->n_filter_g )
-                    req_filter = 1;
+            /* check if filters were requested for individual objects */
+            for( u = 0; u < options->op_tbl->nelems; u++)
+            {
+                int k; 
 
-                /* check if filters were requested for individual objects */
-                for( u = 0; u < options->op_tbl->nelems; u++)
+                for( k = 0; k < options->op_tbl->objs[u].nfilters; k++)
                 {
-                    int k; 
-                    
-                    for( k = 0; k < options->op_tbl->objs[u].nfilters; k++)
+                    if ( options->op_tbl->objs[u].filter->filtn > 0 )
                     {
-                        if ( options->op_tbl->objs[u].filter->filtn > 0 )
-                        {
-                            
-                            req_filter = 1;
-                            
-                        }
-                        
+
+                        req_filter = 1;
+
                     }
+
                 }
+            }
+
+            /* early detection of references */
+            if((dset_in = H5Dopen2(fidin, travt->objs[i].name, H5P_DEFAULT)) < 0)
+                goto error;
+            if((ftype_id = H5Dget_type(dset_in)) < 0)
+                goto error;
+            if(H5T_REFERENCE == H5Tget_class(ftype_id))
+                is_ref = 1;
+            if(H5Tclose(ftype_id) < 0)
+                goto error;
+            if(H5Dclose(dset_in) < 0)
+                goto error;
+
+
+            /*-------------------------------------------------------------------------
+            * check if we should use H5Ocopy or not
+            * if there is a request for filters/layout, we read/write the object
+            * otherwise we do a copy using H5Ocopy
+            *-------------------------------------------------------------------------
+            */
+            if ( options->op_tbl->nelems  || 
+                options->all_filter == 1 || 
+                options->all_layout == 1 || 
+                is_ref) 
+            {
+
+                int      j;
 
-                /* early detection of references */
                 if((dset_in = H5Dopen2(fidin, travt->objs[i].name, H5P_DEFAULT)) < 0)
                     goto error;
+                if((f_space_id = H5Dget_space(dset_in)) < 0)
+                    goto error;
                 if((ftype_id = H5Dget_type(dset_in)) < 0)
                     goto error;
-                if(H5T_REFERENCE == H5Tget_class(ftype_id))
-                    is_ref = 1;
-                if(H5Tclose(ftype_id) < 0)
+                if((dcpl_id = H5Dget_create_plist(dset_in)) < 0)
                     goto error;
-                if(H5Dclose(dset_in) < 0)
+                if((dcpl_out = H5Pcopy(dcpl_id)) < 0)
+                    goto error;
+                if((rank = H5Sget_simple_extent_ndims(f_space_id)) < 0)
+                    goto error;
+                HDmemset(dims, 0, sizeof dims);
+                if(H5Sget_simple_extent_dims(f_space_id, dims, NULL) < 0)
+                    goto error;
+                nelmts = 1;
+                for ( j = 0; j < rank; j++)
+                {
+                    nelmts *= dims[j];
+                }
+
+                if(options->use_native == 1)
+                    wtype_id = h5tools_get_native_type(ftype_id);
+                else
+                    wtype_id = H5Tcopy(ftype_id); 
+
+                if((msize = H5Tget_size(wtype_id)) == 0)
                     goto error;
-                  
 
                 /*-------------------------------------------------------------------------
-                 * check if we should use H5Ocopy or not
-                 * if there is a request for filters/layout, we read/write the object
-                 * otherwise we do a copy using H5Ocopy
-                 *-------------------------------------------------------------------------
-                 */
-                if ( options->op_tbl->nelems  || 
-                     options->all_filter == 1 || 
-                     options->all_layout == 1 || 
-                     is_ref) 
+                * check if the dataset creation property list has filters that
+                * are not registered in the current configuration
+                * 1) the external filters GZIP and SZIP might not be available
+                * 2) the internal filters might be turned off
+                *-------------------------------------------------------------------------
+                */
+                if (h5tools_canreadf((travt->objs[i].name),dcpl_id)==1)
                 {
-                    
-                    int      j;
-                   
-                    if((dset_in = H5Dopen2(fidin, travt->objs[i].name, H5P_DEFAULT)) < 0)
-                        goto error;
-                    if((f_space_id = H5Dget_space(dset_in)) < 0)
-                        goto error;
-                    if((ftype_id = H5Dget_type(dset_in)) < 0)
-                        goto error;
-                    if((dcpl_id = H5Dget_create_plist(dset_in)) < 0)
-                        goto error;
-                    if((dcpl_out = H5Pcopy(dcpl_id)) < 0)
-                        goto error;
-                    if((rank = H5Sget_simple_extent_ndims(f_space_id)) < 0)
-                        goto error;
-                    HDmemset(dims, 0, sizeof dims);
-                    if(H5Sget_simple_extent_dims(f_space_id, dims, NULL) < 0)
-                        goto error;
-                    nelmts = 1;
-                    for ( j = 0; j < rank; j++)
-                    {
-                        nelmts *= dims[j];
-                    }
+                    apply_s=1;
+                    apply_f=1;
 
-                    if(options->use_native == 1)
-                        wtype_id = h5tools_get_native_type(ftype_id);
-                    else
-                        wtype_id = H5Tcopy(ftype_id); 
-
-                    if((msize = H5Tget_size(wtype_id)) == 0)
-                        goto error;
-                      
                     /*-------------------------------------------------------------------------
-                     * check if the dataset creation property list has filters that
-                     * are not registered in the current configuration
-                     * 1) the external filters GZIP and SZIP might not be available
-                     * 2) the internal filters might be turned off
-                     *-------------------------------------------------------------------------
-                     */
-                    if (h5tools_canreadf((travt->objs[i].name),dcpl_id)==1)
+                    * references are a special case
+                    * we cannot just copy the buffers, but instead we recreate the reference
+                    * in a second traversal of the output file
+                    *-------------------------------------------------------------------------
+                    */
+                    if (H5T_REFERENCE!=H5Tget_class(wtype_id))
                     {
-                        apply_s=1;
-                        apply_f=1;
+                        /* get the storage size of the input dataset */
+                        dsize_in=H5Dget_storage_size(dset_in);
+
+                        /* check for datasets too small */
+                        if (nelmts*msize < options->min_comp )
+                            apply_s=0;
+
+                        /* apply the filter */
+                        if (apply_s) 
+                        {
+                            if (apply_filters(travt->objs[i].name,
+                                rank,
+                                dims,
+                                msize,
+                                dcpl_out,
+                                options,
+                                &has_filter) < 0)
+                                goto error;
+                        }
 
                         /*-------------------------------------------------------------------------
-                        * references are a special case
-                        * we cannot just copy the buffers, but instead we recreate the reference
-                        * in a second traversal of the output file
+                        * create the output dataset;
+                        * disable error checking in case the dataset cannot be created with the
+                        * modified dcpl; in that case use the original instead
                         *-------------------------------------------------------------------------
                         */
-                        if (H5T_REFERENCE!=H5Tget_class(wtype_id))
+                        H5E_BEGIN_TRY {
+                            dset_out = H5Dcreate2(fidout, travt->objs[i].name, wtype_id, f_space_id, H5P_DEFAULT, dcpl_out, H5P_DEFAULT);
+                        } H5E_END_TRY;
+
+                        if(dset_out == FAIL) 
                         {
-                            /* get the storage size of the input dataset */
-                            dsize_in=H5Dget_storage_size(dset_in);
+                            if(options->verbose)
+                                printf(" warning: could not create dataset <%s>. Applying original settings\n",
+                                travt->objs[i].name);
 
-                            /* check for datasets too small */
-                            if (nelmts*msize < options->min_comp )
-                                apply_s=0;
+                            if((dset_out = H5Dcreate2(fidout, travt->objs[i].name, wtype_id, f_space_id, H5P_DEFAULT, dcpl_id, H5P_DEFAULT)) < 0)
+                                goto error;
+                            apply_f = 0;
+                        }
 
-                            /* apply the filter */
-                            if (apply_s) 
-                            {
-                                if (apply_filters(travt->objs[i].name,
-                                    rank,
-                                    dims,
-                                    msize,
-                                    dcpl_out,
-                                    options,
-                                    &has_filter) < 0)
-                                    goto error;
-                            }
+                        /*-------------------------------------------------------------------------
+                        * read/write
+                        *-------------------------------------------------------------------------
+                        */
+                        if (nelmts)
+                        {
+                            size_t need = (size_t)(nelmts*msize);  /* bytes needed */
+                            if ( need < H5TOOLS_MALLOCSIZE )
+                                buf = HDmalloc(need);
 
-                            /*-------------------------------------------------------------------------
-                             * create the output dataset;
-                             * disable error checking in case the dataset cannot be created with the
-                             * modified dcpl; in that case use the original instead
-                             *-------------------------------------------------------------------------
-                             */
-                            H5E_BEGIN_TRY {
-                                dset_out = H5Dcreate2(fidout, travt->objs[i].name, wtype_id, f_space_id, H5P_DEFAULT, dcpl_out, H5P_DEFAULT);
-                            } H5E_END_TRY;
-
-                            if(dset_out == FAIL) 
+                            if (buf != NULL )
                             {
-                                if(options->verbose)
-                                     printf(" warning: could not create dataset <%s>. Applying original settings\n",
-                                            travt->objs[i].name);
-
-                                if((dset_out = H5Dcreate2(fidout, travt->objs[i].name, wtype_id, f_space_id, H5P_DEFAULT, dcpl_id, H5P_DEFAULT)) < 0)
+                                if (H5Dread(dset_in,wtype_id,H5S_ALL,H5S_ALL,H5P_DEFAULT,buf) < 0)
                                     goto error;
-                                apply_f = 0;
-                            }
+                                if (H5Dwrite(dset_out,wtype_id,H5S_ALL,H5S_ALL,H5P_DEFAULT,buf) < 0)
+                                    goto error;
+                            }      
 
-                            /*-------------------------------------------------------------------------
-                             * read/write
-                             *-------------------------------------------------------------------------
-                             */
-                            if (nelmts)
+                            else /* possibly not enough memory, read/write by hyperslabs */
                             {
-                                size_t need = (size_t)(nelmts*msize);  /* bytes needed */
-                                if ( need < H5TOOLS_MALLOCSIZE )
-                                    buf = HDmalloc(need);
+                                size_t        p_type_nbytes = msize; /*size of memory type */
+                                hsize_t       p_nelmts = nelmts;     /*total selected elmts */
+                                hsize_t       elmtno;                /*counter  */
+                                int           carry;                 /*counter carry value */
+                                unsigned int  vl_data = 0;           /*contains VL datatypes */
+
+                                /* stripmine info */
+                                hsize_t       sm_size[H5S_MAX_RANK]; /*stripmine size */
+                                hsize_t       sm_nbytes;             /*bytes per stripmine */
+                                hsize_t       sm_nelmts;             /*elements per stripmine*/
+                                hid_t         sm_space;              /*stripmine data space */
+
+                                /* hyperslab info */
+                                hsize_t       hs_offset[H5S_MAX_RANK];/*starting offset */
+                                hsize_t       hs_size[H5S_MAX_RANK];  /*size this pass */
+                                hsize_t       hs_nelmts;              /*elements in request */
+                                hsize_t       zero[8];                /*vector of zeros */
+                                int           k;          
+
+                                /* check if we have VL data in the dataset's datatype */
+                                if (H5Tdetect_class(wtype_id, H5T_VLEN) == TRUE)
+                                    vl_data = TRUE;
+
+                                /*
+                                * determine the strip mine size and allocate a buffer. The strip mine is
+                                * a hyperslab whose size is manageable.
+                                */
+                                sm_nbytes = p_type_nbytes;
 
-                                if (buf != NULL )
+                                for (k = rank; k > 0; --k) 
                                 {
-                                    if (H5Dread(dset_in,wtype_id,H5S_ALL,H5S_ALL,H5P_DEFAULT,buf) < 0)
-                                        goto error;
-                                    if (H5Dwrite(dset_out,wtype_id,H5S_ALL,H5S_ALL,H5P_DEFAULT,buf) < 0)
-                                        goto error;
-                                }      
+                                    hsize_t size = H5TOOLS_BUFSIZE / sm_nbytes;
+                                    if ( size == 0) /* datum size > H5TOOLS_BUFSIZE */
+                                        size = 1;
+                                    sm_size[k - 1] = MIN(dims[k - 1], size);
+                                    sm_nbytes *= sm_size[k - 1];
+                                    assert(sm_nbytes > 0);
+                                }
+                                sm_buf = HDmalloc((size_t)sm_nbytes);
+
+                                sm_nelmts = sm_nbytes / p_type_nbytes;
+                                sm_space = H5Screate_simple(1, &sm_nelmts, NULL);
 
-                                else /* possibly not enough memory, read/write by hyperslabs */
+                                /* the stripmine loop */
+                                memset(hs_offset, 0, sizeof hs_offset);
+                                memset(zero, 0, sizeof zero);
+
+                                for (elmtno = 0; elmtno < p_nelmts; elmtno += hs_nelmts) 
                                 {
-                                    size_t        p_type_nbytes = msize; /*size of memory type */
-                                    hsize_t       p_nelmts = nelmts;     /*total selected elmts */
-                                    hsize_t       elmtno;                /*counter  */
-                                    int           carry;                 /*counter carry value */
-                                    unsigned int  vl_data = 0;           /*contains VL datatypes */
-
-                                    /* stripmine info */
-                                    hsize_t       sm_size[H5S_MAX_RANK]; /*stripmine size */
-                                    hsize_t       sm_nbytes;             /*bytes per stripmine */
-                                    hsize_t       sm_nelmts;             /*elements per stripmine*/
-                                    hid_t         sm_space;              /*stripmine data space */
-
-                                    /* hyperslab info */
-                                    hsize_t       hs_offset[H5S_MAX_RANK];/*starting offset */
-                                    hsize_t       hs_size[H5S_MAX_RANK];  /*size this pass */
-                                    hsize_t       hs_nelmts;              /*elements in request */
-                                    hsize_t       zero[8];                /*vector of zeros */
-                                    int           k;          
-
-                                    /* check if we have VL data in the dataset's datatype */
-                                    if (H5Tdetect_class(wtype_id, H5T_VLEN) == TRUE)
-                                        vl_data = TRUE;
-
-                                    /*
-                                     * determine the strip mine size and allocate a buffer. The strip mine is
-                                     * a hyperslab whose size is manageable.
-                                     */
-                                    sm_nbytes = p_type_nbytes;
-
-                                    for (k = rank; k > 0; --k) 
-                                    {
-                                        hsize_t size = H5TOOLS_BUFSIZE / sm_nbytes;
-                                        if ( size == 0) /* datum size > H5TOOLS_BUFSIZE */
-                                            size = 1;
-                                        sm_size[k - 1] = MIN(dims[k - 1], size);
-                                        sm_nbytes *= sm_size[k - 1];
-                                        assert(sm_nbytes > 0);
-                                    }
-                                    sm_buf = HDmalloc((size_t)sm_nbytes);
-
-                                    sm_nelmts = sm_nbytes / p_type_nbytes;
-                                    sm_space = H5Screate_simple(1, &sm_nelmts, NULL);
-
-                                    /* the stripmine loop */
-                                    memset(hs_offset, 0, sizeof hs_offset);
-                                    memset(zero, 0, sizeof zero);
-
-                                    for (elmtno = 0; elmtno < p_nelmts; elmtno += hs_nelmts) 
+                                    /* calculate the hyperslab size */
+                                    if (rank > 0) 
                                     {
-                                        /* calculate the hyperslab size */
-                                        if (rank > 0) 
+                                        for (k = 0, hs_nelmts = 1; k < rank; k++) 
                                         {
-                                            for (k = 0, hs_nelmts = 1; k < rank; k++) 
-                                            {
-                                                hs_size[k] = MIN(dims[k] - hs_offset[k], sm_size[k]);
-                                                hs_nelmts *= hs_size[k];
-                                            }
-
-                                            if (H5Sselect_hyperslab(f_space_id, H5S_SELECT_SET, hs_offset, NULL, hs_size, NULL) < 0)
-                                                goto error;
-                                            if (H5Sselect_hyperslab(sm_space, H5S_SELECT_SET, zero, NULL, &hs_nelmts, NULL) < 0)
-                                                goto error;
-                                        } 
-                                        else 
-                                        {
-                                            H5Sselect_all(f_space_id);
-                                            H5Sselect_all(sm_space);
-                                            hs_nelmts = 1;
-                                        } /* rank */
+                                            hs_size[k] = MIN(dims[k] - hs_offset[k], sm_size[k]);
+                                            hs_nelmts *= hs_size[k];
+                                        }
 
-                                        /* read/write */
-                                        if (H5Dread(dset_in, wtype_id, sm_space, f_space_id, H5P_DEFAULT, sm_buf) < 0) 
+                                        if (H5Sselect_hyperslab(f_space_id, H5S_SELECT_SET, hs_offset, NULL, hs_size, NULL) < 0)
                                             goto error;
-                                        if (H5Dwrite(dset_out, wtype_id, sm_space, f_space_id, H5P_DEFAULT, sm_buf) < 0) 
+                                        if (H5Sselect_hyperslab(sm_space, H5S_SELECT_SET, zero, NULL, &hs_nelmts, NULL) < 0)
                                             goto error;
+                                    } 
+                                    else 
+                                    {
+                                        H5Sselect_all(f_space_id);
+                                        H5Sselect_all(sm_space);
+                                        hs_nelmts = 1;
+                                    } /* rank */
+
+                                    /* read/write */
+                                    if (H5Dread(dset_in, wtype_id, sm_space, f_space_id, H5P_DEFAULT, sm_buf) < 0) 
+                                        goto error;
+                                    if (H5Dwrite(dset_out, wtype_id, sm_space, f_space_id, H5P_DEFAULT, sm_buf) < 0) 
+                                        goto error;
 
-                                        /* reclaim any VL memory, if necessary */
-                                        if(vl_data)
-                                            H5Dvlen_reclaim(wtype_id, sm_space, H5P_DEFAULT, sm_buf);
+                                    /* reclaim any VL memory, if necessary */
+                                    if(vl_data)
+                                        H5Dvlen_reclaim(wtype_id, sm_space, H5P_DEFAULT, sm_buf);
 
-                                        /* calculate the next hyperslab offset */
-                                        for (k = rank, carry = 1; k > 0 && carry; --k) 
-                                        {
-                                            hs_offset[k - 1] += hs_size[k - 1];
-                                            if (hs_offset[k - 1] == dims[k - 1])
-                                                hs_offset[k - 1] = 0;
-                                            else
-                                                carry = 0;
-                                        } /* k */
-                                    } /* elmtno */
-
-                                    H5Sclose(sm_space);
-                                    /* free */
-                                    if (sm_buf!=NULL)
+                                    /* calculate the next hyperslab offset */
+                                    for (k = rank, carry = 1; k > 0 && carry; --k) 
                                     {
-                                        HDfree(sm_buf);
-                                        sm_buf=NULL;
-                                    }
-                                } /* hyperslab read */
-                            }/*nelmts*/
-
-                            /*-------------------------------------------------------------------------
-                             * amount of compression used
-                             *-------------------------------------------------------------------------
-                             */
-                            if (options->verbose) 
+                                        hs_offset[k - 1] += hs_size[k - 1];
+                                        if (hs_offset[k - 1] == dims[k - 1])
+                                            hs_offset[k - 1] = 0;
+                                        else
+                                            carry = 0;
+                                    } /* k */
+                                } /* elmtno */
+
+                                H5Sclose(sm_space);
+                                /* free */
+                                if (sm_buf!=NULL)
+                                {
+                                    HDfree(sm_buf);
+                                    sm_buf=NULL;
+                                }
+                            } /* hyperslab read */
+                        }/*nelmts*/
+
+                        /*-------------------------------------------------------------------------
+                        * amount of compression used
+                        *-------------------------------------------------------------------------
+                        */
+                        if (options->verbose) 
+                        {
+                            double ratio=0;
+
+                            /* only print the compression ration if there was a filter request */
+                            if (apply_s && apply_f && req_filter)
                             {
-                                double ratio=0;
+                                hssize_t a, b;
 
-                                /* only print the compression ration if there was a filter request */
-                                if (apply_s && apply_f && req_filter)
-                                {
-                                    hssize_t a, b;
+                                /* get the storage size of the output dataset */
+                                dsize_out=H5Dget_storage_size(dset_out);
 
-                                    /* get the storage size of the output dataset */
-                                    dsize_out=H5Dget_storage_size(dset_out);
+                                /* compression ratio = uncompressed size /  compressed size */
 
-                                    /* compression ratio = uncompressed size /  compressed size */
+                                a = dsize_in; b = dsize_out;
+                                if (b!=0)
+                                    ratio = (double) a / (double) b;
 
-                                    a = dsize_in; b = dsize_out;
-                                    if (b!=0)
-                                        ratio = (double) a / (double) b;
-                                  
-                                    print_dataset_info(dcpl_out,travt->objs[i].name,ratio,1);
-                                }
-                                else
-                                    print_dataset_info(dcpl_id,travt->objs[i].name,ratio,0);
+                                print_dataset_info(dcpl_out,travt->objs[i].name,ratio,1);
+                            }
+                            else
+                                print_dataset_info(dcpl_id,travt->objs[i].name,ratio,0);
 
-                                /* print a message that the filter was not applied 
-                                (in case there was a filter)
-                                */
-                                if ( has_filter && apply_s == 0 )
-                                    printf(" <warning: filter not applied to %s. dataset smaller than %d bytes>\n",
-                                            travt->objs[i].name,
-                                            (int)options->min_comp);
-
-                                if ( has_filter && apply_f == 0 )
-                                    printf(" <warning: could not apply the filter to %s>\n",
-                                            travt->objs[i].name);
-
-                            } /* verbose */
-
-                            /*-------------------------------------------------------------------------
-                             * copy attrs
-                             *-------------------------------------------------------------------------
-                             */
-                            if (copy_attr(dset_in,dset_out,options) < 0)
-                                goto error;
+                            /* print a message that the filter was not applied 
+                            (in case there was a filter)
+                            */
+                            if ( has_filter && apply_s == 0 )
+                                printf(" <warning: filter not applied to %s. dataset smaller than %d bytes>\n",
+                                travt->objs[i].name,
+                                (int)options->min_comp);
 
-                            /*close */
-                            if (H5Dclose(dset_out) < 0)
-                                goto error;
+                            if ( has_filter && apply_f == 0 )
+                                printf(" <warning: could not apply the filter to %s>\n",
+                                travt->objs[i].name);
 
-                        }/*!H5T_REFERENCE*/
-                    }/*h5tools_canreadf*/
+                        } /* verbose */
 
+                        /*-------------------------------------------------------------------------
+                        * copy attrs
+                        *-------------------------------------------------------------------------
+                        */
+                        if (copy_attr(dset_in,dset_out,options) < 0)
+                            goto error;
+
+                        /*close */
+                        if (H5Dclose(dset_out) < 0)
+                            goto error;
+
+                    }/*!H5T_REFERENCE*/
+                }/*h5tools_canreadf*/
 
-                    /*-------------------------------------------------------------------------
-                     * close
-                     *-------------------------------------------------------------------------
-                     */
-                    if (H5Tclose(ftype_id) < 0)
-                        goto error;
-                    if (H5Tclose(wtype_id) < 0)
-                        goto error;
-                    if (H5Pclose(dcpl_id) < 0)
-                        goto error;
-                    if (H5Pclose(dcpl_out) < 0)
-                        goto error;
-                    if (H5Sclose(f_space_id) < 0)
-                        goto error;
-                    if (H5Dclose(dset_in) < 0)
-                        goto error;
 
-                }
                 /*-------------------------------------------------------------------------
-                 * we do not have request for filter/chunking use H5Ocopy instead
-                 *-------------------------------------------------------------------------
-                 */
-                else 
-                {
-                    hid_t        pid;
+                * close
+                *-------------------------------------------------------------------------
+                */
+                if (H5Tclose(ftype_id) < 0)
+                    goto error;
+                if (H5Tclose(wtype_id) < 0)
+                    goto error;
+                if (H5Pclose(dcpl_id) < 0)
+                    goto error;
+                if (H5Pclose(dcpl_out) < 0)
+                    goto error;
+                if (H5Sclose(f_space_id) < 0)
+                    goto error;
+                if (H5Dclose(dset_in) < 0)
+                    goto error;
 
-                    /* create property to pass copy options */
-                    if ( (pid = H5Pcreate(H5P_OBJECT_COPY)) < 0) 
-                        goto error;
+            }
+            /*-------------------------------------------------------------------------
+            * we do not have request for filter/chunking use H5Ocopy instead
+            *-------------------------------------------------------------------------
+            */
+            else 
+            {
+                hid_t        pid;
 
-                    /* set options for object copy */
-                    if(H5Pset_copy_object(pid, H5O_COPY_WITHOUT_ATTR_FLAG) < 0) 
-                        goto error;
+                /* create property to pass copy options */
+                if ( (pid = H5Pcreate(H5P_OBJECT_COPY)) < 0) 
+                    goto error;
 
-                    /*-------------------------------------------------------------------------
-                     * do the copy
-                     *-------------------------------------------------------------------------
-                     */
-
-                    if(H5Ocopy(fidin,          /* Source file or group identifier */
-                            travt->objs[i].name,       /* Name of the source object to be copied */
-                            fidout,                    /* Destination file or group identifier  */
-                            travt->objs[i].name,       /* Name of the destination object  */
-                            pid,                       /* Properties which apply to the copy   */
-                            H5P_DEFAULT) < 0)            /* Properties which apply to the new hard link */              
-                        goto error;
+                /* set options for object copy */
+                if(H5Pset_copy_object(pid, H5O_COPY_WITHOUT_ATTR_FLAG) < 0) 
+                    goto error;
 
-                    /* close property */
-                    if(H5Pclose(pid) < 0)
-                        goto error;
+                /*-------------------------------------------------------------------------
+                * do the copy
+                *-------------------------------------------------------------------------
+                */
+
+                if(H5Ocopy(fidin,          /* Source file or group identifier */
+                    travt->objs[i].name,       /* Name of the source object to be copied */
+                    fidout,                    /* Destination file or group identifier  */
+                    travt->objs[i].name,       /* Name of the destination object  */
+                    pid,                       /* Properties which apply to the copy   */
+                    H5P_DEFAULT) < 0)            /* Properties which apply to the new hard link */              
+                    goto error;
 
+                /* close property */
+                if(H5Pclose(pid) < 0)
+                    goto error;
 
-                    /*-------------------------------------------------------------------------
-                     * copy attrs manually
-                     *-------------------------------------------------------------------------
-                     */
-                    if((dset_in = H5Dopen2(fidin, travt->objs[i].name, H5P_DEFAULT)) < 0)
-                        goto error;
-                    if((dset_out = H5Dopen2(fidout, travt->objs[i].name, H5P_DEFAULT)) < 0)
-                        goto error;
-                    if(copy_attr(dset_in, dset_out, options) < 0)
-                        goto error;
-                    if(H5Dclose(dset_in) < 0)
-                        goto error;
-                    if(H5Dclose(dset_out) < 0)
-                        goto error;
+
+                /*-------------------------------------------------------------------------
+                * copy attrs manually
+                *-------------------------------------------------------------------------
+                */
+                if((dset_in = H5Dopen2(fidin, travt->objs[i].name, H5P_DEFAULT)) < 0)
+                    goto error;
+                if((dset_out = H5Dopen2(fidout, travt->objs[i].name, H5P_DEFAULT)) < 0)
+                    goto error;
+                if(copy_attr(dset_in, dset_out, options) < 0)
+                    goto error;
+                if(H5Dclose(dset_in) < 0)
+                    goto error;
+                if(H5Dclose(dset_out) < 0)
+                    goto error;
 
 
-                    if (options->verbose)
-                        printf(FORMAT_OBJ,"dset",travt->objs[i].name );
-                    
+                if (options->verbose)
+                    printf(FORMAT_OBJ,"dset",travt->objs[i].name );
 
-                } /* end do we have request for filter/chunking */
 
+            } /* end do we have request for filter/chunking */
 
-                break;
+
+            break;
 
             /*-------------------------------------------------------------------------
-             * H5TRAV_TYPE_NAMED_DATATYPE
-             *-------------------------------------------------------------------------
-             */
-            case H5TRAV_TYPE_NAMED_DATATYPE:
+            * H5TRAV_TYPE_NAMED_DATATYPE
+            *-------------------------------------------------------------------------
+            */
+        case H5TRAV_TYPE_NAMED_DATATYPE:
 
-                if(options->verbose)
-                    printf(FORMAT_OBJ, "type", travt->objs[i].name);
+            if(options->verbose)
+                printf(FORMAT_OBJ, "type", travt->objs[i].name);
 
-                if((type_in = H5Topen2(fidin, travt->objs[i].name, H5P_DEFAULT)) < 0)
-                    goto error;
+            if((type_in = H5Topen2(fidin, travt->objs[i].name, H5P_DEFAULT)) < 0)
+                goto error;
 
-                if((type_out = H5Tcopy(type_in)) < 0)
-                    goto error;
+            if((type_out = H5Tcopy(type_in)) < 0)
+                goto error;
 
-                if((H5Tcommit2(fidout, travt->objs[i].name, type_out, H5P_DEFAULT, H5P_DEFAULT, H5P_DEFAULT)) < 0)
-                    goto error;
+            if((H5Tcommit2(fidout, travt->objs[i].name, type_out, H5P_DEFAULT, H5P_DEFAULT, H5P_DEFAULT)) < 0)
+                goto error;
 
-                /*-------------------------------------------------------------------------
-                 * copy attrs
-                 *-------------------------------------------------------------------------
-                 */
-                if(copy_attr(type_in, type_out, options) < 0)
-                    goto error;
+            /*-------------------------------------------------------------------------
+            * copy attrs
+            *-------------------------------------------------------------------------
+            */
+            if(copy_attr(type_in, type_out, options) < 0)
+                goto error;
 
-                if(H5Tclose(type_in) < 0)
-                    goto error;
-                if(H5Tclose(type_out) < 0)
-                    goto error;
+            if(H5Tclose(type_in) < 0)
+                goto error;
+            if(H5Tclose(type_out) < 0)
+                goto error;
 
-              
 
-                break;
+
+            break;
 
 
             /*-------------------------------------------------------------------------
-             * H5TRAV_TYPE_LINK
-             * H5TRAV_TYPE_UDLINK
-             *
-             * Only handles external links; H5Lcopy will fail for other UD link types
-             * since we don't have creation or copy callbacks for them.
-             *-------------------------------------------------------------------------
-             */
-
-            case H5TRAV_TYPE_LINK:
-            case H5TRAV_TYPE_UDLINK:
+            * H5TRAV_TYPE_LINK
+            * H5TRAV_TYPE_UDLINK
+            *
+            * Only handles external links; H5Lcopy will fail for other UD link types
+            * since we don't have creation or copy callbacks for them.
+            *-------------------------------------------------------------------------
+            */
+
+        case H5TRAV_TYPE_LINK:
+        case H5TRAV_TYPE_UDLINK:
             {
 
                 if(options->verbose)
@@ -1055,8 +1081,8 @@ int do_copy_objects(hid_t fidin,
             }
             break;
 
-            default:
-                goto error;
+        default:
+            goto error;
         } /* switch */
 
         /* free */
@@ -1075,7 +1101,8 @@ error:
         H5Gclose(grp_in);
         H5Gclose(grp_out);
         H5Pclose(dcpl_id);
-        H5Pclose(gcpl_id);
+        H5Pclose(gcpl_in);
+        H5Pclose(gcpl_out);
         H5Sclose(f_space_id);
         H5Dclose(dset_in);
         H5Dclose(dset_out);
@@ -1094,21 +1121,21 @@ error:
 
 
 /*-------------------------------------------------------------------------
- * Function: copy_attr
- *
- * Purpose: copy attributes located in LOC_IN, which is obtained either from
- * loc_id = H5Gopen2( fid, name);
- * loc_id = H5Dopen2( fid, name);
- * loc_id = H5Topen2( fid, name);
- *
- * Return: 0, ok, -1 no
- *
- * Programmer: Pedro Vicente, pvn@ncsa.uiuc.edu
- *
- * Date: October, 28, 2003
- *
- *-------------------------------------------------------------------------
- */
+* Function: copy_attr
+*
+* Purpose: copy attributes located in LOC_IN, which is obtained either from
+* loc_id = H5Gopen2( fid, name);
+* loc_id = H5Dopen2( fid, name);
+* loc_id = H5Topen2( fid, name);
+*
+* Return: 0, ok, -1 no
+*
+* Programmer: Pedro Vicente, pvn@ncsa.uiuc.edu
+*
+* Date: October, 28, 2003
+*
+*-------------------------------------------------------------------------
+*/
 
 int copy_attr(hid_t loc_in,
               hid_t loc_out,
@@ -1129,71 +1156,71 @@ int copy_attr(hid_t loc_in,
     H5O_info_t oinfo;             /* object info */
     int        j;
     unsigned   u;
-    
+
     if(H5Oget_info(loc_in, &oinfo) < 0)
         goto error;
-    
-   /*-------------------------------------------------------------------------
+
+    /*-------------------------------------------------------------------------
     * copy all attributes
     *-------------------------------------------------------------------------
     */
-    
+
     for ( u = 0; u < (unsigned)oinfo.num_attrs; u++)
     {
-        
+
         buf=NULL;
-        
+
         /* open attribute */
         if((attr_id = H5Aopen_by_idx(loc_in, ".", H5_INDEX_CRT_ORDER, H5_ITER_INC, (hsize_t)u, H5P_DEFAULT, H5P_DEFAULT)) < 0)
             goto error;
-        
+
         /* get name */
         if (H5Aget_name( attr_id, (size_t)255, name ) < 0)
             goto error;
-        
+
         /* get the file datatype  */
         if ((ftype_id = H5Aget_type( attr_id )) < 0 )
             goto error;
-        
+
         /* get the dataspace handle  */
         if ((space_id = H5Aget_space( attr_id )) < 0 )
             goto error;
-        
+
         /* get dimensions  */
         if ( (rank = H5Sget_simple_extent_dims(space_id, dims, NULL)) < 0 )
             goto error;
-        
+
         nelmts=1;
         for (j=0; j<rank; j++)
             nelmts*=dims[j];
-        
+
         if (options->use_native==1)
             wtype_id = h5tools_get_native_type(ftype_id);
         else
             wtype_id = H5Tcopy(ftype_id); 
-        
+
         if ((msize=H5Tget_size(wtype_id))==0)
             goto error;
-        
-       /*-------------------------------------------------------------------------
+
+        /*-------------------------------------------------------------------------
         * object references are a special case
         * we cannot just copy the buffers, but instead we recreate the reference
         * this is done on a second sweep of the file that just copies
         * the referenced objects
         *-------------------------------------------------------------------------
         */
-        
+
         if (H5T_REFERENCE==H5Tget_class(wtype_id))
         {
             ;
         }
         else 
         {
-          /*-------------------------------------------------------------------------
-           * read to memory
-           *-------------------------------------------------------------------------
-           */
-            
+            /*-------------------------------------------------------------------------
+            * read to memory
+            *-------------------------------------------------------------------------
+            */
+
             buf = (void *)HDmalloc((size_t)(nelmts * msize));
             if(buf == NULL) {
                 error_msg(progname, "cannot read into memory\n" );
@@ -1201,46 +1228,46 @@ int copy_attr(hid_t loc_in,
             }
             if(H5Aread(attr_id, wtype_id, buf) < 0)
                 goto error;
-            
-           /*-------------------------------------------------------------------------
+
+            /*-------------------------------------------------------------------------
             * copy
             *-------------------------------------------------------------------------
             */
-            
+
             if((attr_out = H5Acreate2(loc_out, name, ftype_id, space_id, H5P_DEFAULT, H5P_DEFAULT)) < 0)
                 goto error;
             if(H5Awrite(attr_out, wtype_id, buf) < 0)
                 goto error;
-            
+
             /*close*/
             if(H5Aclose(attr_out) < 0)
                 goto error;
-            
-            
+
+
             if(buf)
                 free(buf);
-            
+
         } /*H5T_REFERENCE*/
-        
-        
+
+
         if(options->verbose)
             printf(FORMAT_OBJ_ATTR, "attr", name);
-        
+
         /*-------------------------------------------------------------------------
-         * close
-         *-------------------------------------------------------------------------
-         */
-        
+        * close
+        *-------------------------------------------------------------------------
+        */
+
         if (H5Tclose(ftype_id) < 0) goto error;
         if (H5Tclose(wtype_id) < 0) goto error;
         if (H5Sclose(space_id) < 0) goto error;
         if (H5Aclose(attr_id) < 0) goto error;
-        
+
     } /* u */
-    
-    
+
+
     return 0;
-    
+
 error:
     H5E_BEGIN_TRY {
         H5Tclose(ftype_id);
@@ -1258,12 +1285,12 @@ error:
 
 
 /*-------------------------------------------------------------------------
- * Function: print_dataset_info
- *
- * Purpose: print name, filters, percentage compression of a dataset
- *
- *-------------------------------------------------------------------------
- */
+* Function: print_dataset_info
+*
+* Purpose: print name, filters, percentage compression of a dataset
+*
+*-------------------------------------------------------------------------
+*/
 static void print_dataset_info(hid_t dcpl_id,
                                char *objname,
                                double ratio,
@@ -1280,27 +1307,27 @@ static void print_dataset_info(hid_t dcpl_id,
     size_t       cd_nelmts;      /* filter client number of values */
     char         f_objname[256];    /* filter objname */
     int          i;
-    
-    
+
+
     strcpy(strfilter,"\0");
-    
+
     /* get information about input filters */
     if((nfilters = H5Pget_nfilters(dcpl_id)) < 0)
         return;
-    
+
     for(i = 0; i < nfilters; i++) {
         cd_nelmts = NELMTS(cd_values);
-        
+
         filtn = H5Pget_filter2(dcpl_id, (unsigned)i, &filt_flags, &cd_nelmts,
             cd_values, sizeof(f_objname), f_objname, NULL);
-        
+
         switch(filtn) {
         default:
             break;
-            
+
         case H5Z_FILTER_DEFLATE:
             strcat(strfilter,"GZIP ");
-            
+
 #if defined (PRINT_DEBUG)
             {
                 unsigned level=cd_values[0];
@@ -1309,10 +1336,10 @@ static void print_dataset_info(hid_t dcpl_id,
             }
 #endif
             break;
-            
+
         case H5Z_FILTER_SZIP:
             strcat(strfilter,"SZIP ");
-            
+
 #if defined (PRINT_DEBUG)
             {
                 unsigned options_mask=cd_values[0]; /* from dcpl, not filt*/
@@ -1325,29 +1352,29 @@ static void print_dataset_info(hid_t dcpl_id,
                     strcpy(temp,"NN) ");
             }
             strcat(strfilter,temp);
-            
+
 #endif
-            
+
             break;
-            
+
         case H5Z_FILTER_SHUFFLE:
             strcat(strfilter,"SHUF ");
             break;
-            
+
         case H5Z_FILTER_FLETCHER32:
             strcat(strfilter,"FLET ");
             break;
-            
+
         case H5Z_FILTER_NBIT:
             strcat(strfilter,"NBIT ");
             break;
-            
+
         case H5Z_FILTER_SCALEOFFSET:
             strcat(strfilter,"SCALEOFFSET ");
             break;
         } /* switch */
     }/*i*/
-    
+
     if(!pr)
         printf(FORMAT_OBJ,"dset",objname );
     else
@@ -1362,18 +1389,18 @@ static void print_dataset_info(hid_t dcpl_id,
 }
 
 /*-------------------------------------------------------------------------
- * Function: copy_user_block 
- *
- * Purpose: copy user block from one file to another
- *
- * Return: 0, ok, -1 no
- *
- * Programmer: Peter Cao 
- *
- * Date: October, 25, 2007
- *
- *-------------------------------------------------------------------------
- */
+* Function: copy_user_block 
+*
+* Purpose: copy user block from one file to another
+*
+* Return: 0, ok, -1 no
+*
+* Programmer: Peter Cao 
+*
+* Date: October, 25, 2007
+*
+*-------------------------------------------------------------------------
+*/
 static int
 copy_user_block(const char *infile, const char *outfile, hsize_t size)
 {
@@ -1448,18 +1475,18 @@ done:
 
 
 /*-------------------------------------------------------------------------
- * Function: print_user_block 
- *
- * Purpose: print user block
- *
- * Return: 0, ok, -1 no
- *
- * Programmer: Pedro Vicente 
- *
- * Date: August, 20, 2008
- *
- *-------------------------------------------------------------------------
- */
+* Function: print_user_block 
+*
+* Purpose: print user block
+*
+* Return: 0, ok, -1 no
+*
+* Programmer: Pedro Vicente 
+*
+* Date: August, 20, 2008
+*
+*-------------------------------------------------------------------------
+*/
 #if defined (H5REPACK_DEBUG_USER_BLOCK)  
 static 
 void print_user_block(const char *filename, hid_t fid)
@@ -1476,25 +1503,25 @@ void print_user_block(const char *filename, hid_t fid)
         error_msg(progname, "failed to retrieve file creation property list\n");
         goto done;
     } 
-    
+
     if(H5Pget_userblock(fcpl, &ub_size) < 0) 
     {
         error_msg(progname, "failed to retrieve userblock size\n");
         goto done;
     } 
-    
+
     if(H5Pclose(fcpl) < 0) 
     {
         error_msg(progname, "failed to close property list\n");
         goto done;
     } 
-    
+
     /* open file */
     if((fh = HDopen(filename, O_RDONLY, 0)) < 0) 
     {
         goto done;
     }
- 
+
     size = ub_size;
 
     /* read file */
@@ -1522,7 +1549,7 @@ void print_user_block(const char *filename, hid_t fid)
             goto done;
         } 
 
-       
+
         /* update size of userblock left to transfer */
         size -= nread;
     } 
@@ -1530,7 +1557,7 @@ void print_user_block(const char *filename, hid_t fid)
 done:
     if(fh > 0)
         HDclose(fh);
-  
+
 
     return;    
 }
diff --git a/tools/h5repack/h5repack_verify.c b/tools/h5repack/h5repack_verify.c
index a7454d6..92d758e 100644
--- a/tools/h5repack/h5repack_verify.c
+++ b/tools/h5repack/h5repack_verify.c
@@ -275,7 +275,7 @@ int has_layout(hid_t pid,
 }
 
 /*-------------------------------------------------------------------------
- * Function: h5repack_cmpdcpl
+ * Function: h5repack_cmp_pl
  *
  * Purpose: compare 2 files for identical property lists of all objects
  *
@@ -288,17 +288,20 @@ int has_layout(hid_t pid,
  *-------------------------------------------------------------------------
  */
 
-int h5repack_cmpdcpl(const char *fname1,
+int h5repack_cmp_pl(const char *fname1,
                      const char *fname2)
 {
-    hid_t         fid1=-1;       /* file ID */
-    hid_t         fid2=-1;       /* file ID */
-    hid_t         dset1=-1;      /* dataset ID */
-    hid_t         dset2=-1;      /* dataset ID */
-    hid_t         dcpl1=-1;      /* dataset creation property list ID */
-    hid_t         dcpl2=-1;      /* dataset creation property list ID */
-    trav_table_t  *travt1=NULL;
-    trav_table_t  *travt2=NULL;
+    hid_t         fid1=-1;         /* file ID */
+    hid_t         fid2=-1;         /* file ID */
+    hid_t         dset1=-1;        /* dataset ID */
+    hid_t         dset2=-1;        /* dataset ID */
+    hid_t         gid=-1;          /* group ID */
+    hid_t         dcpl1=-1;        /* dataset creation property list ID */
+    hid_t         dcpl2=-1;        /* dataset creation property list ID */
+    hid_t         gcplid=-1;       /* group creation property list */
+    unsigned      crt_order_flag1; /* group creation order flag */
+    unsigned      crt_order_flag2; /* group creation order flag */
+    trav_table_t  *trav=NULL;
     int           ret=1;
     unsigned int  i;
 
@@ -330,26 +333,57 @@ int h5repack_cmpdcpl(const char *fname1,
     * get file table list of objects
     *-------------------------------------------------------------------------
     */
-    trav_table_init(&travt1);
-    trav_table_init(&travt2);
-    if(h5trav_gettable(fid1, travt1) < 0)
+    trav_table_init(&trav);
+    if(h5trav_gettable(fid1, trav) < 0)
         goto error;
-    if(h5trav_gettable(fid2, travt2) < 0)
-        goto error;
-
-
+  
    /*-------------------------------------------------------------------------
     * traverse the suppplied object list
     *-------------------------------------------------------------------------
     */
-
-    for(i = 0; i < travt1->nobjs; i++)
+    for(i = 0; i < trav->nobjs; i++)
     {
-        if(travt1->objs[i].type == H5TRAV_TYPE_DATASET)
+
+        if(trav->objs[i].type == H5TRAV_TYPE_GROUP)
+        {
+
+            if ((gid = H5Gopen2(fid1, trav->objs[i].name, H5P_DEFAULT)) < 0)
+                goto error;
+            if ((gcplid = H5Gget_create_plist(gid)) < 0)
+                goto error;
+            if (H5Pget_link_creation_order(gcplid, &crt_order_flag1) < 0)
+                goto error;
+            if (H5Pclose(gcplid) < 0)
+                goto error;
+            if (H5Gclose(gid) < 0)
+                goto error;
+
+            if ((gid = H5Gopen2(fid2, trav->objs[i].name, H5P_DEFAULT)) < 0)
+                goto error;
+            if ((gcplid = H5Gget_create_plist(gid)) < 0)
+                goto error;
+            if (H5Pget_link_creation_order(gcplid, &crt_order_flag2) < 0)
+                goto error;
+            if (H5Pclose(gcplid) < 0)
+                goto error;
+            if (H5Gclose(gid) < 0)
+                goto error;
+
+            if ( crt_order_flag1 != crt_order_flag2 )
+            {
+                error_msg(progname, "property lists for <%s> are different\n",trav->objs[i].name);
+                goto error;
+            }
+
+        }
+
+
+
+        else if(trav->objs[i].type == H5TRAV_TYPE_DATASET)
         {
-            if((dset1 = H5Dopen2(fid1, travt1->objs[i].name, H5P_DEFAULT)) < 0)
+            if((dset1 = H5Dopen2(fid1, trav->objs[i].name, H5P_DEFAULT)) < 0)
                 goto error;
-            if((dset2 = H5Dopen2(fid2, travt1->objs[i].name, H5P_DEFAULT)) < 0)
+            if((dset2 = H5Dopen2(fid2, trav->objs[i].name, H5P_DEFAULT)) < 0)
                 goto error;
             if((dcpl1 = H5Dget_create_plist(dset1)) < 0)
                 goto error;
@@ -365,7 +399,7 @@ int h5repack_cmpdcpl(const char *fname1,
 
             if(ret == 0)
             {
-                error_msg(progname, "property lists for <%s> are different\n",travt1->objs[i].name);
+                error_msg(progname, "property lists for <%s> are different\n",trav->objs[i].name);
                 goto error;
             }
 
@@ -389,8 +423,7 @@ int h5repack_cmpdcpl(const char *fname1,
     *-------------------------------------------------------------------------
     */
 
-    trav_table_free(travt1);
-    trav_table_free(travt2);
+    trav_table_free(trav);
 
    /*-------------------------------------------------------------------------
     * close
@@ -415,8 +448,9 @@ error:
         H5Dclose(dset2);
         H5Fclose(fid1);
         H5Fclose(fid2);
-        trav_table_free(travt1);
-        trav_table_free(travt2);
+        H5Pclose(gcplid);
+        H5Gclose(gid);
+        trav_table_free(trav);
     } H5E_END_TRY;
     return -1;
 
diff --git a/tools/h5repack/h5repacktst.c b/tools/h5repack/h5repacktst.c
index c6afce1..27a30b4 100644
--- a/tools/h5repack/h5repacktst.c
+++ b/tools/h5repack/h5repacktst.c
@@ -1,17 +1,17 @@
 /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
- * Copyright by The HDF Group.                                               *
- * Copyright by the Board of Trustees of the University of Illinois.         *
- * All rights reserved.                                                      *
- *                                                                           *
- * This file is part of HDF5.  The full HDF5 copyright notice, including     *
- * terms governing use, modification, and redistribution, is contained in    *
- * the files COPYING and Copyright.html.  COPYING can be found at the root   *
- * of the source code distribution tree; Copyright.html can be found at the  *
- * root level of an installed copy of the electronic HDF5 document set and   *
- * is linked from the top-level documents page.  It can also be found at     *
- * http://hdfgroup.org/HDF5/doc/Copyright.html.  If you do not have          *
- * access to either file, you may request a copy from help@hdfgroup.org.     *
- * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
+* Copyright by The HDF Group.                                               *
+* Copyright by the Board of Trustees of the University of Illinois.         *
+* All rights reserved.                                                      *
+*                                                                           *
+* This file is part of HDF5.  The full HDF5 copyright notice, including     *
+* terms governing use, modification, and redistribution, is contained in    *
+* the files COPYING and Copyright.html.  COPYING can be found at the root   *
+* of the source code distribution tree; Copyright.html can be found at the  *
+* root level of an installed copy of the electronic HDF5 document set and   *
+* is linked from the top-level documents page.  It can also be found at     *
+* http://hdfgroup.org/HDF5/doc/Copyright.html.  If you do not have          *
+* access to either file, you may request a copy from help@hdfgroup.org.     *
+* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
 
 #include "h5repack.h"
 #include "h5test.h"
@@ -76,7 +76,7 @@
 
 
 const char *H5REPACK_FILENAMES[] = {
-   "h5repack_big_out",
+    "h5repack_big_out",
     NULL
 };
 
@@ -98,9 +98,9 @@ int d_status = EXIT_SUCCESS;
 #define USERBLOCK_SIZE  2048
 
 /*-------------------------------------------------------------------------
- * prototypes
- *-------------------------------------------------------------------------
- */
+* prototypes
+*-------------------------------------------------------------------------
+*/
 int make_all_objects(hid_t loc_id);
 int make_attributes(hid_t loc_id);
 int make_hlinks(hid_t loc_id);
@@ -118,12 +118,12 @@ int make_all(hid_t loc_id);
 int make_fill(hid_t loc_id);
 int make_big(hid_t loc_id);
 int make_testfiles(void);
-void write_dset_in(hid_t loc_id,const char* dset_name,hid_t file_id,int make_diffs );
-void write_attr_in(hid_t loc_id,const char* dset_name,hid_t fid,int make_diffs );
-int write_dset(hid_t loc_id,int rank,hsize_t *dims,const char *dset_name,hid_t type_id,void *buf );
+int write_dset_in(hid_t loc_id,const char* dset_name,hid_t file_id,int make_diffs );
+int write_attr_in(hid_t loc_id,const char* dset_name,hid_t fid,int make_diffs );
+int write_dset(hid_t loc_id,int rank,hsize_t *dims,const char *dset_name,hid_t tid,void *buf );
 int make_dset(hid_t loc_id,const char *name,hid_t sid,hid_t dcpl,void *buf);
-int make_attr(hid_t loc_id,int rank,hsize_t *dims,const char *attr_name,hid_t type_id,void *buf);
-void make_dset_reg_ref(hid_t loc_id);
+int make_attr(hid_t loc_id,int rank,hsize_t *dims,const char *attr_name,hid_t tid,void *buf);
+int make_dset_reg_ref(hid_t loc_id);
 int make_external(hid_t loc_id);
 static int make_userblock(void);
 static int verify_userblock( const char* filename);
@@ -131,18 +131,18 @@ static int make_userblock_file(void);
 
 
 /*-------------------------------------------------------------------------
- * Function: main
- *
- * Purpose: Executes h5repack tests
- *
- * Return: Success: zero
- *  Failure: 1
- *
- * Programmer:  Pedro Vicente <pvn@ncsa.uiuc.edu>
- *             January, 6, 2004
- *
- *-------------------------------------------------------------------------
- */
+* Function: main
+*
+* Purpose: Executes h5repack tests
+*
+* Return: Success: zero
+*  Failure: 1
+*
+* Programmer:  Pedro Vicente <pvn@ncsa.uiuc.edu>
+*             January, 6, 2004
+*
+*-------------------------------------------------------------------------
+*/
 
 int main (void)
 {
@@ -151,20 +151,20 @@ int main (void)
 #if defined (H5_HAVE_FILTER_SZIP)
     int szip_can_encode = 0;
 #endif
-    
+
     /* initialize */
     memset(&diff_options, 0, sizeof (diff_opt_t));
     memset(&pack_options, 0, sizeof (pack_opt_t));
-    
+
     /* run tests  */
     puts("Testing h5repack:");
-    
+
     /* make the test files */
     TESTING("    generating datasets");
     if (make_testfiles() < 0)
         GOERROR;
     PASSED();
-    
+
     /*-------------------------------------------------------------------------
     * Format of the tests:
     *
@@ -177,7 +177,7 @@ int main (void)
     * file with fill values
     *-------------------------------------------------------------------------
     */
-    
+
     TESTING("    copy of datasets (fill values)");
     if (h5repack_init (&pack_options, 0) < 0)
         GOERROR;
@@ -187,7 +187,7 @@ int main (void)
         GOERROR;
     if (h5repack_verify(FNAME0OUT,&pack_options)<=0)
         GOERROR;
-    if (h5repack_cmpdcpl(FNAME0,FNAME0OUT)<=0)
+    if (h5repack_cmp_pl(FNAME0,FNAME0OUT)<=0)
         GOERROR;
     if (h5repack_end (&pack_options) < 0)
         GOERROR;
@@ -207,13 +207,13 @@ int main (void)
         GOERROR;
     if (h5repack_verify(FNAME1OUT,&pack_options)<=0)
         GOERROR;
-    if (h5repack_cmpdcpl(FNAME1,FNAME1OUT)<=0)
+    if (h5repack_cmp_pl(FNAME1,FNAME1OUT)<=0)
         GOERROR;
     if (h5repack_end (&pack_options) < 0)
         GOERROR;
     PASSED();
-    
-    
+
+
     /*-------------------------------------------------------------------------
     * file with attributes
     *-------------------------------------------------------------------------
@@ -227,12 +227,12 @@ int main (void)
         GOERROR;
     if (h5repack_verify(FNAME2OUT,&pack_options)<=0)
         GOERROR;
-    if (h5repack_cmpdcpl(FNAME2,FNAME2OUT)<=0)
+    if (h5repack_cmp_pl(FNAME2,FNAME2OUT)<=0)
         GOERROR;
     if (h5repack_end (&pack_options) < 0)
         GOERROR;
     PASSED();
-    
+
     /*-------------------------------------------------------------------------
     * file with hardlinks
     *-------------------------------------------------------------------------
@@ -246,13 +246,13 @@ int main (void)
         GOERROR;
     if (h5repack_verify(FNAME3OUT,&pack_options)<=0)
         GOERROR;
-    if (h5repack_cmpdcpl(FNAME3,FNAME3OUT)<=0)
+    if (h5repack_cmp_pl(FNAME3,FNAME3OUT)<=0)
         GOERROR;
     if (h5repack_end (&pack_options) < 0)
         GOERROR;
-    
+
     PASSED();
-    
+
     /*-------------------------------------------------------------------------
     * alloc early test
     *-------------------------------------------------------------------------
@@ -269,25 +269,25 @@ int main (void)
     if (h5repack_end (&pack_options) < 0)
         GOERROR;
     PASSED();
-    
+
     /*-------------------------------------------------------------------------
     * the remaining files differ in the dcpl's
     *-------------------------------------------------------------------------
     */
-    
+
     /*-------------------------------------------------------------------------
     * deflate
     *-------------------------------------------------------------------------
     */
     TESTING("    adding deflate filter");
-    
+
 #ifdef H5_HAVE_FILTER_DEFLATE
-    
+
     /*-------------------------------------------------------------------------
     * test an individual object option
     *-------------------------------------------------------------------------
     */
-    
+
     if (h5repack_init (&pack_options, 0) < 0)
         GOERROR;
     if (h5repack_addfilter("dset1:GZIP=9",&pack_options) < 0)
@@ -306,16 +306,16 @@ int main (void)
 #else
     SKIPPED();
 #endif
-    
+
     /*-------------------------------------------------------------------------
     * test all objects option
     *-------------------------------------------------------------------------
     */
-    
+
     TESTING("    adding deflate filter to all");
-    
+
 #ifdef H5_HAVE_FILTER_DEFLATE
-    
+
     if (h5repack_init (&pack_options, 0) < 0)
         GOERROR;
     if (h5repack_addfilter("GZIP=1",&pack_options) < 0)
@@ -330,29 +330,29 @@ int main (void)
         GOERROR;
     if (h5repack_end (&pack_options) < 0)
         GOERROR;
-    
+
     PASSED();
 #else
     SKIPPED();
 #endif
-    
+
     /*-------------------------------------------------------------------------
     * SZIP
     *-------------------------------------------------------------------------
     */
-    
+
     TESTING("    adding szip filter");
-    
+
 #if defined (H5_HAVE_FILTER_SZIP)
     if (h5tools_can_encode(H5Z_FILTER_SZIP) >0) {
         szip_can_encode = 1;
     }
-    
+
     /*-------------------------------------------------------------------------
     * test an individual object option
     *-------------------------------------------------------------------------
     */
-    
+
     if (szip_can_encode) {
         if (h5repack_init (&pack_options, 0) < 0)
             GOERROR;
@@ -368,7 +368,7 @@ int main (void)
             GOERROR;
         if (h5repack_end (&pack_options) < 0)
             GOERROR;
-        
+
         PASSED();
     } else {
         SKIPPED();
@@ -376,14 +376,14 @@ int main (void)
 #else
     SKIPPED();
 #endif
-    
-    
+
+
     /*-------------------------------------------------------------------------
     * test all objects option
     *-------------------------------------------------------------------------
     */
     TESTING("    adding szip filter to all");
-    
+
 #if defined (H5_HAVE_FILTER_SZIP)
     if (szip_can_encode) {
         if (h5repack_init (&pack_options, 0) < 0)
@@ -398,7 +398,7 @@ int main (void)
             GOERROR;
         if (h5repack_end (&pack_options) < 0)
             GOERROR;
-        
+
         PASSED();
     } else {
         SKIPPED();
@@ -406,17 +406,17 @@ int main (void)
 #else
     SKIPPED();
 #endif
-    
-    
+
+
     TESTING("    addding shuffle filter");
-    
+
 #ifdef H5_HAVE_FILTER_SHUFFLE
-    
+
     /*-------------------------------------------------------------------------
     * test an individual object option
     *-------------------------------------------------------------------------
     */
-    
+
     if (h5repack_init (&pack_options, 0) < 0)
         GOERROR;
     if (h5repack_addfilter("dset1:SHUF",&pack_options) < 0)
@@ -431,21 +431,21 @@ int main (void)
         GOERROR;
     if (h5repack_end (&pack_options) < 0)
         GOERROR;
-    
+
     PASSED();
 #else
     SKIPPED();
 #endif
-    
+
     /*-------------------------------------------------------------------------
     * test all objects option
     *-------------------------------------------------------------------------
     */
-    
+
     TESTING("    addding shuffle filter to all");
-    
+
 #ifdef H5_HAVE_FILTER_SHUFFLE
-    
+
     if (h5repack_init (&pack_options, 0) < 0)
         GOERROR;
     if (h5repack_addfilter("SHUF",&pack_options) < 0)
@@ -460,21 +460,21 @@ int main (void)
         GOERROR;
     if (h5repack_end (&pack_options) < 0)
         GOERROR;
-    
+
     PASSED();
 #else
     SKIPPED();
 #endif
-    
+
     TESTING("    adding checksum filter");
-    
+
 #ifdef H5_HAVE_FILTER_FLETCHER32
-    
+
     /*-------------------------------------------------------------------------
     * test an individual object option
     *-------------------------------------------------------------------------
     */
-    
+
     if (h5repack_init (&pack_options, 0) < 0)
         GOERROR;
     if (h5repack_addfilter("dset1:FLET",&pack_options) < 0)
@@ -489,22 +489,22 @@ int main (void)
         GOERROR;
     if (h5repack_end (&pack_options) < 0)
         GOERROR;
-    
+
     PASSED();
 #else
     SKIPPED();
 #endif
-    
+
     /*-------------------------------------------------------------------------
     * test all objects option
     *-------------------------------------------------------------------------
     */
-    
-    
+
+
     TESTING("    adding checksum filter to all");
-    
+
 #ifdef H5_HAVE_FILTER_FLETCHER32
-    
+
     if (h5repack_init (&pack_options, 0) < 0)
         GOERROR;
     if (h5repack_addfilter("FLET",&pack_options) < 0)
@@ -519,47 +519,47 @@ int main (void)
         GOERROR;
     if (h5repack_end (&pack_options) < 0)
         GOERROR;
-    
+
     PASSED();
 #else
     SKIPPED();
 #endif
-    
-    
+
+
     TESTING("    filter queue fletcher, shuffle, deflate, szip");
-    
+
     /*-------------------------------------------------------------------------
     * add some filters
     *-------------------------------------------------------------------------
     */
-    
+
     if (h5repack_init (&pack_options, 0) < 0)
         GOERROR;
     if (h5repack_addlayout("dset1:CHUNK 20x10",&pack_options) < 0)
         GOERROR;
-    
+
 #if defined (H5_HAVE_FILTER_FLETCHER32)
     if (h5repack_addfilter("dset1:FLET",&pack_options) < 0)
         GOERROR;
 #endif
-    
+
 #ifdef H5_HAVE_FILTER_SHUFFLE
     if (h5repack_addfilter("dset1:SHUF",&pack_options) < 0)
         GOERROR;
 #endif
-    
+
 #if defined (H5_HAVE_FILTER_SZIP)
     if (szip_can_encode) {
         if (h5repack_addfilter("dset1:SZIP=8,NN",&pack_options) < 0)
             GOERROR;
     }
 #endif
-    
+
 #ifdef H5_HAVE_FILTER_DEFLATE
     if (h5repack_addfilter("dset1:GZIP=1",&pack_options) < 0)
         GOERROR;
 #endif
-    
+
     if (h5repack(FNAME4,FNAME4OUT,&pack_options) < 0)
         GOERROR;
     if (h5diff(FNAME4,FNAME4OUT,NULL,NULL,&diff_options) >0)
@@ -568,17 +568,17 @@ int main (void)
         GOERROR;
     if (h5repack_end (&pack_options) < 0)
         GOERROR;
-    
+
     PASSED();
-    
-    
+
+
     TESTING("    adding layout chunked");
-    
+
     /*-------------------------------------------------------------------------
     * test an individual object option
     *-------------------------------------------------------------------------
     */
-    
+
     if (h5repack_init (&pack_options, 0) < 0)
         GOERROR;
     if (h5repack_addlayout("dset1:CHUNK=20x10",&pack_options) < 0)
@@ -592,13 +592,13 @@ int main (void)
     if (h5repack_end (&pack_options) < 0)
         GOERROR;
     PASSED();
-    
+
     /*-------------------------------------------------------------------------
     * test all objects option
     *-------------------------------------------------------------------------
     */
     TESTING("    adding layout chunked to all");
-    
+
     if (h5repack_init (&pack_options, 0) < 0)
         GOERROR;
     if (h5repack_addlayout("CHUNK=20x10",&pack_options) < 0)
@@ -611,11 +611,11 @@ int main (void)
         GOERROR;
     if (h5repack_end (&pack_options) < 0)
         GOERROR;
-    
+
     PASSED();
-    
+
     TESTING("    adding layout contiguous");
-    
+
     /*-------------------------------------------------------------------------
     * test an individual object option
     *-------------------------------------------------------------------------
@@ -632,11 +632,11 @@ int main (void)
         GOERROR;
     if (h5repack_end (&pack_options) < 0)
         GOERROR;
-    
+
     PASSED();
-    
+
     TESTING("    adding layout contiguous to all");
-    
+
     /*-------------------------------------------------------------------------
     * test all objects option
     *-------------------------------------------------------------------------
@@ -653,16 +653,16 @@ int main (void)
         GOERROR;
     if (h5repack_end (&pack_options) < 0)
         GOERROR;
-    
+
     PASSED();
-    
+
     TESTING("    adding layout compact");
-    
+
     /*-------------------------------------------------------------------------
     * test an individual object option
     *-------------------------------------------------------------------------
     */
-    
+
     if (h5repack_init (&pack_options, 0) < 0)
         GOERROR;
     if (h5repack_addlayout("dset1:COMPA",&pack_options) < 0)
@@ -676,14 +676,14 @@ int main (void)
     if (h5repack_end (&pack_options) < 0)
         GOERROR;
     PASSED();
-    
+
     TESTING("    adding layout compact to all");
-    
+
     /*-------------------------------------------------------------------------
     * test all objects option
     *-------------------------------------------------------------------------
     */
-    
+
     if (h5repack_init (&pack_options, 0) < 0)
         GOERROR;
     if (h5repack_addlayout("COMPA",&pack_options) < 0)
@@ -696,12 +696,12 @@ int main (void)
         GOERROR;
     if (h5repack_end (&pack_options) < 0)
         GOERROR;
-    
+
     PASSED();
-    
-    
+
+
     TESTING("    layout compact to contiguous conversion");
-    
+
     /*-------------------------------------------------------------------------
     * layout compact to contiguous conversion
     *-------------------------------------------------------------------------
@@ -719,9 +719,9 @@ int main (void)
     if (h5repack_end (&pack_options) < 0)
         GOERROR;
     PASSED();
-    
+
     TESTING("    layout compact to chunk conversion");
-    
+
     /*-------------------------------------------------------------------------
     * layout compact to chunk conversion
     *-------------------------------------------------------------------------
@@ -739,9 +739,9 @@ int main (void)
     if (h5repack_end (&pack_options) < 0)
         GOERROR;
     PASSED();
-    
+
     TESTING("    layout compact to compact conversion");
-    
+
     /*-------------------------------------------------------------------------
     * layout compact to compact conversion
     *-------------------------------------------------------------------------
@@ -759,7 +759,7 @@ int main (void)
     if (h5repack_end (&pack_options) < 0)
         GOERROR;
     PASSED();
-    
+
     TESTING("    layout contiguous to compact conversion");
     /*-------------------------------------------------------------------------
     * layout contiguous to compact conversion
@@ -778,7 +778,7 @@ int main (void)
     if (h5repack_end (&pack_options) < 0)
         GOERROR;
     PASSED();
-    
+
     TESTING("    layout contiguous to chunk conversion");
     /*-------------------------------------------------------------------------
     * layout contiguous to chunk conversion
@@ -797,9 +797,9 @@ int main (void)
     if (h5repack_end (&pack_options) < 0)
         GOERROR;
     PASSED();
-    
+
     TESTING("    layout contiguous to contiguous conversion");
-    
+
     /*-------------------------------------------------------------------------
     * layout contiguous to contiguous conversion
     *-------------------------------------------------------------------------
@@ -817,7 +817,7 @@ int main (void)
     if (h5repack_end (&pack_options) < 0)
         GOERROR;
     PASSED();
-    
+
     TESTING("    layout chunked to compact conversion");
     /*-------------------------------------------------------------------------
     * layout chunked to compact conversion
@@ -836,9 +836,9 @@ int main (void)
     if (h5repack_end (&pack_options) < 0)
         GOERROR;
     PASSED();
-    
+
     TESTING("    layout chunked to contiguous conversion");
-    
+
     /*-------------------------------------------------------------------------
     * layout chunked to contiguous conversion
     *-------------------------------------------------------------------------
@@ -856,7 +856,7 @@ int main (void)
     if (h5repack_end (&pack_options) < 0)
         GOERROR;
     PASSED();
-    
+
     TESTING("    layout chunked to chunk conversion");
     /*-------------------------------------------------------------------------
     * layout chunked to chunked conversion
@@ -875,8 +875,8 @@ int main (void)
     if (h5repack_end (&pack_options) < 0)
         GOERROR;
     PASSED();
-    
-    
+
+
     /*-------------------------------------------------------------------------
     * the following tests assume the input files have filters
     * FNAME7
@@ -886,10 +886,10 @@ int main (void)
     * FNAME11
     *-------------------------------------------------------------------------
     */
-    
-    
+
+
     TESTING("    copy of szip filter");
-    
+
 #if defined (H5_HAVE_FILTER_SZIP)
     if (szip_can_encode) {
         if (h5repack_init (&pack_options, 0) < 0)
@@ -900,11 +900,11 @@ int main (void)
             GOERROR;
         if (h5repack_verify(FNAME7OUT,&pack_options)<=0)
             GOERROR;
-        if (h5repack_cmpdcpl(FNAME7,FNAME7OUT)<=0)
+        if (h5repack_cmp_pl(FNAME7,FNAME7OUT)<=0)
             GOERROR;
         if (h5repack_end (&pack_options) < 0)
             GOERROR;
-        
+
         PASSED();
     } else {
         SKIPPED();
@@ -912,9 +912,9 @@ int main (void)
 #else
     SKIPPED();
 #endif
-    
+
     TESTING("    removing szip filter");
-    
+
 #if defined (H5_HAVE_FILTER_SZIP)
     if (szip_can_encode) {
         if (h5repack_init (&pack_options, 0) < 0)
@@ -929,7 +929,7 @@ int main (void)
             GOERROR;
         if (h5repack_end (&pack_options) < 0)
             GOERROR;
-        
+
         PASSED();
     } else {
         SKIPPED();
@@ -937,10 +937,10 @@ int main (void)
 #else
     SKIPPED();
 #endif
-    
-    
+
+
     TESTING("    copy of deflate filter");
-    
+
 #ifdef H5_HAVE_FILTER_DEFLATE
     if (h5repack_init (&pack_options, 0) < 0)
         GOERROR;
@@ -952,15 +952,15 @@ int main (void)
         GOERROR;
     if (h5repack_end (&pack_options) < 0)
         GOERROR;
-    
+
     PASSED();
 #else
     SKIPPED();
 #endif
-    
-    
+
+
     TESTING("    removing deflate filter");
-    
+
 #ifdef H5_HAVE_FILTER_DEFLATE
     if (h5repack_init (&pack_options, 0) < 0)
         GOERROR;
@@ -974,16 +974,16 @@ int main (void)
         GOERROR;
     if (h5repack_end (&pack_options) < 0)
         GOERROR;
-    
+
     PASSED();
 #else
     SKIPPED();
 #endif
-    
-    
-    
+
+
+
     TESTING("    copy of shuffle filter");
-    
+
 #ifdef H5_HAVE_FILTER_SHUFFLE
     if (h5repack_init (&pack_options, 0) < 0)
         GOERROR;
@@ -995,14 +995,14 @@ int main (void)
         GOERROR;
     if (h5repack_end (&pack_options) < 0)
         GOERROR;
-    
+
     PASSED();
 #else
     SKIPPED();
 #endif
-    
+
     TESTING("    removing shuffle filter");
-    
+
 #ifdef H5_HAVE_FILTER_SHUFFLE
     if (h5repack_init (&pack_options, 0) < 0)
         GOERROR;
@@ -1016,14 +1016,14 @@ int main (void)
         GOERROR;
     if (h5repack_end (&pack_options) < 0)
         GOERROR;
-    
+
     PASSED();
 #else
     SKIPPED();
 #endif
-    
+
     TESTING("    copy of fletcher filter");
-    
+
 #ifdef H5_HAVE_FILTER_FLETCHER32
     if (h5repack_init (&pack_options, 0) < 0)
         GOERROR;
@@ -1035,14 +1035,14 @@ int main (void)
         GOERROR;
     if (h5repack_end (&pack_options) < 0)
         GOERROR;
-    
+
     PASSED();
 #else
     SKIPPED();
 #endif
-    
+
     TESTING("    removing fletcher filter");
-    
+
 #ifdef H5_HAVE_FILTER_FLETCHER32
     if (h5repack_init (&pack_options, 0) < 0)
         GOERROR;
@@ -1056,15 +1056,15 @@ int main (void)
         GOERROR;
     if (h5repack_end (&pack_options) < 0)
         GOERROR;
-    
+
     PASSED();
 #else
     SKIPPED();
 #endif
-    
-    
+
+
     TESTING("    copy of nbit filter");
-    
+
 #ifdef H5_HAVE_FILTER_NBIT
     if (h5repack_init (&pack_options, 0) < 0)
         GOERROR;
@@ -1076,14 +1076,14 @@ int main (void)
         GOERROR;
     if (h5repack_end (&pack_options) < 0)
         GOERROR;
-    
+
     PASSED();
 #else
     SKIPPED();
 #endif
-    
+
     TESTING("    removing nbit filter");
-    
+
 #ifdef H5_HAVE_FILTER_NBIT
     if (h5repack_init (&pack_options, 0) < 0)
         GOERROR;
@@ -1097,15 +1097,15 @@ int main (void)
         GOERROR;
     if (h5repack_end (&pack_options) < 0)
         GOERROR;
-    
+
     PASSED();
 #else
     SKIPPED();
 #endif
-    
-    
+
+
     TESTING("    adding nbit filter");
-    
+
 #ifdef H5_HAVE_FILTER_NBIT
     if (h5repack_init (&pack_options, 0) < 0)
         GOERROR;
@@ -1119,15 +1119,15 @@ int main (void)
         GOERROR;
     if (h5repack_end (&pack_options) < 0)
         GOERROR;
-    
+
     PASSED();
 #else
     SKIPPED();
 #endif
-    
-    
+
+
     TESTING("    copy of scaleoffset filter");
-    
+
 #ifdef H5_HAVE_FILTER_SCALEOFFSET
     if (h5repack_init (&pack_options, 0) < 0)
         GOERROR;
@@ -1139,14 +1139,14 @@ int main (void)
         GOERROR;
     if (h5repack_end (&pack_options) < 0)
         GOERROR;
-    
+
     PASSED();
 #else
     SKIPPED();
 #endif
-    
+
     TESTING("    removing scaleoffset filter");
-    
+
 #ifdef H5_HAVE_FILTER_SCALEOFFSET
     if (h5repack_init (&pack_options, 0) < 0)
         GOERROR;
@@ -1160,15 +1160,15 @@ int main (void)
         GOERROR;
     if (h5repack_end (&pack_options) < 0)
         GOERROR;
-    
+
     PASSED();
 #else
     SKIPPED();
 #endif
-    
-    
+
+
     TESTING("    adding scaleoffset filter");
-    
+
 #ifdef H5_HAVE_FILTER_SCALEOFFSET
     if (h5repack_init (&pack_options, 0) < 0)
         GOERROR;
@@ -1182,14 +1182,14 @@ int main (void)
         GOERROR;
     if (h5repack_end (&pack_options) < 0)
         GOERROR;
-    
+
     PASSED();
 #else
     SKIPPED();
 #endif
-    
-    
-    
+
+
+
     /*-------------------------------------------------------------------------
     * file with all filters
     *  dset_all
@@ -1199,14 +1199,14 @@ int main (void)
     *  dset_fletcher32
     *-------------------------------------------------------------------------
     */
-    
-    
+
+
     TESTING("    filter conversion from deflate to szip");
-    
+
 #if defined (H5_HAVE_FILTER_SZIP) \
     && defined (H5_HAVE_FILTER_DEFLATE) \
     && defined (H5_HAVE_FILTER_FLETCHER32) && defined (H5_HAVE_FILTER_SHUFFLE)
-    
+
     if (szip_can_encode) {
         if (h5repack_init (&pack_options, 0) < 0)
             GOERROR;
@@ -1220,7 +1220,7 @@ int main (void)
             GOERROR;
         if (h5repack_end (&pack_options) < 0)
             GOERROR;
-        
+
         PASSED();
     } else {
         SKIPPED();
@@ -1228,13 +1228,13 @@ int main (void)
 #else
     SKIPPED();
 #endif
-    
+
     TESTING("    filter conversion from szip to deflate");
-    
+
 #if defined (H5_HAVE_FILTER_SZIP) \
     && defined (H5_HAVE_FILTER_DEFLATE) \
     && defined (H5_HAVE_FILTER_FLETCHER32) && defined (H5_HAVE_FILTER_SHUFFLE)
-    
+
     if (szip_can_encode) {
         if (h5repack_init (&pack_options, 0) < 0)
             GOERROR;
@@ -1248,7 +1248,7 @@ int main (void)
             GOERROR;
         if (h5repack_end (&pack_options) < 0)
             GOERROR;
-        
+
         PASSED();
     } else {
         SKIPPED();
@@ -1256,18 +1256,18 @@ int main (void)
 #else
     SKIPPED();
 #endif
-    
-    
+
+
     /*-------------------------------------------------------------------------
     * test the NONE global option
     *-------------------------------------------------------------------------
     */
-    
+
     TESTING("    removing all filters");
-    
+
 #if defined (H5_HAVE_FILTER_SZIP) && defined (H5_HAVE_FILTER_DEFLATE) \
     && defined (H5_HAVE_FILTER_FLETCHER32) && defined (H5_HAVE_FILTER_SHUFFLE)
-    
+
     if (h5repack_init (&pack_options, 0) < 0)
         GOERROR;
     if (h5repack_addfilter("NONE",&pack_options) < 0)
@@ -1280,12 +1280,12 @@ int main (void)
         GOERROR;
     if (h5repack_end (&pack_options) < 0)
         GOERROR;
-    
+
     PASSED();
 #else
     SKIPPED();
 #endif
-    
+
     /*-------------------------------------------------------------------------
     * test a big file
     *-------------------------------------------------------------------------
@@ -1302,7 +1302,7 @@ int main (void)
     if (h5repack_end (&pack_options) < 0)
         GOERROR;
     PASSED();
-    
+
     /*-------------------------------------------------------------------------
     * test external dataset
     *-------------------------------------------------------------------------
@@ -1319,7 +1319,7 @@ int main (void)
     if (h5repack_end (&pack_options) < 0)
         GOERROR;
     PASSED();
-    
+
     /*-------------------------------------------------------------------------
     * test file with userblock
     *-------------------------------------------------------------------------
@@ -1338,7 +1338,7 @@ int main (void)
     if(h5repack_end(&pack_options) < 0)
         GOERROR;
     PASSED();
-    
+
     /*-------------------------------------------------------------------------
     * test --latest options
     *-------------------------------------------------------------------------
@@ -1363,17 +1363,17 @@ int main (void)
     if (h5repack_end (&pack_options) < 0)
         GOERROR;
     PASSED();
-    
-    
+
+
     /*-------------------------------------------------------------------------
     * test several global filters
     *-------------------------------------------------------------------------
     */
-    
+
     TESTING("    several global filters");
-    
+
 #if defined (H5_HAVE_FILTER_DEFLATE) && defined (H5_HAVE_FILTER_SHUFFLE)
-    
+
     if (h5repack_init (&pack_options, 0) < 0)
         GOERROR;
     if (h5repack_addfilter("GZIP=1",&pack_options) < 0)
@@ -1388,28 +1388,28 @@ int main (void)
         GOERROR;
     if (h5repack_end (&pack_options) < 0)
         GOERROR;
-    
+
     PASSED();
 #else
     SKIPPED();
 #endif
-    
-    
+
+
     /*-------------------------------------------------------------------------
     * test file with userblock
     *-------------------------------------------------------------------------
     */
     TESTING("    file with added userblock");
-    
+
 #ifdef H5_HAVE_FILTER_DEFLATE
-    
+
     if(h5repack_init(&pack_options, 0) < 0)
         GOERROR;
-    
+
     /* add the options for a user block size and user block filename */
     pack_options.ublock_size = USERBLOCK_SIZE;
     pack_options.ublock_filename = FNAME_UB;
-    
+
     if(h5repack(FNAME8, FNAME8OUT, &pack_options) < 0)
         GOERROR;
     if(h5diff(FNAME8, FNAME8OUT, NULL, NULL, &diff_options) > 0)
@@ -1420,44 +1420,44 @@ int main (void)
         GOERROR;
     if(h5repack_end(&pack_options) < 0)
         GOERROR;
-    
-    
+
+
     PASSED();
 #else
     SKIPPED();
 #endif
-    
-    
+
+
     /*-------------------------------------------------------------------------
     * test file with aligment
     *-------------------------------------------------------------------------
     */
     TESTING("    file with aligment");
-    
+
 #ifdef H5_HAVE_FILTER_DEFLATE
-    
+
     if(h5repack_init(&pack_options, 0) < 0)
         GOERROR;
-    
+
     /* add the options for aligment */
     pack_options.alignment = 1;
     pack_options.threshold = 1;
-    
+
     if(h5repack(FNAME8, FNAME8OUT, &pack_options) < 0)
         GOERROR;
     if(h5diff(FNAME8, FNAME8OUT, NULL, NULL, &diff_options) > 0)
         GOERROR;
     if(h5repack_verify(FNAME8OUT, &pack_options) <= 0)
         GOERROR;
-    
-    
+
+
     /* verify aligment */
     {
         hsize_t threshold;
         hsize_t alignment;
         hid_t fapl;
         hid_t fid;
-        
+
         if (( fid = H5Fopen(FNAME8OUT, H5F_ACC_RDONLY, H5P_DEFAULT)) < 0 )
             GOERROR;
         if ((fapl = H5Fget_access_plist(fid)) < 0)
@@ -1472,264 +1472,264 @@ int main (void)
             GOERROR;
         if (H5Fclose(fid) < 0)
             GOERROR;
-        
+
     }
-    
-    
+
+
     if(h5repack_end(&pack_options) < 0)
         GOERROR;
-    
-    
+
+
     PASSED();
 #else
     SKIPPED();
 #endif
-    
-    
-    
-    
-    
+
+
+
+
+
     /*-------------------------------------------------------------------------
     * clean temporary test files
     *-------------------------------------------------------------------------
     */
     {
         hid_t       fapl;
-        
+
         /* setup */
         h5_reset();
         fapl = h5_fileaccess();
         h5_cleanup(H5REPACK_FILENAMES, fapl);
-        
+
     }
-    
+
     puts("All h5repack tests passed.");
-    
+
     return 0;
-    
+
 error:
     puts("***** H5REPACK TESTS FAILED *****");
     return 1;
-    
+
 }
 
 
 /*-------------------------------------------------------------------------
- * Function: make_testfiles
- *
- * Purpose: make a test file with all types of HDF5 objects,
- *   datatypes and filters
- *
- *-------------------------------------------------------------------------
- */
+* Function: make_testfiles
+*
+* Purpose: make a test file with all types of HDF5 objects,
+*   datatypes and filters
+*
+*-------------------------------------------------------------------------
+*/
 int make_testfiles(void)
 {
-    hid_t  loc_id;  
-    
-    
+    hid_t  fid;  
+
     /*-------------------------------------------------------------------------
     * create a file for general copy test
     *-------------------------------------------------------------------------
     */
-    if((loc_id = H5Fcreate(FNAME0,H5F_ACC_TRUNC,H5P_DEFAULT,H5P_DEFAULT)) < 0)
+    if((fid = H5Fcreate(FNAME0,H5F_ACC_TRUNC,H5P_DEFAULT,H5P_DEFAULT)) < 0)
         return -1;
-    if (make_fill(loc_id) < 0)
+    if (make_fill(fid) < 0)
         goto out;
-    if(H5Fclose(loc_id) < 0)
+    if(H5Fclose(fid) < 0)
         return -1;
-    
+
     /*-------------------------------------------------------------------------
     * create another file for general copy test (all datatypes)
     *-------------------------------------------------------------------------
     */
-    if((loc_id = H5Fcreate(FNAME1,H5F_ACC_TRUNC,H5P_DEFAULT,H5P_DEFAULT)) < 0)
+    if((fid = H5Fcreate(FNAME1,H5F_ACC_TRUNC,H5P_DEFAULT,H5P_DEFAULT)) < 0)
         return -1;
-    if (make_all_objects(loc_id) < 0)
+    if (make_all_objects(fid) < 0)
         goto out;
-    if(H5Fclose(loc_id) < 0)
+    if(H5Fclose(fid) < 0)
         return -1;
-    
+
     /*-------------------------------------------------------------------------
     * create a file for attributes copy test
     *-------------------------------------------------------------------------
     */
-    if((loc_id = H5Fcreate(FNAME2,H5F_ACC_TRUNC,H5P_DEFAULT,H5P_DEFAULT)) < 0)
+    if((fid = H5Fcreate(FNAME2,H5F_ACC_TRUNC,H5P_DEFAULT,H5P_DEFAULT)) < 0)
         return -1;
-    if (make_attributes(loc_id) < 0)
+    if (make_attributes(fid) < 0)
         goto out;
-    if(H5Fclose(loc_id) < 0)
+    if(H5Fclose(fid) < 0)
         return -1;
-        
+
     /*-------------------------------------------------------------------------
     * create a file for hard links test
     *-------------------------------------------------------------------------
     */
-    if((loc_id = H5Fcreate(FNAME3,H5F_ACC_TRUNC,H5P_DEFAULT,H5P_DEFAULT)) < 0)
+    if((fid = H5Fcreate(FNAME3,H5F_ACC_TRUNC,H5P_DEFAULT,H5P_DEFAULT)) < 0)
         return -1;
-    if (make_hlinks(loc_id) < 0)
+    if (make_hlinks(fid) < 0)
         goto out;
-    if(H5Fclose(loc_id) < 0)
+    if(H5Fclose(fid) < 0)
         return -1;
-    
+
     /*-------------------------------------------------------------------------
     * create a file for layouts test
     *-------------------------------------------------------------------------
     */
-    if((loc_id = H5Fcreate(FNAME4,H5F_ACC_TRUNC,H5P_DEFAULT,H5P_DEFAULT)) < 0)
+    if((fid = H5Fcreate(FNAME4,H5F_ACC_TRUNC,H5P_DEFAULT,H5P_DEFAULT)) < 0)
         return -1;
-    if (make_layout(loc_id) < 0)
+    if (make_layout(fid) < 0)
         goto out;
-    if(H5Fclose(loc_id) < 0)
+    if(H5Fclose(fid) < 0)
         return -1;
-    
+
     /*-------------------------------------------------------------------------
     * create a file for the H5D_ALLOC_TIME_EARLY test
     *-------------------------------------------------------------------------
     */
     if (make_early() < 0)
         goto out;
-    
+
     /*-------------------------------------------------------------------------
     * create a file with the SZIP filter
     *-------------------------------------------------------------------------
     */
 #ifdef H5_HAVE_FILTER_SZIP
-    if((loc_id = H5Fcreate(FNAME7,H5F_ACC_TRUNC,H5P_DEFAULT,H5P_DEFAULT)) < 0)
+    if((fid = H5Fcreate(FNAME7,H5F_ACC_TRUNC,H5P_DEFAULT,H5P_DEFAULT)) < 0)
         return -1;
-    if (make_szip(loc_id) < 0)
+    if (make_szip(fid) < 0)
         goto out;
-    if(H5Fclose(loc_id) < 0)
+    if(H5Fclose(fid) < 0)
         return -1;
 #endif /* H5_HAVE_FILTER_SZIP */
-    
-        
+
+
     /*-------------------------------------------------------------------------
     * create a file with the deflate filter
     *-------------------------------------------------------------------------
     */
-    if((loc_id = H5Fcreate(FNAME8,H5F_ACC_TRUNC,H5P_DEFAULT,H5P_DEFAULT)) < 0)
+    if((fid = H5Fcreate(FNAME8,H5F_ACC_TRUNC,H5P_DEFAULT,H5P_DEFAULT)) < 0)
         return -1;
-    if (make_deflate(loc_id) < 0)
+    if (make_deflate(fid) < 0)
         goto out;
-    if(H5Fclose(loc_id) < 0)
+    if(H5Fclose(fid) < 0)
         return -1;
-    
+
     /*-------------------------------------------------------------------------
     * create a file with the shuffle filter
     *-------------------------------------------------------------------------
     */
-    if((loc_id = H5Fcreate(FNAME9,H5F_ACC_TRUNC,H5P_DEFAULT,H5P_DEFAULT)) < 0)
+    if((fid = H5Fcreate(FNAME9,H5F_ACC_TRUNC,H5P_DEFAULT,H5P_DEFAULT)) < 0)
         return -1;
-    if (make_shuffle(loc_id) < 0)
+    if (make_shuffle(fid) < 0)
         goto out;
-    if(H5Fclose(loc_id) < 0)
+    if(H5Fclose(fid) < 0)
         return -1;
-    
+
     /*-------------------------------------------------------------------------
     * create a file with the fletcher32 filter
     *-------------------------------------------------------------------------
     */
-    if((loc_id = H5Fcreate(FNAME10,H5F_ACC_TRUNC,H5P_DEFAULT,H5P_DEFAULT)) < 0)
+    if((fid = H5Fcreate(FNAME10,H5F_ACC_TRUNC,H5P_DEFAULT,H5P_DEFAULT)) < 0)
         return -1;
-    if (make_fletcher32(loc_id) < 0)
+    if (make_fletcher32(fid) < 0)
         goto out;
-    if(H5Fclose(loc_id) < 0)
+    if(H5Fclose(fid) < 0)
         return -1;
-    
+
     /*-------------------------------------------------------------------------
     * create a file with all the filters
     *-------------------------------------------------------------------------
     */
-    if((loc_id = H5Fcreate(FNAME11,H5F_ACC_TRUNC,H5P_DEFAULT,H5P_DEFAULT)) < 0)
+    if((fid = H5Fcreate(FNAME11,H5F_ACC_TRUNC,H5P_DEFAULT,H5P_DEFAULT)) < 0)
         return -1;
-    if (make_all(loc_id) < 0)
+    if (make_all(fid) < 0)
         goto out;
-    if(H5Fclose(loc_id) < 0)
+    if(H5Fclose(fid) < 0)
         return -1;
-    
+
     /*-------------------------------------------------------------------------
     * create a file with the nbit filter
     *-------------------------------------------------------------------------
     */
-    if((loc_id = H5Fcreate(FNAME12,H5F_ACC_TRUNC,H5P_DEFAULT,H5P_DEFAULT)) < 0)
+    if((fid = H5Fcreate(FNAME12,H5F_ACC_TRUNC,H5P_DEFAULT,H5P_DEFAULT)) < 0)
         return -1;
-    if (make_nbit(loc_id) < 0)
+    if (make_nbit(fid) < 0)
         goto out;
-    if(H5Fclose(loc_id) < 0)
+    if(H5Fclose(fid) < 0)
         return -1;
-    
+
     /*-------------------------------------------------------------------------
     * create a file with the scaleoffset filter
     *-------------------------------------------------------------------------
     */
-    if((loc_id = H5Fcreate(FNAME13,H5F_ACC_TRUNC,H5P_DEFAULT,H5P_DEFAULT)) < 0)
+    if((fid = H5Fcreate(FNAME13,H5F_ACC_TRUNC,H5P_DEFAULT,H5P_DEFAULT)) < 0)
         return -1;
-    if (make_scaleoffset(loc_id) < 0)
+    if (make_scaleoffset(fid) < 0)
         goto out;
-    if(H5Fclose(loc_id) < 0)
+    if(H5Fclose(fid) < 0)
         return -1;
-    
+
     /*-------------------------------------------------------------------------
     * create a big dataset
     *-------------------------------------------------------------------------
     */
-    if((loc_id = H5Fcreate(FNAME14,H5F_ACC_TRUNC,H5P_DEFAULT,H5P_DEFAULT)) < 0)
+    if((fid = H5Fcreate(FNAME14,H5F_ACC_TRUNC,H5P_DEFAULT,H5P_DEFAULT)) < 0)
         return -1;
-    if (make_big(loc_id) < 0)
+    if (make_big(fid) < 0)
         goto out;
-    if(H5Fclose(loc_id) < 0)
+    if(H5Fclose(fid) < 0)
         return -1;
-    
+
     /*-------------------------------------------------------------------------
     * create a file with external dataset
     *-------------------------------------------------------------------------
     */
-    if((loc_id = H5Fcreate(FNAME15,H5F_ACC_TRUNC,H5P_DEFAULT,H5P_DEFAULT)) < 0)
+    if((fid = H5Fcreate(FNAME15,H5F_ACC_TRUNC,H5P_DEFAULT,H5P_DEFAULT)) < 0)
         return -1;
-    if (make_external(loc_id) < 0)
+    if (make_external(fid) < 0)
         goto out;
-    if(H5Fclose(loc_id) < 0)
+    if(H5Fclose(fid) < 0)
         return -1;
-    
+
     /*-------------------------------------------------------------------------
     * create a file with userblock
     *-------------------------------------------------------------------------
     */
     if(make_userblock() < 0)
         goto out;
-    
+
     /*-------------------------------------------------------------------------
     * create a userblock file
     *-------------------------------------------------------------------------
     */
     if(make_userblock_file() < 0)
         goto out;
-    
+
     return 0;
-    
+
 out:
-    H5Fclose(loc_id);
+    H5Fclose(fid);
     return -1;
 }
 
 
 
 /*-------------------------------------------------------------------------
- * Function: make_all_objects
- *
- * Purpose: make a test file with all types of HDF5 objects
- *
- *-------------------------------------------------------------------------
- */
+* Function: make_all_objects
+*
+* Purpose: make a test file with all types of HDF5 objects
+*
+*-------------------------------------------------------------------------
+*/
 int make_all_objects(hid_t loc_id)
 {
-    hid_t   dset_id;
-    hid_t   group_id;
-    hid_t   type_id;
-    hid_t   root_id;
-    hid_t   space_id;
+    hid_t   did=-1;
+    hid_t   gid=-1;
+    hid_t   tid=-1;
+    hid_t   rid=-1;
+    hid_t   sid=-1;
+    hid_t   gcplid=-1;  
     hsize_t dims[1]={2};
-    /* Compound datatype */
+    /* compound datatype */
     typedef struct s_t
     {
         int    a;
@@ -1737,124 +1737,184 @@ int make_all_objects(hid_t loc_id)
     } s_t;
 
     /*-------------------------------------------------------------------------
-     * H5G_DATASET
-     *-------------------------------------------------------------------------
-     */
-    space_id = H5Screate_simple(1, dims, NULL);
-    dset_id  = H5Dcreate2(loc_id, "dset_referenced", H5T_NATIVE_INT, space_id, H5P_DEFAULT, H5P_DEFAULT, H5P_DEFAULT);
-    H5Sclose(space_id);
+    * H5G_DATASET
+    *-------------------------------------------------------------------------
+    */
+    if ((sid = H5Screate_simple(1, dims, NULL)) < 0)
+        goto out;
+    if ((did = H5Dcreate2(loc_id, "dset_referenced", H5T_NATIVE_INT, sid, H5P_DEFAULT, H5P_DEFAULT, H5P_DEFAULT)) < 0)
+        goto out;
+    
 
     /*-------------------------------------------------------------------------
-     * H5G_GROUP
-     *-------------------------------------------------------------------------
-     */
-    group_id  = H5Gcreate2(loc_id, "g1", H5P_DEFAULT, H5P_DEFAULT, H5P_DEFAULT);
-    root_id   = H5Gopen2(loc_id, "/", H5P_DEFAULT);
+    * H5G_GROUP
+    *-------------------------------------------------------------------------
+    */
+    if ((gid  = H5Gcreate2(loc_id, "g1", H5P_DEFAULT, H5P_DEFAULT, H5P_DEFAULT)) < 0)
+        goto out;
+    if (H5Gclose(gid) < 0)
+        goto out;    
 
-    /*-------------------------------------------------------------------------
-     * H5G_TYPE
-     *-------------------------------------------------------------------------
-     */
+    /* create a group "g2" with H5P_CRT_ORDER_TRACKED set */
+    if ((gcplid = H5Pcreate(H5P_GROUP_CREATE)) < 0)
+        goto out;
+    if (H5Pset_link_creation_order(gcplid, H5P_CRT_ORDER_TRACKED) < 0)
+        goto out;
+    if ((gid = H5Gcreate2(loc_id, "g2", H5P_DEFAULT, gcplid, H5P_DEFAULT)) < 0)
+        goto out;
+    if (H5Gclose(gid) < 0)
+        goto out;
 
-    /* Create a memory compound datatype */
-    type_id = H5Tcreate(H5T_COMPOUND, sizeof(s_t));
-    H5Tinsert(type_id, "a", HOFFSET(s_t, a), H5T_NATIVE_INT);
-    H5Tinsert(type_id, "b", HOFFSET(s_t, b), H5T_NATIVE_FLOAT);
+    /*-------------------------------------------------------------------------
+    * H5G_TYPE
+    *-------------------------------------------------------------------------
+    */
 
-    /* Commit compound datatype and close it */
-    H5Tcommit2(loc_id, "type", type_id, H5P_DEFAULT, H5P_DEFAULT, H5P_DEFAULT);
-    H5Tclose(type_id);
+    /* create a compound datatype */
+    if ((tid = H5Tcreate(H5T_COMPOUND, sizeof(s_t))) < 0)
+        goto out;
+    if (H5Tinsert(tid, "a", HOFFSET(s_t, a), H5T_NATIVE_INT) < 0)
+        goto out;
+    if (H5Tinsert(tid, "b", HOFFSET(s_t, b), H5T_NATIVE_FLOAT) < 0)
+        goto out;
+    if (H5Tcommit2(loc_id, "type", tid, H5P_DEFAULT, H5P_DEFAULT, H5P_DEFAULT) < 0)
+        goto out;
 
     /*-------------------------------------------------------------------------
-     * H5G_LINK
-     *-------------------------------------------------------------------------
-     */
+    * H5G_LINK
+    *-------------------------------------------------------------------------
+    */
 
-    H5Lcreate_soft("dset", loc_id, "link", H5P_DEFAULT, H5P_DEFAULT);
+    if (H5Lcreate_soft("dset", loc_id, "link", H5P_DEFAULT, H5P_DEFAULT) < 0)
+        goto out;
 
     /*-------------------------------------------------------------------------
-     * H5G_UDLINK
-     *-------------------------------------------------------------------------
-     */
+    * H5G_UDLINK
+    *-------------------------------------------------------------------------
+    */
     /* Create an external link. Other UD links are not supported by h5repack */
-    H5Lcreate_external("file", "path", loc_id, "ext_link", H5P_DEFAULT, H5P_DEFAULT);
+    if (H5Lcreate_external("file", "path", loc_id, "ext_link", H5P_DEFAULT, H5P_DEFAULT) < 0)
+        goto out;
 
     /*-------------------------------------------------------------------------
-     * write a series of datasetes
-     *-------------------------------------------------------------------------
-     */
+    * write a series of datasetes at root
+    *-------------------------------------------------------------------------
+    */
 
-    write_dset_in(root_id,"dset_referenced",loc_id,0);
+    if ((rid  = H5Gopen2(loc_id, "/", H5P_DEFAULT)) < 0)
+        goto out;
+    if (write_dset_in(rid,"dset_referenced",loc_id,0) < 0)
+        goto out;
+    if (H5Gclose(rid) < 0)
+        goto out;
 
-    /* Close */
-    H5Dclose(dset_id);
-    H5Gclose(group_id);
-    H5Gclose(root_id);
+    /* close */
+    if (H5Dclose(did) < 0)
+        goto out;
+    if (H5Sclose(sid) < 0)
+        goto out;
+    if (H5Tclose(tid) < 0)
+        goto out;
+    if (H5Pclose(gcplid) < 0)
+        goto out;
 
     return 0;
+
+out:
+    H5E_BEGIN_TRY 
+    {
+        H5Dclose(did);
+        H5Gclose(gid);
+        H5Gclose(rid);
+        H5Sclose(sid);
+        H5Tclose(tid);
+        H5Pclose(gcplid);
+    } H5E_END_TRY;
+    return -1;
 }
 
 
 /*-------------------------------------------------------------------------
- * Function: make_attributes
- *
- * Purpose: make a test file with all types of attributes
- *
- *-------------------------------------------------------------------------
- */
+* Function: make_attributes
+*
+* Purpose: make a test file with all types of attributes
+*
+*-------------------------------------------------------------------------
+*/
 int make_attributes(hid_t loc_id)
 {
-    hid_t   dset_id;
-    hid_t   group_id;
-    hid_t   root_id;
-    hid_t   space_id;
+    hid_t   did=-1;
+    hid_t   gid=-1;
+    hid_t   rid=-1;
+    hid_t   sid=-1;
     hsize_t dims[1]={2};
 
     /*-------------------------------------------------------------------------
     * H5G_DATASET
     *-------------------------------------------------------------------------
     */
-
-    space_id = H5Screate_simple(1, dims, NULL);
-    dset_id  = H5Dcreate2(loc_id, "dset", H5T_NATIVE_INT, space_id, H5P_DEFAULT, H5P_DEFAULT, H5P_DEFAULT);
-    H5Sclose(space_id);
+    if ((sid = H5Screate_simple(1, dims, NULL)) < 0)
+        goto out;
+    if ((did  = H5Dcreate2(loc_id, "dset", H5T_NATIVE_INT, sid, H5P_DEFAULT, H5P_DEFAULT, H5P_DEFAULT)) < 0)
+        goto out;    
 
     /*-------------------------------------------------------------------------
     * H5G_GROUP
     *-------------------------------------------------------------------------
     */
-    group_id  = H5Gcreate2(loc_id, "g1", H5P_DEFAULT, H5P_DEFAULT, H5P_DEFAULT);
-    root_id   = H5Gopen2(loc_id, "/", H5P_DEFAULT);
+    if ((gid  = H5Gcreate2(loc_id, "g1", H5P_DEFAULT, H5P_DEFAULT, H5P_DEFAULT)) < 0)
+        goto out;
+    if ((rid   = H5Gopen2(loc_id, "/", H5P_DEFAULT)) < 0)
+        goto out;
 
     /*-------------------------------------------------------------------------
     * write a series of attributes on the dataset, group, and root group
     *-------------------------------------------------------------------------
     */
 
-    write_attr_in(dset_id,"dset",loc_id,0);
-    write_attr_in(group_id,"dset",loc_id,0);
-    write_attr_in(root_id,"dset",loc_id,0);
-
-    /* Close */
-    H5Dclose(dset_id);
-    H5Gclose(group_id);
-    H5Gclose(root_id);
+    if ( write_attr_in(did,"dset",loc_id,0) < 0)
+        goto out;
+    if (write_attr_in(gid,"dset",loc_id,0) < 0)
+        goto out;
+    if (write_attr_in(rid,"dset",loc_id,0) < 0)
+        goto out;
 
+   /* close */
+    if (H5Dclose(did) < 0)
+        goto out;
+    if (H5Gclose(gid) < 0)
+        goto out;
+    if (H5Gclose(rid) < 0)
+        goto out;
+    if (H5Sclose(sid) < 0)
+        goto out;
+ 
     return 0;
+
+out:
+    H5E_BEGIN_TRY 
+    {
+        H5Dclose(did);
+        H5Gclose(gid);
+        H5Gclose(rid);
+        H5Sclose(sid);
+    } H5E_END_TRY;
+    return -1;
+
 }
 
 /*-------------------------------------------------------------------------
- * Function: make_hlinks
- *
- * Purpose: make a test file with hard links
- *
- *-------------------------------------------------------------------------
- */
+* Function: make_hlinks
+*
+* Purpose: make a test file with hard links
+*
+*-------------------------------------------------------------------------
+*/
 int make_hlinks(hid_t loc_id)
 {
-    hid_t   group1_id;
-    hid_t   group2_id;
-    hid_t   group3_id;
+    hid_t   g1id=-1;
+    hid_t   g2id=-1;
+    hid_t   g3id=-1;
     hsize_t dims[2]={3,2};
     int     buf[3][2]= {{1,1},{1,2},{2,2}};
 
@@ -1872,39 +1932,53 @@ int make_hlinks(hid_t loc_id)
     if(H5Lcreate_hard(loc_id, "dset", H5L_SAME_LOC, "link3 to dset", H5P_DEFAULT, H5P_DEFAULT) < 0)
         return -1;
 
-
     /*-------------------------------------------------------------------------
     * create a group and some hard links to it
     *-------------------------------------------------------------------------
     */
 
-    if((group1_id = H5Gcreate2(loc_id, "g1", H5P_DEFAULT, H5P_DEFAULT, H5P_DEFAULT)) < 0)
-        return -1;
-    if((group2_id = H5Gcreate2(group1_id, "g2", H5P_DEFAULT, H5P_DEFAULT, H5P_DEFAULT)) < 0)
-        return -1;
-    if((group3_id = H5Gcreate2(group2_id, "g3", H5P_DEFAULT, H5P_DEFAULT, H5P_DEFAULT)) < 0)
-        return -1;
+    if((g1id = H5Gcreate2(loc_id, "g1", H5P_DEFAULT, H5P_DEFAULT, H5P_DEFAULT)) < 0)
+        goto out;
+    if((g2id = H5Gcreate2(g1id, "g2", H5P_DEFAULT, H5P_DEFAULT, H5P_DEFAULT)) < 0)
+        goto out;
+    if((g3id = H5Gcreate2(g2id, "g3", H5P_DEFAULT, H5P_DEFAULT, H5P_DEFAULT)) < 0)
+        goto out;
 
-    if(H5Lcreate_hard(loc_id, "g1", group2_id, "link1 to g1", H5P_DEFAULT, H5P_DEFAULT) < 0)
-        return -1;
-    if(H5Lcreate_hard(group1_id, "g2", group3_id, "link1 to g2", H5P_DEFAULT, H5P_DEFAULT) < 0)
-        return -1;
+    if(H5Lcreate_hard(loc_id, "g1", g2id, "link1 to g1", H5P_DEFAULT, H5P_DEFAULT) < 0)
+        goto out;
+    if(H5Lcreate_hard(g1id, "g2", g3id, "link1 to g2", H5P_DEFAULT, H5P_DEFAULT) < 0)
+        goto out;
 
-    H5Gclose(group1_id);
-    H5Gclose(group2_id);
-    H5Gclose(group3_id);
 
+    /* close */
+    if (H5Gclose(g1id) < 0)
+        goto out;
+    if (H5Gclose(g2id) < 0)
+        goto out;
+    if (H5Gclose(g3id) < 0)
+        goto out;
+ 
     return 0;
+
+out:
+    H5E_BEGIN_TRY 
+    {
+        H5Gclose(g1id);
+        H5Gclose(g2id);
+        H5Gclose(g3id);
+    } H5E_END_TRY;
+    return -1;
+
 }
 
 
 /*-------------------------------------------------------------------------
- * Function: make_szip
- *
- * Purpose: make a dataset with the SZIP filter
- *
- *-------------------------------------------------------------------------
- */
+* Function: make_szip
+*
+* Purpose: make a dataset with the SZIP filter
+*
+*-------------------------------------------------------------------------
+*/
 #ifdef H5_HAVE_FILTER_SZIP
 int make_szip(hid_t loc_id)
 {
@@ -1916,8 +1990,8 @@ int make_szip(hid_t loc_id)
     hsize_t  chunk_dims[RANK]={CDIM1,CDIM2};
     int      buf[DIM1][DIM2];
     int      i, j, n;
-    int szip_can_encode = 0;
-    
+    int      szip_can_encode = 0;
+
     for (i=n=0; i<DIM1; i++)
     {
         for (j=0; j<DIM2; j++)
@@ -1934,7 +2008,7 @@ int make_szip(hid_t loc_id)
     /* set up chunk */
     if(H5Pset_chunk(dcpl, RANK, chunk_dims) < 0)
         goto out;
-    
+
     /*-------------------------------------------------------------------------
     * SZIP
     *-------------------------------------------------------------------------
@@ -1956,14 +2030,14 @@ int make_szip(hid_t loc_id)
     {
         /* WARNING? SZIP is decoder only, can't generate test files */
     }
-    
+
     if(H5Sclose(sid) < 0)
         goto out;
     if(H5Pclose(dcpl) < 0)
         goto out;
-    
+
     return 0;
-    
+
 out:
     H5E_BEGIN_TRY {
         H5Pclose(dcpl);
@@ -1976,12 +2050,12 @@ out:
 
 
 /*-------------------------------------------------------------------------
- * Function: make_deflate
- *
- * Purpose: make a dataset with the deflate filter
- *
- *-------------------------------------------------------------------------
- */
+* Function: make_deflate
+*
+* Purpose: make a dataset with the deflate filter
+*
+*-------------------------------------------------------------------------
+*/
 int make_deflate(hid_t loc_id)
 {
     hid_t      dcpl; /* dataset creation property list */
@@ -1992,7 +2066,7 @@ int make_deflate(hid_t loc_id)
     hobj_ref_t bufref[1]; /* reference */
     hsize_t    dims1r[1]={1};
     int        i, j, n;
-    
+
     for (i=n=0; i<DIM1; i++)
     {
         for (j=0; j<DIM2; j++)
@@ -2000,7 +2074,7 @@ int make_deflate(hid_t loc_id)
             buf[i][j]=n++;
         }
     }
-    
+
     /* create a space */
     if((sid = H5Screate_simple(RANK, dims, NULL)) < 0)
         return -1;
@@ -2010,7 +2084,7 @@ int make_deflate(hid_t loc_id)
     /* set up chunk */
     if(H5Pset_chunk(dcpl, RANK, chunk_dims) < 0)
         goto out;
-        
+
     /*-------------------------------------------------------------------------
     * GZIP
     *-------------------------------------------------------------------------
@@ -2021,16 +2095,16 @@ int make_deflate(hid_t loc_id)
         goto out;
     if (make_dset(loc_id,"dset_deflate",sid,dcpl,buf) < 0)
         goto out;
-    
+
     /* create a reference to the dataset, test second seeep of file for references */
-    
+
     if (H5Rcreate(&bufref[0],loc_id,"dset_deflate",H5R_OBJECT,-1) < 0)
         goto out;
     if (write_dset(loc_id,1,dims1r,"ref",H5T_STD_REF_OBJ,bufref) < 0)
         goto out;
 #endif
-    
-        
+
+
     /*-------------------------------------------------------------------------
     * close space and dcpl
     *-------------------------------------------------------------------------
@@ -2039,9 +2113,9 @@ int make_deflate(hid_t loc_id)
         goto out;
     if(H5Pclose(dcpl) < 0)
         goto out;
-    
+
     return 0;
-    
+
 out:
     H5E_BEGIN_TRY {
         H5Pclose(dcpl);
@@ -2052,12 +2126,12 @@ out:
 
 
 /*-------------------------------------------------------------------------
- * Function: make_shuffle
- *
- * Purpose: make a dataset with the shuffle filter
- *
- *-------------------------------------------------------------------------
- */
+* Function: make_shuffle
+*
+* Purpose: make a dataset with the shuffle filter
+*
+*-------------------------------------------------------------------------
+*/
 int make_shuffle(hid_t loc_id)
 {
     hid_t    dcpl; /* dataset creation property list */
@@ -2066,7 +2140,7 @@ int make_shuffle(hid_t loc_id)
     hsize_t  chunk_dims[RANK]={CDIM1,CDIM2};
     int      buf[DIM1][DIM2];
     int      i, j, n;
-    
+
     for (i=n=0; i<DIM1; i++)
     {
         for (j=0; j<DIM2; j++)
@@ -2083,7 +2157,7 @@ int make_shuffle(hid_t loc_id)
     /* set up chunk */
     if(H5Pset_chunk(dcpl, RANK, chunk_dims) < 0)
         goto out;
-    
+
     /*-------------------------------------------------------------------------
     * shuffle
     *-------------------------------------------------------------------------
@@ -2095,8 +2169,8 @@ int make_shuffle(hid_t loc_id)
     if (make_dset(loc_id,"dset_shuffle",sid,dcpl,buf) < 0)
         goto out;
 #endif
-    
-        
+
+
     /*-------------------------------------------------------------------------
     * close space and dcpl
     *-------------------------------------------------------------------------
@@ -2105,9 +2179,9 @@ int make_shuffle(hid_t loc_id)
         goto out;
     if(H5Pclose(dcpl) < 0)
         goto out;
-    
+
     return 0;
-    
+
 out:
     H5E_BEGIN_TRY {
         H5Pclose(dcpl);
@@ -2117,12 +2191,12 @@ out:
 }
 
 /*-------------------------------------------------------------------------
- * Function: make_fletcher32
- *
- * Purpose: make a dataset with the fletcher32 filter
- *
- *-------------------------------------------------------------------------
- */
+* Function: make_fletcher32
+*
+* Purpose: make a dataset with the fletcher32 filter
+*
+*-------------------------------------------------------------------------
+*/
 int make_fletcher32(hid_t loc_id)
 {
     hid_t    dcpl; /* dataset creation property list */
@@ -2131,7 +2205,7 @@ int make_fletcher32(hid_t loc_id)
     hsize_t  chunk_dims[RANK]={CDIM1,CDIM2};
     int      buf[DIM1][DIM2];
     int      i, j, n;
-    
+
     for (i=n=0; i<DIM1; i++)
     {
         for (j=0; j<DIM2; j++)
@@ -2148,8 +2222,8 @@ int make_fletcher32(hid_t loc_id)
     /* set up chunk */
     if(H5Pset_chunk(dcpl, RANK, chunk_dims) < 0)
         goto out;
-    
-    
+
+
     /*-------------------------------------------------------------------------
     * fletcher32
     *-------------------------------------------------------------------------
@@ -2164,7 +2238,7 @@ int make_fletcher32(hid_t loc_id)
     if (make_dset(loc_id,"dset_fletcher32",sid,dcpl,buf) < 0)
         goto out;
 #endif
-    
+
     /*-------------------------------------------------------------------------
     * close space and dcpl
     *-------------------------------------------------------------------------
@@ -2173,9 +2247,9 @@ int make_fletcher32(hid_t loc_id)
         goto out;
     if(H5Pclose(dcpl) < 0)
         goto out;
-    
+
     return 0;
-    
+
 out:
     H5E_BEGIN_TRY {
         H5Pclose(dcpl);
@@ -2186,12 +2260,12 @@ out:
 
 
 /*-------------------------------------------------------------------------
- * Function: make_nbit
- *
- * Purpose: make a dataset with the nbit filter
- *
- *-------------------------------------------------------------------------
- */
+* Function: make_nbit
+*
+* Purpose: make a dataset with the nbit filter
+*
+*-------------------------------------------------------------------------
+*/
 int make_nbit(hid_t loc_id)
 {
     hid_t    dcpl; /* dataset creation property list */
@@ -2202,7 +2276,7 @@ int make_nbit(hid_t loc_id)
     hsize_t  chunk_dims[RANK]={CDIM1,CDIM2};
     int      buf[DIM1][DIM2];
     int      i, j, n;
-    
+
     for (i=n=0; i<DIM1; i++)
     {
         for (j=0; j<DIM2; j++)
@@ -2219,14 +2293,14 @@ int make_nbit(hid_t loc_id)
     /* set up chunk */
     if(H5Pset_chunk(dcpl, RANK, chunk_dims) < 0)
         goto out;
-    
+
     dtid = H5Tcopy(H5T_NATIVE_INT);
     if (H5Tset_precision(dtid,(H5Tget_precision(dtid) - 1)) < 0)
     {
         H5Tclose(dtid);
         goto out;
     }
-    
+
 #if defined H5_HAVE_FILTER_NBIT
     /* remove the filters from the dcpl */
     if(H5Premove_filter(dcpl, H5Z_FILTER_ALL) < 0)
@@ -2247,7 +2321,7 @@ int make_nbit(hid_t loc_id)
         goto out;
     }
     H5Dclose(dsid);
-    
+
     if(H5Premove_filter(dcpl, H5Z_FILTER_ALL) < 0) {
         H5Tclose(dtid);
         goto out;
@@ -2262,7 +2336,7 @@ int make_nbit(hid_t loc_id)
     }
     H5Dclose(dsid);
 #endif
-    
+
     /*-------------------------------------------------------------------------
     * close
     *-------------------------------------------------------------------------
@@ -2273,9 +2347,9 @@ int make_nbit(hid_t loc_id)
         goto out;
     if (H5Tclose(dtid) < 0)
         goto out;
-    
+
     return 0;
-    
+
 out:
     H5E_BEGIN_TRY {
         H5Pclose(dcpl);
@@ -2286,12 +2360,12 @@ out:
 
 
 /*-------------------------------------------------------------------------
- * Function: make_scaleoffset
- *
- * Purpose: make a dataset with the scaleoffset filter
- *
- *-------------------------------------------------------------------------
- */
+* Function: make_scaleoffset
+*
+* Purpose: make a dataset with the scaleoffset filter
+*
+*-------------------------------------------------------------------------
+*/
 int make_scaleoffset(hid_t loc_id)
 {
     hid_t    dcpl; /* dataset creation property list */
@@ -2302,7 +2376,7 @@ int make_scaleoffset(hid_t loc_id)
     hsize_t  chunk_dims[RANK]={CDIM1,CDIM2};
     int      buf[DIM1][DIM2];
     int      i, j, n;
-    
+
     for (i=n=0; i<DIM1; i++)
     {
         for (j=0; j<DIM2; j++)
@@ -2319,9 +2393,9 @@ int make_scaleoffset(hid_t loc_id)
     /* set up chunk */
     if(H5Pset_chunk(dcpl, RANK, chunk_dims) < 0)
         goto out;
-    
+
     dtid = H5Tcopy(H5T_NATIVE_INT);
-    
+
 #if defined (H5_HAVE_FILTER_SCALEOFFSET)
     /* remove the filters from the dcpl */
     if(H5Premove_filter(dcpl, H5Z_FILTER_ALL) < 0) {
@@ -2352,7 +2426,7 @@ int make_scaleoffset(hid_t loc_id)
     H5Tclose(dtid);
     H5Dclose(dsid);
 #endif
-    
+
     /*-------------------------------------------------------------------------
     * close space and dcpl
     *-------------------------------------------------------------------------
@@ -2361,9 +2435,9 @@ int make_scaleoffset(hid_t loc_id)
         goto out;
     if(H5Pclose(dcpl) < 0)
         goto out;
-    
+
     return 0;
-    
+
 out:
     H5E_BEGIN_TRY {
         H5Pclose(dcpl);
@@ -2374,12 +2448,12 @@ out:
 
 
 /*-------------------------------------------------------------------------
- * Function: make_all
- *
- * Purpose: make a file with all filters
- *
- *-------------------------------------------------------------------------
- */
+* Function: make_all
+*
+* Purpose: make a file with all filters
+*
+*-------------------------------------------------------------------------
+*/
 int make_all(hid_t loc_id)
 {
     hid_t    dcpl; /* dataset creation property list */
@@ -2399,7 +2473,7 @@ int make_all(hid_t loc_id)
 #if defined (H5_HAVE_FILTER_SZIP)
     int szip_can_encode = 0;
 #endif
-    
+
     for (i=n=0; i<DIM1; i++)
     {
         for (j=0; j<DIM2; j++)
@@ -2414,26 +2488,28 @@ int make_all(hid_t loc_id)
     if ((dcpl = H5Pcreate(H5P_DATASET_CREATE)) < 0)
         goto out;
     /* set up chunk */
-    if(H5Pset_chunk(dcpl, RANK, chunk_dims) < 0)
+    if (H5Pset_chunk(dcpl, RANK, chunk_dims) < 0)
         goto out;
-    
+
 #if defined (H5_HAVE_FILTER_SHUFFLE)
     /* set the shuffle filter */
     if (H5Pset_shuffle(dcpl) < 0)
         goto out;
 #endif
-    
+
 #if defined (H5_HAVE_FILTER_FLETCHER32)
     /* set the checksum filter */
     if (H5Pset_fletcher32(dcpl) < 0)
         goto out;
 #endif
-    
+
 #if defined (H5_HAVE_FILTER_SZIP)
-    if (h5tools_can_encode(H5Z_FILTER_SZIP) == 1) {
+    if (h5tools_can_encode(H5Z_FILTER_SZIP) == 1) 
+    {
         szip_can_encode = 1;
     }
-    if (szip_can_encode) {
+    if (szip_can_encode) 
+    {
         /* set szip data */
         if(H5Pset_szip (dcpl,szip_options_mask,szip_pixels_per_block) < 0)
             goto out;
@@ -2441,16 +2517,16 @@ int make_all(hid_t loc_id)
         /* WARNING? SZIP is decoder only, can't generate test data using szip */
     }
 #endif
-    
+
 #if defined (H5_HAVE_FILTER_DEFLATE)
     /* set deflate data */
     if(H5Pset_deflate(dcpl, 9) < 0)
         goto out;
 #endif
-    
+
     if (make_dset(loc_id,"dset_all",sid,dcpl,buf) < 0)
         goto out;
-    
+
 #if defined (H5_HAVE_FILTER_FLETCHER32)
     /* remove the filters from the dcpl */
     if (H5Premove_filter(dcpl,H5Z_FILTER_ALL) < 0)
@@ -2461,11 +2537,12 @@ int make_all(hid_t loc_id)
     if (make_dset(loc_id,"dset_fletcher32",sid,dcpl,buf) < 0)
         goto out;
 #endif
-    
-       
+
+
     /* Make sure encoding is enabled */
 #if defined (H5_HAVE_FILTER_SZIP)
-    if (szip_can_encode) {
+    if (szip_can_encode) 
+    {
         /* remove the filters from the dcpl */
         if (H5Premove_filter(dcpl,H5Z_FILTER_ALL) < 0)
             goto out;
@@ -2474,12 +2551,13 @@ int make_all(hid_t loc_id)
             goto out;
         if (make_dset(loc_id,"dset_szip",sid,dcpl,buf) < 0)
             goto out;
-    } else {
+    } else 
+    {
         /* WARNING? SZIP is decoder only, can't generate test dataset */
     }
 #endif
-    
-   
+
+
 #if defined (H5_HAVE_FILTER_SHUFFLE)
     /* remove the filters from the dcpl */
     if (H5Premove_filter(dcpl,H5Z_FILTER_ALL) < 0)
@@ -2490,8 +2568,8 @@ int make_all(hid_t loc_id)
     if (make_dset(loc_id,"dset_shuffle",sid,dcpl,buf) < 0)
         goto out;
 #endif
-    
-       
+
+
 #if defined (H5_HAVE_FILTER_DEFLATE)
     /* remove the filters from the dcpl */
     if (H5Premove_filter(dcpl,H5Z_FILTER_ALL) < 0)
@@ -2502,40 +2580,43 @@ int make_all(hid_t loc_id)
     if (make_dset(loc_id,"dset_deflate",sid,dcpl,buf) < 0)
         goto out;
 #endif
-    
-    
-      
+
+
+
 #if defined (H5_HAVE_FILTER_NBIT)
     /* remove the filters from the dcpl */
-    if(H5Premove_filter(dcpl, H5Z_FILTER_ALL) < 0)
+    if (H5Premove_filter(dcpl, H5Z_FILTER_ALL) < 0)
         goto out;
     /* set the shuffle filter */
-    if(H5Pset_nbit(dcpl) < 0)
+    if (H5Pset_nbit(dcpl) < 0)
+        goto out;
+    if ((dtid = H5Tcopy(H5T_NATIVE_INT)) < 0)
+        goto out;
+    if (H5Tset_precision(dtid, (H5Tget_precision(dtid) - 1)) < 0)
         goto out;
-    dtid = H5Tcopy(H5T_NATIVE_INT);
-    H5Tset_precision(dtid, (H5Tget_precision(dtid) - 1));
     if((dsid = H5Dcreate2(loc_id, "dset_nbit", dtid, sid, H5P_DEFAULT, dcpl, H5P_DEFAULT)) < 0)
         goto out;
     if(H5Dwrite(dsid, dtid, H5S_ALL, H5S_ALL, H5P_DEFAULT, buf) < 0)
         goto out;
-    
+
     /* close */
     if(H5Tclose(dtid) < 0)
         return -1;
     if(H5Dclose(dsid) < 0)
         return -1;
 #endif
-    
-        
+
+
     if(H5Sclose(sid) < 0)
         goto out;
     if(H5Pclose(dcpl) < 0)
         goto out;
-    
+
     return 0;
-    
+
 out:
-    H5E_BEGIN_TRY {
+    H5E_BEGIN_TRY 
+    {
         H5Pclose(dcpl);
         H5Sclose(sid);
     } H5E_END_TRY;
@@ -2545,18 +2626,18 @@ out:
 
 
 /*-------------------------------------------------------------------------
- * Function: make_early
- *
- * Purpose: create a file for the H5D_ALLOC_TIME_EARLY test
- *
- *-------------------------------------------------------------------------
- */
+* Function: make_early
+*
+* Purpose: create a file for the H5D_ALLOC_TIME_EARLY test
+*
+*-------------------------------------------------------------------------
+*/
 int make_early(void)
 {
     hsize_t dims[1] ={3000};
     hsize_t cdims[1]={30};
     hid_t   fid=-1;
-    hid_t   dset_id=-1;
+    hid_t   did=-1;
     hid_t   sid=-1;
     hid_t   tid=-1;
     hid_t   dcpl=-1;
@@ -2564,37 +2645,38 @@ int make_early(void)
     char    name[10];
     int     iter=100;
 
-    if((fid = H5Fcreate(FNAME5, H5F_ACC_TRUNC, H5P_DEFAULT, H5P_DEFAULT)) < 0)
+    if ((fid = H5Fcreate(FNAME5, H5F_ACC_TRUNC, H5P_DEFAULT, H5P_DEFAULT)) < 0)
         return -1;
-    if(H5Fclose(fid) < 0)
+    if (H5Fclose(fid) < 0)
         goto out;
 
-    if((sid = H5Screate_simple(1, dims, NULL)) < 0)
+    if ((sid = H5Screate_simple(1, dims, NULL)) < 0)
         goto out;
-    if((dcpl = H5Pcreate(H5P_DATASET_CREATE)) < 0)
+    if ((dcpl = H5Pcreate(H5P_DATASET_CREATE)) < 0)
         goto out;
-    if(H5Pset_chunk(dcpl, 1, cdims) < 0)
+    if (H5Pset_chunk(dcpl, 1, cdims) < 0)
         goto out;
-    if(H5Pset_alloc_time(dcpl, H5D_ALLOC_TIME_EARLY) < 0)
+    if (H5Pset_alloc_time(dcpl, H5D_ALLOC_TIME_EARLY) < 0)
         goto out;
 
-    for(i = 0; i < iter; i++) {
-        if((fid = H5Fopen(FNAME5, H5F_ACC_RDWR, H5P_DEFAULT)) < 0)
+    for(i = 0; i < iter; i++) 
+    {
+        if ((fid = H5Fopen(FNAME5, H5F_ACC_RDWR, H5P_DEFAULT)) < 0)
             goto out;
-        if((dset_id = H5Dcreate2(fid, "early", H5T_NATIVE_DOUBLE, sid, H5P_DEFAULT, dcpl, H5P_DEFAULT)) < 0)
+        if ((did = H5Dcreate2(fid, "early", H5T_NATIVE_DOUBLE, sid, H5P_DEFAULT, dcpl, H5P_DEFAULT)) < 0)
             goto out;
-        if((tid = H5Tcopy(H5T_NATIVE_DOUBLE)) < 0)
+        if ((tid = H5Tcopy(H5T_NATIVE_DOUBLE)) < 0)
             goto out;
         sprintf(name, "%d", i);
-        if((H5Tcommit2(fid, name, tid, H5P_DEFAULT, H5P_DEFAULT, H5P_DEFAULT)) < 0)
+        if ((H5Tcommit2(fid, name, tid, H5P_DEFAULT, H5P_DEFAULT, H5P_DEFAULT)) < 0)
             goto out;
-        if(H5Tclose(tid) < 0)
+        if (H5Tclose(tid) < 0)
             goto out;
-        if(H5Dclose(dset_id) < 0)
+        if (H5Dclose(did) < 0)
             goto out;
-        if(H5Ldelete(fid, "early", H5P_DEFAULT) < 0)
+        if (H5Ldelete(fid, "early", H5P_DEFAULT) < 0)
             goto out;
-        if(H5Fclose(fid) < 0)
+        if (H5Fclose(fid) < 0)
             goto out;
     }
 
@@ -2603,34 +2685,36 @@ int make_early(void)
     *-------------------------------------------------------------------------
     */
 
-    if((fid = H5Fcreate(FNAME6, H5F_ACC_TRUNC, H5P_DEFAULT, H5P_DEFAULT)) < 0)
+    if ((fid = H5Fcreate(FNAME6, H5F_ACC_TRUNC, H5P_DEFAULT, H5P_DEFAULT)) < 0)
         return -1;
 
-    for(i = 0; i < iter; i++) {
-        if((tid = H5Tcopy(H5T_NATIVE_DOUBLE)) < 0)
+    for(i = 0; i < iter; i++) 
+    {
+        if ((tid = H5Tcopy(H5T_NATIVE_DOUBLE)) < 0)
             goto out;
         sprintf(name, "%d", i);
-        if((H5Tcommit2(fid, name, tid, H5P_DEFAULT, H5P_DEFAULT, H5P_DEFAULT)) < 0)
+        if ((H5Tcommit2(fid, name, tid, H5P_DEFAULT, H5P_DEFAULT, H5P_DEFAULT)) < 0)
             goto out;
-        if(H5Tclose(tid) < 0)
+        if (H5Tclose(tid) < 0)
             goto out;
     }
 
-    if(H5Sclose(sid) < 0)
+    if (H5Sclose(sid) < 0)
         goto out;
-    if(H5Pclose(dcpl) < 0)
+    if (H5Pclose(dcpl) < 0)
         goto out;
-    if(H5Fclose(fid) < 0)
+    if (H5Fclose(fid) < 0)
         goto out;
 
     return 0;
 
 out:
-    H5E_BEGIN_TRY {
+    H5E_BEGIN_TRY 
+    {
         H5Tclose(tid);
         H5Pclose(dcpl);
         H5Sclose(sid);
-        H5Dclose(dset_id);
+        H5Dclose(did);
         H5Fclose(fid);
     } H5E_END_TRY;
     return -1;
@@ -2638,23 +2722,23 @@ out:
 
 
 /*-------------------------------------------------------------------------
- * Function: make_layout
- *
- * Purpose: make several datasets with several layouts in location LOC_ID
- *
- *-------------------------------------------------------------------------
- */
+* Function: make_layout
+*
+* Purpose: make several datasets with several layouts in location LOC_ID
+*
+*-------------------------------------------------------------------------
+*/
 int make_layout(hid_t loc_id)
 {
-    hid_t    dcpl; /* dataset creation property list */
-    hid_t    sid;  /* dataspace ID */
+    hid_t    dcpl=-1; /* dataset creation property list */
+    hid_t    sid=-1;  /* dataspace ID */
     hsize_t  dims[RANK]={DIM1,DIM2};
     hsize_t  chunk_dims[RANK]={CDIM1,CDIM2};
     int      buf[DIM1][DIM2];
     int      i, j, n;
     char     name[6];
-    
-    
+
+
     for (i=n=0; i<DIM1; i++)
     {
         for (j=0; j<DIM2; j++)
@@ -2662,7 +2746,7 @@ int make_layout(hid_t loc_id)
             buf[i][j]=n++;
         }
     }
-    
+
     /*-------------------------------------------------------------------------
     * make several dataset with no filters
     *-------------------------------------------------------------------------
@@ -2673,8 +2757,8 @@ int make_layout(hid_t loc_id)
         if (write_dset(loc_id,RANK,dims,name,H5T_NATIVE_INT,buf) < 0)
             return -1;
     }
-    
-    
+
+
     /*-------------------------------------------------------------------------
     * make several dataset with several layout options
     *-------------------------------------------------------------------------
@@ -2687,7 +2771,7 @@ int make_layout(hid_t loc_id)
     {
         goto out;
     }
-    
+
     /*-------------------------------------------------------------------------
     * H5D_COMPACT
     *-------------------------------------------------------------------------
@@ -2698,7 +2782,7 @@ int make_layout(hid_t loc_id)
     {
         goto out;
     }
-    
+
     /*-------------------------------------------------------------------------
     * H5D_CONTIGUOUS
     *-------------------------------------------------------------------------
@@ -2709,7 +2793,7 @@ int make_layout(hid_t loc_id)
     {
         goto out;
     }
-    
+
     /*-------------------------------------------------------------------------
     * H5D_CHUNKED
     *-------------------------------------------------------------------------
@@ -2720,7 +2804,7 @@ int make_layout(hid_t loc_id)
     {
         goto out;
     }
-    
+
     /*-------------------------------------------------------------------------
     * close space and dcpl
     *-------------------------------------------------------------------------
@@ -2729,11 +2813,12 @@ int make_layout(hid_t loc_id)
         goto out;
     if(H5Pclose(dcpl) < 0)
         goto out;
-    
+
     return 0;
-    
+
 out:
-    H5E_BEGIN_TRY {
+    H5E_BEGIN_TRY 
+    {
         H5Pclose(dcpl);
         H5Sclose(sid);
     } H5E_END_TRY;
@@ -2741,12 +2826,12 @@ out:
 }
 
 /*-------------------------------------------------------------------------
- * Function: make a file with an integer dataset with a fill value
- *
- * Purpose: test copy of fill values
- *
- *-------------------------------------------------------------------------
- */
+* Function: make a file with an integer dataset with a fill value
+*
+* Purpose: test copy of fill values
+*
+*-------------------------------------------------------------------------
+*/
 int make_fill(hid_t loc_id)
 {
     hid_t   did=-1;
@@ -2755,7 +2840,7 @@ int make_fill(hid_t loc_id)
     hsize_t dims[2]={3,2};
     int     buf[3][2]= {{1,1},{1,2},{2,2}};
     int     fillvalue = 2;
-    
+
     /*-------------------------------------------------------------------------
     * H5T_INTEGER, write a fill value
     *-------------------------------------------------------------------------
@@ -2770,7 +2855,7 @@ int make_fill(hid_t loc_id)
         goto out;
     if(H5Dwrite(did, H5T_NATIVE_INT, H5S_ALL, H5S_ALL, H5P_DEFAULT, buf) < 0)
         goto out;
-    
+
     /* close */
     if(H5Sclose(sid) < 0)
         goto out;
@@ -2778,9 +2863,9 @@ int make_fill(hid_t loc_id)
         goto out;
     if(H5Dclose(did) < 0)
         goto out;
-    
+
     return 0;
-    
+
 out:
     H5E_BEGIN_TRY {
         H5Pclose(dcpl);
@@ -2792,13 +2877,13 @@ out:
 }
 
 /*-------------------------------------------------------------------------
- * Function: make_big
- *
- * Purpose: used in test read by hyperslabs. Creates a 128MB dataset.
- *  Only 1 1024Kb hyperslab is written.
- *
- *-------------------------------------------------------------------------
- */
+* Function: make_big
+*
+* Purpose: used in test read by hyperslabs. Creates a 128MB dataset.
+*  Only 1 1024Kb hyperslab is written.
+*
+*-------------------------------------------------------------------------
+*/
 
 int make_big(hid_t loc_id)
 {
@@ -2815,11 +2900,11 @@ int make_big(hid_t loc_id)
     size_t  nelmts=(size_t)1024;
     signed  char fillvalue=-1;
     signed  char *buf=NULL;
-    
+
     /* write one 1024 byte hyperslab */
     hs_start[0] = 0;
     hs_size[0]  = 1024;
-    
+
     /* create */
     if((dcpl = H5Pcreate(H5P_DATASET_CREATE)) < 0)
         goto out;
@@ -2837,18 +2922,18 @@ int make_big(hid_t loc_id)
         goto out;
     if((size = H5Tget_size(tid))<=0)
         goto out;
-    
+
     /* initialize buffer to 0  */
     buf=(signed  char *) calloc( nelmts, size);
-    
+
     if (H5Sselect_hyperslab (f_sid,H5S_SELECT_SET,hs_start,NULL,hs_size, NULL) < 0)
         goto out;
     if (H5Dwrite (did,H5T_NATIVE_SCHAR,m_sid,f_sid,H5P_DEFAULT,buf) < 0)
         goto out;
-    
+
     free(buf);
     buf=NULL;
-    
+
     /* close */
     if(H5Sclose(f_sid) < 0)
         goto out;
@@ -2858,9 +2943,9 @@ int make_big(hid_t loc_id)
         goto out;
     if(H5Dclose(did) < 0)
         goto out;
-    
+
     return 0;
-    
+
 out:
     H5E_BEGIN_TRY {
         H5Pclose(dcpl);
@@ -2874,12 +2959,12 @@ out:
 
 
 /*-------------------------------------------------------------------------
- * Function: make_external
- *
- * Purpose: create a external dataset
- *
- *-------------------------------------------------------------------------
- */
+* Function: make_external
+*
+* Purpose: create a external dataset
+*
+*-------------------------------------------------------------------------
+*/
 
 int make_external(hid_t loc_id)
 {
@@ -2890,10 +2975,10 @@ int make_external(hid_t loc_id)
     hsize_t cur_size[1];		/* data space current size	*/
     hsize_t max_size[1];		/* data space maximum size	*/
     hsize_t size;
-    
+
     cur_size[0] = max_size[0] = 2;
     size = max_size[0] * sizeof(int);
-    
+
     /* create */
     if((dcpl = H5Pcreate(H5P_DATASET_CREATE)) < 0)
         goto out;
@@ -2905,7 +2990,7 @@ int make_external(hid_t loc_id)
         goto out;
     if(H5Dwrite(did, H5T_NATIVE_INT, H5S_ALL, H5S_ALL, H5P_DEFAULT, buf) < 0)
         goto out;
-    
+
     /* close */
     if(H5Sclose(sid) < 0)
         goto out;
@@ -2913,11 +2998,12 @@ int make_external(hid_t loc_id)
         goto out;
     if(H5Dclose(did) < 0)
         goto out;
-    
+
     return 0;
-    
+
 out:
-    H5E_BEGIN_TRY {
+    H5E_BEGIN_TRY 
+    {
         H5Pclose(dcpl);
         H5Sclose(sid);
         H5Dclose(did);
@@ -2927,12 +3013,12 @@ out:
 }
 
 /*-------------------------------------------------------------------------
- * Function: make_userblock
- *
- * Purpose: create a file for the userblock copying test
- *
- *-------------------------------------------------------------------------
- */
+* Function: make_userblock
+*
+* Purpose: create a file for the userblock copying test
+*
+*-------------------------------------------------------------------------
+*/
 static int
 make_userblock(void)
 {
@@ -2989,12 +3075,12 @@ out:
 } /* end make_userblock() */
 
 /*-------------------------------------------------------------------------
- * Function: verify_userblock
- *
- * Purpose: Verify that the userblock was copied correctly
- *
- *-------------------------------------------------------------------------
- */
+* Function: verify_userblock
+*
+* Purpose: Verify that the userblock was copied correctly
+*
+*-------------------------------------------------------------------------
+*/
 static int
 verify_userblock( const char* filename)
 {
@@ -3059,12 +3145,12 @@ out:
 
 
 /*-------------------------------------------------------------------------
- * Function: make_userblock_file
- *
- * Purpose: create a file for the userblock add test
- *
- *-------------------------------------------------------------------------
- */
+* Function: make_userblock_file
+*
+* Purpose: create a file for the userblock add test
+*
+*-------------------------------------------------------------------------
+*/
 static int
 make_userblock_file(void)
 {
@@ -3099,44 +3185,43 @@ out:
 }
 
 /*-------------------------------------------------------------------------
- * Function: write_dset_in
- *
- * Purpose: write datasets in LOC_ID
- *
- * Programmer: Pedro Vicente, pvn@ncsa.uiuc.edu
- *
- * Date: November 12, 2003
- *
- *-------------------------------------------------------------------------
- */
-
-
-void write_dset_in(hid_t loc_id,
+* Function: write_dset_in
+*
+* Purpose: write datasets in LOC_ID
+*
+* Programmer: Pedro Vicente, pvn@ncsa.uiuc.edu
+*
+* Date: November 12, 2003
+*
+*-------------------------------------------------------------------------
+*/
+
+
+int write_dset_in(hid_t loc_id,
                    const char* dset_name, /* for saving reference to dataset*/
                    hid_t file_id,
                    int make_diffs /* flag to modify data buffers */)
 {
-    /* Compound datatype */
+    /* compound datatype */
     typedef struct s_t
     {
         char   a;
         double b;
     } s_t;
-    
+
     typedef enum
     {
         RED,
-            GREEN
+        GREEN
     } e_t;
-    
-    hid_t   dset_id;
-    hid_t   space_id;
-    hid_t   type_id;
-    hid_t   plist_id;
-    herr_t  status;
+
+    hid_t   did=-1;
+    hid_t   sid=-1;
+    hid_t   tid=-1;
+    hid_t   pid=-1;
     int     val, i, j, k, n;
     float   f;
-    
+
     /* create 1D attributes with dimension [2], 2 elements */
     hsize_t    dims[1]={2};
     hsize_t    dims1r[1]={2};
@@ -3150,7 +3235,7 @@ void write_dset_in(hid_t loc_id,
     int        buf6[2][3]= {{1,2,3},{4,5,6}};  /* array */
     int        buf7[2]= {1,2};                 /* integer */
     float      buf8[2]= {1,2};                 /* float */
-    
+
     /* create 2D attributes with dimension [3][2], 6 elements */
     hsize_t    dims2[2]={3,2};
     hsize_t    dims2r[2]={1,1};
@@ -3162,7 +3247,7 @@ void write_dset_in(hid_t loc_id,
     int        buf62[6][3]= {{1,2,3},{4,5,6},{7,8,9},{10,11,12},{13,14,15},{16,17,18}};  /* array */
     int        buf72[3][2]= {{1,2},{3,4},{5,6}};                     /* integer */
     float      buf82[3][2]= {{1,2},{3,4},{5,6}};                     /* float */
-    
+
     /* create 3D attributes with dimension [4][3][2], 24 elements */
     hsize_t    dims3[3]={4,3,2};
     hsize_t    dims3r[3]={1,1,1};
@@ -3176,19 +3261,19 @@ void write_dset_in(hid_t loc_id,
     int        buf63[24][3];      /* array */
     int        buf73[4][3][2];    /* integer */
     float      buf83[4][3][2];    /* float */
-    
-    
+
+
     /*-------------------------------------------------------------------------
     * 1D
     *-------------------------------------------------------------------------
     */
-    
+
     /*-------------------------------------------------------------------------
     * H5T_STRING
     *-------------------------------------------------------------------------
     */
-    
-    
+
+
     if (make_diffs)
     {
         for (i=0; i<2; i++)
@@ -3197,37 +3282,45 @@ void write_dset_in(hid_t loc_id,
                 buf1[i][j]='z';
             }
     }
-    
-    
-    type_id = H5Tcopy(H5T_C_S1);
-    status  = H5Tset_size(type_id, (size_t)2);
-    write_dset(loc_id,1,dims,"string",type_id,buf1);
-    status = H5Tclose(type_id);
-    
-    
+
+
+    if ((tid = H5Tcopy(H5T_C_S1)) < 0)
+        goto out;
+    if (H5Tset_size(tid, (size_t)2) < 0)
+        goto out;
+    if (write_dset(loc_id,1,dims,"string",tid,buf1) < 0)
+        goto out;
+    if (H5Tclose(tid) < 0)
+        goto out;
+
+
     /* create hard link */
-    status = H5Lcreate_hard(loc_id, "string", H5L_SAME_LOC, "string_link", H5P_DEFAULT, H5P_DEFAULT);
-    
+    if (H5Lcreate_hard(loc_id, "string", H5L_SAME_LOC, "string_link", H5P_DEFAULT, H5P_DEFAULT) < 0)
+        goto out;
+
     /*-------------------------------------------------------------------------
     * H5T_BITFIELD
     *-------------------------------------------------------------------------
     */
-    
+
     if (make_diffs)
     {
         for (i=0; i<2; i++)
             buf2[i]=buf2[1]=0;
     }
-    
-    type_id = H5Tcopy(H5T_STD_B8LE);
-    write_dset(loc_id,1,dims,"bitfield",type_id,buf2);
-    status = H5Tclose(type_id);
-    
+
+    if ((tid = H5Tcopy(H5T_STD_B8LE)) < 0)
+        goto out;
+    if (write_dset(loc_id,1,dims,"bitfield",tid,buf2) < 0)
+        goto out;
+    if (H5Tclose(tid) < 0)
+        goto out;
+
     /*-------------------------------------------------------------------------
     * H5T_OPAQUE
     *-------------------------------------------------------------------------
     */
-    
+
     if (make_diffs)
     {
         for (i=0; i<2; i++)
@@ -3235,18 +3328,22 @@ void write_dset_in(hid_t loc_id,
             buf3[i].a=0; buf3[i].b=0;
         }
     }
-    
-    type_id = H5Tcreate(H5T_OPAQUE, (size_t)1);
-    status = H5Tset_tag(type_id, "1-byte opaque type"); /* must set this */
-    write_dset(loc_id,1,dims,"opaque",type_id,buf2);
-    status = H5Tclose(type_id);
-    
+
+    if ((tid = H5Tcreate(H5T_OPAQUE, (size_t)1)) < 0)
+        goto out;
+    if (H5Tset_tag(tid, "1-byte opaque type") < 0)
+        goto out;
+    if (write_dset(loc_id,1,dims,"opaque",tid,buf2) < 0)
+        goto out;
+    if (H5Tclose(tid) < 0)
+        goto out;
+
     /*-------------------------------------------------------------------------
     * H5T_COMPOUND
     *-------------------------------------------------------------------------
     */
-    
-    
+
+
     if (make_diffs)
     {
         for (i=0; i<2; i++)
@@ -3254,13 +3351,18 @@ void write_dset_in(hid_t loc_id,
             buf45[i]=GREEN;
         }
     }
-    
-    type_id = H5Tcreate (H5T_COMPOUND, sizeof(s_t));
-    H5Tinsert(type_id, "a", HOFFSET(s_t, a), H5T_NATIVE_CHAR);
-    H5Tinsert(type_id, "b", HOFFSET(s_t, b), H5T_NATIVE_DOUBLE);
-    write_dset(loc_id,1,dims,"compound",type_id,buf3);
-    status = H5Tclose(type_id);
-    
+
+    if ((tid = H5Tcreate (H5T_COMPOUND, sizeof(s_t))) < 0)
+        goto out;
+    if (H5Tinsert(tid, "a", HOFFSET(s_t, a), H5T_NATIVE_CHAR) < 0)
+        goto out;
+    if (H5Tinsert(tid, "b", HOFFSET(s_t, b), H5T_NATIVE_DOUBLE) < 0)
+        goto out;
+    if (write_dset(loc_id,1,dims,"compound",tid,buf3) < 0)
+        goto out;
+    if (H5Tclose(tid) < 0)
+        goto out;
+
     /*-------------------------------------------------------------------------
     * H5T_REFERENCE
     *-------------------------------------------------------------------------
@@ -3270,31 +3372,39 @@ void write_dset_in(hid_t loc_id,
     buf4[1]=0;
     if (dset_name)
     {
-        status=H5Rcreate(&buf4[0],file_id,dset_name,H5R_OBJECT,-1);
-        write_dset(loc_id,1,dims1r,"refobj",H5T_STD_REF_OBJ,buf4);
+        if (H5Rcreate(&buf4[0],file_id,dset_name,H5R_OBJECT,-1) < 0)
+            goto out;
+        if (write_dset(loc_id,1,dims1r,"refobj",H5T_STD_REF_OBJ,buf4) < 0)
+            goto out;
     }
-    
+
     /* Dataset region reference ( H5R_DATASET_REGION  )  */
-    make_dset_reg_ref(loc_id);
-    
-    
+    if (make_dset_reg_ref(loc_id) < 0)
+        goto out;
+
+
     /*-------------------------------------------------------------------------
     * H5T_ENUM
     *-------------------------------------------------------------------------
     */
-    type_id = H5Tcreate(H5T_ENUM, sizeof(e_t));
-    H5Tenum_insert(type_id, "RED",   (val = 0, &val));
-    H5Tenum_insert(type_id, "GREEN", (val = 1, &val));
-    write_dset(loc_id,1,dims,"enum",type_id,buf45);
-    status = H5Tclose(type_id);
-    
+    if ((tid = H5Tcreate(H5T_ENUM, sizeof(e_t))) < 0)
+        goto out;
+    if (H5Tenum_insert(tid, "RED",   (val = 0, &val)) < 0)
+        goto out;
+    if (H5Tenum_insert(tid, "GREEN", (val = 1, &val)) < 0)
+        goto out;
+    if (write_dset(loc_id,1,dims,"enum",tid,buf45) < 0)
+        goto out;
+    if (H5Tclose(tid) < 0)
+        goto out;
+
     /*-------------------------------------------------------------------------
     * H5T_VLEN
     *-------------------------------------------------------------------------
     */
-    
+
     /* Allocate and initialize VL dataset to write */
-    
+
     buf5[0].len = 1;
     buf5[0].p = malloc( 1 * sizeof(int));
     ((int *)buf5[0].p)[0]=1;
@@ -3302,29 +3412,35 @@ void write_dset_in(hid_t loc_id,
     buf5[1].p = malloc( 2 * sizeof(int));
     ((int *)buf5[1].p)[0] = 2;
     ((int *)buf5[1].p)[1] = 3;
-    
+
     if(make_diffs) {
         ((int *)buf5[0].p)[0] = 0;
         ((int *)buf5[1].p)[0] = 0;
         ((int *)buf5[1].p)[1] = 0;
     }
-    
-    space_id = H5Screate_simple(1, dims, NULL);
-    type_id = H5Tvlen_create(H5T_NATIVE_INT);
-    dset_id = H5Dcreate2(loc_id, "vlen", type_id, space_id, H5P_DEFAULT, H5P_DEFAULT, H5P_DEFAULT);
-    status = H5Dwrite(dset_id, type_id, H5S_ALL, H5S_ALL, H5P_DEFAULT, buf5);
-    assert(status >= 0);
-    status = H5Dvlen_reclaim(type_id, space_id, H5P_DEFAULT, buf5);
-    assert(status >= 0);
-    status = H5Dclose(dset_id);
-    status = H5Tclose(type_id);
-    status = H5Sclose(space_id);
-    
+
+    if ((sid = H5Screate_simple(1, dims, NULL)) < 0)
+        goto out;
+    if ((tid = H5Tvlen_create(H5T_NATIVE_INT)) < 0)
+        goto out;
+    if ((did = H5Dcreate2(loc_id, "vlen", tid, sid, H5P_DEFAULT, H5P_DEFAULT, H5P_DEFAULT)) < 0)
+        goto out;
+    if (H5Dwrite(did, tid, H5S_ALL, H5S_ALL, H5P_DEFAULT, buf5) < 0)
+        goto out;
+    if (H5Dvlen_reclaim(tid, sid, H5P_DEFAULT, buf5) < 0)
+        goto out;
+    if (H5Dclose(did) < 0)
+        goto out;
+    if (H5Tclose(tid) < 0)
+        goto out;
+    if (H5Sclose(sid) < 0)
+        goto out;
+
     /*-------------------------------------------------------------------------
     * H5T_ARRAY
     *-------------------------------------------------------------------------
     */
-    
+
     if (make_diffs)
     {
         for (i=0; i<2; i++)
@@ -3333,10 +3449,13 @@ void write_dset_in(hid_t loc_id,
                 buf6[i][j]=0;
             }
     }
-    
-    type_id = H5Tarray_create2(H5T_NATIVE_INT, 1, dimarray);
-    write_dset(loc_id, 1, dims, "array", type_id, buf6);
-    status = H5Tclose(type_id);
+
+    if ((tid = H5Tarray_create2(H5T_NATIVE_INT, 1, dimarray)) < 0)
+        goto out;
+    if (write_dset(loc_id, 1, dims, "array", tid, buf6) < 0)
+        goto out;
+    if (H5Tclose(tid) < 0)
+        goto out;
 
     {
 
@@ -3363,10 +3482,13 @@ void write_dset_in(hid_t loc_id,
         }
 
         /* create a type larger than H5TOOLS_MALLOCSIZE */
-        tid = H5Tarray_create2(H5T_NATIVE_DOUBLE, 1, tdims);
+        if ((tid = H5Tarray_create2(H5T_NATIVE_DOUBLE, 1, tdims)) < 0)
+            goto out;
         size = H5Tget_size(tid);
-        sid = H5Screate_simple(1, sdims, NULL);
-        did = H5Dcreate2(loc_id, "arrayd", tid, sid, H5P_DEFAULT, H5P_DEFAULT, H5P_DEFAULT);
+        if ((sid = H5Screate_simple(1, sdims, NULL)) < 0)
+            goto out;
+        if ((did = H5Dcreate2(loc_id, "arrayd", tid, sid, H5P_DEFAULT, H5P_DEFAULT, H5P_DEFAULT)) < 0)
+            goto out;
 #if defined(WRITE_ARRAY)
         H5Dwrite(did, tid, H5S_ALL, H5S_ALL, H5P_DEFAULT, dbuf);
 #endif
@@ -3377,12 +3499,12 @@ void write_dset_in(hid_t loc_id,
         H5Sclose(sid);
         free( dbuf );
     }
-    
+
     /*-------------------------------------------------------------------------
     * H5T_INTEGER and H5T_FLOAT
     *-------------------------------------------------------------------------
     */
-    
+
     if (make_diffs)
     {
         for (i=0; i<2; i++)
@@ -3391,72 +3513,90 @@ void write_dset_in(hid_t loc_id,
             buf8[i]=0;
         }
     }
-    
-    write_dset(loc_id,1,dims,"integer",H5T_NATIVE_INT,buf7);
-    write_dset(loc_id,1,dims,"float",H5T_NATIVE_FLOAT,buf8);
-    
-    
+
+    if (write_dset(loc_id,1,dims,"integer",H5T_NATIVE_INT,buf7) < 0)
+        goto out;
+    if (write_dset(loc_id,1,dims,"float",H5T_NATIVE_FLOAT,buf8) < 0)
+        goto out;
+
+
     /*-------------------------------------------------------------------------
     * 2D
     *-------------------------------------------------------------------------
     */
-    
+
     /*-------------------------------------------------------------------------
     * H5T_STRING
     *-------------------------------------------------------------------------
     */
-    
+
     if (make_diffs)
     {
         memset(buf12, 'z', sizeof buf12);
     }
-    
-    
-    type_id = H5Tcopy(H5T_C_S1);
-    status  = H5Tset_size(type_id, (size_t)2);
-    write_dset(loc_id,2,dims2,"string2D",type_id,buf12);
-    status = H5Tclose(type_id);
-    
+
+
+    if ((tid = H5Tcopy(H5T_C_S1)) < 0)
+        goto out;
+    if (H5Tset_size(tid, (size_t)2) < 0)
+        goto out;
+    if (write_dset(loc_id,2,dims2,"string2D",tid,buf12) < 0)
+        goto out;
+    if (H5Tclose(tid) < 0)
+        goto out;
+
     /*-------------------------------------------------------------------------
     * H5T_BITFIELD
     *-------------------------------------------------------------------------
     */
-    
-    
+
+
     if (make_diffs)
     {
         memset(buf22,0,sizeof buf22);
     }
-    
-    type_id = H5Tcopy(H5T_STD_B8LE);
-    write_dset(loc_id,2,dims2,"bitfield2D",type_id,buf22);
-    status = H5Tclose(type_id);
-    
+
+    if ((tid = H5Tcopy(H5T_STD_B8LE)) < 0)
+        goto out;
+    if (write_dset(loc_id,2,dims2,"bitfield2D",tid,buf22) < 0)
+        goto out; 
+    if (H5Tclose(tid) < 0)
+        goto out; 
+
     /*-------------------------------------------------------------------------
     * H5T_OPAQUE
     *-------------------------------------------------------------------------
     */
-    type_id = H5Tcreate(H5T_OPAQUE, (size_t)1);
-    status = H5Tset_tag(type_id, "1-byte opaque type"); /* must set this */
-    write_dset(loc_id,2,dims2,"opaque2D",type_id,buf22);
-    status = H5Tclose(type_id);
-    
+    if ((tid = H5Tcreate(H5T_OPAQUE, (size_t)1)) < 0)
+        goto out;
+    if (H5Tset_tag(tid, "1-byte opaque type") < 0)
+        goto out; 
+    if (write_dset(loc_id,2,dims2,"opaque2D",tid,buf22) < 0)
+        goto out;
+    if (H5Tclose(tid) < 0)
+        goto out;
+
     /*-------------------------------------------------------------------------
     * H5T_COMPOUND
     *-------------------------------------------------------------------------
     */
-    
+
     if (make_diffs)
     {
         memset(buf32,0,sizeof buf32);
     }
-    
-    type_id = H5Tcreate (H5T_COMPOUND, sizeof(s_t));
-    H5Tinsert(type_id, "a", HOFFSET(s_t, a), H5T_NATIVE_CHAR);
-    H5Tinsert(type_id, "b", HOFFSET(s_t, b), H5T_NATIVE_DOUBLE);
-    write_dset(loc_id,2,dims2,"compound2D",type_id,buf32);
-    status = H5Tclose(type_id);
-    
+
+    if ((tid = H5Tcreate (H5T_COMPOUND, sizeof(s_t))) < 0)
+        goto out;
+    if (H5Tinsert(tid, "a", HOFFSET(s_t, a), H5T_NATIVE_CHAR) < 0)
+        goto out;
+    if (H5Tinsert(tid, "b", HOFFSET(s_t, b), H5T_NATIVE_DOUBLE) < 0)
+        goto out;
+    if (write_dset(loc_id,2,dims2,"compound2D",tid,buf32) < 0)
+        goto out;
+    if (H5Tclose(tid) < 0)
+        goto out;
+
     /*-------------------------------------------------------------------------
     * H5T_REFERENCE
     *-------------------------------------------------------------------------
@@ -3464,277 +3604,367 @@ void write_dset_in(hid_t loc_id,
     /* Create references to dataset */
     if (dset_name)
     {
-        status = H5Rcreate(&buf42[0][0], file_id, dset_name, H5R_OBJECT, -1);
-        write_dset(loc_id, 2, dims2r, "refobj2D", H5T_STD_REF_OBJ, buf42);
+        if (H5Rcreate(&buf42[0][0], file_id, dset_name, H5R_OBJECT, -1) < 0)
+            goto out;
+        if (write_dset(loc_id, 2, dims2r, "refobj2D", H5T_STD_REF_OBJ, buf42) < 0)
+            goto out;
     }
-    
+
     /*-------------------------------------------------------------------------
     * H5T_ENUM
     *-------------------------------------------------------------------------
     */
-    
-    type_id = H5Tcreate(H5T_ENUM, sizeof(e_t));
-    H5Tenum_insert(type_id, "RED",   (val = 0, &val));
-    H5Tenum_insert(type_id, "GREEN", (val = 1, &val));
-    write_dset(loc_id,2,dims2,"enum2D",type_id,0);
-    status = H5Tclose(type_id);
-    
+
+    if ((tid = H5Tcreate(H5T_ENUM, sizeof(e_t))) < 0)
+        goto out;
+    if (H5Tenum_insert(tid, "RED",   (val = 0, &val)) < 0)
+        goto out;
+    if (H5Tenum_insert(tid, "GREEN", (val = 1, &val)) < 0)
+        goto out;
+    if (write_dset(loc_id,2,dims2,"enum2D",tid,0) < 0)
+        goto out;
+    if (H5Tclose(tid) < 0)
+        goto out;
+
     /*-------------------------------------------------------------------------
     * H5T_VLEN
     *-------------------------------------------------------------------------
     */
-    
+
     /* Allocate and initialize VL dataset to write */
     n = 0;
     for(i = 0; i < 3; i++)
-        for(j = 0; j < 2; j++) {
+    {
+        for(j = 0; j < 2; j++) 
+        {
             int l;
-            
+
             buf52[i][j].p = malloc((i + 1) * sizeof(int));
             buf52[i][j].len = i + 1;
             for(l = 0; l < i + 1; l++)
+            {
                 if(make_diffs)
                     ((int *)buf52[i][j].p)[l] = 0;
                 else
                     ((int *)buf52[i][j].p)[l] = n++;
+            }
         }
-        
-        space_id = H5Screate_simple(2, dims2, NULL);
-        type_id = H5Tvlen_create(H5T_NATIVE_INT);
-        dset_id = H5Dcreate2(loc_id, "vlen2D", type_id, space_id, H5P_DEFAULT, H5P_DEFAULT, H5P_DEFAULT);
-        status = H5Dwrite(dset_id, type_id, H5S_ALL, H5S_ALL, H5P_DEFAULT, buf52);
-        assert(status >= 0);
-        status = H5Dvlen_reclaim(type_id, space_id, H5P_DEFAULT, buf52);
-        assert(status >= 0);
-        status = H5Dclose(dset_id);
-        status = H5Tclose(type_id);
-        status = H5Sclose(space_id);
-        
-        /*-------------------------------------------------------------------------
-        * H5T_ARRAY
-        *-------------------------------------------------------------------------
-        */
-        
-        if (make_diffs)
-        {
-            memset(buf62,0,sizeof buf62);
-        }
-        
-        
-        type_id = H5Tarray_create2(H5T_NATIVE_INT, 1, dimarray);
-        write_dset(loc_id, 2, dims2, "array2D", type_id, buf62);
-        status = H5Tclose(type_id);
-        
-        /*-------------------------------------------------------------------------
-        * H5T_INTEGER, write a fill value
-        *-------------------------------------------------------------------------
-        */
-        
-        
-        if(make_diffs) {
-            memset(buf72, 0, sizeof buf72);
-            memset(buf82, 0, sizeof buf82);
-        }
-        
-        
-        plist_id = H5Pcreate(H5P_DATASET_CREATE);
-        space_id = H5Screate_simple(2, dims2, NULL);
-        dset_id = H5Dcreate2(loc_id, "integer2D", H5T_NATIVE_INT, space_id, H5P_DEFAULT, plist_id, H5P_DEFAULT);
-        status = H5Dwrite(dset_id, H5T_NATIVE_INT, H5S_ALL, H5S_ALL, H5P_DEFAULT, buf72);
-        status = H5Pclose(plist_id);
-        status = H5Dclose(dset_id);
-        status = H5Sclose(space_id);
-        
-        /*-------------------------------------------------------------------------
-        * H5T_FLOAT
-        *-------------------------------------------------------------------------
-        */
-        
-        write_dset(loc_id,2,dims2,"float2D",H5T_NATIVE_FLOAT,buf82);
-        
-        
-        /*-------------------------------------------------------------------------
-        * 3D
-        *-------------------------------------------------------------------------
-        */
-        
-        /*-------------------------------------------------------------------------
-        * H5T_STRING
-        *-------------------------------------------------------------------------
-        */
-        
-        if (make_diffs)
-        {
-            memset(buf13,'z',sizeof buf13);
+    }
+
+    if ((sid = H5Screate_simple(2, dims2, NULL)) < 0)
+        goto out;
+    if ((tid = H5Tvlen_create(H5T_NATIVE_INT)) < 0)
+        goto out;
+    if ((did = H5Dcreate2(loc_id, "vlen2D", tid, sid, H5P_DEFAULT, H5P_DEFAULT, H5P_DEFAULT)) < 0)
+        goto out;
+    if (H5Dwrite(did, tid, H5S_ALL, H5S_ALL, H5P_DEFAULT, buf52) < 0)
+        goto out;
+    if (H5Dvlen_reclaim(tid, sid, H5P_DEFAULT, buf52) < 0)
+        goto out;
+    if (H5Dclose(did) < 0)
+        goto out;
+    if (H5Tclose(tid) < 0)
+        goto out;
+    if (H5Sclose(sid) < 0)
+        goto out;
+
+    /*-------------------------------------------------------------------------
+    * H5T_ARRAY
+    *-------------------------------------------------------------------------
+    */
+
+    if (make_diffs)
+    {
+        memset(buf62,0,sizeof buf62);
+    }
+
+
+    if ((tid = H5Tarray_create2(H5T_NATIVE_INT, 1, dimarray)) < 0)
+        goto out;
+    if (write_dset(loc_id, 2, dims2, "array2D", tid, buf62) < 0)
+        goto out;
+    if (H5Tclose(tid) < 0)
+        goto out;
+
+    /*-------------------------------------------------------------------------
+    * H5T_INTEGER, write a fill value
+    *-------------------------------------------------------------------------
+    */
+
+
+    if(make_diffs) {
+        memset(buf72, 0, sizeof buf72);
+        memset(buf82, 0, sizeof buf82);
+    }
+
+
+    if ((pid = H5Pcreate(H5P_DATASET_CREATE)) < 0)
+        goto out;
+    if ((sid = H5Screate_simple(2, dims2, NULL)) < 0)
+        goto out;
+    if ((did = H5Dcreate2(loc_id, "integer2D", H5T_NATIVE_INT, sid, H5P_DEFAULT, pid, H5P_DEFAULT)) < 0)
+        goto out;
+    if (H5Dwrite(did, H5T_NATIVE_INT, H5S_ALL, H5S_ALL, H5P_DEFAULT, buf72) < 0)
+        goto out;
+    if (H5Pclose(pid) < 0)
+        goto out;
+    if (H5Dclose(did) < 0)
+        goto out;
+    if (H5Sclose(sid) < 0)
+        goto out;
+
+    /*-------------------------------------------------------------------------
+    * H5T_FLOAT
+    *-------------------------------------------------------------------------
+    */
+
+    if (write_dset(loc_id,2,dims2,"float2D",H5T_NATIVE_FLOAT,buf82) < 0)
+        goto out;
+
+
+    /*-------------------------------------------------------------------------
+    * 3D
+    *-------------------------------------------------------------------------
+    */
+
+    /*-------------------------------------------------------------------------
+    * H5T_STRING
+    *-------------------------------------------------------------------------
+    */
+
+    if (make_diffs)
+    {
+        memset(buf13,'z',sizeof buf13);
+    }
+
+    if ((tid = H5Tcopy(H5T_C_S1)) < 0)
+        goto out;
+    if (H5Tset_size(tid, (size_t)2) < 0)
+        goto out;
+    if (write_dset(loc_id,3,dims3,"string3D",tid,buf13) < 0)
+        goto out;
+    if (H5Tclose(tid) < 0)
+        goto out;
+
+    /*-------------------------------------------------------------------------
+    * H5T_BITFIELD
+    *-------------------------------------------------------------------------
+    */
+
+
+    n=1;
+    for (i = 0; i < 4; i++) {
+        for (j = 0; j < 3; j++) {
+            for (k = 0; k < 2; k++) {
+                if (make_diffs) buf23[i][j][k]=0;
+                else buf23[i][j][k]=n++;
+            }
         }
-        
-        type_id = H5Tcopy(H5T_C_S1);
-        status  = H5Tset_size(type_id, (size_t)2);
-        write_dset(loc_id,3,dims3,"string3D",type_id,buf13);
-        status = H5Tclose(type_id);
-        
-        /*-------------------------------------------------------------------------
-        * H5T_BITFIELD
-        *-------------------------------------------------------------------------
-        */
-        
-        
-        n=1;
-        for (i = 0; i < 4; i++) {
-            for (j = 0; j < 3; j++) {
-                for (k = 0; k < 2; k++) {
-                    if (make_diffs) buf23[i][j][k]=0;
-                    else buf23[i][j][k]=n++;
+    }
+
+
+    if ((tid = H5Tcopy(H5T_STD_B8LE)) < 0)
+        goto out;
+    if (write_dset(loc_id,3,dims3,"bitfield3D",tid,buf23) < 0)
+        goto out;
+    if (H5Tclose(tid) < 0)
+        goto out;
+
+    /*-------------------------------------------------------------------------
+    * H5T_OPAQUE
+    *-------------------------------------------------------------------------
+    */
+    if ((tid = H5Tcreate(H5T_OPAQUE, (size_t)1)) < 0)
+        goto out;
+    if (H5Tset_tag(tid, "1-byte opaque type") < 0)
+        goto out;
+    if (write_dset(loc_id,3,dims3,"opaque3D",tid,buf23) < 0)
+        goto out;
+    if (H5Tclose(tid) < 0)
+        goto out;
+
+    /*-------------------------------------------------------------------------
+    * H5T_COMPOUND
+    *-------------------------------------------------------------------------
+    */
+
+    n=1;
+    for (i = 0; i < 4; i++) {
+        for (j = 0; j < 3; j++) {
+            for (k = 0; k < 2; k++) {
+                if (make_diffs) {
+                    buf33[i][j][k].a=0;
+                    buf33[i][j][k].b=0;
+                }
+                else {
+                    buf33[i][j][k].a=n++;
+                    buf33[i][j][k].b=n++;
                 }
             }
         }
-        
-        
-        type_id = H5Tcopy(H5T_STD_B8LE);
-        write_dset(loc_id,3,dims3,"bitfield3D",type_id,buf23);
-        status = H5Tclose(type_id);
-        
-        /*-------------------------------------------------------------------------
-        * H5T_OPAQUE
-        *-------------------------------------------------------------------------
-        */
-        type_id = H5Tcreate(H5T_OPAQUE, (size_t)1);
-        status = H5Tset_tag(type_id, "1-byte opaque type"); /* must set this */
-        write_dset(loc_id,3,dims3,"opaque3D",type_id,buf23);
-        status = H5Tclose(type_id);
-        
-        /*-------------------------------------------------------------------------
-        * H5T_COMPOUND
-        *-------------------------------------------------------------------------
-        */
-        
-        n=1;
-        for (i = 0; i < 4; i++) {
-            for (j = 0; j < 3; j++) {
-                for (k = 0; k < 2; k++) {
-                    if (make_diffs) {
-                        buf33[i][j][k].a=0;
-                        buf33[i][j][k].b=0;
-                    }
-                    else {
-                        buf33[i][j][k].a=n++;
-                        buf33[i][j][k].b=n++;
-                    }
+    }
+
+
+    if ((tid = H5Tcreate (H5T_COMPOUND, sizeof(s_t))) < 0)
+        goto out;
+    if (H5Tinsert(tid, "a", HOFFSET(s_t, a), H5T_NATIVE_CHAR) < 0)
+        goto out;
+    if (H5Tinsert(tid, "b", HOFFSET(s_t, b), H5T_NATIVE_DOUBLE) < 0)
+        goto out;
+    if (write_dset(loc_id,3,dims3,"compound3D",tid,buf33) < 0)
+        goto out;
+    if (H5Tclose(tid) < 0)
+        goto out;
+
+    /*-------------------------------------------------------------------------
+    * H5T_REFERENCE
+    *-------------------------------------------------------------------------
+    */
+    /* Create references to dataset */
+    if (dset_name)
+    {
+        if (H5Rcreate(&buf43[0][0][0], file_id, dset_name, H5R_OBJECT, -1) < 0)
+            goto out;
+        if (write_dset(loc_id, 3, dims3r, "refobj3D", H5T_STD_REF_OBJ, buf43) < 0)
+            goto out;
+    }
+
+    /*-------------------------------------------------------------------------
+    * H5T_ENUM
+    *-------------------------------------------------------------------------
+    */
+
+    if ((tid = H5Tcreate(H5T_ENUM, sizeof(e_t))) < 0)
+        goto out;
+    if (H5Tenum_insert(tid, "RED",   (val = 0, &val)) < 0)
+        goto out;
+    if (H5Tenum_insert(tid, "GREEN", (val = 1, &val)) < 0)
+        goto out;
+    if (write_dset(loc_id,3,dims3,"enum3D",tid,0) < 0)
+        goto out;
+    if (H5Tclose(tid) < 0)
+        goto out;
+
+    /*-------------------------------------------------------------------------
+    * H5T_VLEN
+    *-------------------------------------------------------------------------
+    */
+
+    /* Allocate and initialize VL dataset to write */
+    n = 0;
+    for(i = 0; i < 4; i++)
+    {
+        for(j = 0; j < 3; j++)
+        {
+            for(k = 0; k < 2; k++) 
+            {
+                int l;
+
+                buf53[i][j][k].p = malloc((i + 1) * sizeof(int));
+                buf53[i][j][k].len = i + 1;
+                for(l = 0; l < i + 1; l++)
+                {
+                    if(make_diffs)
+                        ((int *)buf53[i][j][k].p)[l] = 0;
+                    else
+                        ((int *)buf53[i][j][k].p)[l] = n++;
                 }
             }
         }
-        
-        
-        type_id = H5Tcreate (H5T_COMPOUND, sizeof(s_t));
-        H5Tinsert(type_id, "a", HOFFSET(s_t, a), H5T_NATIVE_CHAR);
-        H5Tinsert(type_id, "b", HOFFSET(s_t, b), H5T_NATIVE_DOUBLE);
-        write_dset(loc_id,3,dims3,"compound3D",type_id,buf33);
-        status = H5Tclose(type_id);
-        
-        /*-------------------------------------------------------------------------
-        * H5T_REFERENCE
-        *-------------------------------------------------------------------------
-        */
-        /* Create references to dataset */
-        if (dset_name)
+    }
+
+    if ((sid = H5Screate_simple(3, dims3, NULL)) < 0)
+        goto out;
+    if ((tid = H5Tvlen_create(H5T_NATIVE_INT)) < 0)
+        goto out;
+    if ((did = H5Dcreate2(loc_id, "vlen3D", tid, sid, H5P_DEFAULT, H5P_DEFAULT, H5P_DEFAULT)) < 0)
+        goto out;
+    if (H5Dwrite(did, tid, H5S_ALL, H5S_ALL, H5P_DEFAULT, buf53) < 0)
+        goto out;
+
+    if (H5Dvlen_reclaim(tid, sid, H5P_DEFAULT, buf53) < 0)
+        goto out;
+  
+    if (H5Dclose(did) < 0)
+        goto out;
+    if (H5Tclose(tid) < 0)
+        goto out;
+    if (H5Sclose(sid) < 0)
+        goto out;
+
+    /*-------------------------------------------------------------------------
+    * H5T_ARRAY
+    *-------------------------------------------------------------------------
+    */
+
+
+    n = 1;
+    for(i = 0; i < 24; i++)
+    {
+        for(j = 0; j < (int)dimarray[0]; j++)
         {
-            status = H5Rcreate(&buf43[0][0][0], file_id, dset_name, H5R_OBJECT, -1);
-            write_dset(loc_id, 3, dims3r, "refobj3D", H5T_STD_REF_OBJ, buf43);
+            if(make_diffs)
+                buf63[i][j] = 0;
+            else
+                buf63[i][j] = n++;
         }
-        
-        /*-------------------------------------------------------------------------
-        * H5T_ENUM
-        *-------------------------------------------------------------------------
-        */
-        
-        type_id = H5Tcreate(H5T_ENUM, sizeof(e_t));
-        H5Tenum_insert(type_id, "RED",   (val = 0, &val));
-        H5Tenum_insert(type_id, "GREEN", (val = 1, &val));
-        write_dset(loc_id,3,dims3,"enum3D",type_id,0);
-        status = H5Tclose(type_id);
-        
-        /*-------------------------------------------------------------------------
-        * H5T_VLEN
-        *-------------------------------------------------------------------------
-        */
-        
-        /* Allocate and initialize VL dataset to write */
-        n = 0;
-        for(i = 0; i < 4; i++)
-            for(j = 0; j < 3; j++)
-                for(k = 0; k < 2; k++) {
-                    int l;
-                    
-                    buf53[i][j][k].p = malloc((i + 1) * sizeof(int));
-                    buf53[i][j][k].len = i + 1;
-                    for(l = 0; l < i + 1; l++)
-                        if(make_diffs)
-                            ((int *)buf53[i][j][k].p)[l] = 0;
-                        else
-                            ((int *)buf53[i][j][k].p)[l] = n++;
+    }
+
+    if ((tid = H5Tarray_create2(H5T_NATIVE_INT, 1, dimarray)) < 0)
+        goto out;
+    if (write_dset(loc_id, 3, dims3, "array3D", tid, buf63) < 0)
+        goto out;
+    if (H5Tclose(tid) < 0)
+        goto out;
+
+    /*-------------------------------------------------------------------------
+    * H5T_INTEGER and H5T_FLOAT
+    *-------------------------------------------------------------------------
+    */
+    n=1; f=1;
+    for (i = 0; i < 4; i++) {
+        for (j = 0; j < 3; j++) {
+            for (k = 0; k < 2; k++) {
+                if (make_diffs) {
+                    buf73[i][j][k]=0;
+                    buf83[i][j][k]=0;
                 }
-                
-                space_id = H5Screate_simple(3, dims3, NULL);
-                type_id = H5Tvlen_create(H5T_NATIVE_INT);
-                dset_id = H5Dcreate2(loc_id, "vlen3D", type_id, space_id, H5P_DEFAULT, H5P_DEFAULT, H5P_DEFAULT);
-                status = H5Dwrite(dset_id, type_id, H5S_ALL, H5S_ALL, H5P_DEFAULT, buf53);
-                assert(status >= 0);
-                status = H5Dvlen_reclaim(type_id, space_id, H5P_DEFAULT, buf53);
-                assert(status >= 0);
-                status = H5Dclose(dset_id);
-                status = H5Tclose(type_id);
-                status = H5Sclose(space_id);
-                
-                /*-------------------------------------------------------------------------
-                * H5T_ARRAY
-                *-------------------------------------------------------------------------
-                */
-                
-                
-                n = 1;
-                for(i = 0; i < 24; i++)
-                    for(j = 0; j < (int)dimarray[0]; j++)
-                        if(make_diffs)
-                            buf63[i][j] = 0;
-                        else
-                            buf63[i][j] = n++;
-                        
-                        type_id = H5Tarray_create2(H5T_NATIVE_INT, 1, dimarray);
-                        write_dset(loc_id, 3, dims3, "array3D", type_id, buf63);
-                        status = H5Tclose(type_id);
-                        
-                        /*-------------------------------------------------------------------------
-                        * H5T_INTEGER and H5T_FLOAT
-                        *-------------------------------------------------------------------------
-                        */
-                        n=1; f=1;
-                        for (i = 0; i < 4; i++) {
-                            for (j = 0; j < 3; j++) {
-                                for (k = 0; k < 2; k++) {
-                                    if (make_diffs) {
-                                        buf73[i][j][k]=0;
-                                        buf83[i][j][k]=0;
-                                    }
-                                    else {
-                                        buf73[i][j][k]=n++;
-                                        buf83[i][j][k]=f++;
-                                    }
-                                }
-                            }
-                        }
-                        write_dset(loc_id,3,dims3,"integer3D",H5T_NATIVE_INT,buf73);
-                        write_dset(loc_id,3,dims3,"float3D",H5T_NATIVE_FLOAT,buf83);
-}
+                else {
+                    buf73[i][j][k]=n++;
+                    buf83[i][j][k]=f++;
+                }
+            }
+        }
+    }
+    if (write_dset(loc_id,3,dims3,"integer3D",H5T_NATIVE_INT,buf73) < 0)
+        goto out;
+    if (write_dset(loc_id,3,dims3,"float3D",H5T_NATIVE_FLOAT,buf83) < 0)
+        goto out;
+
 
+    return 0;
+
+
+out:
+    H5E_BEGIN_TRY 
+    {
+        H5Pclose(pid);
+        H5Sclose(sid);
+        H5Dclose(did);
+        H5Tclose(tid);
+    } H5E_END_TRY;
+    return -1;
+}
 
+ 
 
 /*-------------------------------------------------------------------------
- * Function: make_dset_reg_ref
- *
- * Purpose: write dataset region references
- *
- *-------------------------------------------------------------------------
- */
+* Function: make_dset_reg_ref
+*
+* Purpose: write dataset region references
+*
+*-------------------------------------------------------------------------
+*/
 
 #define SPACE1_RANK 1
 #define SPACE1_DIM1 1
@@ -3743,94 +3973,110 @@ void write_dset_in(hid_t loc_id,
 #define SPACE2_DIM2 10
 #define NPOINTS 10
 
-void make_dset_reg_ref(hid_t loc_id)
+int make_dset_reg_ref(hid_t loc_id)
 {
-    hid_t           dset1; /* Dataset ID   */
-    hid_t           dset2; /* Dereferenced dataset ID */
-    hid_t           sid1;  /* Dataspace ID #1  */
-    hid_t           sid2;  /* Dataspace ID #2  */
+    hid_t           did1=-1; /* Dataset ID   */
+    hid_t           did2=-1; /* Dereferenced dataset ID */
+    hid_t           sid1=-1;  /* Dataspace ID #1  */
+    hid_t           sid2=-1;  /* Dataspace ID #2  */
     hsize_t         dims1[] = {SPACE1_DIM1};
     hsize_t         dims2[] = {SPACE2_DIM1, SPACE2_DIM2};
     hsize_t         start[SPACE2_RANK];     /* Starting location of hyperslab */
     hsize_t         stride[SPACE2_RANK];    /* Stride of hyperslab */
     hsize_t         count[SPACE2_RANK];     /* Element count of hyperslab */
     hsize_t         block[SPACE2_RANK];     /* Block size of hyperslab */
-    hdset_reg_ref_t *wbuf;  /* buffer to write to disk */
-    int             *dwbuf; /* Buffer for writing numeric data to disk */
+    hdset_reg_ref_t *wbuf=NULL;  /* buffer to write to disk */
+    int             *dwbuf=NULL; /* Buffer for writing numeric data to disk */
     int             i;      /* counting variables */
-    herr_t          ret;    /* Generic return value  */
-    
+
     /* Allocate write & read buffers */
     wbuf = (hdset_reg_ref_t *)calloc(sizeof(hdset_reg_ref_t), (size_t)SPACE1_DIM1);
     dwbuf = (int *)malloc(sizeof(int) * SPACE2_DIM1 * SPACE2_DIM2);
-    
+
     /* Create dataspace for datasets */
-    sid2 = H5Screate_simple(SPACE2_RANK, dims2, NULL);
-    
+    if ((sid2 = H5Screate_simple(SPACE2_RANK, dims2, NULL)) < 0)
+        goto out;
+
     /* Create a dataset */
-    dset2 = H5Dcreate2(loc_id, "dsetreg", H5T_NATIVE_UCHAR, sid2, H5P_DEFAULT, H5P_DEFAULT, H5P_DEFAULT);
-    
-    for(i = 0; i < SPACE2_DIM1 * SPACE2_DIM2; i++)
+    if ((did2 = H5Dcreate2(loc_id, "dsetreg", H5T_NATIVE_UCHAR, sid2, H5P_DEFAULT, H5P_DEFAULT, H5P_DEFAULT)) < 0)
+        goto out;
+
+    for (i = 0; i < SPACE2_DIM1 * SPACE2_DIM2; i++)
         dwbuf[i] = i * 3;
-    
+
     /* Write selection to disk */
-    ret = H5Dwrite(dset2, H5T_NATIVE_INT, H5S_ALL, H5S_ALL, H5P_DEFAULT, dwbuf);
-    assert(ret >= 0);
-    
-    /* Close Dataset */
-    ret = H5Dclose(dset2);
-    assert(ret >= 0);
-    
+    if (H5Dwrite(did2, H5T_NATIVE_INT, H5S_ALL, H5S_ALL, H5P_DEFAULT, dwbuf) < 0)
+        goto out;
+
     /* Create dataspace for the reference dataset */
-    sid1 = H5Screate_simple(SPACE1_RANK, dims1, NULL);
-    
+    if ((sid1 = H5Screate_simple(SPACE1_RANK, dims1, NULL)) < 0)
+        goto out;
+
     /* Create a dataset */
-    dset1 = H5Dcreate2(loc_id, "refreg", H5T_STD_REF_DSETREG, sid1, H5P_DEFAULT, H5P_DEFAULT, H5P_DEFAULT);
-    
-    /* Create references */
-    
+    if ((did1 = H5Dcreate2(loc_id, "refreg", H5T_STD_REF_DSETREG, sid1, H5P_DEFAULT, H5P_DEFAULT, H5P_DEFAULT)) < 0)
+        goto out;
+
     /* Select 6x6 hyperslab for first reference */
     start[0] = 2; start[1] = 2;
     stride[0] = 1; stride[1] = 1;
     count[0] = 6; count[1] = 6;
     block[0] = 1; block[1] = 1;
-    ret = H5Sselect_hyperslab(sid2, H5S_SELECT_SET, start, stride, count, block);
-    assert(ret >= 0);
-    
+    if (H5Sselect_hyperslab(sid2, H5S_SELECT_SET, start, stride, count, block) < 0)
+        goto out;
+
+
     /* Store dataset region */
-    ret = H5Rcreate(&wbuf[0], loc_id, "dsetreg", H5R_DATASET_REGION, sid2);
-    assert(ret >= 0);
-    
+    if (H5Rcreate(&wbuf[0], loc_id, "dsetreg", H5R_DATASET_REGION, sid2) < 0)
+        goto out;
+
     /* Write selection to disk */
-    ret=H5Dwrite(dset1,H5T_STD_REF_DSETREG,H5S_ALL,H5S_ALL,H5P_DEFAULT,wbuf);
-    assert(ret >= 0);
-    
+    if (H5Dwrite(did1,H5T_STD_REF_DSETREG,H5S_ALL,H5S_ALL,H5P_DEFAULT,wbuf) < 0)
+        goto out;
+
     /* Close all objects */
-    ret = H5Sclose(sid1);
-    assert(ret >= 0);
-    ret = H5Dclose(dset1);
-    assert(ret >= 0);
-    ret = H5Sclose(sid2);
-    assert(ret >= 0);
-    
-    free(wbuf);
-    free(dwbuf);
+    if (H5Sclose(sid1) < 0)
+        goto out;
+    if (H5Dclose(did1) < 0)
+        goto out;
+    if (H5Sclose(sid2) < 0)
+        goto out;
+    if (H5Dclose(did2) < 0)
+        goto out;
+
+    if (wbuf)
+        free(wbuf);
+    if (dwbuf)
+        free(dwbuf);
+
+    return 0;
+
+out:
+    H5E_BEGIN_TRY 
+    {
+
+        H5Sclose(sid1);
+        H5Sclose(sid2);
+        H5Dclose(did1);
+        H5Dclose(did2);
+
+    } H5E_END_TRY;
+    return -1;
 }
 
 /*-------------------------------------------------------------------------
- * Function: write_attr_in
- *
- * Purpose: write attributes in LOC_ID (dataset, group, named datatype)
- *
- * Programmer: Pedro Vicente, pvn@ncsa.uiuc.edu
- *
- * Date: November 12, 2003
- *
- *-------------------------------------------------------------------------
- */
-
-
-void write_attr_in(hid_t loc_id,
+* Function: write_attr_in
+*
+* Purpose: write attributes in LOC_ID (dataset, group, named datatype)
+*
+* Programmer: Pedro Vicente, pvn@ncsa.uiuc.edu
+*
+* Date: November 12, 2003
+*
+*-------------------------------------------------------------------------
+*/
+
+
+int write_attr_in(hid_t loc_id,
                    const char* dset_name, /* for saving reference to dataset*/
                    hid_t fid, /* for reference create */
                    int make_diffs /* flag to modify data buffers */)
@@ -3841,20 +4087,19 @@ void write_attr_in(hid_t loc_id,
         char   a;
         double b;
     } s_t;
-    
+
     typedef enum
     {
         RED,
-            GREEN
+        GREEN
     } e_t;
-    
-    hid_t   attr_id;
-    hid_t   space_id;
-    hid_t   type_id;
-    herr_t  status;
+
+    hid_t   aid;
+    hid_t   sid;
+    hid_t   tid;
     int     val, i, j, k, n;
     float   f;
-    
+
     /* create 1D attributes with dimension [2], 2 elements */
     hsize_t    dims[1]={2};
     char       buf1[2][2]= {"ab","de"};        /* string */
@@ -3867,7 +4112,7 @@ void write_attr_in(hid_t loc_id,
     int        buf6[2][3]= {{1,2,3},{4,5,6}};  /* array */
     int        buf7[2]= {1,2};                 /* integer */
     float      buf8[2]= {1,2};                 /* float */
-    
+
     /* create 2D attributes with dimension [3][2], 6 elements */
     hsize_t    dims2[2]={3,2};
     char       buf12[6][2]= {"ab","cd","ef","gh","ij","kl"};         /* string */
@@ -3879,7 +4124,7 @@ void write_attr_in(hid_t loc_id,
     int        buf62[6][3]= {{1,2,3},{4,5,6},{7,8,9},{10,11,12},{13,14,15},{16,17,18}};  /* array */
     int        buf72[3][2]= {{1,2},{3,4},{5,6}};                     /* integer */
     float      buf82[3][2]= {{1,2},{3,4},{5,6}};                     /* float */
-    
+
     /* create 3D attributes with dimension [4][3][2], 24 elements */
     hsize_t    dims3[3]={4,3,2};
     char       buf13[24][2]= {"ab","cd","ef","gh","ij","kl","mn","pq",
@@ -3893,18 +4138,18 @@ void write_attr_in(hid_t loc_id,
     int        buf63[24][3];      /* array */
     int        buf73[4][3][2];    /* integer */
     float      buf83[4][3][2];    /* float */
-    
-    
+
+
     /*-------------------------------------------------------------------------
     * 1D attributes
     *-------------------------------------------------------------------------
     */
-    
+
     /*-------------------------------------------------------------------------
     * H5T_STRING
     *-------------------------------------------------------------------------
     */
-    
+
     if (make_diffs)
     {
         for (i=0; i<2; i++)
@@ -3925,16 +4170,20 @@ void write_attr_in(hid_t loc_id,
     [ 1 ]          d                z
     [ 1 ]          e                z
     */
-    type_id = H5Tcopy(H5T_C_S1);
-    status  = H5Tset_size(type_id, (size_t)2);
-    make_attr(loc_id,1,dims,"string",type_id,buf1);
-    status = H5Tclose(type_id);
+    if ((tid = H5Tcopy(H5T_C_S1)) < 0)
+        goto out;
+    if (H5Tset_size(tid, (size_t)2) < 0)
+        goto out;
+    if (make_attr(loc_id,1,dims,"string",tid,buf1) < 0)
+        goto out;
+    if (H5Tclose(tid) < 0)
+        goto out;
 
     /*-------------------------------------------------------------------------
     * H5T_BITFIELD
     *-------------------------------------------------------------------------
     */
-    
+
     if (make_diffs)
     {
         for (i=0; i<2; i++)
@@ -3952,15 +4201,18 @@ void write_attr_in(hid_t loc_id,
     [ 1 ]          2               0               2
     */
 
-    type_id = H5Tcopy(H5T_STD_B8LE);
-    make_attr(loc_id,1,dims,"bitfield",type_id,buf2);
-    status = H5Tclose(type_id);
-    
+    if ((tid = H5Tcopy(H5T_STD_B8LE)) < 0)
+        goto out;
+    if (make_attr(loc_id,1,dims,"bitfield",tid,buf2) < 0)
+        goto out;
+    if (H5Tclose(tid) < 0)
+        goto out;
+
     /*-------------------------------------------------------------------------
     * H5T_OPAQUE
     *-------------------------------------------------------------------------
     */
-    
+
     /*
     buf2[2]= {1,2};
     $h5diff file7.h5 file6.h5 g1 g1 -v
@@ -3972,17 +4224,21 @@ void write_attr_in(hid_t loc_id,
     [ 0 ]          1               0               1
     [ 1 ]          2               0               2
     */
-    
-    type_id = H5Tcreate(H5T_OPAQUE, (size_t)1);
-    status = H5Tset_tag(type_id, "1-byte opaque type"); /* must set this */
-    make_attr(loc_id,1,dims,"opaque",type_id,buf2);
-    status = H5Tclose(type_id);
-    
+
+    if ((tid = H5Tcreate(H5T_OPAQUE, (size_t)1)) < 0)
+        goto out;
+    if (H5Tset_tag(tid, "1-byte opaque type") < 0)
+        goto out;
+    if (make_attr(loc_id,1,dims,"opaque",tid,buf2) < 0)
+        goto out;
+    if (H5Tclose(tid) < 0)
+        goto out;
+
     /*-------------------------------------------------------------------------
     * H5T_COMPOUND
     *-------------------------------------------------------------------------
     */
-    
+
     if (make_diffs)
     {
         for (i=0; i<2; i++)
@@ -3990,7 +4246,7 @@ void write_attr_in(hid_t loc_id,
             buf3[i].a=0; buf3[i].b=0;
         }
     }
-    
+
     /*
     buf3[2]= {{1,2},{3,4}};
     $h5diff file7.h5 file6.h5 g1 g1 -v
@@ -4003,13 +4259,18 @@ void write_attr_in(hid_t loc_id,
     [ 1 ]          3               5               2
     [ 1 ]          4               5               1
     */
-    
-    type_id = H5Tcreate (H5T_COMPOUND, sizeof(s_t));
-    H5Tinsert(type_id, "a", HOFFSET(s_t, a), H5T_NATIVE_CHAR);
-    H5Tinsert(type_id, "b", HOFFSET(s_t, b), H5T_NATIVE_DOUBLE);
-    make_attr(loc_id,1,dims,"compound",type_id,buf3);
-    status = H5Tclose(type_id);
-    
+
+    if ((tid = H5Tcreate (H5T_COMPOUND, sizeof(s_t))) < 0)
+        goto out;
+    if (H5Tinsert(tid, "a", HOFFSET(s_t, a), H5T_NATIVE_CHAR) < 0)
+        goto out;
+    if (H5Tinsert(tid, "b", HOFFSET(s_t, b), H5T_NATIVE_DOUBLE) < 0)
+        goto out;
+    if (make_attr(loc_id,1,dims,"compound",tid,buf3) < 0)
+        goto out;
+    if (H5Tclose(tid) < 0)
+        goto out;
+
     /*-------------------------------------------------------------------------
     * H5T_REFERENCE
     *-------------------------------------------------------------------------
@@ -4017,12 +4278,15 @@ void write_attr_in(hid_t loc_id,
     /* object references ( H5R_OBJECT  */
     if (dset_name)
     {
-        status=H5Rcreate(&buf4[0],fid,dset_name,H5R_OBJECT,-1);
-        status=H5Rcreate(&buf4[1],fid,dset_name,H5R_OBJECT,-1);
-        make_attr(loc_id,1,dims,"reference",H5T_STD_REF_OBJ,buf4);
+        if (H5Rcreate(&buf4[0],fid,dset_name,H5R_OBJECT,-1) < 0)
+            goto out;
+        if (H5Rcreate(&buf4[1],fid,dset_name,H5R_OBJECT,-1) < 0)
+            goto out;
+        if (make_attr(loc_id,1,dims,"reference",H5T_STD_REF_OBJ,buf4) < 0)
+            goto out;
     }
-    
-    
+
+
     /*-------------------------------------------------------------------------
     * H5T_ENUM
     *-------------------------------------------------------------------------
@@ -4044,19 +4308,24 @@ void write_attr_in(hid_t loc_id,
     [ 0 ]          RED              GREEN
     [ 1 ]          RED              GREEN
     */
-    type_id = H5Tcreate(H5T_ENUM, sizeof(e_t));
-    H5Tenum_insert(type_id, "RED",   (val = 0, &val));
-    H5Tenum_insert(type_id, "GREEN", (val = 1, &val));
-    make_attr(loc_id,1,dims,"enum",type_id,buf45);
-    status = H5Tclose(type_id);
+    if ((tid = H5Tcreate(H5T_ENUM, sizeof(e_t))) < 0)
+        goto out;
+    if (H5Tenum_insert(tid, "RED",   (val = 0, &val)) < 0)
+        goto out;
+    if (H5Tenum_insert(tid, "GREEN", (val = 1, &val)) < 0)
+        goto out;
+    if (make_attr(loc_id,1,dims,"enum",tid,buf45) < 0)
+        goto out;
+    if (H5Tclose(tid) < 0)
+        goto out;
 
     /*-------------------------------------------------------------------------
     * H5T_VLEN
     *-------------------------------------------------------------------------
     */
-    
+
     /* Allocate and initialize VL dataset to write */
-    
+
     buf5[0].len = 1;
     buf5[0].p = malloc( 1 * sizeof(int));
     ((int *)buf5[0].p)[0]=1;
@@ -4064,7 +4333,7 @@ void write_attr_in(hid_t loc_id,
     buf5[1].p = malloc(2 * sizeof(int));
     ((int *)buf5[1].p)[0] = 2;
     ((int *)buf5[1].p)[1] = 3;
-    
+
     if(make_diffs)
     {
         ((int *)buf5[0].p)[0] = 0;
@@ -4080,23 +4349,29 @@ void write_attr_in(hid_t loc_id,
     [ 1 ]          2               0               2
     [ 1 ]          3               0               3
     */
-    
-    space_id = H5Screate_simple(1, dims, NULL);
-    type_id = H5Tvlen_create(H5T_NATIVE_INT);
-    attr_id = H5Acreate2(loc_id, "vlen", type_id, space_id, H5P_DEFAULT, H5P_DEFAULT);
-    status = H5Awrite(attr_id, type_id, buf5);
-    assert(status >= 0);
-    status = H5Dvlen_reclaim(type_id, space_id, H5P_DEFAULT, buf5);
-    assert(status >= 0);
-    status = H5Aclose(attr_id);
-    status = H5Tclose(type_id);
-    status = H5Sclose(space_id);
-    
+
+    if ((sid = H5Screate_simple(1, dims, NULL)) < 0)
+        goto out;
+    if ((tid = H5Tvlen_create(H5T_NATIVE_INT)) < 0)
+        goto out;
+    if ((aid = H5Acreate2(loc_id, "vlen", tid, sid, H5P_DEFAULT, H5P_DEFAULT)) < 0)
+        goto out;
+    if (H5Awrite(aid, tid, buf5) < 0)
+        goto out;
+    if (H5Dvlen_reclaim(tid, sid, H5P_DEFAULT, buf5) < 0)
+        goto out;
+    if (H5Aclose(aid) < 0)
+        goto out;
+    if (H5Tclose(tid) < 0)
+        goto out;
+    if (H5Sclose(sid) < 0)
+        goto out;
+
     /*-------------------------------------------------------------------------
     * H5T_ARRAY
     *-------------------------------------------------------------------------
     */
-    
+
     if (make_diffs)
     {
         for (i=0; i<2; i++)
@@ -4119,15 +4394,18 @@ void write_attr_in(hid_t loc_id,
     [ 1 ]          5               0               5
     [ 1 ]          6               0               6
     */
-    type_id = H5Tarray_create2(H5T_NATIVE_INT, 1, dimarray);
-    make_attr(loc_id, 1, dims, "array", type_id, buf6);
-    status = H5Tclose(type_id);
+    if ((tid = H5Tarray_create2(H5T_NATIVE_INT, 1, dimarray)) < 0)
+        goto out;
+    if (make_attr(loc_id, 1, dims, "array", tid, buf6) < 0)
+        goto out;
+    if (H5Tclose(tid) < 0)
+        goto out;
 
     /*-------------------------------------------------------------------------
     * H5T_INTEGER and H5T_FLOAT
     *-------------------------------------------------------------------------
     */
-    
+
     if(make_diffs)
     {
         for(i = 0; i < 2; i++) 
@@ -4136,7 +4414,7 @@ void write_attr_in(hid_t loc_id,
             buf8[i]=0;
         }
     }
-    
+
     /*
     buf7[2]= {1,2};
     buf8[2]= {1,2};
@@ -4151,15 +4429,17 @@ void write_attr_in(hid_t loc_id,
     [ 0 ]          1               0               1
     [ 1 ]          2               0               2
     */
-    make_attr(loc_id,1,dims,"integer",H5T_NATIVE_INT,buf7);
-    make_attr(loc_id,1,dims,"float",H5T_NATIVE_FLOAT,buf8);
+    if (make_attr(loc_id,1,dims,"integer",H5T_NATIVE_INT,buf7) < 0)
+        goto out;
+    if (make_attr(loc_id,1,dims,"float",H5T_NATIVE_FLOAT,buf8) < 0)
+        goto out;
+
 
-    
     /*-------------------------------------------------------------------------
     * 2D attributes
     *-------------------------------------------------------------------------
     */
-    
+
     /*-------------------------------------------------------------------------
     * H5T_STRING
     *-------------------------------------------------------------------------
@@ -4168,7 +4448,7 @@ void write_attr_in(hid_t loc_id,
     {
         memset(buf12, 'z', sizeof buf12);
     }
-    
+
     /*
     buf12[6][2]= {"ab","cd","ef","gh","ij","kl"};
     $h5diff file7.h5 file6.h5 g1 g1 -v
@@ -4188,22 +4468,26 @@ void write_attr_in(hid_t loc_id,
     [ 2 1 ]          k                z
     [ 2 1 ]          l                z
     */
-    
-    type_id = H5Tcopy(H5T_C_S1);
-    status  = H5Tset_size(type_id, (size_t)2);
-    make_attr(loc_id,2,dims2,"string2D",type_id,buf12);
-    status = H5Tclose(type_id);
-    
+
+    if ((tid = H5Tcopy(H5T_C_S1)) < 0)
+        goto out;
+    if (H5Tset_size(tid, (size_t)2) < 0)
+        goto out;
+    if (make_attr(loc_id,2,dims2,"string2D",tid,buf12) < 0)
+        goto out;
+    if (H5Tclose(tid) < 0)
+        goto out;
+
     /*-------------------------------------------------------------------------
     * H5T_BITFIELD
     *-------------------------------------------------------------------------
     */
-    
+
     if (make_diffs)
     {
         memset(buf22,0,sizeof buf22);
     }
-    
+
     /*
     buf22[3][2]= {{1,2},{3,4},{5,6}};
     $h5diff file7.h5 file6.h5 g1 g1 -v
@@ -4217,17 +4501,20 @@ void write_attr_in(hid_t loc_id,
     [ 2 0 ]          5               0               5
     [ 2 1 ]          6               0               6
     */
-    
-    
-    type_id = H5Tcopy(H5T_STD_B8LE);
-    make_attr(loc_id,2,dims2,"bitfield2D",type_id,buf22);
-    status = H5Tclose(type_id);
-    
+
+
+    if ((tid = H5Tcopy(H5T_STD_B8LE)) < 0)
+        goto out;
+    if (make_attr(loc_id,2,dims2,"bitfield2D",tid,buf22) < 0)
+        goto out;
+    if (H5Tclose(tid) < 0)
+        goto out;
+
     /*-------------------------------------------------------------------------
     * H5T_OPAQUE
     *-------------------------------------------------------------------------
     */
-    
+
     /*
     buf22[3][2]= {{1,2},{3,4},{5,6}};
     $h5diff file7.h5 file6.h5 g1 g1 -v
@@ -4241,11 +4528,15 @@ void write_attr_in(hid_t loc_id,
     [ 2 0 ]          5               0               5
     [ 2 1 ]          6               0               6
     */
-    type_id = H5Tcreate(H5T_OPAQUE, (size_t)1);
-    status = H5Tset_tag(type_id, "1-byte opaque type"); /* must set this */
-    make_attr(loc_id,2,dims2,"opaque2D",type_id,buf22);
-    status = H5Tclose(type_id);
-    
+    if ((tid = H5Tcreate(H5T_OPAQUE, (size_t)1)) < 0)
+        goto out;
+    if (H5Tset_tag(tid, "1-byte opaque type") < 0)
+        goto out;
+    if (make_attr(loc_id,2,dims2,"opaque2D",tid,buf22) < 0)
+        goto out;
+    if (H5Tclose(tid) < 0)
+        goto out;
+
     /*-------------------------------------------------------------------------
     * H5T_COMPOUND
     *-------------------------------------------------------------------------
@@ -4254,7 +4545,7 @@ void write_attr_in(hid_t loc_id,
     {
         memset(buf32,0,sizeof buf32);
     }
-    
+
     /*
     buf32[6]= {{1,2},{3,4},{5,6},{7,8},{9,10},{11,12}};
     $h5diff file7.h5 file6.h5 g1 g1 -v
@@ -4268,14 +4559,19 @@ void write_attr_in(hid_t loc_id,
     [ 2 0 ]          5               0               5
     [ 2 1 ]          6               0               6
     */
-    
-    
-    type_id = H5Tcreate (H5T_COMPOUND, sizeof(s_t));
-    H5Tinsert(type_id, "a", HOFFSET(s_t, a), H5T_NATIVE_CHAR);
-    H5Tinsert(type_id, "b", HOFFSET(s_t, b), H5T_NATIVE_DOUBLE);
-    make_attr(loc_id,2,dims2,"compound2D",type_id,buf32);
-    status = H5Tclose(type_id);
-    
+
+
+    if ((tid = H5Tcreate (H5T_COMPOUND, sizeof(s_t))) < 0)
+        goto out;
+    if (H5Tinsert(tid, "a", HOFFSET(s_t, a), H5T_NATIVE_CHAR) < 0)
+        goto out;
+    if (H5Tinsert(tid, "b", HOFFSET(s_t, b), H5T_NATIVE_DOUBLE) < 0)
+        goto out;
+    if (make_attr(loc_id,2,dims2,"compound2D",tid,buf32) < 0)
+        goto out;
+    if (H5Tclose(tid) < 0)
+        goto out;
+
     /*-------------------------------------------------------------------------
     * H5T_REFERENCE
     *-------------------------------------------------------------------------
@@ -4287,12 +4583,14 @@ void write_attr_in(hid_t loc_id,
         {
             for (j = 0; j < 2; j++) 
             {
-                status=H5Rcreate(&buf42[i][j],fid,dset_name,H5R_OBJECT,-1);
+                if (H5Rcreate(&buf42[i][j],fid,dset_name,H5R_OBJECT,-1) < 0)
+                    goto out;
             }
         }
-        make_attr(loc_id,2,dims2,"reference2D",H5T_STD_REF_OBJ,buf42);
+        if (make_attr(loc_id,2,dims2,"reference2D",H5T_STD_REF_OBJ,buf42) < 0)
+            goto out;
     }
-    
+
     /*-------------------------------------------------------------------------
     * H5T_ENUM
     *-------------------------------------------------------------------------
@@ -4304,7 +4602,7 @@ void write_attr_in(hid_t loc_id,
             if (make_diffs) buf452[i][j]=GREEN; else buf452[i][j]=RED;
         }
     }
-    
+
     /*
     Attribute:   <enum2D> and <enum2D>
     position        enum2D of </g1> enum2D of </g1> difference
@@ -4316,18 +4614,23 @@ void write_attr_in(hid_t loc_id,
     [ 2 0 ]          RED              GREEN
     [ 2 1 ]          RED              GREEN
     */
-    
-    type_id = H5Tcreate(H5T_ENUM, sizeof(e_t));
-    H5Tenum_insert(type_id, "RED",   (val = 0, &val));
-    H5Tenum_insert(type_id, "GREEN", (val = 1, &val));
-    make_attr(loc_id,2,dims2,"enum2D",type_id,buf452);
-    status = H5Tclose(type_id);
-    
+
+    if ((tid = H5Tcreate(H5T_ENUM, sizeof(e_t))) < 0)
+        goto out;
+    if (H5Tenum_insert(tid, "RED",   (val = 0, &val)) < 0)
+        goto out;
+    if (H5Tenum_insert(tid, "GREEN", (val = 1, &val)) < 0)
+        goto out;
+    if (make_attr(loc_id,2,dims2,"enum2D",tid,buf452) < 0)
+        goto out;
+    if (H5Tclose(tid) < 0)
+        goto out;
+
     /*-------------------------------------------------------------------------
     * H5T_VLEN
     *-------------------------------------------------------------------------
     */
-    
+
     /* Allocate and initialize VL dataset to write */
     n=0;
     for (i = 0; i < 3; i++) 
@@ -4342,7 +4645,7 @@ void write_attr_in(hid_t loc_id,
                 else ((int *)buf52[i][j].p)[l] = n++;
         }
     }
-    
+
     /*
     position        vlen2D of </g1> vlen2D of </g1> difference
     ------------------------------------------------------------
@@ -4358,23 +4661,29 @@ void write_attr_in(hid_t loc_id,
     [ 2 1 ]          10              0               10
     [ 2 1 ]          11              0               11
     */
-    
-    space_id = H5Screate_simple(2, dims2, NULL);
-    type_id = H5Tvlen_create(H5T_NATIVE_INT);
-    attr_id = H5Acreate2(loc_id, "vlen2D", type_id, space_id, H5P_DEFAULT, H5P_DEFAULT);
-    status = H5Awrite(attr_id, type_id, buf52);
-    assert(status >= 0);
-    status = H5Dvlen_reclaim(type_id, space_id, H5P_DEFAULT, buf52);
-    assert(status >= 0);
-    status = H5Aclose(attr_id);
-    status = H5Tclose(type_id);
-    status = H5Sclose(space_id);
-    
+
+    if ((sid = H5Screate_simple(2, dims2, NULL)) < 0)
+        goto out;
+    if ((tid = H5Tvlen_create(H5T_NATIVE_INT)) < 0)
+        goto out;
+    if ((aid = H5Acreate2(loc_id, "vlen2D", tid, sid, H5P_DEFAULT, H5P_DEFAULT)) < 0)
+        goto out;
+    if (H5Awrite(aid, tid, buf52) < 0)
+        goto out;
+    if (H5Dvlen_reclaim(tid, sid, H5P_DEFAULT, buf52) < 0)
+        goto out;
+    if (H5Aclose(aid) < 0)
+        goto out;
+    if (H5Tclose(tid) < 0)
+        goto out;
+    if (H5Sclose(sid) < 0)
+        goto out;
+
     /*-------------------------------------------------------------------------
     * H5T_ARRAY
     *-------------------------------------------------------------------------
     */
-    
+
     if (make_diffs)
     {
         memset(buf62,0,sizeof buf62);
@@ -4405,15 +4714,18 @@ void write_attr_in(hid_t loc_id,
     [ 2 1 ]          17              0               17
     [ 2 1 ]          18              0               18
     */
-    type_id = H5Tarray_create2(H5T_NATIVE_INT, 1, dimarray);
-    make_attr(loc_id, 2, dims2, "array2D", type_id, buf62);
-    status = H5Tclose(type_id);
-    
+    if ((tid = H5Tarray_create2(H5T_NATIVE_INT, 1, dimarray)) < 0)
+        goto out;
+    if (make_attr(loc_id, 2, dims2, "array2D", tid, buf62) < 0)
+        goto out;
+    if (H5Tclose(tid) < 0)
+        goto out;
+
     /*-------------------------------------------------------------------------
     * H5T_INTEGER and H5T_FLOAT
     *-------------------------------------------------------------------------
     */
-    
+
     if(make_diffs) 
     {
         HDmemset(buf72, 0, sizeof buf72);
@@ -4440,93 +4752,99 @@ void write_attr_in(hid_t loc_id,
     [ 2 0 ]          5               0               5
     [ 2 1 ]          6               0               6
     */
-    
-    make_attr(loc_id,2,dims2,"integer2D",H5T_NATIVE_INT,buf72);
-    make_attr(loc_id,2,dims2,"float2D",H5T_NATIVE_FLOAT,buf82);
-    
-    
+
+    if (make_attr(loc_id,2,dims2,"integer2D",H5T_NATIVE_INT,buf72) < 0)
+        goto out;
+    if (make_attr(loc_id,2,dims2,"float2D",H5T_NATIVE_FLOAT,buf82) < 0)
+        goto out;
+
+
     /*-------------------------------------------------------------------------
     * 3D attributes
     *-------------------------------------------------------------------------
     */
-    
+
     /*-------------------------------------------------------------------------
     * H5T_STRING
     *-------------------------------------------------------------------------
     */
-    
+
     if (make_diffs)
     {
         memset(buf13,'z',sizeof buf13);
     }
-    
+
     /*
     buf13[24][2]= {"ab","cd","ef","gh","ij","kl","mn","pq",
     "rs","tu","vw","xz","AB","CD","EF","GH",
     "IJ","KL","MN","PQ","RS","TU","VW","XZ"};
-    
-     Attribute:   <string3D> and <string3D>
-     position        string3D of </g1> string3D of </g1> difference
-     ------------------------------------------------------------
-     [ 0 0 0 ]          a                z
-     [ 0 0 0 ]          b                z
-     [ 0 0 1 ]          c                z
-     [ 0 0 1 ]          d                z
-     [ 0 1 0 ]          e                z
-     [ 0 1 0 ]          f                z
-     [ 0 1 1 ]          g                z
-     [ 0 1 1 ]          h                z
-     [ 0 2 0 ]          i                z
-     [ 0 2 0 ]          j                z
-     [ 0 2 1 ]          k                z
-     [ 0 2 1 ]          l                z
-     [ 1 0 0 ]          m                z
-     [ 1 0 0 ]          n                z
-     [ 1 0 1 ]          p                z
-     [ 1 0 1 ]          q                z
-     [ 1 1 0 ]          r                z
-     [ 1 1 0 ]          s                z
-     [ 1 1 1 ]          t                z
-     [ 1 1 1 ]          u                z
-     [ 1 2 0 ]          v                z
-     [ 1 2 0 ]          w                z
-     [ 1 2 1 ]          x                z
-     [ 2 0 0 ]          A                z
-     [ 2 0 0 ]          B                z
-     [ 2 0 1 ]          C                z
-     [ 2 0 1 ]          D                z
-     [ 2 1 0 ]          E                z
-     [ 2 1 0 ]          F                z
-     [ 2 1 1 ]          G                z
-     [ 2 1 1 ]          H                z
-     [ 2 2 0 ]          I                z
-     [ 2 2 0 ]          J                z
-     [ 2 2 1 ]          K                z
-     [ 2 2 1 ]          L                z
-     [ 3 0 0 ]          M                z
-     [ 3 0 0 ]          N                z
-     [ 3 0 1 ]          P                z
-     [ 3 0 1 ]          Q                z
-     [ 3 1 0 ]          R                z
-     [ 3 1 0 ]          S                z
-     [ 3 1 1 ]          T                z
-     [ 3 1 1 ]          U                z
-     [ 3 2 0 ]          V                z
-     [ 3 2 0 ]          W                z
-     [ 3 2 1 ]          X                z
-     [ 3 2 1 ]          Z                z
-    */
-    
-    type_id = H5Tcopy(H5T_C_S1);
-    status  = H5Tset_size(type_id, (size_t)2);
-    make_attr(loc_id,3,dims3,"string3D",type_id,buf13);
-    status = H5Tclose(type_id);
-    
+
+    Attribute:   <string3D> and <string3D>
+    position        string3D of </g1> string3D of </g1> difference
+    ------------------------------------------------------------
+    [ 0 0 0 ]          a                z
+    [ 0 0 0 ]          b                z
+    [ 0 0 1 ]          c                z
+    [ 0 0 1 ]          d                z
+    [ 0 1 0 ]          e                z
+    [ 0 1 0 ]          f                z
+    [ 0 1 1 ]          g                z
+    [ 0 1 1 ]          h                z
+    [ 0 2 0 ]          i                z
+    [ 0 2 0 ]          j                z
+    [ 0 2 1 ]          k                z
+    [ 0 2 1 ]          l                z
+    [ 1 0 0 ]          m                z
+    [ 1 0 0 ]          n                z
+    [ 1 0 1 ]          p                z
+    [ 1 0 1 ]          q                z
+    [ 1 1 0 ]          r                z
+    [ 1 1 0 ]          s                z
+    [ 1 1 1 ]          t                z
+    [ 1 1 1 ]          u                z
+    [ 1 2 0 ]          v                z
+    [ 1 2 0 ]          w                z
+    [ 1 2 1 ]          x                z
+    [ 2 0 0 ]          A                z
+    [ 2 0 0 ]          B                z
+    [ 2 0 1 ]          C                z
+    [ 2 0 1 ]          D                z
+    [ 2 1 0 ]          E                z
+    [ 2 1 0 ]          F                z
+    [ 2 1 1 ]          G                z
+    [ 2 1 1 ]          H                z
+    [ 2 2 0 ]          I                z
+    [ 2 2 0 ]          J                z
+    [ 2 2 1 ]          K                z
+    [ 2 2 1 ]          L                z
+    [ 3 0 0 ]          M                z
+    [ 3 0 0 ]          N                z
+    [ 3 0 1 ]          P                z
+    [ 3 0 1 ]          Q                z
+    [ 3 1 0 ]          R                z
+    [ 3 1 0 ]          S                z
+    [ 3 1 1 ]          T                z
+    [ 3 1 1 ]          U                z
+    [ 3 2 0 ]          V                z
+    [ 3 2 0 ]          W                z
+    [ 3 2 1 ]          X                z
+    [ 3 2 1 ]          Z                z
+    */
+
+    if ((tid = H5Tcopy(H5T_C_S1)) < 0)
+        goto out;
+    if (H5Tset_size(tid, (size_t)2) < 0)
+        goto out;
+    if (make_attr(loc_id,3,dims3,"string3D",tid,buf13) < 0)
+        goto out;
+    if (H5Tclose(tid) < 0)
+        goto out;
+
     /*-------------------------------------------------------------------------
     * H5T_BITFIELD
     *-------------------------------------------------------------------------
     */
-    
+
     n=1;
     for (i = 0; i < 4; i++) 
     {
@@ -4539,7 +4857,7 @@ void write_attr_in(hid_t loc_id,
             }
         }
     }
-    
+
     /*
     position        bitfield3D of </g1> bitfield3D of </g1> difference
     ------------------------------------------------------------
@@ -4568,25 +4886,32 @@ void write_attr_in(hid_t loc_id,
     [ 3 2 0 ]          23              0               23
     [ 3 2 1 ]          24              0               24
     */
-    
-    type_id = H5Tcopy(H5T_STD_B8LE);
-    make_attr(loc_id,3,dims3,"bitfield3D",type_id,buf23);
-    status = H5Tclose(type_id);
-    
+
+    if ((tid = H5Tcopy(H5T_STD_B8LE)) < 0)
+        goto out;
+    if (make_attr(loc_id,3,dims3,"bitfield3D",tid,buf23) < 0)
+        goto out;
+    if (H5Tclose(tid) < 0)
+        goto out;
+
     /*-------------------------------------------------------------------------
     * H5T_OPAQUE
     *-------------------------------------------------------------------------
     */
-    type_id = H5Tcreate(H5T_OPAQUE, (size_t)1);
-    status = H5Tset_tag(type_id, "1-byte opaque type"); /* must set this */
-    make_attr(loc_id,3,dims3,"opaque3D",type_id,buf23);
-    status = H5Tclose(type_id);
-    
+    if ((tid = H5Tcreate(H5T_OPAQUE, (size_t)1)) < 0)
+        goto out;
+    if (H5Tset_tag(tid, "1-byte opaque type") < 0)
+        goto out;
+    if (make_attr(loc_id,3,dims3,"opaque3D",tid,buf23) < 0)
+        goto out;
+    if (H5Tclose(tid) < 0)
+        goto out;
+
     /*-------------------------------------------------------------------------
     * H5T_COMPOUND
     *-------------------------------------------------------------------------
     */
-    
+
     n=1;
     for (i = 0; i < 4; i++) 
     {
@@ -4658,15 +4983,20 @@ void write_attr_in(hid_t loc_id,
     [ 3 2 1 ]          47              0               47
     [ 3 2 1 ]          48              0               48
     */
-    
-    
-    
-    type_id = H5Tcreate (H5T_COMPOUND, sizeof(s_t));
-    H5Tinsert(type_id, "a", HOFFSET(s_t, a), H5T_NATIVE_CHAR);
-    H5Tinsert(type_id, "b", HOFFSET(s_t, b), H5T_NATIVE_DOUBLE);
-    make_attr(loc_id,3,dims3,"compound3D",type_id,buf33);
-    status = H5Tclose(type_id);
-    
+
+
+
+    if ((tid = H5Tcreate (H5T_COMPOUND, sizeof(s_t))) < 0)
+        goto out;
+    if (H5Tinsert(tid, "a", HOFFSET(s_t, a), H5T_NATIVE_CHAR) < 0)
+        goto out;
+    if (H5Tinsert(tid, "b", HOFFSET(s_t, b), H5T_NATIVE_DOUBLE) < 0)
+        goto out;
+    if (make_attr(loc_id,3,dims3,"compound3D",tid,buf33) < 0)
+        goto out;
+    if (H5Tclose(tid) < 0)
+        goto out;
+
     /*-------------------------------------------------------------------------
     * H5T_REFERENCE
     *-------------------------------------------------------------------------
@@ -4679,17 +5009,19 @@ void write_attr_in(hid_t loc_id,
             for (j = 0; j < 3; j++) 
             {
                 for (k = 0; k < 2; k++)
-                    status=H5Rcreate(&buf43[i][j][k],fid,dset_name,H5R_OBJECT,-1);
+                    if (H5Rcreate(&buf43[i][j][k],fid,dset_name,H5R_OBJECT,-1) < 0)
+                        goto out;
             }
         }
-        make_attr(loc_id,3,dims3,"reference3D",H5T_STD_REF_OBJ,buf43);
+        if (make_attr(loc_id,3,dims3,"reference3D",H5T_STD_REF_OBJ,buf43) < 0)
+            goto out;
     }
-    
+
     /*-------------------------------------------------------------------------
     * H5T_ENUM
     *-------------------------------------------------------------------------
     */
-    
+
     for (i = 0; i < 4; i++) 
     {
         for (j = 0; j < 3; j++) 
@@ -4707,7 +5039,7 @@ void write_attr_in(hid_t loc_id,
             }
         }
     }
-    
+
     /*
     position        enum3D of </g1> enum3D of </g1> difference
     ------------------------------------------------------------
@@ -4736,19 +5068,24 @@ void write_attr_in(hid_t loc_id,
     [ 3 2 0 ]          GREEN            RED
     [ 3 2 1 ]          GREEN            RED
     */
-    
-    
-    type_id = H5Tcreate(H5T_ENUM, sizeof(e_t));
-    H5Tenum_insert(type_id, "RED",   (val = 0, &val));
-    H5Tenum_insert(type_id, "GREEN", (val = 1, &val));
-    make_attr(loc_id,3,dims3,"enum3D",type_id,buf453);
-    status = H5Tclose(type_id);
-    
+
+
+    if ((tid = H5Tcreate(H5T_ENUM, sizeof(e_t))) < 0)
+        goto out;
+    if (H5Tenum_insert(tid, "RED",   (val = 0, &val)) < 0)
+        goto out;
+    if (H5Tenum_insert(tid, "GREEN", (val = 1, &val)) < 0)
+        goto out;
+    if (make_attr(loc_id,3,dims3,"enum3D",tid,buf453) < 0)
+        goto out;
+    if (H5Tclose(tid) < 0)
+        goto out;
+
     /*-------------------------------------------------------------------------
     * H5T_VLEN
     *-------------------------------------------------------------------------
     */
-    
+
     /* Allocate and initialize VL dataset to write */
     n=0;
     for (i = 0; i < 4; i++) 
@@ -4785,17 +5122,23 @@ void write_attr_in(hid_t loc_id,
     [ 1 1 0 ]          10              0               10
     etc
     */
-    space_id = H5Screate_simple(3, dims3, NULL);
-    type_id = H5Tvlen_create(H5T_NATIVE_INT);
-    attr_id = H5Acreate2(loc_id, "vlen3D", type_id, space_id, H5P_DEFAULT, H5P_DEFAULT);
-    status = H5Awrite(attr_id, type_id, buf53);
-    assert(status >= 0);
-    status = H5Dvlen_reclaim(type_id, space_id, H5P_DEFAULT, buf53);
-    assert(status >= 0);
-    status = H5Aclose(attr_id);
-    status = H5Tclose(type_id);
-    status = H5Sclose(space_id);
-    
+    if ((sid = H5Screate_simple(3, dims3, NULL)) < 0)
+        goto out;
+    if ((tid = H5Tvlen_create(H5T_NATIVE_INT)) < 0)
+        goto out;
+    if ((aid = H5Acreate2(loc_id, "vlen3D", tid, sid, H5P_DEFAULT, H5P_DEFAULT)) < 0)
+        goto out;
+    if (H5Awrite(aid, tid, buf53) < 0)
+        goto out;
+    if (H5Dvlen_reclaim(tid, sid, H5P_DEFAULT, buf53) < 0)
+        goto out;
+    if (H5Aclose(aid) < 0)
+        goto out;
+    if (H5Tclose(tid) < 0)
+        goto out;
+    if (H5Sclose(sid) < 0)
+        goto out;
+
     /*-------------------------------------------------------------------------
     * H5T_ARRAY
     *-------------------------------------------------------------------------
@@ -4821,11 +5164,14 @@ void write_attr_in(hid_t loc_id,
     [ 0 1 0 ]          7               0               7
     etc
     */
-    
-    type_id = H5Tarray_create2(H5T_NATIVE_INT, 1, dimarray);
-    make_attr(loc_id, 3, dims3, "array3D", type_id, buf63);
-    status = H5Tclose(type_id);
-    
+
+    if ((tid = H5Tarray_create2(H5T_NATIVE_INT, 1, dimarray)) < 0)
+        goto out;
+    if (make_attr(loc_id, 3, dims3, "array3D", tid, buf63) < 0)
+        goto out;
+    if (H5Tclose(tid) < 0)
+        goto out;
+
     /*-------------------------------------------------------------------------
     * H5T_INTEGER and H5T_FLOAT
     *-------------------------------------------------------------------------
@@ -4850,7 +5196,7 @@ void write_attr_in(hid_t loc_id,
             }
         }
     }
-    
+
     /*
     position        integer3D of </g1> integer3D of </g1> difference
     ------------------------------------------------------------
@@ -4866,144 +5212,153 @@ void write_attr_in(hid_t loc_id,
     [ 1 1 1 ]          10              0               10
     etc
     */
-    make_attr(loc_id,3,dims3,"integer3D",H5T_NATIVE_INT,buf73);
-    make_attr(loc_id,3,dims3,"float3D",H5T_NATIVE_FLOAT,buf83);
+    if (make_attr(loc_id,3,dims3,"integer3D",H5T_NATIVE_INT,buf73) < 0)
+        goto out;
+    if (make_attr(loc_id,3,dims3,"float3D",H5T_NATIVE_FLOAT,buf83) < 0)
+        goto out;
+
+
+    return 0;
+
+out:
+    H5E_BEGIN_TRY 
+    {
+        H5Aclose(aid);
+        H5Sclose(sid);
+        H5Tclose(tid);
+    } H5E_END_TRY;
+    return -1;
 }
 
 
 
+
 /*-------------------------------------------------------------------------
- * Function: make_dset
- *
- * Purpose: utility function to create and write a dataset in LOC_ID
- *
- * Programmer: Pedro Vicente, pvn@ncsa.uiuc.edu
- *
- * Date: November 12, 2003
- *
- *-------------------------------------------------------------------------
- */
+* Function: make_dset
+*
+* Purpose: utility function to create and write a dataset in LOC_ID
+*
+* Programmer: Pedro Vicente, pvn@ncsa.uiuc.edu
+*
+* Date: November 12, 2003
+*
+*-------------------------------------------------------------------------
+*/
 int make_dset(hid_t loc_id,
               const char *name,
               hid_t sid,
               hid_t dcpl,
               void *buf)
 {
-    hid_t   dsid;
+    hid_t   did=-1;
 
-    /* create the dataset */
-    if((dsid = H5Dcreate2(loc_id, name, H5T_NATIVE_INT, sid, H5P_DEFAULT, dcpl, H5P_DEFAULT)) < 0)
+    if ((did = H5Dcreate2(loc_id, name, H5T_NATIVE_INT, sid, H5P_DEFAULT, dcpl, H5P_DEFAULT)) < 0)
         return -1;
-
-    /* write */
-    if(H5Dwrite(dsid, H5T_NATIVE_INT, H5S_ALL, H5S_ALL, H5P_DEFAULT, buf) < 0)
+    if (H5Dwrite(did, H5T_NATIVE_INT, H5S_ALL, H5S_ALL, H5P_DEFAULT, buf) < 0)
         goto out;
-
-    /* close */
-    if(H5Dclose(dsid) < 0)
+    if (H5Dclose(did) < 0)
         return -1;
-
     return 0;
 
 out:
     H5E_BEGIN_TRY {
-        H5Dclose(dsid);
+        H5Dclose(did);
     } H5E_END_TRY;
     return -1;
 }
 
 
 /*-------------------------------------------------------------------------
- * Function: write_dset
- *
- * Purpose: utility function to create and write a dataset in LOC_ID
- *
- * Programmer: Pedro Vicente, pvn@ncsa.uiuc.edu
- *
- * Date: November 12, 2003
- *
- *-------------------------------------------------------------------------
- */
+* Function: write_dset
+*
+* Purpose: utility function to create and write a dataset in LOC_ID
+*
+* Programmer: Pedro Vicente, pvn@ncsa.uiuc.edu
+*
+* Date: November 12, 2003
+*
+*-------------------------------------------------------------------------
+*/
 
 int write_dset( hid_t loc_id,
-                int rank,
-                hsize_t *dims,
-                const char *dset_name,
-                hid_t type_id,
-                void *buf )
+               int rank,
+               hsize_t *dims,
+               const char *dset_name,
+               hid_t tid,
+               void *buf )
 {
-    hid_t   dset_id;
-    hid_t   space_id;
-
-    /* Create a buf space  */
-    if((space_id = H5Screate_simple(rank, dims, NULL)) < 0)
-        return -1;
-
-    /* Create a dataset */
-    if((dset_id = H5Dcreate2(loc_id, dset_name, type_id, space_id, H5P_DEFAULT, H5P_DEFAULT, H5P_DEFAULT)) < 0)
-        return -1;
-
-    /* Write the buf */
-    if(buf)
-        if(H5Dwrite(dset_id, type_id, H5S_ALL, H5S_ALL, H5P_DEFAULT, buf) < 0)
-            return -1;
+    hid_t   did=-1;
+    hid_t   sid=-1;
 
-    /* Close */
-    if(H5Dclose(dset_id) < 0)
-        return -1;
-    if(H5Sclose(space_id) < 0)
+    if ((sid = H5Screate_simple(rank, dims, NULL)) < 0)
         return -1;
+    if ((did = H5Dcreate2(loc_id, dset_name, tid, sid, H5P_DEFAULT, H5P_DEFAULT, H5P_DEFAULT)) < 0)
+        goto out;
+    if (buf)
+    {
+        if(H5Dwrite(did, tid, H5S_ALL, H5S_ALL, H5P_DEFAULT, buf) < 0)
+            goto out;
+    }
+    if (H5Dclose(did) < 0)
+        goto out;
+    if (H5Sclose(sid) < 0)
+        goto out;
 
     return 0;
+
+out:
+    H5E_BEGIN_TRY {
+        H5Dclose(did);
+        H5Sclose(sid);
+    } H5E_END_TRY;
+    return -1;
 }
 
 
+
 /*-------------------------------------------------------------------------
- * Function: write_attr
- *
- * Purpose: utility function to write an attribute in LOC_ID
- *
- * Programmer: Pedro Vicente, pvn@ncsa.uiuc.edu
- *
- * Date: November 12, 2003
- *
- *-------------------------------------------------------------------------
- */
+* Function: write_attr
+*
+* Purpose: utility function to write an attribute in LOC_ID
+*
+* Programmer: Pedro Vicente, pvn@ncsa.uiuc.edu
+*
+* Date: November 12, 2003
+*
+*-------------------------------------------------------------------------
+*/
 
 int make_attr(hid_t loc_id,
-               int rank,
-               hsize_t *dims,
-               const char *attr_name,
-               hid_t type_id,
-               void *buf)
+              int rank,
+              hsize_t *dims,
+              const char *attr_name,
+              hid_t tid,
+              void *buf)
 {
- hid_t   attr_id;
- hid_t   space_id;
-
- /* create a space  */
- if((space_id = H5Screate_simple(rank, dims, NULL)) < 0)
-  return -1;
+    hid_t   aid;
+    hid_t   sid;
 
- /* create the attribute */
- if((attr_id = H5Acreate2(loc_id, attr_name, type_id, space_id, H5P_DEFAULT, H5P_DEFAULT)) < 0)
-  goto out;
-
- /* write the buffer */
- if(buf)
-   if(H5Awrite(attr_id, type_id, buf) < 0)
-     goto out;
-
- /* close */
- H5Aclose(attr_id);
- H5Sclose(space_id);
- return 0;
+    if ((sid = H5Screate_simple(rank, dims, NULL)) < 0)
+        return -1;
+    if ((aid = H5Acreate2(loc_id, attr_name, tid, sid, H5P_DEFAULT, H5P_DEFAULT)) < 0)
+        goto out;
+    if(buf)
+    {
+        if(H5Awrite(aid, tid, buf) < 0)
+            goto out;
+    }
+    if (H5Aclose(aid) < 0)
+        goto out;
+    if (H5Sclose(sid) < 0)
+        goto out;
+    return 0;
 
 out:
- H5E_BEGIN_TRY {
-  H5Aclose(attr_id);
-  H5Sclose(space_id);
- } H5E_END_TRY;
- return -1;
+    H5E_BEGIN_TRY {
+        H5Aclose(aid);
+        H5Sclose(sid);
+    } H5E_END_TRY;
+    return -1;
 }