/*------------------------------------------------------------------------- * 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 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); 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: 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; }
int main(void) { h5tools_setprogname(PROGRAMNAME); h5tools_setstatus(EXIT_SUCCESS); Test_Obj_Copy(); Test_Ref_Copy(); Test_Extlink_Copy(); 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: init_ref_path_table * * Purpose: Initalize the reference path table * * Return: Non-negative on success, negative on failure * * Programmer: Quincey Koziol * *------------------------------------------------------------------------- */ static int init_ref_path_table(void) { /* Sanity check */ HDassert(thefile > 0); /* Create skip list to store reference path information */ if((ref_path_table = H5SL_create(H5SL_TYPE_HADDR, NULL))==NULL) return (-1); /* Iterate over objects in this file */ if(h5trav_visit(thefile, "/", TRUE, TRUE, init_ref_path_cb, NULL, NULL) < 0) { error_msg("unable to construct reference path table\n"); h5tools_setstatus(EXIT_FAILURE); } /* end if */ return(0); }
/*------------------------------------------------------------------------- * 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: parse_command_line * * Purpose: Parse the command line for the h5dumper. * * Return: Success: EXIT_SUCCESS; * * Failure: Exits function with EXIT_FAILURE value. * *------------------------------------------------------------------------- */ static int parse_command_line(int argc, const char *argv[]) { int opt = FALSE; /* parse command line options */ while ((opt = get_option(argc, argv, s_opts, l_opts)) != EOF) { switch((char)opt) { case 'o': output_file = HDstrdup(opt_arg); if (output_file) h5tools_set_data_output_file(output_file, 1); break; case 'i': input_file = HDstrdup(opt_arg); if (input_file) h5tools_set_input_file(input_file, 1); break;; case 'u': ub_file = HDstrdup(opt_arg); if (ub_file) h5tools_set_output_file(ub_file, 1); else rawoutstream = stdout; break; case 'd': do_delete = TRUE; break; case 'h': usage(h5tools_getprogname()); h5tools_setstatus(EXIT_SUCCESS); goto done; case 'V': print_version (h5tools_getprogname()); h5tools_setstatus(EXIT_SUCCESS); goto done; case '?': default: usage(h5tools_getprogname()); h5tools_setstatus(EXIT_FAILURE); goto done; } } return EXIT_SUCCESS; done: if(input_file) HDfree(input_file); if(output_file) HDfree(output_file); if(ub_file) HDfree(ub_file); 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[]) { 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); }
static int parse_command_line(int argc, const char **argv, pack_opt_t* options) { int opt; int ret_value = 0; /* parse command line options */ while ((opt = get_option(argc, argv, s_opts, l_opts)) != EOF) { switch ((char) opt) { /* -i for backward compability */ case 'i': infile = opt_arg; has_i_o = 1; break; /* -o for backward compability */ case 'o': outfile = opt_arg; has_i_o = 1; break; case 'h': usage(h5tools_getprogname()); h5tools_setstatus(EXIT_SUCCESS); ret_value = -1; goto done; case 'V': print_version(h5tools_getprogname()); h5tools_setstatus(EXIT_SUCCESS); ret_value = -1; goto done; case 'v': options->verbose = 1; break; case 'f': /* parse the -f filter option */ if (h5repack_addfilter(opt_arg, options) < 0) { error_msg("in parsing filter\n"); h5tools_setstatus(EXIT_FAILURE); ret_value = -1; goto done; } break; case 'l': /* parse the -l layout option */ if (h5repack_addlayout(opt_arg, options) < 0) { error_msg("in parsing layout\n"); h5tools_setstatus(EXIT_FAILURE); ret_value = -1; goto done; } break; case 'm': options->min_comp = HDatoi( opt_arg ); if ((int) options->min_comp <= 0) { error_msg("invalid minimum compress size <%s>\n", opt_arg); h5tools_setstatus(EXIT_FAILURE); ret_value = -1; goto done; } break; case 'e': ret_value = read_info(opt_arg, options); if (ret_value < 0) goto done; break; case 'n': options->use_native = 1; break; case 'L': options->latest = 1; break; case 'c': options->grp_compact = HDatoi( opt_arg ); if (options->grp_compact > 0) options->latest = 1; /* must use latest format */ break; case 'd': options->grp_indexed = HDatoi( opt_arg ); if (options->grp_indexed > 0) options->latest = 1; /* must use latest format */ break; case 's': { int idx = 0; int ssize = 0; char *msgPtr = HDstrchr( opt_arg, ':'); options->latest = 1; /* must use latest format */ if (msgPtr == NULL) { ssize = HDatoi( opt_arg ); for (idx = 0; idx < 5; idx++) options->msg_size[idx] = ssize; } else { char msgType[10]; HDstrcpy(msgType, msgPtr + 1); msgPtr[0] = '\0'; ssize = HDatoi( opt_arg ); if (HDstrncmp(msgType, "dspace",6) == 0) { options->msg_size[0] = ssize; } else if (HDstrncmp(msgType, "dtype", 5) == 0) { options->msg_size[1] = ssize; } else if (HDstrncmp(msgType, "fill", 4) == 0) { options->msg_size[2] = ssize; } else if (HDstrncmp(msgType, "pline", 5) == 0) { options->msg_size[3] = ssize; } else if (HDstrncmp(msgType, "attr", 4) == 0) { options->msg_size[4] = ssize; } } } break; case 'u': options->ublock_filename = opt_arg; break; case 'b': options->ublock_size = (hsize_t) HDatol( opt_arg ); break; case 'M': options->meta_block_size = (hsize_t) HDatol( opt_arg ); break; case 't': options->threshold = (hsize_t) HDatol( opt_arg ); break; case 'a': options->alignment = HDatol( opt_arg ); if (options->alignment < 1) { error_msg("invalid alignment size\n", opt_arg); h5tools_setstatus(EXIT_FAILURE); ret_value = -1; goto done; } break; default: break; } /* switch */ } /* while */ if (has_i_o == 0) { /* check for file names to be processed */ if (argc <= opt_ind || argv[opt_ind + 1] == NULL) { error_msg("missing file names\n"); usage(h5tools_getprogname()); h5tools_setstatus(EXIT_FAILURE); ret_value = -1; } } done: return ret_value; }
static int read_info(const char *filename, pack_opt_t *options) { char stype[10]; char comp_info[1024]; FILE *fp = NULL; char c; int i, rc = 1; int ret_value = EXIT_SUCCESS; if ((fp = HDfopen(filename, "r")) == (FILE *) NULL) { error_msg("cannot open options file %s\n", filename); h5tools_setstatus(EXIT_FAILURE); ret_value = EXIT_FAILURE; goto done; } /* cycle until end of file reached */ while (1) { rc = fscanf(fp, "%s", stype); if (rc == -1) break; /*------------------------------------------------------------------------- * filter *------------------------------------------------------------------------- */ if (HDstrcmp(stype,"-f") == 0) { /* find begining of info */ i = 0; c = '0'; while (c != ' ') { fscanf(fp, "%c", &c); if (HDfeof(fp)) break; } c = '0'; /* go until end */ while (c != ' ') { fscanf(fp, "%c", &c); comp_info[i] = c; i++; if (HDfeof(fp)) break; if (c == 10 /*eol*/) break; } comp_info[i - 1] = '\0'; /*cut the last " */ if (h5repack_addfilter(comp_info, options) == -1) { error_msg("could not add compression option\n"); h5tools_setstatus(EXIT_FAILURE); ret_value = EXIT_FAILURE; goto done; } } /*------------------------------------------------------------------------- * layout *------------------------------------------------------------------------- */ else if (HDstrcmp(stype,"-l") == 0) { /* find begining of info */ i = 0; c = '0'; while (c != ' ') { fscanf(fp, "%c", &c); if (HDfeof(fp)) break; } c = '0'; /* go until end */ while (c != ' ') { fscanf(fp, "%c", &c); comp_info[i] = c; i++; if (HDfeof(fp)) break; if (c == 10 /*eol*/) break; } comp_info[i - 1] = '\0'; /*cut the last " */ if (h5repack_addlayout(comp_info, options) == -1) { error_msg("could not add chunck option\n"); h5tools_setstatus(EXIT_FAILURE); ret_value = EXIT_FAILURE; goto done; } } /*------------------------------------------------------------------------- * not valid *------------------------------------------------------------------------- */ else { error_msg("bad file format for %s", filename); h5tools_setstatus(EXIT_FAILURE); ret_value = EXIT_FAILURE; goto done; } } done: if (fp) HDfclose(fp); return ret_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: 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() */
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: parse_command_line * * Purpose: Parses command line and sets up global variable to control output * * Return: Success: 0 * * Failure: -1 * * Programmer: Elena Pourmal * Saturday, August 12, 2006 * *------------------------------------------------------------------------- */ static struct handler_t * parse_command_line(int argc, const char *argv[]) { int opt, i; struct handler_t *hand = NULL; /* Allocate space to hold the command line info */ if((hand = (struct handler_t *)HDcalloc((size_t)argc, sizeof(struct handler_t)))==NULL) { error_msg("unable to parse command line arguments \n"); goto error; } /* parse command line options */ while ((opt = get_option(argc, argv, s_opts, l_opts)) != EOF) { switch ((char)opt) { case 'h': usage(h5tools_getprogname()); h5tools_setstatus(EXIT_SUCCESS); if (hand) { for (i = 0; i < argc; i++) if(hand[i].obj) { free(hand[i].obj); hand[i].obj=NULL; } free(hand); hand = NULL; } goto done; break; case 'V': print_version(h5tools_getprogname()); h5tools_setstatus(EXIT_SUCCESS); if (hand) { for (i = 0; i < argc; i++) if(hand[i].obj) { free(hand[i].obj); hand[i].obj=NULL; } free(hand); hand = NULL; } goto done; break; case 'F': display_all = FALSE; display_file_metadata = TRUE; break; case 'f': display_all = FALSE; display_file = TRUE; break; case 'G': display_all = FALSE; display_group_metadata = TRUE; break; case 'g': display_all = FALSE; display_group = TRUE; break; case 'D': display_all = FALSE; display_dset_metadata = TRUE; break; case 'd': display_all = FALSE; display_dset = TRUE; break; case 'T': display_all = FALSE; display_dset_dtype_meta = TRUE; break; case 'A': display_all = FALSE; display_attr = TRUE; break; case 'S': display_all = FALSE; display_summary = TRUE; break; case 'O': display_all = FALSE; display_object = TRUE; for(i = 0; i < argc; i++) if(!hand[i].obj) { hand[i].obj = HDstrdup(opt_arg); break; } /* end if */ break; default: usage(h5tools_getprogname()); h5tools_setstatus(EXIT_FAILURE); goto error; } /* end switch */ } /* end while */ /* check for file name to be processed */ if (argc <= opt_ind) { error_msg("missing file name\n"); usage(h5tools_getprogname()); h5tools_setstatus(EXIT_FAILURE); goto error; } /* end if */ done: return hand; error: if (hand) { for (i = 0; i < argc; i++) if(hand[i].obj) { free(hand[i].obj); hand[i].obj=NULL; } free(hand); hand = NULL; } h5tools_setstatus(EXIT_FAILURE); return hand; }
/*------------------------------------------------------------------------- * 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()); }
/*------------------------------------------------------------------------- * 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() */