HDFFV-10186 Whitespace change

Mostly tabs to spaces
Remove Modifications comments

3 files changed, 545 insertions, 551 deletions

diff --git a/tools/src/h5repack/h5repack.c b/tools/src/h5repack/h5repack.c
index d047612..6f50cbc 100644
--- a/tools/src/h5repack/h5repack.c
+++ b/tools/src/h5repack/h5repack.c
@@ -51,19 +51,19 @@ static int have_request(pack_opt_t *options);
  *-------------------------------------------------------------------------
  */
 int h5repack(const char* infile, const char* outfile, pack_opt_t *options) {
-	/* check input */
-	if (check_options(options) < 0)
-		return -1;
+    /* check input */
+    if (check_options(options) < 0)
+        return -1;
 
-	/* check for objects in input that are in the file */
-	if (check_objects(infile, options) < 0)
-		return -1;
+    /* check for objects in input that are in the file */
+    if (check_objects(infile, options) < 0)
+        return -1;
 
-	/* copy the objects  */
-	if (copy_objects(infile, outfile, options) < 0)
-		return -1;
+    /* copy the objects  */
+    if (copy_objects(infile, outfile, options) < 0)
+        return -1;
 
-	return 0;
+    return 0;
 }
 
 /*-------------------------------------------------------------------------
@@ -105,7 +105,7 @@ h5repack_init(pack_opt_t *options, int verbose, hbool_t latest)
  */
 
 int h5repack_end(pack_opt_t *options) {
-	return options_table_free(options->op_tbl);
+    return options_table_free(options->op_tbl);
 }
 
 /*-------------------------------------------------------------------------
@@ -121,10 +121,10 @@ int h5repack_end(pack_opt_t *options) {
 int
 h5repack_addfilter(const char* str, pack_opt_t *options)
 {
-    obj_list_t *obj_list = NULL; /* one object list for the -f and -l option entry */
-    filter_info_t filter;       /* filter info for the current -f option entry */
-    unsigned n_objs;    /* number of objects in the current -f or -l option entry */
-    int is_glb;         /* is the filter global */
+    obj_list_t   *obj_list = NULL; /* one object list for the -f and -l option entry */
+    filter_info_t filter;          /* filter info for the current -f option entry */
+    unsigned      n_objs;          /* number of objects in the current -f or -l option entry */
+    int           is_glb;          /* is the filter global */
 
     /* parse the -f option */
     if (NULL == (obj_list = parse_filter(str, &n_objs, &filter, options, &is_glb)))
