/*------------------------------------------------------------------------- * Function: main * * Purpose: h5repack main program * * Return: Success: EXIT_SUCCESS(0) * * Failure: EXIT_FAILURE(1) * * Programmer: Pedro Vicente, [email protected] * * Date: May 9, 2003 * * Comments: * *------------------------------------------------------------------------- */ int main(int argc, const char **argv) { pack_opt_t options; /*the global options */ int ret=-1; h5tools_setprogname(PROGRAMNAME); h5tools_setstatus(EXIT_SUCCESS); /* Initialize h5tools lib */ h5tools_init(); /* initialize options */ h5repack_init(&options,0); parse_command_line(argc, argv, &options); /* get file names if they were not yet got */ if ( has_i_o == 0 ) { if ( argv[ opt_ind ] != NULL && argv[ opt_ind + 1 ] != NULL ) { infile = argv[ opt_ind ]; outfile = argv[ opt_ind + 1 ]; if ( HDstrcmp( infile, outfile ) == 0 ) { error_msg("file names cannot be the same\n"); usage(h5tools_getprogname()); HDexit(EXIT_FAILURE); } } else { error_msg("file names missing\n"); usage(h5tools_getprogname()); HDexit(EXIT_FAILURE); } } /* pack it */ ret=h5repack(infile,outfile,&options); /* free tables */ h5repack_end(&options); if (ret==-1) return 1; else return 0; }
/*------------------------------------------------------------------------- * Function: main * * Purpose: h5repack main program * * Return: Success: EXIT_SUCCESS(0) * * Failure: EXIT_FAILURE(1) * * Programmer: Pedro Vicente, [email protected] * * Date: May 9, 2003 * * Comments: * *------------------------------------------------------------------------- */ int main(int argc, const char **argv) { pack_opt_t options; /*the global options */ h5tools_setprogname(PROGRAMNAME); h5tools_setstatus(EXIT_SUCCESS); /* Initialize h5tools lib */ h5tools_init(); /* update hyperslab buffer size from H5TOOLS_BUFSIZE env if exist */ if (h5tools_getenv_update_hyperslab_bufsize() < 0) { h5tools_setstatus(EXIT_FAILURE); goto done; } /* initialize options */ h5repack_init(&options, 0); if (parse_command_line(argc, argv, &options) < 0) goto done; /* get file names if they were not yet got */ if (has_i_o == 0) { if (argv[opt_ind] != NULL && argv[opt_ind + 1] != NULL) { infile = argv[opt_ind]; outfile = argv[opt_ind + 1]; if ( HDstrcmp( infile, outfile ) == 0) { error_msg("file names cannot be the same\n"); usage(h5tools_getprogname()); h5tools_setstatus(EXIT_FAILURE); goto done; } } else { error_msg("file names missing\n"); usage(h5tools_getprogname()); h5tools_setstatus(EXIT_FAILURE); goto done; } } /* pack it */ h5tools_setstatus(h5repack(infile, outfile, &options)); done: /* free tables */ h5repack_end(&options); leave(h5tools_getstatus()); return 0; }
int main(int argc, const char *argv[])
{
int ret;
const char *fname1 = NULL;
const char *fname2 = NULL;
const char *objname1 = NULL;
const char *objname2 = NULL;
hsize_t nfound=0;
diff_opt_t options;
h5tools_setprogname(PROGRAMNAME);
h5tools_setstatus(EXIT_SUCCESS);
/* Initialize h5tools lib */
h5tools_init();
/*-------------------------------------------------------------------------
* process the command-line
*-------------------------------------------------------------------------
*/
parse_command_line(argc, argv, &fname1, &fname2, &objname1, &objname2, &options);
/*-------------------------------------------------------------------------
* do the diff
*-------------------------------------------------------------------------
*/
nfound = h5diff(fname1,fname2,objname1,objname2,&options);
print_info(&options);
/*-------------------------------------------------------------------------
* exit code
* 1 if differences, 0 if no differences, 2 if error
*-------------------------------------------------------------------------
*/
ret = (nfound == 0 ? 0 : 1 );
/* if graph difference return 1 for differences */
if ( options.contents == 0 )
ret = 1;
/* and return 2 for error */
if (options.err_stat)
ret = 2;
return ret;
}
/*
* Function: main
* Purpose: Start things up.
* Return: EXIT_SUCCESS or EXIT_FAILURE
* Programmer: Bill Wendling, 30. October 2001
* Modifications:
*/
int
main(int argc, char **argv)
{
int exit_value = EXIT_SUCCESS;
struct options *opts = NULL;
#ifndef STANDALONE
/* Initialize h5tools lib */
h5tools_init();
#endif
output = stdout;
opts = parse_command_line(argc, argv);
if (!opts) {
exit_value = EXIT_FAILURE;
goto finish;
}
if (opts->output_file) {
if ((output = HDfopen(opts->output_file, "w")) == NULL) {
fprintf(stderr, "%s: cannot open output file\n", progname);
perror(opts->output_file);
goto finish;
}
}
report_parameters(opts);
run_test_loop(opts);
finish:
free(opts);
return exit_value;
}
/*-------------------------------------------------------------------------
* Function: main
*
* Purpose: HDF5 user block jammer
*
* Return: Success: 0
* Failure: 1
*
* Programmer:
*
* Modifications:
*
*-------------------------------------------------------------------------
*/
int
main (int argc, const char *argv[])
{
int ufid = -1;
int h5fid = -1;
int ofid = -1;
void *edata;
H5E_auto2_t func;
hid_t ifile = -1;
hid_t plist = -1;
herr_t status;
htri_t testval;
hsize_t usize;
hsize_t h5fsize;
hsize_t startub;
hsize_t where;
hsize_t newubsize;
off_t fsize;
h5_stat_t sbuf;
h5_stat_t sbuf2;
int res;
h5tools_setprogname(PROGRAMNAME);
h5tools_setstatus(EXIT_SUCCESS);
/* Disable error reporting */
H5Eget_auto2(H5E_DEFAULT, &func, &edata);
H5Eset_auto2(H5E_DEFAULT, NULL, NULL);
/* Initialize h5tools lib */
h5tools_init();
parse_command_line (argc, argv);
if (ub_file == NULL) {
/* no user block */
error_msg("missing arguemnt for -u <user_file>.\n");
help_ref_msg(stderr);
leave (EXIT_FAILURE);
}
testval = H5Fis_hdf5 (ub_file);
if (testval > 0) {
error_msg("-u <user_file> cannot be HDF5 file, but it appears to be an HDF5 file.\n");
help_ref_msg(stderr);
leave (EXIT_FAILURE);
}
if (input_file == NULL) {
error_msg("missing arguemnt for -i <HDF5 file>.\n");
help_ref_msg(stderr);
leave (EXIT_FAILURE);
}
testval = H5Fis_hdf5 (input_file);
if (testval <= 0) {
error_msg("Input HDF5 file \"%s\" is not HDF5 format.\n", input_file);
help_ref_msg(stderr);
leave (EXIT_FAILURE);
}
ifile = H5Fopen (input_file, H5F_ACC_RDONLY, H5P_DEFAULT);
if (ifile < 0) {
error_msg("Can't open input HDF5 file \"%s\"\n", input_file);
leave (EXIT_FAILURE);
}
plist = H5Fget_create_plist (ifile);
if (plist < 0) {
error_msg("Can't get file creation plist for file \"%s\"\n", input_file);
H5Fclose(ifile);
leave (EXIT_FAILURE);
}
status = H5Pget_userblock (plist, &usize);
if (status < 0) {
error_msg("Can't get user block for file \"%s\"\n", input_file);
H5Pclose(plist);
H5Fclose(ifile);
leave (EXIT_FAILURE);
}
H5Pclose(plist);
H5Fclose(ifile);
ufid = HDopen(ub_file, O_RDONLY, 0);
if(ufid < 0) {
error_msg("unable to open user block file \"%s\"\n", ub_file);
leave (EXIT_FAILURE);
}
res = HDfstat(ufid, &sbuf);
if(res < 0) {
error_msg("Can't stat file \"%s\"\n", ub_file);
HDclose (ufid);
leave (EXIT_FAILURE);
}
fsize = (off_t)sbuf.st_size;
h5fid = HDopen(input_file, O_RDONLY, 0);
if(h5fid < 0) {
error_msg("unable to open HDF5 file for read \"%s\"\n", input_file);
HDclose (ufid);
leave (EXIT_FAILURE);
}
res = HDfstat(h5fid, &sbuf2);
if(res < 0) {
error_msg("Can't stat file \"%s\"\n", input_file);
HDclose (h5fid);
HDclose (ufid);
leave (EXIT_FAILURE);
}
h5fsize = (hsize_t)sbuf2.st_size;
if (output_file == NULL) {
ofid = HDopen (input_file, O_WRONLY, 0);
if (ofid < 0) {
error_msg("unable to open output file \"%s\"\n", output_file);
HDclose (h5fid);
HDclose (ufid);
leave (EXIT_FAILURE);
}
}
else {
ofid = HDopen (output_file, O_WRONLY | O_CREAT | O_TRUNC, 0644);
if (ofid < 0) {
error_msg("unable to create output file \"%s\"\n", output_file);
HDclose (h5fid);
HDclose (ufid);
leave (EXIT_FAILURE);
}
}
newubsize = compute_user_block_size ((hsize_t) fsize);
startub = usize;
if (usize > 0) {
if (do_clobber == TRUE) {
/* where is max of the current size or the new UB */
if (usize > newubsize) {
newubsize = usize;
}
startub = 0; /*blast the old */
}
else {
/* add new ub to current ublock, pad to new offset */
newubsize += usize;
newubsize = compute_user_block_size ((hsize_t) newubsize);
}
}
/* copy the HDF5 from starting at usize to starting at newubsize:
* makes room at 'from' for new ub */
/* if no current ub, usize is 0 */
copy_some_to_file (h5fid, ofid, usize, newubsize, (ssize_t) (h5fsize - usize));
/* copy the old ub to the beginning of the new file */
if (!do_clobber) {
where = copy_some_to_file (h5fid, ofid, (hsize_t) 0, (hsize_t) 0, (ssize_t) usize);
}
/* copy the new ub to the end of the ub */
where = copy_some_to_file (ufid, ofid, (hsize_t) 0, startub, (ssize_t) - 1);
/* pad the ub */
where = write_pad (ofid, where);
if(ub_file)
HDfree (ub_file);
if(input_file)
HDfree (input_file);
if(output_file)
HDfree (output_file);
if(ufid >= 0)
HDclose (ufid);
if(h5fid >= 0)
HDclose (h5fid);
if(ofid >= 0)
HDclose (ofid);
return h5tools_getstatus();
}
/*
* Function: main
* Purpose: Run the program
* Return: EXIT_SUCCESS or EXIT_FAILURE
* Programmer: Bill Wendling, 05. June 2002
* Modifications:
*/
int
main(int argc, char **argv)
{
unsigned long min_buf_size = 128 * ONE_KB, max_buf_size = ONE_MB;
unsigned long file_size = 64 * ONE_MB;
int opt;
prog = argv[0];
/* Initialize h5tools lib */
h5tools_init();
while ((opt = get_option(argc, (const char **)argv, s_opts, l_opts)) > 0) {
switch ((char)opt) {
case '0': case '1': case '2':
case '3': case '4': case '5':
case '6': case '7': case '8':
case '9':
compress_level = opt - '0';
break;
case 'B':
max_buf_size = parse_size_directive(opt_arg);
break;
case 'b':
min_buf_size = parse_size_directive(opt_arg);
break;
case 'c':
compress_percent = (int)HDstrtol(opt_arg, NULL, 10);
if (compress_percent < 0)
compress_percent = 0;
else if (compress_percent > 100)
compress_percent = 100;
break;
case 'p':
option_prefix = opt_arg;
break;
case 'r':
random_test = TRUE;
break;
case 's':
file_size = parse_size_directive(opt_arg);
break;
case '?':
usage();
exit(EXIT_FAILURE);
break;
case 'h':
default:
usage();
exit(EXIT_SUCCESS);
break;
}
}
if (min_buf_size > max_buf_size)
error("minmum buffer size (%d) exceeds maximum buffer size (%d)",
min_buf_size, max_buf_size);
HDfprintf(stdout, "Filesize: %ld\n", file_size);
if (compress_level == Z_DEFAULT_COMPRESSION)
HDfprintf(stdout, "Compression Level: 6\n");
else
HDfprintf(stdout, "Compression Level: %d\n", compress_level);
get_unique_name();
do_write_test(file_size, min_buf_size, max_buf_size);
cleanup();
return EXIT_SUCCESS;
}
int
main (int argc, const char *argv[])
{
hid_t fid_src = -1;
hid_t fid_dst = -1;
unsigned flag = 0;
unsigned verbose = 0;
unsigned parents = 0;
hid_t ocpl_id = (-1); /* Object copy property list */
hid_t lcpl_id = (-1); /* Link creation property list */
int opt;
int li_ret;
h5tool_link_info_t linkinfo;
h5tools_setprogname(PROGRAMNAME);
h5tools_setstatus(EXIT_SUCCESS);
/* initialize h5tools lib */
h5tools_init();
/* init linkinfo struct */
HDmemset(&linkinfo, 0, sizeof(h5tool_link_info_t));
/* Check for no command line parameters */
if(argc == 1)
{
usage();
leave(EXIT_FAILURE);
} /* end if */
/* parse command line options */
while ((opt = get_option(argc, argv, s_opts, l_opts)) != EOF)
{
switch ((char)opt)
{
case 'd':
oname_dst = HDstrdup(opt_arg);
break;
case 'f':
/* validate flag */
if (parse_flag(opt_arg,&flag)<0)
{
usage();
leave(EXIT_FAILURE);
}
str_flag = HDstrdup(opt_arg);
break;
case 'h':
usage();
leave(EXIT_SUCCESS);
break;
case 'i':
fname_src = HDstrdup(opt_arg);
break;
case 'o':
fname_dst = HDstrdup(opt_arg);
break;
case 'p':
parents = 1;
break;
case 's':
oname_src = HDstrdup(opt_arg);
break;
case 'V':
print_version(h5tools_getprogname());
leave(EXIT_SUCCESS);
break;
case 'v':
verbose = 1;
break;
default:
usage();
leave(EXIT_FAILURE);
}
} /* end of while */
/*-------------------------------------------------------------------------
* check for missing file/object names
*-------------------------------------------------------------------------*/
if (fname_src==NULL)
{
error_msg("Input file name missing\n");
usage();
leave(EXIT_FAILURE);
}
if (fname_dst==NULL)
{
error_msg("Output file name missing\n");
usage();
leave(EXIT_FAILURE);
}
if (oname_src==NULL)
{
error_msg("Source object name missing\n");
usage();
leave(EXIT_FAILURE);
}
if (oname_dst==NULL)
{
error_msg("Destination object name missing\n");
usage();
leave(EXIT_FAILURE);
}
/*-------------------------------------------------------------------------
* open output file
*-------------------------------------------------------------------------*/
/* Attempt to open an existing HDF5 file first. Need to open the dst file
before the src file just in case that the dst and src are the same file
*/
fid_dst = h5tools_fopen(fname_dst, H5F_ACC_RDWR, H5P_DEFAULT, NULL, NULL, 0);
/*-------------------------------------------------------------------------
* open input file
*-------------------------------------------------------------------------*/
fid_src = h5tools_fopen(fname_src, H5F_ACC_RDONLY, H5P_DEFAULT, NULL, NULL, 0);
/*-------------------------------------------------------------------------
* test for error in opening input file
*-------------------------------------------------------------------------*/
if (fid_src==-1)
{
error_msg("Could not open input file <%s>...Exiting\n", fname_src);
leave(EXIT_FAILURE);
}
/*-------------------------------------------------------------------------
* create an output file when failed to open it
*-------------------------------------------------------------------------*/
/* If we couldn't open an existing file, try creating file */
/* (use "EXCL" instead of "TRUNC", so we don't blow away existing non-HDF5 file) */
if(fid_dst < 0)
fid_dst = H5Fcreate(fname_dst, H5F_ACC_EXCL, H5P_DEFAULT, H5P_DEFAULT);
/*-------------------------------------------------------------------------
* test for error in opening output file
*-------------------------------------------------------------------------*/
if (fid_dst==-1)
{
error_msg("Could not open output file <%s>...Exiting\n", fname_dst);
leave(EXIT_FAILURE);
}
/*-------------------------------------------------------------------------
* print some info
*-------------------------------------------------------------------------*/
if (verbose)
{
printf("Copying file <%s> and object <%s> to file <%s> and object <%s>\n",
fname_src, oname_src, fname_dst, oname_dst);
if (flag) {
HDassert(str_flag);
printf("Using %s flag\n", str_flag);
}
}
/*-------------------------------------------------------------------------
* create property lists for copy
*-------------------------------------------------------------------------*/
/* create property to pass copy options */
if ( (ocpl_id = H5Pcreate(H5P_OBJECT_COPY)) < 0)
goto error;
/* set options for object copy */
if (flag)
{
if ( H5Pset_copy_object(ocpl_id, flag) < 0)
goto error;
}
/* Create link creation property list */
if((lcpl_id = H5Pcreate(H5P_LINK_CREATE)) < 0) {
error_msg("Could not create link creation property list\n");
goto error;
} /* end if */
/* Check for creating intermediate groups */
if(parents) {
/* Set the intermediate group creation property */
if(H5Pset_create_intermediate_group(lcpl_id, 1) < 0) {
error_msg("Could not set property for creating parent groups\n");
goto error;
} /* end if */
/* Display some output if requested */
if(verbose)
printf("%s: Creating parent groups\n", h5tools_getprogname());
} /* end if */
else /* error, if parent groups doesn't already exist in destination file */
{
size_t i, len;
len = HDstrlen(oname_dst);
/* check if all the parents groups exist. skip root group */
for (i = 1; i < len; i++)
{
if ('/'==oname_dst[i])
{
char *str_ptr;
str_ptr = (char *)HDcalloc(i + 1, sizeof(char));
HDstrncpy(str_ptr, oname_dst, i);
str_ptr[i]='\0';
if (H5Lexists(fid_dst, str_ptr, H5P_DEFAULT) <= 0)
{
error_msg("group <%s> doesn't exist. Use -p to create parent groups.\n", str_ptr);
HDfree(str_ptr);
goto error;
}
HDfree(str_ptr);
}
}
}
/*-------------------------------------------------------------------------
* do the copy
*-------------------------------------------------------------------------*/
if(verbose)
linkinfo.opt.msg_mode = 1;
li_ret = H5tools_get_symlink_info(fid_src, oname_src, &linkinfo, 1);
if (li_ret == 0) /* dangling link */
{
if(H5Lcopy(fid_src, oname_src,
fid_dst, oname_dst,
H5P_DEFAULT, H5P_DEFAULT) < 0)
goto error;
}
else /* valid link */
{
if (H5Ocopy(fid_src, /* Source file or group identifier */
oname_src, /* Name of the source object to be copied */
fid_dst, /* Destination file or group identifier */
oname_dst, /* Name of the destination object */
ocpl_id, /* Object copy property list */
lcpl_id)<0) /* Link creation property list */
goto error;
}
/* free link info path */
if (linkinfo.trg_path)
HDfree(linkinfo.trg_path);
/* close propertis */
if(H5Pclose(ocpl_id)<0)
goto error;
if(H5Pclose(lcpl_id)<0)
goto error;
/* close files */
if (H5Fclose(fid_src)<0)
goto error;
if (H5Fclose(fid_dst)<0)
goto error;
leave(EXIT_SUCCESS);
error:
printf("Error in copy...Exiting\n");
/* free link info path */
if (linkinfo.trg_path)
HDfree(linkinfo.trg_path);
H5E_BEGIN_TRY {
H5Pclose(ocpl_id);
H5Pclose(lcpl_id);
H5Fclose(fid_src);
H5Fclose(fid_dst);
} H5E_END_TRY;
leave(EXIT_FAILURE);
}
/*-------------------------------------------------------------------------
* Function: main
*
* Modifications:
* 2/2010; Vailin Choi
* Get the size of user block
*
*-------------------------------------------------------------------------
*/
int
main(int argc, const char *argv[])
{
iter_t iter;
const char *fname = NULL;
hid_t fid = -1;
hid_t fcpl;
struct handler_t *hand = NULL;
H5F_info_t finfo;
int i;
h5tools_setprogname(PROGRAMNAME);
h5tools_setstatus(EXIT_SUCCESS);
/* Disable error reporting */
H5Eset_auto2(H5E_DEFAULT, NULL, NULL);
/* Initialize h5tools lib */
h5tools_init();
if((hand = parse_command_line(argc, argv))==NULL) {
goto done;
}
fname = argv[opt_ind];
printf("Filename: %s\n", fname);
HDmemset(&iter, 0, sizeof(iter));
fid = H5Fopen(fname, H5F_ACC_RDONLY, H5P_DEFAULT);
if(fid < 0) {
error_msg("unable to open file \"%s\"\n", fname);
h5tools_setstatus(EXIT_FAILURE);
goto done;
} /* end if */
/* Initialize iter structure */
iter.fid = fid;
if(H5Fget_filesize(fid, &iter.filesize) < 0)
warn_msg("Unable to retrieve file size\n");
HDassert(iter.filesize != 0);
/* Get storge info for file-level structures */
if(H5Fget_info(fid, &finfo) < 0)
warn_msg("Unable to retrieve file info\n");
else {
iter.super_ext_size = finfo.super_ext_size;
iter.SM_hdr_storage_size = finfo.sohm.hdr_size;
iter.SM_index_storage_size = finfo.sohm.msgs_info.index_size;
iter.SM_heap_storage_size = finfo.sohm.msgs_info.heap_size;
} /* end else */
if((fcpl = H5Fget_create_plist(fid)) < 0)
warn_msg("Unable to retrieve file creation property\n");
if(H5Pget_userblock(fcpl, &iter.ublk_size) < 0)
warn_msg("Unable to retrieve userblock size\n");
/* Walk the objects or all file */
if(display_object) {
unsigned u;
u = 0;
while(hand[u].obj) {
if (h5trav_visit(fid, hand[u].obj, TRUE, TRUE, obj_stats, lnk_stats, &iter) < 0)
warn_msg("Unable to traverse object \"%s\"\n", hand[u].obj);
else
print_statistics(hand[u].obj, &iter);
u++;
} /* end while */
} /* end if */
else {
if (h5trav_visit(fid, "/", TRUE, TRUE, obj_stats, lnk_stats, &iter) < 0)
warn_msg("Unable to traverse objects/links in file \"%s\"\n", fname);
else
print_statistics("/", &iter);
} /* end else */
done:
if(hand) {
for (i = 0; i < argc; i++)
if(hand[i].obj) {
free(hand[i].obj);
hand[i].obj=NULL;
}
free(hand);
hand = NULL;
/* Free iter structure */
iter_free(&iter);
if(fid >= 0 && H5Fclose(fid) < 0) {
error_msg("unable to close file \"%s\"\n", fname);
h5tools_setstatus(EXIT_FAILURE);
}
}
leave(h5tools_getstatus());
}
int
main(int argc, const char *argv[])
{
iter_t iter;
const char *fname = NULL;
hid_t fid;
struct handler_t *hand;
H5F_info_t finfo;
/* Disable error reporting */
H5Eset_auto2(H5E_DEFAULT, NULL, NULL);
/* Initialize h5tools lib */
h5tools_init();
hand = parse_command_line (argc, argv);
if(!hand) {
error_msg(progname, "unable to parse command line arguments \n");
leave(EXIT_FAILURE);
} /* end if */
fname = argv[opt_ind];
printf("Filename: %s\n", fname);
fid = H5Fopen(fname, H5F_ACC_RDONLY, H5P_DEFAULT);
if(fid < 0) {
error_msg(progname, "unable to open file \"%s\"\n", fname);
leave(EXIT_FAILURE);
} /* end if */
/* Initialize iter structure */
iter_init(&iter, fid);
/* Get storge info for SOHM's btree/list/heap and superblock extension */
if(H5Fget_info(fid, &finfo) < 0)
warn_msg(progname, "Unable to retrieve SOHM info\n");
else {
iter.super_ext_size = finfo.super_ext_size;
iter.SM_hdr_storage_size = finfo.sohm.hdr_size;
iter.SM_index_storage_size = finfo.sohm.msgs_info.index_size;
iter.SM_heap_storage_size = finfo.sohm.msgs_info.heap_size;
} /* end else */
/* Walk the objects or all file */
if(display_object) {
unsigned u;
u = 0;
while(hand[u].obj) {
if (h5trav_visit(fid, hand[u].obj, TRUE, TRUE, obj_stats, lnk_stats, &iter) < 0)
warn_msg(progname, "Unable to traverse object \"%s\"\n", hand[u].obj);
else
print_statistics(hand[u].obj, &iter);
u++;
} /* end while */
} /* end if */
else {
if (h5trav_visit(fid, "/", TRUE, TRUE, obj_stats, lnk_stats, &iter) < 0)
warn_msg(progname, "Unable to traverse objects/links in file \"%s\"\n", fname);
else
print_statistics("/", &iter);
} /* end else */
if (hand) free(hand);
if(H5Fclose(fid) < 0) {
error_msg(progname, "unable to close file \"%s\"\n", fname);
leave(EXIT_FAILURE);
}
leave(EXIT_SUCCESS);
}
int
main(int argv , char *argc[])
{
GIFTOMEM GifMemoryStruct;
GIFIMAGEDESC gifImageDesc;
FILE *fpGif;
/* replacing int32 with long */
long i, ImageCount;
long filesize;
BYTE *MemGif;
BYTE *StartPos;
char *GIFFileName;
char *HDFFileName;
/*
* Initialize all GifMemoryStruct pointers to null to prevent hassles
* later on
*/
GifMemoryStruct.GifHeader = NULL;
GifMemoryStruct.GifImageDesc = NULL;
GifMemoryStruct.GifGraphicControlExtension = NULL;
GifMemoryStruct.GifPlainTextExtension = NULL;
GifMemoryStruct.GifApplicationExtension = NULL;
GifMemoryStruct.GifCommentExtension = NULL;
/* Initialize h5tools lib */
h5tools_init();
if ( argc[1] && (strcmp("-V",argc[1])==0) )
{
print_version("gif2h5");
exit(EXIT_SUCCESS);
}
if (argv < 3) {
printf("Usage: gif2h5 <GIFFILE> <HDFFILE>\n");
fprintf(stdout, " gif2h5 -V \n");
fprintf(stdout, " Print HDF5 library version and exit\n");
exit(EXIT_FAILURE);
}
GIFFileName = argc[1];
HDFFileName = argc[2];
if (!(fpGif = fopen(GIFFileName,"rb"))) {
printf("Unable to open GIF file for reading.\n");
exit(EXIT_FAILURE);
}
/* Get the whole file into memory. Mem's much faster than I/O */
fseek(fpGif, 0L , 2);
filesize = ftell(fpGif);
fseek(fpGif, 0L , 0);
if (filesize == 0)
printf("File Size Zero");
if (!(MemGif = StartPos = (BYTE *)malloc((size_t)filesize))) {
printf("Out of memory");
exit(EXIT_FAILURE);
}
if (fread(MemGif,(size_t)filesize,1,fpGif) != 1) {
printf("Corrupted Input File");
exit(EXIT_FAILURE);
}
fseek(fpGif,0L,0);
/*
* Call Gif2Mem and break the whole file into parts. Gif2Mem also calls
* decompresses the images so we don't have to worry about that
*/
Gif2Mem(MemGif, &GifMemoryStruct);
if (ferror(fpGif)) {
printf("File Stream Error\n\n");
exit(EXIT_FAILURE);
}
fclose(fpGif);
/*
* Call WriteHDF from here. Go ahead and change WriteHDF to write whatever
* format you want
*/
if (WriteHDF(GifMemoryStruct , HDFFileName))
printf("HDF Write Error\n\n");
/* Free all buffers */
/* replacing int32 with long */
ImageCount = (long)((GifMemoryStruct.GifHeader)->ImageCount);
for(i = 0; i < ImageCount ; i++) {
gifImageDesc = *(GifMemoryStruct.GifImageDesc[i]);
if (gifImageDesc.Image != NULL)
free(gifImageDesc.Image);
if (GifMemoryStruct.GifImageDesc[i] != NULL)
{
free(GifMemoryStruct.GifImageDesc[i]);
GifMemoryStruct.GifImageDesc[i] = NULL;
}
if (GifMemoryStruct.GifGraphicControlExtension[i] != NULL)
{
free(GifMemoryStruct.GifGraphicControlExtension[i]);
GifMemoryStruct.GifGraphicControlExtension[i] = NULL;
}
}
free(StartPos);
if (GifMemoryStruct.GifHeader != NULL)
{
free(GifMemoryStruct.GifHeader);
GifMemoryStruct.GifHeader = NULL;
}
if (GifMemoryStruct.GifApplicationExtension != NULL)
{
free(GifMemoryStruct.GifApplicationExtension);
GifMemoryStruct.GifApplicationExtension = NULL;
}
if (GifMemoryStruct.GifImageDesc != NULL)
{
free(GifMemoryStruct.GifImageDesc);
GifMemoryStruct.GifImageDesc = NULL;
}
if (GifMemoryStruct.GifGraphicControlExtension != NULL)
{
free(GifMemoryStruct.GifGraphicControlExtension);
GifMemoryStruct.GifGraphicControlExtension = NULL;
}
return EXIT_SUCCESS;
}
int main(int argc, const char *argv[])
{
int nID = 0;
const char *fname1 = NULL;
const char *fname2 = NULL;
const char *objname1 = NULL;
const char *objname2 = NULL;
diff_opt_t options;
h5tools_setprogname(PROGRAMNAME);
h5tools_setstatus(EXIT_SUCCESS);
/* Initialize h5tools lib */
h5tools_init();
outBuffOffset = 0;
g_Parallel = 1;
MPI_Init(&argc, (char***) &argv);
MPI_Comm_rank(MPI_COMM_WORLD, &nID);
MPI_Comm_size(MPI_COMM_WORLD, &g_nTasks);
if(g_nTasks == 1)
{
printf("Only 1 task available...doing serial diff\n");
g_Parallel = 0;
parse_command_line(argc, argv, &fname1, &fname2, &objname1, &objname2, &options);
h5diff(fname1, fname2, objname1, objname2, &options);
print_info(&options);
}
/* Parallel h5diff */
else {
/* Have the manager process the command-line */
if(nID == 0)
{
parse_command_line(argc, argv, &fname1, &fname2, &objname1, &objname2, &options);
h5diff(fname1, fname2, objname1, objname2, &options);
MPI_Barrier(MPI_COMM_WORLD);
print_info(&options);
print_manager_output();
}
/* All other tasks become workers and wait for assignments. */
else {
ph5diff_worker(nID);
MPI_Barrier(MPI_COMM_WORLD);
} /* end else */
} /* end else */
MPI_Finalize();
return 0;
}
/*-------------------------------------------------------------------------
* Function: main
*
* Purpose: Create group(s) in an HDF5 file
*
* Programmer: Quincey Koziol, 2/13/2007
*
*-------------------------------------------------------------------------
*/
int
main(int argc, const char *argv[])
{
hid_t fid; /* HDF5 file ID */
hid_t fapl_id; /* File access property list ID */
hid_t lcpl_id; /* Link creation property list ID */
size_t curr_group; /* Current group to create */
h5tools_setprogname(PROGRAMNAME);
h5tools_setstatus(EXIT_SUCCESS);
/* Disable the HDF5 library's error reporting */
H5Eset_auto2(H5E_DEFAULT, NULL, NULL);
/* Initialize h5tools lib */
h5tools_init();
/* Parse command line */
HDmemset(¶ms, 0, sizeof(params));
if(parse_command_line(argc, argv, ¶ms) < 0) {
error_msg("unable to parse command line arguments\n");
leave(EXIT_FAILURE);
} /* end if */
/* Create file access property list */
if((fapl_id = H5Pcreate(H5P_FILE_ACCESS)) < 0) {
error_msg("Could not create file access property list\n");
leave(EXIT_FAILURE);
} /* end if */
/* Check for creating groups with new format version */
if(params.latest) {
/* Set the "use the latest version of the format" bounds */
if(H5Pset_libver_bounds(fapl_id, H5F_LIBVER_LATEST, H5F_LIBVER_LATEST) < 0) {
error_msg("Could not set property for using latest version of the format\n");
leave(EXIT_FAILURE);
} /* end if */
/* Display some output if requested */
if(params.verbose)
printf("%s: Creating groups with latest version of the format\n", h5tools_getprogname());
} /* end if */
/* Attempt to open an existing HDF5 file first */
fid = h5tools_fopen(params.fname, H5F_ACC_RDWR, fapl_id, NULL, NULL, 0);
/* If we couldn't open an existing file, try creating file */
/* (use "EXCL" instead of "TRUNC", so we don't blow away existing non-HDF5 file) */
if(fid < 0)
fid = H5Fcreate(params.fname, H5F_ACC_EXCL, H5P_DEFAULT, fapl_id);
/* Test for error in opening file */
if(fid < 0) {
error_msg("Could not open output file '%s'\n", params.fname);
leave(EXIT_FAILURE);
} /* end if */
/* Create link creation property list */
if((lcpl_id = H5Pcreate(H5P_LINK_CREATE)) < 0) {
error_msg("Could not create link creation property list\n");
leave(EXIT_FAILURE);
} /* end if */
/* Check for creating intermediate groups */
if(params.parents) {
/* Set the intermediate group creation property */
if(H5Pset_create_intermediate_group(lcpl_id, TRUE) < 0) {
error_msg("Could not set property for creating parent groups\n");
leave(EXIT_FAILURE);
} /* end if */
/* Display some output if requested */
if(params.verbose)
printf("%s: Creating parent groups\n", h5tools_getprogname());
} /* end if */
/* Loop over creating requested groups */
for(curr_group = 0; curr_group < params.ngroups; curr_group++) {
hid_t gid; /* Group ID */
/* Attempt to create a group */
if((gid = H5Gcreate2(fid, params.groups[curr_group], lcpl_id, H5P_DEFAULT, H5P_DEFAULT)) < 0) {
error_msg("Could not create group '%s'\n", params.groups[curr_group]);
leave(EXIT_FAILURE);
} /* end if */
/* Close the group */
if(H5Gclose(gid) < 0) {
error_msg("Could not close group '%s'??\n", params.groups[curr_group]);
leave(EXIT_FAILURE);
} /* end if */
/* Display some output if requested */
if(params.verbose)
printf("%s: created group '%s'\n", h5tools_getprogname(), params.groups[curr_group]);
} /* end for */
/* Close link creation property list */
if(H5Pclose(lcpl_id) < 0) {
error_msg("Could not close link creation property list\n");
leave(EXIT_FAILURE);
} /* end if */
/* Close file */
if(H5Fclose(fid) < 0) {
error_msg("Could not close output file '%s'??\n", params.fname);
leave(EXIT_FAILURE);
} /* end if */
/* Close file access property list */
if(H5Pclose(fapl_id) < 0) {
error_msg("Could not close file access property list\n");
leave(EXIT_FAILURE);
} /* end if */
/* Shut down h5tools lib */
h5tools_close();
leave(EXIT_SUCCESS);
} /* end main() */
/*-------------------------------------------------------------------------
* Function: main
*
* Purpose: HDF5 user block unjammer
*
* Return: Success: 0
* Failure: 1
*
* Programmer:
*
* Modifications:
*
*-------------------------------------------------------------------------
*/
int
main (int argc, const char *argv[])
{
char *ifname;
void *edata;
H5E_auto2_t func;
hid_t ifile;
hsize_t usize;
htri_t testval;
herr_t status;
hid_t plist;
h5tools_setprogname(PROGRAMNAME);
h5tools_setstatus(EXIT_SUCCESS);
/* Initialize h5tools lib */
h5tools_init();
/* Disable error reporting */
H5Eget_auto2(H5E_DEFAULT, &func, &edata);
H5Eset_auto2(H5E_DEFAULT, NULL, NULL);
parse_command_line (argc, argv);
if (argc <= (opt_ind))
{
error_msg("missing file name\n");
usage (h5tools_getprogname());
return (EXIT_FAILURE);
}
ifname = HDstrdup (argv[opt_ind]);
testval = H5Fis_hdf5 (ifname);
if (testval <= 0)
{
error_msg("Input HDF5 file is not HDF \"%s\"\n", ifname);
return (EXIT_FAILURE);
}
ifile = H5Fopen (ifname, H5F_ACC_RDONLY, H5P_DEFAULT);
if (ifile < 0)
{
error_msg("Can't open input HDF5 file \"%s\"\n", ifname);
return (EXIT_FAILURE);
}
plist = H5Fget_create_plist (ifile);
if (plist < 0)
{
error_msg("Can't get file creation plist for file \"%s\"\n",
ifname);
return (EXIT_FAILURE);
}
status = H5Pget_userblock (plist, &usize);
if (status < 0)
{
error_msg("Can't get user block for file \"%s\"\n", ifname);
return (EXIT_FAILURE);
}
printf ("%ld\n", (long) usize);
H5Pclose (plist);
H5Fclose (ifile);
return (EXIT_SUCCESS);
}
int main(int argc , char **argv)
{
BYTE *Image;
/* compression structs */
CHAR *HDFName = NULL;
CHAR *GIFName = NULL;
BYTE* b;
BYTE GlobalPalette[256][3];
BYTE Red[256];
BYTE Green[256];
BYTE Blue[256];
int RWidth, RHeight;
int ColorMapSize, InitCodeSize, Background, BitsPerPixel;
int j,nc;
int i;
int numcols;
BYTE pc2nc[256] , r1[256] , g1[256] , b1[256];
int arg_index = 2;
int bool_is_image = 0; /* 0 = false , 1 = true */
char *image_name = NULL;
int idx;
/* Initialize h5tools lib */
h5tools_init();
if ( argv[1] && (strcmp("-V",argv[1])==0) )
{
print_version("gif2h5");
exit(EXIT_SUCCESS);
}
if (argc < 4)
{
/* they didn't supply at least one image -- bail */
usage();
return EXIT_FAILURE;
}
HDFName = argv[1];
GIFName = argv[2];
/* get the options */
while (arg_index++ < argc - 1)
{
if (!strcmp(argv[arg_index] , "-i")) {
bool_is_image = 1;
continue;
}
if (bool_is_image)
{
/* allocate space to store the image name */
size_t len = strlen(argv[arg_index]);
image_name = (CHAR*) malloc( len + 1);
strcpy(image_name , argv[arg_index]);
bool_is_image = 0;
continue;
}
/* oops. This was not meant to happen */
usage();
goto out;
}
/* Do Endian Order testing and set Endian Order */
idx = 0x0001;
b = (BYTE *) &idx;
EndianOrder = (b[0] ? 1:0);
if (!(fpGif = fopen(GIFName , "wb")))
{
printf("Error opening gif file for output. Aborting.\n");
goto out;
}
Background = 0;
{
hsize_t width, height, planes;
hid_t fid;
char interlace[20];
hssize_t npals;
hsize_t pal_dims[2];
unsigned char *pal;
if ((fid = H5Fopen(HDFName , H5F_ACC_RDONLY , H5P_DEFAULT)) < 0)
{
fprintf(stderr , "Unable to open HDF file for input. Aborting.\n");
goto out;
}
/* read image */
if ( H5IMget_image_info( fid, image_name, &width, &height, &planes, interlace, &npals ) < 0 )
goto out;
Image = (BYTE*) malloc( (size_t) width * (size_t) height );
if ( H5IMread_image( fid, image_name, Image ) < 0 )
goto out;
if (npals)
{
if ( H5IMget_palette_info( fid, image_name, 0, pal_dims ) < 0 )
goto out;
pal = (BYTE*) malloc( (size_t) pal_dims[0] * (size_t) pal_dims[1] );
if ( H5IMget_palette( fid, image_name, 0, pal ) < 0 )
goto out;
numcols = (int) pal_dims[0];
for (i = 0, j = 0 ; i < numcols ; j+=3, i++)
{
GlobalPalette[i][0] = pal[j];
GlobalPalette[i][1] = pal[j+1];
GlobalPalette[i][2] = pal[j+2];
}
free(pal);
}
H5Fclose(fid);
RWidth = (int)width;
RHeight = (int)height;
/*
* If the first image does not have a palette, I make my own global
* color table Obviously this is not the best thing to do, better
* steps would be:
*
* 1. Check for either a global palette or a global attribute called
* palette
* 2. Check for palettes in any of the other images.
*/
if (!npals)
{
numcols = 256;
for (i = 0 ; i < numcols ; i++)
{
Red[i] = 255 - i;
Green[i] = 255 - i;
Blue[i] = 255 - i;
}
}
else
{
for (i = 0 ; i < numcols ; i++)
{
Red[i] = GlobalPalette[i][0];
Green[i] = GlobalPalette[i][1];
Blue[i] = GlobalPalette[i][2];
}
}
for (i = 0; i < numcols; i++)
{
pc2nc[i] = r1[i] = g1[i] = b1[i] = 0;
}
/* compute number of unique colors */
nc = 0;
for (i = 0; i < numcols; i++)
{
/* see if color #i is already used */
for (j = 0; j < i; j++)
{
if (Red[i] == Red[j] && Green[i] == Green[j] && Blue[i] == Blue[j])
break;
}
if (j==i)
{
/* wasn't found */
pc2nc[i] = nc;
r1[nc] = Red[i];
g1[nc] = Green[i];
b1[nc] = Blue[i];
nc++;
}
else
{
pc2nc[i] = pc2nc[j];
}
}
/* figure out 'BitsPerPixel' */
for (i = 1; i < 8; i++)
{
if ((1<<i) >= nc)
break;
}
BitsPerPixel = i;
ColorMapSize = 1 << BitsPerPixel;
if (BitsPerPixel <= 1)
InitCodeSize = 2;
else
InitCodeSize = BitsPerPixel;
if (!fpGif)
{
fprintf(stderr, "WriteGIF: file not open for writing\n" );
goto out;
}
fwrite("GIF87a", sizeof( char ), 6, fpGif); /* the GIF magic number */
putword(RWidth, fpGif); /* screen descriptor */
putword(RHeight, fpGif);
i = 0x00; /* No, there is no color map */
i |= (8-1)<<4; /* OR in the color resolution (hardwired 8) */
i |= (BitsPerPixel - 1); /* OR in the # of bits per pixel */
fputc(i,fpGif);
fputc(Background,fpGif); /* background color */
fputc(0, fpGif); /* future expansion byte */
/*
* Put Image Descriptor
* Hardwiring Left Offset and Top Offset to 0x00
*/
fputc(0x2c , fpGif);
putword(0x00 , fpGif);
putword(0x00 , fpGif);
putword(RWidth , fpGif);
putword(RHeight , fpGif);
/* since we always have a local color palette ... */
fputc((0x80 | (BitsPerPixel - 1)) , fpGif);
for (i = 0; i < ColorMapSize; i++)
{
/* write out Global colormap */
fputc(r1[i], fpGif);
fputc(g1[i], fpGif);
fputc(b1[i], fpGif);
}
fputc(InitCodeSize , fpGif);
i = hdfWriteGIF(fpGif , Image , 0 , RHeight , RWidth , r1, g1 , b1 , pc2nc , 256 , 8 , BitsPerPixel);
fputc(0x00, fpGif);
free(Image);
}
if (fputc(';',fpGif) == EOF)
{
/* Write GIF file terminator */
fprintf(stderr , "Error!");
goto out;
}
if (fpGif != NULL)
fclose(fpGif);
if (image_name != NULL)
free(image_name);
return EXIT_SUCCESS;
out:
if (fpGif != NULL)
fclose(fpGif);
if (image_name != NULL)
free(image_name);
return EXIT_FAILURE;
}
int
main (int argc, const char *argv[])
{
int fd;
unsigned int size;
char *filename;
long res;
char *buf;
h5tools_setprogname(PROGRAMNAME);
h5tools_setstatus(EXIT_SUCCESS);
/* Initialize h5tools lib */
h5tools_init();
parse_command_line (argc, argv);
if (nbytes == NULL)
{
/* missing arg */
error_msg("missing size\n");
usage (h5tools_getprogname());
exit (EXIT_FAILURE);
}
if (argc <= (opt_ind))
{
error_msg("missing file name\n");
usage (h5tools_getprogname());
exit (EXIT_FAILURE);
}
filename = HDstrdup (argv[opt_ind]);
size = 0;
res = sscanf (nbytes, "%u", &size);
if (res == EOF)
{
/* fail */
error_msg("missing file name\n");
usage (h5tools_getprogname());
exit (EXIT_FAILURE);
}
fd = HDopen (filename, O_RDONLY, 0);
if (fd < 0)
{
error_msg("can't open file %s\n", filename);
exit (EXIT_FAILURE);
}
buf = (char *)HDmalloc ((unsigned)(size + 1));
if (buf == NULL)
{
HDclose (fd);
exit (EXIT_FAILURE);
}
res = HDread (fd, buf, (unsigned)size);
if (res < (long)size)
{
if (buf)
HDfree (buf);
HDclose (fd);
exit (EXIT_FAILURE);
}
HDwrite (1, buf, (unsigned)size);
if (buf)
HDfree (buf);
HDclose (fd);
return (EXIT_SUCCESS);
}
/*-------------------------------------------------------------------------
* Function: main
*
* Purpose: HDF5 user block unjammer
*
* Return: Success: 0
* Failure: 1
*
* Programmer:
*
* Modifications:
*
*-------------------------------------------------------------------------
*/
int
main(int argc, const char *argv[])
{
void *edata;
H5E_auto2_t func;
hid_t ifile = -1;
hid_t plist = -1;
off_t fsize;
hsize_t usize;
htri_t testval;
herr_t status;
int res;
h5_stat_t sbuf;
h5tools_setprogname(PROGRAMNAME);
h5tools_setstatus(EXIT_SUCCESS);
/* Disable error reporting */
H5Eget_auto2(H5E_DEFAULT, &func, &edata);
H5Eset_auto2(H5E_DEFAULT, NULL, NULL);
/* Initialize h5tools lib */
h5tools_init();
if(EXIT_FAILURE == parse_command_line(argc, argv))
goto done;
if (input_file == NULL) {
/* no user block */
error_msg("missing arguemnt for HDF5 file input.\n");
help_ref_msg(stderr);
h5tools_setstatus(EXIT_FAILURE);
goto done;
}
testval = H5Fis_hdf5(input_file);
if (testval <= 0) {
error_msg("Input HDF5 file \"%s\" is not HDF\n", input_file);
help_ref_msg (stderr);
h5tools_setstatus(EXIT_FAILURE);
goto done;
}
ifile = H5Fopen(input_file, H5F_ACC_RDONLY , H5P_DEFAULT);
if (ifile < 0) {
error_msg("Can't open input HDF5 file \"%s\"\n", input_file);
h5tools_setstatus(EXIT_FAILURE);
goto done;
}
plist = H5Fget_create_plist(ifile);
if (plist < 0) {
error_msg("Can't get file creation plist for file \"%s\"\n", input_file);
h5tools_setstatus(EXIT_FAILURE);
goto done;
}
status = H5Pget_userblock(plist, & usize);
if (status < 0) {
error_msg("Can't get user block for file \"%s\"\n", input_file);
h5tools_setstatus(EXIT_FAILURE);
goto done;
}
status = H5Pclose(plist);
HDassert(status >= 0);
status = H5Fclose(ifile);
HDassert(status >= 0);
if (usize == 0) {
/* no user block to remove: message? */
error_msg("\"%s\" has no user block: no change to file\n", input_file);
h5tools_setstatus(EXIT_SUCCESS);
goto done;
}
res = HDfstat(HDfileno(rawinstream), &sbuf);
if(res < 0) {
error_msg("Can't stat file \"%s\"\n", input_file);
h5tools_setstatus(EXIT_FAILURE);
goto done;
}
fsize = sbuf.st_size;
if (do_delete && (ub_file != NULL)) {
error_msg("??\"%s\"\n", ub_file);
h5tools_setstatus(EXIT_FAILURE);
goto done;
}
if (output_file == NULL) {
error_msg("unable to open output HDF5 file \"%s\"\n", input_file);
h5tools_setstatus(EXIT_FAILURE);
goto done;
}
/* copy from 0 to 'usize - 1' into ufid */
if (!do_delete) {
if(copy_to_file(rawinstream, rawoutstream, 0, (ssize_t) usize) < 0) {
error_msg("unable to copy user block to output file \"%s\"\n", ub_file);
h5tools_setstatus(EXIT_FAILURE);
goto done;
}
}
/* copy from usize to end of file into h5fid,
* starting at end of user block if present */
if(copy_to_file(rawinstream, rawdatastream, (ssize_t) usize, (ssize_t)(fsize - (ssize_t)usize)) < 0) {
error_msg("unable to copy hdf5 data to output file \"%s\"\n", output_file);
h5tools_setstatus(EXIT_FAILURE);
goto done;
}
done:
if(input_file)
HDfree(input_file);
if(output_file)
HDfree(output_file);
if(ub_file) {
HDfree(ub_file);
}
h5tools_close();
return h5tools_getstatus();
}
/*-------------------------------------------------------------------------
* Function: main
*
* Purpose: h5watch
*
* Return: Success: 0
* Failure: 1
*
* Programmer: Vailin Choi; August 2010
*
*-------------------------------------------------------------------------
*/
int
main(int argc, const char *argv[])
{
char drivername[50];
char *fname = NULL;
char *dname = NULL;
void *edata;
H5E_auto2_t func;
char *x;
hid_t fid = -1;
hid_t fapl = -1;
/* Set up tool name and exit status */
h5tools_setprogname(PROGRAMNAME);
h5tools_setstatus(EXIT_SUCCESS);
/* Disable error reporting */
H5Eget_auto2(H5E_DEFAULT, &func, &edata);
H5Eset_auto2(H5E_DEFAULT, NULL, NULL);
/* Initialize h5tools lib */
h5tools_init();
/* parse command line options */
parse_command_line(argc, argv);
if(argc <= opt_ind) {
error_msg("missing dataset name\n");
usage(h5tools_getprogname());
leave(EXIT_FAILURE);
}
/* Mostly copied from tools/h5ls coding & modified accordingly */
/*
* [OBJECT] is specified as
* [<filename>/<path_to_dataset>/<dsetname>]
*
* Example: ../dir1/foo/bar/dset
* \_________/\______/
* file obj
*
* The dichotomy is determined by calling H5Fopen() repeatedly until it
* succeeds. The first call uses the entire name and each subsequent call
* chops off the last component. If we reach the beginning of the name
* then there must have been something wrong with the file (perhaps it
* doesn't exist).
*/
if((fname = HDstrdup(argv[opt_ind])) == NULL) {
error_msg("memory allocation failed (file %s:line %d)\n",
__FILE__, __LINE__);
h5tools_setstatus(EXIT_FAILURE);
}
/* Create a copy of file access property list */
if((fapl = H5Pcreate(H5P_FILE_ACCESS)) < 0)
return -1;
/* Set to use the latest library format */
if(H5Pset_libver_bounds(fapl, H5F_LIBVER_LATEST, H5F_LIBVER_LATEST) < 0)
return -1;
do {
while(fname && *fname) {
fid = h5tools_fopen(fname, H5F_ACC_RDONLY|H5F_ACC_SWMR_READ, fapl, NULL, drivername, sizeof drivername);
if(fid >= 0) {
HDfprintf(stdout, "Opened \"%s\" with %s driver.\n", fname, drivername);
break; /*success*/
} /* end if */
/* Shorten the file name; lengthen the object name */
x = dname;
dname = HDstrrchr(fname, '/');
if(x)
*x = '/';
if(!dname)
break;
*dname = '\0';
} /* end while */
/* Try opening the file again if somehow unstable */
} while(g_retry-- > 0 && fid == FAIL);
if(fid < 0) {
error_msg("unable to open file \"%s\"\n", fname);
if(fname) HDfree(fname);
if(fapl >= 0) H5Pclose(fapl);
leave(EXIT_FAILURE);
}
if(!dname) {
error_msg("no dataset specified\n");
h5tools_setstatus(EXIT_FAILURE);
} else {
*dname = '/';
x = dname;
if((dname = HDstrdup(dname)) == NULL) {
error_msg("memory allocation failed (file %s:line %d)\n",
__FILE__, __LINE__);
h5tools_setstatus(EXIT_FAILURE);
} else {
*x = '\0';
/* Validate dataset */
if(check_dataset(fid, dname) < 0)
h5tools_setstatus(EXIT_FAILURE);
/* Validate input "fields" */
else if(g_list_of_fields && *g_list_of_fields)
if(process_cmpd_fields(fid, dname) < 0)
h5tools_setstatus(EXIT_FAILURE);
}
}
/* If everything is fine, start monitoring the datset */
if(h5tools_getstatus() != EXIT_FAILURE)
if(monitor_dataset(fid, dname) < 0)
h5tools_setstatus(EXIT_FAILURE);
/* Free spaces */
if(fname) HDfree(fname);
if(dname) HDfree(dname);
if(g_list_of_fields) HDfree(g_list_of_fields);
if(g_listv) {
H5LD_clean_vector(g_listv);
HDfree(g_listv);
}
if(g_dup_fields) HDfree(g_dup_fields);
/* Close the file access property list */
if(fapl >= 0 && H5Pclose(fapl) < 0) {
error_msg("unable to close file access property list\n");
h5tools_setstatus(EXIT_FAILURE);
}
/* Close the file */
if(H5Fclose(fid) < 0) {
error_msg("unable to close file\n");
h5tools_setstatus(EXIT_FAILURE);
}
H5Eset_auto2(H5E_DEFAULT, func, edata);
/* exit */
leave(h5tools_getstatus());
} /* main() */