mirror/hdf5
2
0
Fork 0
mirror of https://github.com/HDFGroup/hdf5.git synced 2025-04-12 17:31:09 +08:00
Code Issues Packages Projects Releases Wiki Activity

HDFFV-10186 Whitespace change

Browse Source 
Mostly tabs to spaces
Remove Modifications comments
This commit is contained in:
Allen Byrne 2017-05-09 16:52:05 -05:00
parent e062a77e0e
commit 4f36f613a6
7 changed files with 707 additions and 768 deletions

6
hl/tools/gif2h5/gif2mem.c

@ -218,7 +218,7 @@ Gif2Mem(BYTE *MemGif, GIFTOMEM *GifMemoryStruct)
PlainTextCount++;
if (PlainTextCount > PlainTextArray)
PlainTextArray = (BYTE)((PlainTextArray << 1) + 1);
PlainTextArray = (BYTE)((PlainTextArray << 1) + 1);
if (!(gifPlainText = (GIFPLAINTEXT **)realloc(gifPlainText , sizeof(GIFPLAINTEXT *) * PlainTextArray))) {
printf("Out of memory!");
@ -240,7 +240,7 @@ Gif2Mem(BYTE *MemGif, GIFTOMEM *GifMemoryStruct)
CommentCount++;
if (CommentCount > CommentArray)
CommentArray = (BYTE)((CommentArray << 1) + 1);
CommentArray = (BYTE)((CommentArray << 1) + 1);
if (!(gifComment = (GIFCOMMENT **)realloc(gifComment , sizeof(GIFCOMMENT *) * CommentArray))) {
printf("Out of memory!");
@ -305,7 +305,7 @@ Gif2Mem(BYTE *MemGif, GIFTOMEM *GifMemoryStruct)
ApplicationCount++;
if (ApplicationCount > ApplicationArray)
ApplicationArray = (BYTE)((ApplicationArray << 1) + 1);
ApplicationArray = (BYTE)((ApplicationArray << 1) + 1);
if (!(gifApplication = (GIFAPPLICATION **)realloc(gifApplication , sizeof(GIFAPPLICATION *) * ApplicationArray))) {
printf("Out of memory!");

1
tools/lib/h5tools_type.c

@ -46,7 +46,6 @@ h5tools_get_native_type(hid_t type)
return(p_type);
}
/*-------------------------------------------------------------------------
* Function: h5tools_get_little_endian_type
*

446
tools/src/h5dump/h5dump_xml.c

File diff suppressed because it is too large Load Diff

767
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 */
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 (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;
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;
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;
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;
/* 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 */
/* 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;
/* 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 */
/* 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];
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 */
/*-------------------------------------------------------------------------
* 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;
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->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\
if (options->all_layout == 1 && has_ck) {
error_msg(
"invalid chunking input: 'all' option\
is present with other objects\n");
return -1;
}
return -1;
}
/*-------------------------------------------------------------------------
* objects to filter
*-------------------------------------------------------------------------
*/
/*-------------------------------------------------------------------------
* 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 */
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 (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));
}
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;
has_cp = 1;
} /* j */
} /* i */
} /* j */
} /* i */
if (options->all_filter == 1 && has_cp) {
error_msg(
"invalid compression input: 'all' option\
if (options->all_filter == 1 && has_cp) {
error_msg(
"invalid compression input: 'all' option\
is present with other objects\n");
return -1;
}
return -1;
}
/*-------------------------------------------------------------------------
* check options for the latest format
*-------------------------------------------------------------------------
*/
/*-------------------------------------------------------------------------
* 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;
}
}
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;
}
}
/*--------------------------------------------------------------------------------
* 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;
}
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
*---------------------------------------------------------------------------------
*/
/*--------------------------------------------------------------------------------
* 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;
}
if (options->alignment == 0 && options->threshold != 0) {
error_msg("alignment for H5Pset_alignment missing\n");
return -1;
}
return 0;
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;
hid_t fid;
unsigned int i;
trav_table_t *travt = NULL;
/* nothing to do */
if (options->op_tbl->nelems == 0)
return 0;
/* 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;
}
/*-------------------------------------------------------------------------
* 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
*-------------------------------------------------------------------------
*/
/*-------------------------------------------------------------------------
* get the list of objects in the file
*-------------------------------------------------------------------------
*/
/* init table */
trav_table_init(&travt);
/* init table */
trav_table_init(&travt);
/* get the list of objects in the file */
if (h5trav_gettable(fid, travt) < 0)
goto out;
/* get the list of objects in the file */
if (h5trav_gettable(fid, travt) < 0)
goto out;
/*-------------------------------------------------------------------------
* compare with user supplied list
*-------------------------------------------------------------------------
*/
/*-------------------------------------------------------------------------
* compare with user supplied list
*-------------------------------------------------------------------------
*/
if (options->verbose)
printf("Opening file <%s>. Searching for objects to modify...\n",
fname);
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);
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");
/* 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;
/* 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 (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 */
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;
/*-------------------------------------------------------------------------
* 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";
}

213
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;
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");
/* 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

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

4
tools/test/misc/talign.c

@ -17,7 +17,7 @@
*/
#include <string.h>
#include <stdlib.h>
/*#include <unistd.h> *//* Required for unlink() */
/*#include <unistd.h> *//* Required for unlink() */
#include "hdf5.h"
#include "H5private.h"
@ -106,7 +106,7 @@ int main(void)
H5Tclose(array_dt);
plist = H5Pcreate(H5P_DATASET_XFER);
if((error = H5Pset_preserve(plist, 1)) < 0)
if((error = H5Pset_preserve(plist, 1)) < 0)
goto out;
/*