@@ -163,10 +163,10 @@ int
 h5repack_addlayout(const char* str, pack_opt_t *options)
 {
     obj_list_t *obj_list = NULL; /*one object list for the -t and -c option entry */
-    unsigned n_objs; /*number of objects in the current -t or -c option entry */
-    pack_info_t pack; /*info about layout to extract from parse */
-    int j;
-    int ret_value = -1;
+    unsigned    n_objs;          /*number of objects in the current -t or -c option entry */
+    pack_info_t pack;            /*info about layout to extract from parse */
+    int         j;
+    int         ret_value = -1;
 
     init_packobject(&pack);
 
@@ -232,62 +232,62 @@ h5repack_addlayout(const char* str, pack_opt_t *options)
  *-------------------------------------------------------------------------
  */
 hid_t copy_named_datatype(hid_t type_in, hid_t fidout,
-		named_dt_t **named_dt_head_p, trav_table_t *travt, pack_opt_t *options) {
-	named_dt_t *dt = *named_dt_head_p; /* Stack pointer */
-	named_dt_t *dt_ret = NULL; /* Datatype to return */
-	H5O_info_t oinfo; /* Object info of input dtype */
-	hid_t ret_value = -1; /* The identifier of the named dtype in the out file */
-
-	if (H5Oget_info(type_in, &oinfo) < 0)
-		goto done;
-
-	if (*named_dt_head_p) {
-		/* Stack already exists, search for the datatype */
-		while (dt && dt->addr_in != oinfo.addr)
-			dt = dt->next;
-
-		dt_ret = dt;
-	}
-	else {
-		/* Create the stack */
-		size_t i;
-
-		for (i = 0; i < travt->nobjs; i++) {
-			if (travt->objs[i].type == H5TRAV_TYPE_NAMED_DATATYPE) {
-				/* Push onto the stack */
-				if (NULL == (dt = (named_dt_t *) HDmalloc(sizeof(named_dt_t)))) {
-					goto done;
-				}
-				dt->next = *named_dt_head_p;
-				*named_dt_head_p = dt;
-
-				/* Update the address and id */
-				dt->addr_in = travt->objs[i].objno;
-				dt->id_out = -1;
-
-				/* Check if this type is the one requested */
-				if (oinfo.addr == dt->addr_in) {
-					HDassert(!dt_ret);
-					dt_ret = dt;
-				} /* end if */
-			} /* end if */
-		} /* end for */
-	} /* end else */
-
-	/* Handle the case that the requested datatype was not found.  This is
-	 * possible if the datatype was committed anonymously in the input file. */
-	if (!dt_ret) {
-		/* Push the new datatype onto the stack */
-		if (NULL == (dt_ret = (named_dt_t *) HDmalloc(sizeof(named_dt_t)))) {
-			goto done;
-		}
-		dt_ret->next = *named_dt_head_p;
-		*named_dt_head_p = dt_ret;
+        named_dt_t **named_dt_head_p, trav_table_t *travt, pack_opt_t *options) {
+    named_dt_t *dt = *named_dt_head_p; /* Stack pointer */
+    named_dt_t *dt_ret = NULL;         /* Datatype to return */
+    H5O_info_t  oinfo;                 /* Object info of input dtype */
+    hid_t ret_value = -1;              /* The identifier of the named dtype in the out file */
 
-		/* Update the address and id */
-		dt_ret->addr_in = oinfo.addr;
-		dt_ret->id_out = -1;
-	} /* end if */
+    if (H5Oget_info(type_in, &oinfo) < 0)
+        goto done;
+
+    if (*named_dt_head_p) {
+        /* Stack already exists, search for the datatype */
+        while (dt && dt->addr_in != oinfo.addr)
+            dt = dt->next;
+
+        dt_ret = dt;
+    }
+    else {
+        /* Create the stack */
+        size_t i;
+
+        for (i = 0; i < travt->nobjs; i++) {
+            if (travt->objs[i].type == H5TRAV_TYPE_NAMED_DATATYPE) {
+                /* Push onto the stack */
+                if (NULL == (dt = (named_dt_t *) HDmalloc(sizeof(named_dt_t)))) {
+                    goto done;
+                }
+                dt->next = *named_dt_head_p;
+                *named_dt_head_p = dt;
+
+                /* Update the address and id */
+                dt->addr_in = travt->objs[i].objno;
+                dt->id_out = -1;
+
+                /* Check if this type is the one requested */
+                if (oinfo.addr == dt->addr_in) {
+                    HDassert(!dt_ret);
+                    dt_ret = dt;
+                } /* end if */
+            } /* end if */
+        } /* end for */
+    } /* end else */
+
+    /* Handle the case that the requested datatype was not found.  This is
+    * possible if the datatype was committed anonymously in the input file. */
+    if (!dt_ret) {
+        /* Push the new datatype onto the stack */
+        if (NULL == (dt_ret = (named_dt_t *) HDmalloc(sizeof(named_dt_t)))) {
+            goto done;
+        }
+        dt_ret->next = *named_dt_head_p;
+        *named_dt_head_p = dt_ret;
+
+        /* Update the address and id */
+        dt_ret->addr_in = oinfo.addr;
+        dt_ret->id_out = -1;
+    } /* end if */
 
 	/* If the requested datatype does not yet exist in the output file, copy it
 	 * anonymously */
@@ -302,17 +302,17 @@ hid_t copy_named_datatype(hid_t type_in, hid_t fidout,
 			goto done;
 	} /* end if */
 
-	/* Set return value */
-	ret_value = dt_ret->id_out;
+    /* Set return value */
+    ret_value = dt_ret->id_out;
 
-	/* Increment the ref count on id_out, because the calling function will try
-	 * to close it */
-	if(H5Iinc_ref(ret_value) < 0) {
-		ret_value = -1;
-	}
+    /* Increment the ref count on id_out, because the calling function will try
+    * to close it */
+    if(H5Iinc_ref(ret_value) < 0) {
+        ret_value = -1;
+    }
 
 done:
-	return (ret_value);
+    return (ret_value);
 } /* end copy_named_datatype */
 
 /*-------------------------------------------------------------------------
@@ -327,22 +327,22 @@ done:
  *-------------------------------------------------------------------------
  */
 int named_datatype_free(named_dt_t **named_dt_head_p, int ignore_err) {
-	named_dt_t *dt = *named_dt_head_p;
-	int ret_value = -1;
+    named_dt_t *dt = *named_dt_head_p;
+    int         ret_value = -1;
 
-	while (dt) {
-		/* Pop the datatype off the stack and free it */
-		if (H5Tclose(dt->id_out) < 0 && !ignore_err)
-			goto done;
-		dt = dt->next;
-		HDfree(*named_dt_head_p);
-		*named_dt_head_p = dt;
-	} /* end while */
+    while (dt) {
+        /* Pop the datatype off the stack and free it */
+        if (H5Tclose(dt->id_out) < 0 && !ignore_err)
+            goto done;
+        dt = dt->next;
+        HDfree(*named_dt_head_p);
+        *named_dt_head_p = dt;
+    } /* end while */
 
-	ret_value = 0;
+    ret_value = 0;
 
 done:
-	return (ret_value);
+    return (ret_value);
 } /* end named_datatype_free */
 
 /*-------------------------------------------------------------------------
@@ -363,25 +363,25 @@ done:
  */
 int
 copy_attr(hid_t loc_in, hid_t loc_out, named_dt_t **named_dt_head_p,
-		trav_table_t *travt, pack_opt_t *options)
+        trav_table_t *travt, pack_opt_t *options)
 {
-    int ret_value = 0; /*no need to LEAVE() on ERROR: HERR_INIT(int, SUCCEED) */
-    hid_t attr_id = -1; /* attr ID */
-    hid_t attr_out = -1; /* attr ID */
-    hid_t space_id = -1; /* space ID */
-    hid_t ftype_id = -1; /* file type ID */
-    hid_t wtype_id = -1; /* read/write type ID */
-    size_t msize; /* size of type */
-    void *buf = NULL; /* data buffer */
-    hsize_t nelmts; /* number of elements in dataset */
-    int rank; /* rank of dataset */
-    htri_t is_named; /* Whether the datatype is named */
-    hsize_t dims[H5S_MAX_RANK];/* dimensions of dataset */
-    char name[255];
-    H5O_info_t oinfo; /* object info */
-    int j;
-    unsigned u;
-    hbool_t is_ref = 0;
+    int         ret_value = 0; /*no need to LEAVE() on ERROR: HERR_INIT(int, SUCCEED) */
+    hid_t       attr_id = -1;  /* attr ID */
+    hid_t       attr_out = -1; /* attr ID */
+    hid_t       space_id = -1; /* space ID */
+    hid_t       ftype_id = -1; /* file type ID */
+    hid_t       wtype_id = -1; /* read/write type ID */
+    size_t      msize;         /* size of type */
+    void       *buf = NULL;    /* data buffer */
+    hsize_t     nelmts;        /* number of elements in dataset */
+    int         rank;          /* rank of dataset */
+    htri_t      is_named;      /* Whether the datatype is named */
+    hsize_t     dims[H5S_MAX_RANK];/* dimensions of dataset */
+    char        name[255];
+    H5O_info_t  oinfo;         /* object info */
+    int         j;
+    unsigned    u;
+    hbool_t     is_ref = 0;
     H5T_class_t type_class = -1;
 
     if (H5Oget_info(loc_in, &oinfo) < 0)
@@ -568,193 +568,188 @@ done:
  * Programmer: pvn@ncsa.uiuc.edu
  *
  * Date: September, 22, 2003
- *
- * Modification:
- *   Peter Cao, July 9, 2007
- *   Add "-L, --latest" and other options to pack a file with the latest file format
- *
  *-------------------------------------------------------------------------
  */
 static int check_options(pack_opt_t *options) {
-	unsigned int i;
-	int k, j, has_cp = 0, has_ck = 0;
-	char slayout[30];
-
-	/*-------------------------------------------------------------------------
-	 * objects to layout
-	 *-------------------------------------------------------------------------
-	 */
-	if (options->verbose && have_request(options) /* only print if requested */) {
-		printf("Objects to modify layout are...\n");
-		if (options->all_layout == 1) {
-			switch (options->layout_g) {
-			case H5D_COMPACT:
-				strcpy(slayout, "compact");
-				break;
-			case H5D_CONTIGUOUS:
-				strcpy(slayout, "contiguous");
-				break;
-			case H5D_CHUNKED:
-				strcpy(slayout, "chunked");
-				break;
-			case H5D_VIRTUAL:
-				strcpy(slayout, "virtual");
-				break;
-			case H5D_LAYOUT_ERROR:
-			case H5D_NLAYOUTS:
-				error_msg("invalid layout\n");
-				return -1;
-			default:
-				strcpy(slayout, "invalid layout\n");
-				return -1;
-			}
-			printf(" Apply %s layout to all\n", slayout);
-			if (H5D_CHUNKED == options->layout_g) {
-				printf("with dimension [");
-				for (j = 0; j < options->chunk_g.rank; j++)
-					printf("%d ", (int) options->chunk_g.chunk_lengths[j]);
-				printf("]\n");
-			}
-		}
-	}/* verbose */
-
-	for (i = 0; i < options->op_tbl->nelems; i++) {
-		char* name = options->op_tbl->objs[i].path;
-
-		if (options->op_tbl->objs[i].chunk.rank > 0) {
-			if (options->verbose) {
-				printf(" <%s> with chunk size ", name);
-				for (k = 0; k < options->op_tbl->objs[i].chunk.rank; k++)
-					printf("%d ",
-							(int) options->op_tbl->objs[i].chunk.chunk_lengths[k]);
-				printf("\n");
-			}
-			has_ck = 1;
-		}
-		else if (options->op_tbl->objs[i].chunk.rank == -2) {
-			if (options->verbose)
-				printf(" <%s> %s\n", name, "NONE (contigous)");
-			has_ck = 1;
-		}
-	}
-
-	if (options->all_layout == 1 && has_ck) {
-		error_msg(
-				"invalid chunking input: 'all' option\
+    unsigned int i;
+    int          k, j, has_cp = 0, has_ck = 0;
+    char         slayout[30];
+
+    /*-------------------------------------------------------------------------
+    * objects to layout
+    *-------------------------------------------------------------------------
+    */
+    if (options->verbose && have_request(options) /* only print if requested */) {
+        printf("Objects to modify layout are...\n");
+        if (options->all_layout == 1) {
+            switch (options->layout_g) {
+            case H5D_COMPACT:
+                strcpy(slayout, "compact");
+                break;
+            case H5D_CONTIGUOUS:
+                strcpy(slayout, "contiguous");
+                break;
+            case H5D_CHUNKED:
+                strcpy(slayout, "chunked");
+                break;
+            case H5D_VIRTUAL:
+                strcpy(slayout, "virtual");
+                break;
+            case H5D_LAYOUT_ERROR:
+            case H5D_NLAYOUTS:
+                error_msg("invalid layout\n");
+                return -1;
+            default:
+                strcpy(slayout, "invalid layout\n");
+                return -1;
+            }
+            printf(" Apply %s layout to all\n", slayout);
+            if (H5D_CHUNKED == options->layout_g) {
+                printf("with dimension [");
+                for (j = 0; j < options->chunk_g.rank; j++)
+                    printf("%d ", (int) options->chunk_g.chunk_lengths[j]);
+                printf("]\n");
+            }
+        }
+    }/* verbose */
+
+    for (i = 0; i < options->op_tbl->nelems; i++) {
+        char* name = options->op_tbl->objs[i].path;
+
+        if (options->op_tbl->objs[i].chunk.rank > 0) {
+            if (options->verbose) {
+                printf(" <%s> with chunk size ", name);
+                for (k = 0; k < options->op_tbl->objs[i].chunk.rank; k++)
+                    printf("%d ",
+                            (int) options->op_tbl->objs[i].chunk.chunk_lengths[k]);
+                printf("\n");
+            }
+            has_ck = 1;
+        }
+        else if (options->op_tbl->objs[i].chunk.rank == -2) {
+            if (options->verbose)
+                printf(" <%s> %s\n", name, "NONE (contigous)");
+            has_ck = 1;
+        }
+    }
+
+    if (options->all_layout == 1 && has_ck) {
+        error_msg(
+                "invalid chunking input: 'all' option\
                             is present with other objects\n");
-		return -1;
-	}
-
-	/*-------------------------------------------------------------------------
-	 * objects to filter
-	 *-------------------------------------------------------------------------
-	 */
-
-	if (options->verbose && have_request(options) /* only print if requested */) {
-		printf("Objects to apply filter are...\n");
-		if (options->all_filter == 1) {
-			for (k = 0; k < options->n_filter_g; k++) {
-				H5Z_filter_t filtn = options->filter_g[k].filtn;
-				switch (filtn) {
-				case H5Z_FILTER_NONE:
-					printf(" Uncompress all\n");
-					break;
-				case H5Z_FILTER_SHUFFLE:
-				case H5Z_FILTER_FLETCHER32:
-					printf(" All with %s\n", get_sfilter(filtn));
-					break;
-				case H5Z_FILTER_SZIP:
-				case H5Z_FILTER_DEFLATE:
-					printf(" All with %s, parameter %d\n", get_sfilter(filtn),
-							options->filter_g[k].cd_values[0]);
-					break;
-				default:
-					printf(" User Defined %d\n", filtn);
-					break;
-				} /* k */
-			};
-		}
-	} /* verbose */
-
-	for (i = 0; i < options->op_tbl->nelems; i++) {
-		pack_info_t pack = options->op_tbl->objs[i];
-		char* name = pack.path;
-
-		for (j = 0; j < pack.nfilters; j++) {
-			if (options->verbose) {
-				printf(" <%s> with %s filter\n", name,
-						get_sfilter(pack.filter[j].filtn));
-			}
-
-			has_cp = 1;
-
-		} /* j */
-	} /* i */
-
-	if (options->all_filter == 1 && has_cp) {
-		error_msg(
-				"invalid compression input: 'all' option\
+        return -1;
+    }
+
+    /*-------------------------------------------------------------------------
+    * objects to filter
+    *-------------------------------------------------------------------------
+    */
+
+    if (options->verbose && have_request(options) /* only print if requested */) {
+        printf("Objects to apply filter are...\n");
+        if (options->all_filter == 1) {
+            for (k = 0; k < options->n_filter_g; k++) {
+                H5Z_filter_t filtn = options->filter_g[k].filtn;
+                switch (filtn) {
+                case H5Z_FILTER_NONE:
+                    printf(" Uncompress all\n");
+                    break;
+                case H5Z_FILTER_SHUFFLE:
+                case H5Z_FILTER_FLETCHER32:
+                    printf(" All with %s\n", get_sfilter(filtn));
+                    break;
+                case H5Z_FILTER_SZIP:
+                case H5Z_FILTER_DEFLATE:
+                    printf(" All with %s, parameter %d\n", get_sfilter(filtn),
+                            options->filter_g[k].cd_values[0]);
+                    break;
+                default:
+                    printf(" User Defined %d\n", filtn);
+                    break;
+                } /* k */
+            };
+        }
+    } /* verbose */
+
+    for (i = 0; i < options->op_tbl->nelems; i++) {
+        pack_info_t pack = options->op_tbl->objs[i];
+        char* name = pack.path;
+
+        for (j = 0; j < pack.nfilters; j++) {
+            if (options->verbose) {
+                printf(" <%s> with %s filter\n", name,
+                        get_sfilter(pack.filter[j].filtn));
+            }
+
+            has_cp = 1;
+
+        } /* j */
+    } /* i */
+
+    if (options->all_filter == 1 && has_cp) {
+        error_msg(
+                "invalid compression input: 'all' option\
                             is present with other objects\n");
-		return -1;
-	}
-
-	/*-------------------------------------------------------------------------
-	 * check options for the latest format
-	 *-------------------------------------------------------------------------
-	 */
-
-	if (options->grp_compact < 0) {
-		error_msg(
-				"invalid maximum number of links to store as header messages\n");
-		return -1;
-	}
-	if (options->grp_indexed < 0) {
-		error_msg(
-				"invalid minimum number of links to store in the indexed format\n");
-		return -1;
-	}
-	if (options->grp_indexed > options->grp_compact) {
-		error_msg(
-				"minimum indexed size is greater than the maximum compact size\n");
-		return -1;
-	}
-	for (i = 0; i < 8; i++) {
-		if (options->msg_size[i] < 0) {
-			error_msg("invalid shared message size\n");
-			return -1;
-		}
-	}
-
-	/*--------------------------------------------------------------------------------
-	 * verify new user userblock options; file name must be present
-	 *---------------------------------------------------------------------------------
-	 */
-	if (options->ublock_filename != NULL && options->ublock_size == 0) {
-		if (options->verbose) {
-			printf(
-					"Warning: user block size missing for file %s. Assigning a default size of 1024...\n",
-					options->ublock_filename);
-			options->ublock_size = 1024;
-		}
-	}
-
-	if (options->ublock_filename == NULL && options->ublock_size != 0) {
-		error_msg("file name missing for user block\n",
-				options->ublock_filename);
-		return -1;
-	}
-
-	/*--------------------------------------------------------------------------------
-	 * verify alignment options; threshold is zero default but alignment not
-	 *---------------------------------------------------------------------------------
-	 */
-
-	if (options->alignment == 0 && options->threshold != 0) {
-		error_msg("alignment for H5Pset_alignment missing\n");
-		return -1;
-	}
-
-	return 0;
+        return -1;
+    }
+
+    /*-------------------------------------------------------------------------
+    * check options for the latest format
+    *-------------------------------------------------------------------------
+    */
+
+    if (options->grp_compact < 0) {
+        error_msg(
+                "invalid maximum number of links to store as header messages\n");
+        return -1;
+    }
+    if (options->grp_indexed < 0) {
+        error_msg(
+                "invalid minimum number of links to store in the indexed format\n");
+        return -1;
+    }
+    if (options->grp_indexed > options->grp_compact) {
+        error_msg(
+                "minimum indexed size is greater than the maximum compact size\n");
+        return -1;
+    }
+    for (i = 0; i < 8; i++) {
+        if (options->msg_size[i] < 0) {
+            error_msg("invalid shared message size\n");
+            return -1;
+        }
+    }
+
+    /*--------------------------------------------------------------------------------
+    * verify new user userblock options; file name must be present
+    *---------------------------------------------------------------------------------
+    */
+    if (options->ublock_filename != NULL && options->ublock_size == 0) {
+        if (options->verbose) {
+            printf(
+                    "Warning: user block size missing for file %s. Assigning a default size of 1024...\n",
+                    options->ublock_filename);
+            options->ublock_size = 1024;
+        }
+    }
+
+    if (options->ublock_filename == NULL && options->ublock_size != 0) {
+        error_msg("file name missing for user block\n",
+                options->ublock_filename);
+        return -1;
+    }
+
+    /*--------------------------------------------------------------------------------
+    * verify alignment options; threshold is zero default but alignment not
+    *---------------------------------------------------------------------------------
+    */
+
+    if (options->alignment == 0 && options->threshold != 0) {
+        error_msg("alignment for H5Pset_alignment missing\n");
+        return -1;
+    }
+
+    return 0;
 }
 
 /*-------------------------------------------------------------------------
@@ -772,119 +767,119 @@ static int check_options(pack_opt_t *options) {
  *-------------------------------------------------------------------------
  */
 static int check_objects(const char* fname, pack_opt_t *options) {
-	hid_t fid;
-	unsigned int i;
-	trav_table_t *travt = NULL;
-
-	/* nothing to do */
-	if (options->op_tbl->nelems == 0)
-		return 0;
-
-	/*-------------------------------------------------------------------------
-	 * open the file
-	 *-------------------------------------------------------------------------
-	 */
-	if ((fid = h5tools_fopen(fname, H5F_ACC_RDONLY, H5P_DEFAULT, NULL, NULL, 0))
-			< 0) {
-		printf("<%s>: %s\n", fname, H5FOPENERROR);
-		return -1;
-	}
-
-	/*-------------------------------------------------------------------------
-	 * get the list of objects in the file
-	 *-------------------------------------------------------------------------
-	 */
-
-	/* init table */
-	trav_table_init(&travt);
-
-	/* get the list of objects in the file */
-	if (h5trav_gettable(fid, travt) < 0)
-		goto out;
-
-	/*-------------------------------------------------------------------------
-	 * compare with user supplied list
-	 *-------------------------------------------------------------------------
-	 */
-
-	if (options->verbose)
-		printf("Opening file <%s>. Searching for objects to modify...\n",
-				fname);
-
-	for (i = 0; i < options->op_tbl->nelems; i++) {
-		char* name = options->op_tbl->objs[i].path;
-		if (options->verbose)
-			printf(" <%s>", name);
-
-		/* the input object names are present in the file and are valid */
-		if (h5trav_getindext(name, travt) < 0) {
-			error_msg("%s Could not find <%s> in file <%s>. Exiting...\n",
-					(options->verbose ? "\n" : ""), name, fname);
-			goto out;
-		}
-		if (options->verbose)
-			printf("...Found\n");
-
-		/* check for extra filter conditions */
-		switch (options->op_tbl->objs[i].filter->filtn) {
-		/* chunk size must be smaller than pixels per block */
-		case H5Z_FILTER_SZIP:
-			{
-				int j;
-				hsize_t csize = 1;
-				unsigned ppb = options->op_tbl->objs[i].filter->cd_values[0];
-				hsize_t dims[H5S_MAX_RANK];
-				int rank;
-				hid_t did;
-				hid_t sid;
-
-				if (options->op_tbl->objs[i].chunk.rank > 0) {
-					rank = options->op_tbl->objs[i].chunk.rank;
-					for (j = 0; j < rank; j++)
-						csize *= options->op_tbl->objs[i].chunk.chunk_lengths[j];
-				}
-				else {
-					if ((did = H5Dopen2(fid, name, H5P_DEFAULT)) < 0)
-						goto out;
-					if ((sid = H5Dget_space(did)) < 0)
-						goto out;
-					if ((rank = H5Sget_simple_extent_ndims(sid)) < 0)
-						goto out;
-					HDmemset(dims, 0, sizeof dims);
-					if (H5Sget_simple_extent_dims(sid, dims, NULL) < 0)
-						goto out;
-					for (j = 0; j < rank; j++)
-						csize *= dims[j];
-					if (H5Sclose(sid) < 0)
-						goto out;
-					if (H5Dclose(did) < 0)
-						goto out;
-				}
-
-				if (csize < ppb) {
-					printf(
-							" <warning: SZIP settins, chunk size is smaller than pixels per block>\n");
-					goto out;
-				}
-			}
-			break;
-		default:
-			break;
-		}
-	} /* i */
-
-	/*-------------------------------------------------------------------------
-	 * close
-	 *-------------------------------------------------------------------------
-	 */
-	H5Fclose(fid);
-	trav_table_free(travt);
-	return 0;
+    hid_t         fid;
+    unsigned int  i;
+    trav_table_t *travt = NULL;
+
+    /* nothing to do */
+    if (options->op_tbl->nelems == 0)
+        return 0;
+
+    /*-------------------------------------------------------------------------
+    * open the file
+    *-------------------------------------------------------------------------
+    */
+    if ((fid = h5tools_fopen(fname, H5F_ACC_RDONLY, H5P_DEFAULT, NULL, NULL, 0))
+            < 0) {
+        printf("<%s>: %s\n", fname, H5FOPENERROR);
+        return -1;
+    }
+
+    /*-------------------------------------------------------------------------
+    * get the list of objects in the file
+    *-------------------------------------------------------------------------
+    */
+
+    /* init table */
+    trav_table_init(&travt);
+
+    /* get the list of objects in the file */
+    if (h5trav_gettable(fid, travt) < 0)
+        goto out;
+
+    /*-------------------------------------------------------------------------
+    * compare with user supplied list
+    *-------------------------------------------------------------------------
+    */
+
+    if (options->verbose)
+        printf("Opening file <%s>. Searching for objects to modify...\n",
+                fname);
+
+    for (i = 0; i < options->op_tbl->nelems; i++) {
+        char* name = options->op_tbl->objs[i].path;
+        if (options->verbose)
+            printf(" <%s>", name);
+
+        /* the input object names are present in the file and are valid */
+        if (h5trav_getindext(name, travt) < 0) {
+            error_msg("%s Could not find <%s> in file <%s>. Exiting...\n",
+                    (options->verbose ? "\n" : ""), name, fname);
+            goto out;
+        }
+        if (options->verbose)
+            printf("...Found\n");
+
+        /* check for extra filter conditions */
+        switch (options->op_tbl->objs[i].filter->filtn) {
+        /* chunk size must be smaller than pixels per block */
+        case H5Z_FILTER_SZIP:
+            {
+                int j;
+                hsize_t csize = 1;
+                unsigned ppb = options->op_tbl->objs[i].filter->cd_values[0];
+                hsize_t dims[H5S_MAX_RANK];
+                int rank;
+                hid_t did;
+                hid_t sid;
+
+                if (options->op_tbl->objs[i].chunk.rank > 0) {
+                    rank = options->op_tbl->objs[i].chunk.rank;
+                    for (j = 0; j < rank; j++)
+                        csize *= options->op_tbl->objs[i].chunk.chunk_lengths[j];
+                }
+                else {
+                    if ((did = H5Dopen2(fid, name, H5P_DEFAULT)) < 0)
+                        goto out;
+                    if ((sid = H5Dget_space(did)) < 0)
+                        goto out;
+                    if ((rank = H5Sget_simple_extent_ndims(sid)) < 0)
+                        goto out;
+                    HDmemset(dims, 0, sizeof dims);
+                    if (H5Sget_simple_extent_dims(sid, dims, NULL) < 0)
+                        goto out;
+                    for (j = 0; j < rank; j++)
+                        csize *= dims[j];
+                    if (H5Sclose(sid) < 0)
+                        goto out;
+                    if (H5Dclose(did) < 0)
+                        goto out;
+                }
+
+                if (csize < ppb) {
+                    printf(
+                            " <warning: SZIP settins, chunk size is smaller than pixels per block>\n");
+                    goto out;
+                }
+            }
+            break;
+        default:
+            break;
+        }
+    } /* i */
+
+    /*-------------------------------------------------------------------------
+    * close
+    *-------------------------------------------------------------------------
+    */
+    H5Fclose(fid);
+    trav_table_free(travt);
+    return 0;
 
 out:
-	H5Fclose(fid);
-	trav_table_free(travt);
-	return -1;
+    H5Fclose(fid);
+    trav_table_free(travt);
+    return -1;
 }
 
 /*-------------------------------------------------------------------------
@@ -900,10 +895,10 @@ out:
  */
 static int have_request(pack_opt_t *options) {
 
-	if (options->all_filter || options->all_layout || options->op_tbl->nelems)
-		return 1;
+    if (options->all_filter || options->all_layout || options->op_tbl->nelems)
+        return 1;
 
-	return 0;
+    return 0;
 
 }
 
@@ -918,21 +913,21 @@ static int have_request(pack_opt_t *options) {
  */
 
 static const char* get_sfilter(H5Z_filter_t filtn) {
-	if (filtn == H5Z_FILTER_NONE)
-		return "NONE";
-	else if (filtn == H5Z_FILTER_DEFLATE)
-		return "GZIP";
-	else if (filtn == H5Z_FILTER_SZIP)
-		return "SZIP";
-	else if (filtn == H5Z_FILTER_SHUFFLE)
-		return "SHUFFLE";
-	else if (filtn == H5Z_FILTER_FLETCHER32)
-		return "FLETCHER32";
-	else if (filtn == H5Z_FILTER_NBIT)
-		return "NBIT";
-	else if (filtn == H5Z_FILTER_SCALEOFFSET)
-		return "SOFF";
-	else
-		return "UD";
+    if (filtn == H5Z_FILTER_NONE)
+        return "NONE";
+    else if (filtn == H5Z_FILTER_DEFLATE)
+        return "GZIP";
+    else if (filtn == H5Z_FILTER_SZIP)
+        return "SZIP";
+    else if (filtn == H5Z_FILTER_SHUFFLE)
+        return "SHUFFLE";
+    else if (filtn == H5Z_FILTER_FLETCHER32)
+        return "FLETCHER32";
+    else if (filtn == H5Z_FILTER_NBIT)
+        return "NBIT";
+    else if (filtn == H5Z_FILTER_SCALEOFFSET)
+        return "SOFF";
+    else
+        return "UD";
 }
 
diff --git a/tools/src/h5repack/h5repack_copy.c b/tools/src/h5repack/h5repack_copy.c
index 604e85f..5ec77a7 100644
--- a/tools/src/h5repack/h5repack_copy.c
+++ b/tools/src/h5repack/h5repack_copy.c
@@ -31,7 +31,7 @@
  */
 
 /* size of buffer/# of bytes to xfer at a time when copying userblock */
-#define USERBLOCK_XFER_SIZE     512     
+#define USERBLOCK_XFER_SIZE     512
 
 /* check H5Dread()/H5Dwrite() error, e.g. memory allocation error inside the library. */
 #define CHECK_H5DRW_ERROR(_fun, _fail, _did, _mtid, _msid, _fsid, _pid, _buf)  {  \
@@ -52,12 +52,12 @@
  *-------------------------------------------------------------------------
  */
 static int Get_hyperslab(hid_t dcpl_id, int rank_dset, hsize_t dims_dset[],
-		size_t size_datum, hsize_t dims_hslab[], hsize_t * hslab_nbytes_p);
+        size_t size_datum, hsize_t dims_hslab[], hsize_t * hslab_nbytes_p);
 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);
+        pack_opt_t *options);
 static int copy_user_block(const char *infile, const char *outfile,
-		hsize_t size);
+        hsize_t size);
 #if defined (H5REPACK_DEBUG_USER_BLOCK)
 static void print_user_block(const char *filename, hid_t fid);
 #endif
@@ -65,18 +65,19 @@ static herr_t walk_error_callback(unsigned n, const H5E_error2_t *err_desc, void
 
 /* get the major number from the error stack. */
 static herr_t walk_error_callback(H5_ATTR_UNUSED unsigned n, const H5E_error2_t *err_desc, void *udata) {
-	if (err_desc)
-		*((hid_t *) udata) = err_desc->maj_num;
+    if (err_desc)
+        *((hid_t *) udata) = err_desc->maj_num;
 
-	return 0;
+    return 0;
 }
 
 /*-------------------------------------------------------------------------
  * Function: copy_objects
  *
- * Purpose: duplicate all HDF5 objects in the file
+ * Purpose:  duplicate all HDF5 objects in the file
  *
- * Return: 0, ok, -1 no
+ * Return:   0, ok,
+ *          -1 no
  *
  * Programmer: Pedro Vicente, pvn@ncsa.uiuc.edu
  *
@@ -87,21 +88,21 @@ static herr_t walk_error_callback(H5_ATTR_UNUSED unsigned n, const H5E_error2_t
 
 int copy_objects(const char* fnamein, const char* fnameout, pack_opt_t *options)
 {
-    int   	  ret_value = 0; /*no need to LEAVE() on ERROR: HERR_INIT(int, SUCCEED) */
+    int           ret_value = 0;          /* no need to LEAVE() on ERROR: HERR_INIT(int, SUCCEED) */
     hid_t         fidin;
     hid_t         fidout = -1;
     trav_table_t  *travt = NULL;
-    hsize_t       ub_size = 0;        	/* size of user block */
-    hid_t         fcpl = H5P_DEFAULT; 	/* file creation property list ID */
-    hid_t         fapl = H5P_DEFAULT; 	/* file access property list ID */
-    H5F_fspace_strategy_t set_strategy;	/* Strategy to be set in outupt file */
-    hbool_t	  set_persist;		/* Persist free-space status to be set in output file */
-    hsize_t	  set_threshold;	/* Free-space section threshold to be set in output file */
-    hsize_t	  set_pagesize;		/* File space page size to be set in output file */
-    H5F_fspace_strategy_t in_strategy;	/* Strategy from input file */
-    hbool_t	  in_persist;		/* Persist free-space status from input file */
-    hsize_t	  in_threshold;		/* Free-space section threshold from input file */
-    hsize_t	  in_pagesize;		/* File space page size from input file */
+    hsize_t       ub_size = 0;            /* size of user block */
+    hid_t         fcpl = H5P_DEFAULT;     /* file creation property list ID */
+    hid_t         fapl = H5P_DEFAULT;     /* file access property list ID */
+    H5F_fspace_strategy_t set_strategy;   /* Strategy to be set in outupt file */
+    hbool_t       set_persist;            /* Persist free-space status to be set in output file */
+    hsize_t       set_threshold;          /* Free-space section threshold to be set in output file */
+    hsize_t       set_pagesize;           /* File space page size to be set in output file */
+    H5F_fspace_strategy_t in_strategy;    /* Strategy from input file */
+    hbool_t       in_persist;             /* Persist free-space status from input file */
+    hsize_t       in_threshold;           /* Free-space section threshold from input file */
+    hsize_t       in_pagesize;            /* File space page size from input file */
 
     /*-------------------------------------------------------------------------
      * open input file
@@ -126,17 +127,17 @@ int copy_objects(const char* fnamein, const char* fnameout, pack_opt_t *options)
             HGOTO_ERROR(FAIL, H5E_tools_min_id_g, "H5Pclose failed");
         }
 
-	/* If the -S option is not set, get "strategy" from the input file */
-	if(H5Pget_file_space_strategy(fcpl_in, &in_strategy, &in_persist, &in_threshold) < 0) {
-	    error_msg("failed to retrieve file space strategy\n");
-            HGOTO_ERROR(FAIL, H5E_tools_min_id_g, "H5Pclose failed");
-        }
+    /* If the -S option is not set, get "strategy" from the input file */
+    if(H5Pget_file_space_strategy(fcpl_in, &in_strategy, &in_persist, &in_threshold) < 0) {
+        error_msg("failed to retrieve file space strategy\n");
+        HGOTO_ERROR(FAIL, H5E_tools_min_id_g, "H5Pclose failed");
+    }
 
-	/* If the -G option is not set, get "pagesize" from the input file */
-	if(H5Pget_file_space_page_size(fcpl_in, &in_pagesize) < 0) {
-	    error_msg("failed to retrieve file space threshold\n");
-	    HGOTO_ERROR(FAIL, H5E_tools_min_id_g, "H5Pclose failed");
-	}
+    /* If the -G option is not set, get "pagesize" from the input file */
+    if(H5Pget_file_space_page_size(fcpl_in, &in_pagesize) < 0) {
+        error_msg("failed to retrieve file space threshold\n");
+        HGOTO_ERROR(FAIL, H5E_tools_min_id_g, "H5Pclose failed");
+    }
 
         if (H5Pclose(fcpl_in) < 0) {
             error_msg("failed to close property list\n");
@@ -295,9 +296,9 @@ print_user_block(fnamein, fidin);
     }
 
     /*-------------------------------------------------------------------------
-    * Set file space information
-    *-------------------------------------------------------------------------
-    */
+     * Set file space information
+     *-------------------------------------------------------------------------
+     */
 
     /* either use the FCPL already created or create a new one */
     if (fcpl == H5P_DEFAULT) {
@@ -323,7 +324,7 @@ print_user_block(fnamein, fidin);
         set_persist = FS_PERSIST_DEF;
     else if(options->fs_persist != 0) /* Set "persist" as specified by user */
         set_persist = (hbool_t)options->fs_persist;
-    
+
     if(options->fs_threshold == -1) /* A "0" threshold is specified by user */
         set_threshold = (hsize_t)0;
     else if(options->fs_threshold != 0) /* Set threshold as specified by user */
@@ -331,7 +332,7 @@ print_user_block(fnamein, fidin);
 
     /* Set file space information as specified */
     if(H5Pset_file_space_strategy(fcpl, set_strategy, set_persist, set_threshold) < 0) {
-	error_msg("failed to set file space strategy\n");
+        error_msg("failed to set file space strategy\n");
         HGOTO_ERROR(FAIL, H5E_tools_min_id_g, "H5Pclose failed");
     }
 
@@ -343,7 +344,7 @@ print_user_block(fnamein, fidin);
     if(set_pagesize != FS_PAGESIZE_DEF) /* Set non-default file space page size as specified */
         if(H5Pset_file_space_page_size(fcpl, set_pagesize) < 0) {
             error_msg("failed to set file space page size\n");
-	    HGOTO_ERROR(FAIL, H5E_tools_min_id_g, "H5Pclose failed");
+            HGOTO_ERROR(FAIL, H5E_tools_min_id_g, "H5Pclose failed");
         }
 
     /*-------------------------------------------------------------------------
@@ -490,10 +491,10 @@ done:
 int Get_hyperslab(hid_t dcpl_id, int rank_dset, hsize_t dims_dset[],
         size_t size_datum, hsize_t dims_hslab[], hsize_t * hslab_nbytes_p)
 {
-    int ret_value = 0; /*no need to LEAVE() on ERROR: HERR_INIT(int, SUCCEED) */
-    int k;
+    int     ret_value = 0; /*no need to LEAVE() on ERROR: HERR_INIT(int, SUCCEED) */
+    int     k;
     H5D_layout_t dset_layout;
-    int rank_chunk;
+    int     rank_chunk;
     hsize_t dims_chunk[H5S_MAX_RANK];
     hsize_t size_chunk = 1;
     hsize_t nchunk_fit; /* number of chunks that fits in hyperslab buffer (H5TOOLS_BUFSIZE) */
@@ -705,36 +706,36 @@ done:
  */
 
 int do_copy_objects(hid_t fidin, hid_t fidout, trav_table_t *travt,
-		pack_opt_t *options) /* repack options */
+        pack_opt_t *options) /* repack options */
 {
     int   ret_value = 0; /*no need to LEAVE() on ERROR: HERR_INIT(int, SUCCEED) */
-    hid_t grp_in = -1; /* group ID */
-    hid_t grp_out = -1; /* group ID */
-    hid_t dset_in = -1; /* read dataset ID */
+    hid_t grp_in = -1;   /* group ID */
+    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_in = -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_in = -1;  /* named type ID */
     hid_t type_out = -1; /* named type ID */
-    hid_t dcpl_in = -1; /* dataset creation property list ID */
+    hid_t dcpl_in = -1;  /* dataset creation property list ID */
     hid_t dcpl_out = -1; /* dataset creation property list ID */
     hid_t f_space_id = -1; /* file space ID */
     hid_t ftype_id = -1; /* file type ID */
     hid_t wtype_id = -1; /* read/write type ID */
     named_dt_t *named_dt_head = NULL; /* Pointer to the stack of named datatypes copied */
-    size_t msize; /* size of type */
-    hsize_t nelmts; /* number of elements in dataset */
+    size_t msize;        /* size of type */
+    hsize_t nelmts;      /* number of elements in dataset */
     H5D_space_status_t space_status; /* determines whether space has been allocated for the dataset  */
-    int rank; /* rank of dataset */
+    int rank;            /* rank of dataset */
     hsize_t dims[H5S_MAX_RANK];/* dimensions of dataset */
-    hsize_t dsize_in; /* input dataset size before filter */
-    hsize_t dsize_out; /* output dataset size after filter */
-    int apply_s; /* flag for apply filter to small dataset sizes */
-    int apply_f; /* flag for apply filter to return error on H5Dcreate */
-    void *buf = NULL; /* buffer for raw data */
+    hsize_t dsize_in;    /* input dataset size before filter */
+    hsize_t dsize_out;   /* output dataset size after filter */
+    int apply_s;         /* flag for apply filter to small dataset sizes */
+    int apply_f;         /* flag for apply filter to return error on H5Dcreate */
+    void *buf = NULL;    /* buffer for raw data */
     void *hslab_buf = NULL; /* hyperslab buffer for raw data */
-    int has_filter; /* current object has a filter */
-    int req_filter; /* there was a request for a filter */
+    int has_filter;      /* current object has a filter */
+    int req_filter;      /* there was a request for a filter */
     int req_obj_layout = 0; /* request layout to current object */
     unsigned crt_order_flags; /* group creation order flag */
     unsigned i;
@@ -1349,20 +1350,19 @@ done:
  *
  *-------------------------------------------------------------------------
  */
-static void print_dataset_info(hid_t dcpl_id, char *objname, double ratio,
-    int pr)
+static void print_dataset_info(hid_t dcpl_id, char *objname, double ratio, int pr)
 {
-    char strfilter[255];
+    char     strfilter[255];
 #if defined (PRINT_DEBUG )
-    char temp[255];
+    char     temp[255];
 #endif
-    int nfilters; /* number of filters */
-    unsigned filt_flags; /* filter flags */
-    H5Z_filter_t filtn; /* filter identification number */
-    unsigned cd_values[20]; /* filter client data values */
-    size_t cd_nelmts; /* filter client number of values */
-    char f_objname[256]; /* filter objname */
-    int i;
+    int      nfilters;       /* number of filters */
+    unsigned filt_flags;     /* filter flags */
+    H5Z_filter_t filtn;      /* filter identification number */
+    unsigned cd_values[20];  /* filter client data values */
+    size_t   cd_nelmts;      /* filter client number of values */
+    char     f_objname[256]; /* filter objname */
+    int     i;
 
     HDstrcpy(strfilter, "\0");
 
@@ -1461,10 +1461,9 @@ static void print_dataset_info(hid_t dcpl_id, char *objname, double ratio,
  *
  *-------------------------------------------------------------------------
  */
-static int copy_user_block(const char *infile, const char *outfile,
-    hsize_t size)
+static int copy_user_block(const char *infile, const char *outfile, hsize_t size)
 {
-    int ret_value = 0; /*no need to LEAVE() on ERROR: HERR_INIT(int, SUCCEED) */
+    int ret_value = 0;           /*no need to LEAVE() on ERROR: HERR_INIT(int, SUCCEED) */
     int infid = -1, outfid = -1; /* File descriptors */
 
     /* User block must be any power of 2 equal to 512 or greater (512, 1024, 2048, etc.) */
@@ -1541,67 +1540,67 @@ done:
 static
 void print_user_block(const char *filename, hid_t fid)
 {
-    int ret_value = 0; /*no need to LEAVE() on ERROR: HERR_INIT(int, SUCCEED) */
-    int fh; /* file handle  */
-	hsize_t ub_size; /* user block size */
-	hsize_t size; /* size read */
-	hid_t fcpl; /* file creation property list ID for HDF5 file */
-	int i;
-
-	/* get user block size */
-	if(( fcpl = H5Fget_create_plist(fid)) < 0) {
-		error_msg("failed to retrieve file creation property list\n");
+    int     ret_value = 0; /*no need to LEAVE() on ERROR: HERR_INIT(int, SUCCEED) */
+    int     fh;   /* file handle  */
+    hsize_t ub_size; /* user block size */
+    hsize_t size; /* size read */
+    hid_t   fcpl; /* file creation property list ID for HDF5 file */
+    int     i;
+
+    /* get user block size */
+    if(( fcpl = H5Fget_create_plist(fid)) < 0) {
+        error_msg("failed to retrieve file creation property list\n");
         HGOTO_ERROR(H5E_tools_g, H5E_tools_min_id_g, "H5Fget_create_plist failed");
     }
 
-	if(H5Pget_userblock(fcpl, &ub_size) < 0) {
-		error_msg("failed to retrieve userblock size\n");
+    if(H5Pget_userblock(fcpl, &ub_size) < 0) {
+        error_msg("failed to retrieve userblock size\n");
         HGOTO_ERROR(H5E_tools_g, H5E_tools_min_id_g, "H5Pget_userblock failed");
     }
 
-	if(H5Pclose(fcpl) < 0) {
-		error_msg("failed to close property list\n");
+    if(H5Pclose(fcpl) < 0) {
+        error_msg("failed to close property list\n");
         HGOTO_ERROR(H5E_tools_g, H5E_tools_min_id_g, "H5Pclose failed");
     }
 
-	/* open file */
-	if((fh = HDopen(filename, O_RDONLY, 0)) < 0) {
+    /* open file */
+    if((fh = HDopen(filename, O_RDONLY, 0)) < 0) {
         HGOTO_ERROR(H5E_tools_g, H5E_tools_min_id_g, "HDopen failed");
     }
 
-	size = ub_size;
+    size = ub_size;
 
-	/* read file */
-	while(size > 0) {
-		ssize_t nread; /* # of bytes read */
-		char rbuf[USERBLOCK_XFER_SIZE]; /* buffer for reading */
+    /* read file */
+    while(size > 0) {
+        ssize_t nread; /* # of bytes read */
+        char rbuf[USERBLOCK_XFER_SIZE]; /* buffer for reading */
 
-		/* read buffer */
-		if(size > USERBLOCK_XFER_SIZE)
-			nread = HDread(fh, rbuf, (size_t)USERBLOCK_XFER_SIZE);
-		else
-			nread = HDread(fh, rbuf, (size_t)size);
+        /* read buffer */
+        if(size > USERBLOCK_XFER_SIZE)
+            nread = HDread(fh, rbuf, (size_t)USERBLOCK_XFER_SIZE);
+        else
+            nread = HDread(fh, rbuf, (size_t)size);
 
-		for(i = 0; i < nread; i++) {
+        for(i = 0; i < nread; i++) {
 
-			printf("%c ", rbuf[i]);
+            printf("%c ", rbuf[i]);
 
-		}
-		printf("\n");
+        }
+        printf("\n");
 
-		if(nread < 0) {
+        if(nread < 0) {
             HGOTO_ERROR(H5E_tools_g, H5E_tools_min_id_g, "nread < 0");
         }
 
-		/* update size of userblock left to transfer */
-		size -= nread;
-	}
+        /* update size of userblock left to transfer */
+        size -= nread;
+    }
 
 done:
-	if(fh > 0)
-		HDclose(fh);
+    if(fh > 0)
+        HDclose(fh);
 
-	return;
+    return;
 }
 #endif
 
diff --git a/tools/src/h5repack/h5repack_refs.c b/tools/src/h5repack/h5repack_refs.c
index 2c38d94..3245af0 100644
--- a/tools/src/h5repack/h5repack_refs.c
+++ b/tools/src/h5repack/h5repack_refs.c
@@ -25,7 +25,7 @@ static const char* MapIdToName(hid_t refobj_id,trav_table_t *travt);
 static int copy_refs_attr(hid_t loc_in, hid_t loc_out, pack_opt_t *options,
                           trav_table_t *travt, hid_t fidout);
 static herr_t update_ref_value(hid_t obj_id, H5R_type_t ref_type, void *ref_in,
-		hid_t fid_out, void *ref_out, trav_table_t *travt);
+        hid_t fid_out, void *ref_out, trav_table_t *travt);
 
 /*-------------------------------------------------------------------------
  * Function: do_copy_refobjs
@@ -425,13 +425,13 @@ done:
  * Programmer: Pedro Vicente, pvn@ncsa.uiuc.edu
  *
  * Modifier: xcao@hdfgroup.org, 9/12/2011
- * 	         Update values of references(object and region) for the following types:
+ *              Update values of references(object and region) for the following types:
  *               1) References,
  *               2) ARRAY of reference,
  *               3) VLEN of references.
  *               4) COMPOUND of references.
  *          This function does not handle references in other complicated structures,
- *		    such as references in nested compound datatypes.
+ *            such as references in nested compound datatypes.
  *
  * Date: October, 28, 2003
  *
@@ -472,7 +472,7 @@ static int copy_refs_attr(hid_t loc_in,
         HGOTO_ERROR(FAIL, H5E_tools_min_id_g, "H5Oget_info failed");
 
     for(u = 0; u < (unsigned)oinfo.num_attrs; u++) {
-    	is_ref = is_ref_vlen = is_ref_array = is_ref_comp = 0;
+        is_ref = is_ref_vlen = is_ref_array = is_ref_comp = 0;
 
         /* 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)
@@ -528,9 +528,9 @@ static int copy_refs_attr(hid_t loc_in,
                 }
                 H5Tclose(mtid);
             }
-            
-            /* if compound don't contain reference type member, free the above 
-             * mallocs. Otherwise there can be memory leaks by the 'continue' 
+
+            /* if compound don't contain reference type member, free the above
+             * mallocs. Otherwise there can be memory leaks by the 'continue'
              * statement below. */
             if (!ref_comp_field_n) {
                 if (ref_comp_index) {
@@ -539,7 +539,7 @@ static int copy_refs_attr(hid_t loc_in,
                 }
 
                 if (ref_comp_size) {
-            	    HDfree(ref_comp_size);
+                    HDfree(ref_comp_size);
                     ref_comp_size = NULL;
                 }
             }
@@ -588,7 +588,7 @@ static int copy_refs_attr(hid_t loc_in,
             array_rank = (unsigned)H5Tget_array_ndims(mtype_id);
             H5Tget_array_dims2(mtype_id, array_dims);
             for(j = 0; j <array_rank; j++)
-            	array_size *= array_dims[j];
+                array_size *= array_dims[j];
             nelmts *= array_size;
         }
 
@@ -648,7 +648,7 @@ static int copy_refs_attr(hid_t loc_in,
                 }
             } /* H5T_STD_REF_DSETREG */
             else if (is_ref_vlen) {
-            	/* handle VLEN of references */
+                /* handle VLEN of references */
 
                 buf = (hvl_t *)HDmalloc((unsigned)(nelmts * sizeof(hvl_t)));
                 refbuf = buf; /* reuse the read buffer for write */
@@ -688,7 +688,7 @@ static int copy_refs_attr(hid_t loc_in,
                 }
             } /* else if (is_ref_vlen) */
             else if (is_ref_comp) {
-            	/* handle ref fields in a compound */
+                /* handle ref fields in a compound */
 
                 buf = HDmalloc((unsigned)(nelmts * msize));
                 refbuf = buf; /* reuse the read buffer for write */
@@ -728,7 +728,7 @@ static int copy_refs_attr(hid_t loc_in,
                 HGOTO_ERROR(FAIL, H5E_tools_min_id_g, "H5Awrite failed");
 
             if (is_ref_vlen && buf)
-            	H5Dvlen_reclaim (mtype_id, space_id, H5P_DEFAULT, buf);
+                H5Dvlen_reclaim (mtype_id, space_id, H5P_DEFAULT, buf);
         } /* if (nelmts) */
 
         if (refbuf == buf)
@@ -780,10 +780,10 @@ done:
         HDfree(buf);
 
     if (ref_comp_index)
-    	HDfree(ref_comp_index);
+        HDfree(ref_comp_index);
 
     if (ref_comp_size)
-    	HDfree(ref_comp_size);
+        HDfree(ref_comp_size);
 
     H5E_BEGIN_TRY {
         H5Tclose(ftype_id);
@@ -797,9 +797,9 @@ done:
 }
 
 /*-------------------------------------------------------------------------
- * Function:	MapIdToName
+ * Function:    MapIdToName
  *
- * Purpose:	map a ID from a reference to a dataset name
+ * Purpose:    map a ID from a reference to a dataset name
  *
  *-------------------------------------------------------------------------
  */
@@ -832,16 +832,16 @@ out:
 }
 
 /*-------------------------------------------------------------------------
- * Function:	Update_Ref_value
+ * Function:    Update_Ref_value
  *
- * Purpose:	Update a reference value
+ * Purpose:    Update a reference value
  *
  * Programmer: xcao@hdfgroup.org 9/12/2011
  *
  *-------------------------------------------------------------------------
  */
 static herr_t update_ref_value(hid_t obj_id, H5R_type_t ref_type, void *ref_in,
-		hid_t fid_out, void *ref_out, trav_table_t *travt)
+        hid_t fid_out, void *ref_out, trav_table_t *travt)
 {
     int    ret_value = 0; /*no need to LEAVE() on ERROR: HERR_INIT(int, SUCCEED) */
     const char* ref_obj_name;