diff options
Diffstat (limited to 'tools/lib')
| -rw-r--r-- | tools/lib/h5tools.c | 3179 | ||||
| -rw-r--r-- | tools/lib/h5tools.h | 165 | ||||
| -rw-r--r-- | tools/lib/h5tools_str.c | 687 | ||||
| -rw-r--r-- | tools/lib/h5tools_str.h | 13 |
4 files changed, 2998 insertions, 1046 deletions
diff --git a/tools/lib/h5tools.c b/tools/lib/h5tools.c index 4955f95..05207de 100644 --- a/tools/lib/h5tools.c +++ b/tools/lib/h5tools.c @@ -26,7 +26,6 @@ #include "h5tools.h" #include "h5tools_ref.h" -#include "h5tools_str.h" #include "h5tools_utils.h" #include "H5private.h" @@ -39,11 +38,196 @@ int compound_data; FILE *rawdatastream; /* should initialize to stdout but gcc moans about it */ int bin_output; /* binary output */ int bin_form; /* binary form */ +int region_output; /* region output */ + +static h5tool_format_t h5tools_dataformat = { +0, /*raw */ + +"", /*fmt_raw */ +"%d", /*fmt_int */ +"%u", /*fmt_uint */ +"%d", /*fmt_schar */ +"%u", /*fmt_uchar */ +"%d", /*fmt_short */ +"%u", /*fmt_ushort */ +"%ld", /*fmt_long */ +"%lu", /*fmt_ulong */ +NULL, /*fmt_llong */ +NULL, /*fmt_ullong */ +"%g", /*fmt_double */ +"%g", /*fmt_float */ + +0, /*ascii */ +0, /*str_locale */ +0, /*str_repeat */ + +"[ ", /*arr_pre */ +",", /*arr_sep */ +" ]", /*arr_suf */ +1, /*arr_linebreak */ + +"", /*cmpd_name */ +",\n", /*cmpd_sep */ +"{\n", /*cmpd_pre */ +"}", /*cmpd_suf */ +"\n", /*cmpd_end */ + +", ", /*vlen_sep */ +"(", /*vlen_pre */ +")", /*vlen_suf */ +"", /*vlen_end */ + +"%s", /*elmt_fmt */ +",", /*elmt_suf1 */ +" ", /*elmt_suf2 */ + +"", /*idx_n_fmt */ +"", /*idx_sep */ +"", /*idx_fmt */ + +80, /*line_ncols *//*standard default columns */ +0, /*line_per_line */ +"", /*line_pre */ +"%s", /*line_1st */ +"%s", /*line_cont */ +"", /*line_suf */ +"", /*line_sep */ +1, /*line_multi_new */ +" ", /*line_indent */ + +1, /*skip_first */ + +1, /*obj_hidefileno */ +" "H5_PRINTF_HADDR_FMT, /*obj_format */ + +1, /*dset_hidefileno */ +"DATASET %s ", /*dset_format */ +"%s", /*dset_blockformat_pre */ +"%s", /*dset_ptformat_pre */ +"%s", /*dset_ptformat */ +1, /*array indices */ +1 /*escape non printable characters */ +}; + +static const h5tools_dump_header_t h5tools_standardformat = { +"standardformat", /*name */ +"HDF5", /*fileebgin */ +"", /*fileend */ +SUPER_BLOCK, /*bootblockbegin */ +"", /*bootblockend */ +H5_TOOLS_GROUP, /*groupbegin */ +"", /*groupend */ +H5_TOOLS_DATASET, /*datasetbegin */ +"", /*datasetend */ +ATTRIBUTE, /*attributebegin */ +"", /*attributeend */ +H5_TOOLS_DATATYPE, /*datatypebegin */ +"", /*datatypeend */ +DATASPACE, /*dataspacebegin */ +"", /*dataspaceend */ +DATA, /*databegin */ +"", /*dataend */ +SOFTLINK, /*softlinkbegin */ +"", /*softlinkend */ +EXTLINK, /*extlinkbegin */ +"", /*extlinkend */ +UDLINK, /*udlinkbegin */ +"", /*udlinkend */ +SUBSET, /*subsettingbegin */ +"", /*subsettingend */ +START, /*startbegin */ +"", /*startend */ +STRIDE, /*stridebegin */ +"", /*strideend */ +COUNT, /*countbegin */ +"", /*countend */ +BLOCK, /*blockbegin */ +"", /*blockend */ + +"{", /*fileblockbegin */ +"}", /*fileblockend */ +"{", /*bootblockblockbegin */ +"}", /*bootblockblockend */ +"{", /*groupblockbegin */ +"}", /*groupblockend */ +"{", /*datasetblockbegin */ +"}", /*datasetblockend */ +"{", /*attributeblockbegin */ +"}", /*attributeblockend */ +"", /*datatypeblockbegin */ +"", /*datatypeblockend */ +"", /*dataspaceblockbegin */ +"", /*dataspaceblockend */ +"{", /*datablockbegin */ +"}", /*datablockend */ +"{", /*softlinkblockbegin */ +"}", /*softlinkblockend */ +"{", /*extlinkblockbegin */ +"}", /*extlinkblockend */ +"{", /*udlinkblockbegin */ +"}", /*udlinkblockend */ +"{", /*strblockbegin */ +"}", /*strblockend */ +"{", /*enumblockbegin */ +"}", /*enumblockend */ +"{", /*structblockbegin */ +"}", /*structblockend */ +"{", /*vlenblockbegin */ +"}", /*vlenblockend */ +"{", /*subsettingblockbegin */ +"}", /*subsettingblockend */ +"(", /*startblockbegin */ +");", /*startblockend */ +"(", /*strideblockbegin */ +");", /*strideblockend */ +"(", /*countblockbegin */ +");", /*countblockend */ +"(", /*blockblockbegin */ +");", /*blockblockend */ + +"", /*dataspacedescriptionbegin */ +"", /*dataspacedescriptionend */ +"(", /*dataspacedimbegin */ +")", /*dataspacedimend */ +}; +static const h5tools_dump_header_t * h5tools_dump_header_format; /* local prototypes */ static int do_bin_output(FILE *stream, hsize_t nelmts, hid_t tid, void *_mem); static int render_bin_output(FILE *stream, hid_t tid, void *_mem); +static hbool_t h5tools_is_zero(const void *_mem, size_t size); + +int h5tools_render_element(FILE *stream, const h5tool_format_t *info, + h5tools_context_t *ctx/*in,out*/, + h5tools_str_t *buffer/*string into which to render */, + hsize_t *curr_pos/*total data element position*/, + size_t ncols, hsize_t local_elmt_counter/*element counter*/, + hsize_t elmt_counter); + +int h5tools_render_region_element(FILE *stream, const h5tool_format_t *info, + h5tools_context_t *ctx/*in,out*/, + h5tools_str_t *buffer/*string into which to render */, + hsize_t *curr_pos/*total data element position*/, + size_t ncols, hsize_t *ptdata, + hsize_t local_elmt_counter/*element counter*/, + hsize_t elmt_counter); + +int h5tools_dump_region_data_points(hid_t region_space, hid_t region_id, + FILE *stream, const h5tool_format_t *info, + h5tools_context_t *ctx/*in,out*/, + h5tools_str_t *buffer/*string into which to render */, + hsize_t *curr_pos/*total data element position*/, + size_t ncols, hsize_t region_elmt_counter/*element counter*/, + hsize_t elmt_counter); + +int h5tools_dump_region_data_blocks(hid_t region_space, hid_t region_id, + FILE *stream, const h5tool_format_t *info, + h5tools_context_t *ctx/*in,out*/, + h5tools_str_t *buffer/*string into which to render */, + hsize_t *curr_pos/*total data element position*/, + size_t ncols, hsize_t region_elmt_counter/*element counter*/, + hsize_t elmt_counter); /* module-scoped variables */ static int h5tools_init_g; /* if h5tools lib has been initialized */ @@ -102,10 +286,12 @@ void h5tools_init(void) { if (!h5tools_init_g) { - if (!rawdatastream) - rawdatastream = stdout; + if (!rawdatastream) + rawdatastream = stdout; - h5tools_init_g++; + h5tools_dump_header_format = &h5tools_standardformat; + + h5tools_init_g++; } } @@ -131,9 +317,9 @@ h5tools_close(void) if (h5tools_init_g) { if (rawdatastream && rawdatastream != stdout) { if (fclose(rawdatastream)) - perror("closing rawdatastream"); + perror("closing rawdatastream"); else - rawdatastream = NULL; + rawdatastream = NULL; } /* Clean up the reference path table, if it's been used */ @@ -164,88 +350,95 @@ h5tools_close(void) static hid_t h5tools_get_fapl(hid_t fapl, const char *driver, unsigned *drivernum) { - hid_t new_fapl; /* Copy of file access property list passed in, or new property list */ + hid_t new_fapl; /* Copy of file access property list passed in, or new property list */ /* Make a copy of the FAPL, for the file open call to use, eventually */ - if(fapl == H5P_DEFAULT) { - if((new_fapl = H5Pcreate(H5P_FILE_ACCESS)) < 0) + if (fapl == H5P_DEFAULT) { + if ((new_fapl = H5Pcreate(H5P_FILE_ACCESS)) < 0) goto error; } /* end if */ else { - if((new_fapl = H5Pcopy(fapl)) < 0) + if ((new_fapl = H5Pcopy(fapl)) < 0) goto error; } /* end else */ /* Determine which driver the user wants to open the file with. Try * that driver. If it can't open it, then fail. */ - if(!strcmp(driver, drivernames[SEC2_IDX])) { + if (!strcmp(driver, drivernames[SEC2_IDX])) { /* SEC2 driver */ - if(H5Pset_fapl_sec2(new_fapl) < 0) + if (H5Pset_fapl_sec2(new_fapl) < 0) goto error; - if(drivernum) + if (drivernum) *drivernum = SEC2_IDX; - } else if(!strcmp(driver, drivernames[FAMILY_IDX])) { + } + else if (!strcmp(driver, drivernames[FAMILY_IDX])) { /* FAMILY Driver */ /* Set member size to be 0 to indicate the current first member size * is the member size. */ - if(H5Pset_fapl_family(new_fapl, (hsize_t)0, H5P_DEFAULT) < 0) + if (H5Pset_fapl_family(new_fapl, (hsize_t) 0, H5P_DEFAULT) < 0) goto error; - if(drivernum) + if (drivernum) *drivernum = FAMILY_IDX; - } else if(!strcmp(driver, drivernames[SPLIT_IDX])) { + } + else if (!strcmp(driver, drivernames[SPLIT_IDX])) { /* SPLIT Driver */ - if(H5Pset_fapl_split(new_fapl, "-m.h5", H5P_DEFAULT, "-r.h5", H5P_DEFAULT) < 0) + if (H5Pset_fapl_split(new_fapl, "-m.h5", H5P_DEFAULT, "-r.h5", H5P_DEFAULT) < 0) goto error; - if(drivernum) + if (drivernum) *drivernum = SPLIT_IDX; - } else if(!strcmp(driver, drivernames[MULTI_IDX])) { + } + else if (!strcmp(driver, drivernames[MULTI_IDX])) { /* MULTI Driver */ - if(H5Pset_fapl_multi(new_fapl, NULL, NULL, NULL, NULL, TRUE) < 0) - goto error; + if (H5Pset_fapl_multi(new_fapl, NULL, NULL, NULL, NULL, TRUE) < 0) + goto error; if(drivernum) - *drivernum = MULTI_IDX; + *drivernum = MULTI_IDX; #ifdef H5_HAVE_STREAM - } else if(!strcmp(driver, drivernames[STREAM_IDX])) { - /* STREAM Driver */ - if(H5Pset_fapl_stream(new_fapl, NULL) < 0) - goto error; + } + else if(!strcmp(driver, drivernames[STREAM_IDX])) { + /* STREAM Driver */ + if(H5Pset_fapl_stream(new_fapl, NULL) < 0) + goto error; - if(drivernum) - *drivernum = STREAM_IDX; + if(drivernum) + *drivernum = STREAM_IDX; #endif /* H5_HAVE_STREAM */ #ifdef H5_HAVE_PARALLEL - } else if(!strcmp(driver, drivernames[MPIO_IDX])) { - /* MPI-I/O Driver */ - /* check if MPI has been initialized. */ - if(!h5tools_mpi_init_g) - MPI_Initialized(&h5tools_mpi_init_g); - if(h5tools_mpi_init_g) { - if(H5Pset_fapl_mpio(new_fapl, MPI_COMM_WORLD, MPI_INFO_NULL) < 0) - goto error; + } + else if(!strcmp(driver, drivernames[MPIO_IDX])) { + /* MPI-I/O Driver */ + /* check if MPI has been initialized. */ + if(!h5tools_mpi_init_g) + MPI_Initialized(&h5tools_mpi_init_g); + if(h5tools_mpi_init_g) { + if(H5Pset_fapl_mpio(new_fapl, MPI_COMM_WORLD, MPI_INFO_NULL) < 0) + goto error; if(drivernum) *drivernum = MPIO_IDX; } /* end if */ - } else if (!strcmp(driver, drivernames[MPIPOSIX_IDX])) { + } + else if (!strcmp(driver, drivernames[MPIPOSIX_IDX])) { /* MPI-I/O Driver */ - /* check if MPI has been initialized. */ - if(!h5tools_mpi_init_g) - MPI_Initialized(&h5tools_mpi_init_g); + /* check if MPI has been initialized. */ + if(!h5tools_mpi_init_g) + MPI_Initialized(&h5tools_mpi_init_g); if(h5tools_mpi_init_g) { if(H5Pset_fapl_mpiposix(new_fapl, MPI_COMM_WORLD, TRUE) < 0) - goto error; + goto error; if(drivernum) *drivernum = MPIPOSIX_IDX; } /* end if */ #endif /* H5_HAVE_PARALLEL */ - } else { + } + else { goto error; } @@ -320,21 +513,22 @@ h5tools_fopen(const char *fname, unsigned flags, hid_t fapl, const char *driver, hid_t fid = FAIL; hid_t my_fapl = H5P_DEFAULT; - if(driver && *driver) { + if (driver && *driver) { /* Get the correct FAPL for the given driver */ - if((my_fapl = h5tools_get_fapl(fapl, driver, &drivernum)) < 0) + if ((my_fapl = h5tools_get_fapl(fapl, driver, &drivernum)) < 0) goto done; H5E_BEGIN_TRY { fid = H5Fopen(fname, flags, my_fapl); } H5E_END_TRY; - if(fid == FAIL) + if (fid == FAIL) goto done; - } else { + } + else { /* Try to open the file using each of the drivers */ - for(drivernum = 0; drivernum < NUM_DRIVERS; drivernum++) { + for (drivernum = 0; drivernum < NUM_DRIVERS; drivernum++) { /* Get the correct FAPL for the given driver */ if((my_fapl = h5tools_get_fapl(fapl, drivernames[drivernum], NULL)) < 0) goto done; @@ -343,7 +537,7 @@ h5tools_fopen(const char *fname, unsigned flags, hid_t fapl, const char *driver, fid = H5Fopen(fname, flags, my_fapl); } H5E_END_TRY; - if(fid != FAIL) + if (fid != FAIL) break; else { /* Close the FAPL */ @@ -354,11 +548,12 @@ h5tools_fopen(const char *fname, unsigned flags, hid_t fapl, const char *driver, } /* Save the driver name */ - if(drivername && drivername_size) { - if(fid != FAIL) { + if (drivername && drivername_size) { + if (fid != FAIL) { strncpy(drivername, drivernames[drivernum], drivername_size); drivername[drivername_size - 1] = '\0'; - } else { + } + else { /*no file opened*/ drivername[0] = '\0'; } @@ -429,16 +624,16 @@ h5tools_simple_prefix(FILE *stream, const h5tool_format_t *info, int i, indentlevel = 0; if (!ctx->need_prefix) - return; + return; memset(&prefix, 0, sizeof(h5tools_str_t)); memset(&str, 0, sizeof(h5tools_str_t)); /* Terminate previous line, if any */ if (ctx->cur_column) { - fputs(OPT(info->line_suf, ""), stream); - putc('\n', stream); - fputs(OPT(info->line_sep, ""), stream); + fputs(OPT(info->line_suf, ""), stream); + putc('\n', stream); + fputs(OPT(info->line_sep, ""), stream); } /* Calculate new prefix */ @@ -448,22 +643,113 @@ h5tools_simple_prefix(FILE *stream, const h5tool_format_t *info, /* Write new prefix to output */ if (ctx->indent_level >= 0) { indentlevel = ctx->indent_level; - } else { + } + else { + /* + * This is because sometimes we don't print out all the header + * info for the data (like the tattr-2.ddl example). If that happens + * the ctx->indent_level is negative so we need to skip the above and + * just print out the default indent levels. + */ + indentlevel = ctx->default_indent_level; + } + + /* when printing array indices, print the indentation before the prefix + the prefix is printed one indentation level before */ + if (info->pindex) { + for (i = 0; i < indentlevel - 1; i++) { + fputs(h5tools_str_fmt(&str, 0, info->line_indent), stream); + } + } + + if (elmtno == 0 && secnum == 0 && info->line_1st) + fputs(h5tools_str_fmt(&prefix, 0, info->line_1st), stream); + else if (secnum && info->line_cont) + fputs(h5tools_str_fmt(&prefix, 0, info->line_cont), stream); + else + fputs(h5tools_str_fmt(&prefix, 0, info->line_pre), stream); + + templength = h5tools_str_len(&prefix); + + for (i = 0; i < indentlevel; i++) { + /*we already made the indent for the array indices case */ + if (!info->pindex) { + fputs(h5tools_str_fmt(&prefix, 0, info->line_indent), stream); + templength += h5tools_str_len(&prefix); + } + else { + /*we cannot count the prefix for the array indices case */ + templength += h5tools_str_len(&str); + } + } + + ctx->cur_column = ctx->prev_prefix_len = templength; + ctx->cur_elmt = 0; + ctx->need_prefix = 0; + + /* Free string */ + h5tools_str_close(&prefix); + h5tools_str_close(&str); +} + +/*------------------------------------------------------------------------- + * Audience: Public + * Chapter: H5Tools Library + * Purpose: Emit a simple prefix to STREAM. + * Description: + * If /ctx->need_prefix/ is set then terminate the current line (if + * applicable), calculate the prefix string, and display it at the start + * of a line. Calls region specific function. + * Return: + * None + *------------------------------------------------------------------------- + */ +static void +h5tools_region_simple_prefix(FILE *stream, const h5tool_format_t *info, + h5tools_context_t *ctx, hsize_t elmtno, hsize_t *ptdata, int secnum) +{ + h5tools_str_t prefix; + h5tools_str_t str; /*temporary for indentation */ + size_t templength = 0; + int i, indentlevel = 0; + + if (!ctx->need_prefix) + return; + + memset(&prefix, 0, sizeof(h5tools_str_t)); + memset(&str, 0, sizeof(h5tools_str_t)); + + /* Terminate previous line, if any */ + if (ctx->cur_column) { + fputs(OPT(info->line_suf, ""), stream); + putc('\n', stream); + fputs(OPT(info->line_sep, ""), stream); + } + + /* Calculate new prefix */ + h5tools_str_region_prefix(&prefix, info, elmtno, ptdata, ctx->ndims, ctx->p_min_idx, + ctx->p_max_idx, ctx); + + /* Write new prefix to output */ + if (ctx->indent_level >= 0) { + indentlevel = ctx->indent_level; + } + else { /* * This is because sometimes we don't print out all the header * info for the data (like the tattr-2.ddl example). If that happens * the ctx->indent_level is negative so we need to skip the above and * just print out the default indent levels. */ - indentlevel = ctx->default_indent_level; + indentlevel = ctx->default_indent_level; } /* when printing array indices, print the indentation before the prefix the prefix is printed one indentation level before */ if (info->pindex) { - for (i = 0; i < indentlevel-1; i++){ - fputs(h5tools_str_fmt(&str, 0, info->line_indent), stream); - } + for (i = 0; i < indentlevel - 1; i++) { + fputs(h5tools_str_fmt(&str, 0, info->line_indent), stream); + } } if (elmtno == 0 && secnum == 0 && info->line_1st) @@ -475,16 +761,16 @@ h5tools_simple_prefix(FILE *stream, const h5tool_format_t *info, templength = h5tools_str_len(&prefix); - for (i = 0; i < indentlevel; i++){ + for (i = 0; i < indentlevel; i++) { /*we already made the indent for the array indices case */ - if (!info->pindex) { - fputs(h5tools_str_fmt(&prefix, 0, info->line_indent), stream); - templength += h5tools_str_len(&prefix); - } - else { - /*we cannot count the prefix for the array indices case */ - templength += h5tools_str_len(&str); - } + if (!info->pindex) { + fputs(h5tools_str_fmt(&prefix, 0, info->line_indent), stream); + templength += h5tools_str_len(&prefix); + } + else { + /*we cannot count the prefix for the array indices case */ + templength += h5tools_str_len(&str); + } } ctx->cur_column = ctx->prev_prefix_len = templength; @@ -532,44 +818,40 @@ h5tools_simple_prefix(FILE *stream, const h5tool_format_t *info, * new field sm_pos in h5tools_context_t, the current stripmine element position *------------------------------------------------------------------------- */ -void +void h5tools_dump_simple_data(FILE *stream, const h5tool_format_t *info, hid_t container, h5tools_context_t *ctx/*in,out*/, unsigned flags, hsize_t nelmts, hid_t type, void *_mem) { - unsigned char *mem = (unsigned char*)_mem; - hsize_t i; /*element counter */ - char *s; - char *section; /*a section of output */ - int secnum; /*section sequence number */ - size_t size; /*size of each datum */ - size_t ncols = 80; /*available output width */ - h5tools_str_t buffer; /*string into which to render */ - int multiline; /*datum was multiline */ - hsize_t curr_pos; /* total data element position */ - int elmt_counter = 0;/*counts the # elements printed. - *I (ptl?) needed something that - *isn't going to get reset when a new - *line is formed. I'm going to use - *this var to count elements and - *break after we see a number equal - *to the ctx->size_last_dim. */ - - /* binary dump */ - if(bin_output) - { + unsigned char *mem = (unsigned char*) _mem; + hsize_t i; /*element counter */ + size_t size; /*size of each datum */ + hid_t region_space; + hid_t region_id; + int dimension_break = 1; + size_t ncols = 80; /*available output width */ + h5tools_str_t buffer; /*string into which to render */ + hsize_t curr_pos; /* total data element position */ + hsize_t elmt_counter = 0;/*counts the # elements printed. + *I (ptl?) needed something that + *isn't going to get reset when a new + *line is formed. I'm going to use + *this var to count elements and + *break after we see a number equal + *to the ctx->size_last_dim. */ + + /* binary dump */ + if (bin_output) { do_bin_output(stream, nelmts, type, _mem); } /* end if */ - else - { + else { /* setup */ HDmemset(&buffer, 0, sizeof(h5tools_str_t)); size = H5Tget_size(type); - if(info->line_ncols > 0) + if (info->line_ncols > 0) ncols = info->line_ncols; - /* pass to the prefix in h5tools_simple_prefix the total position * instead of the current stripmine position i; this is necessary * to print the array indices @@ -579,130 +861,929 @@ h5tools_dump_simple_data(FILE *stream, const h5tool_format_t *info, hid_t contai h5tools_simple_prefix(stream, info, ctx, curr_pos, 0); for (i = 0; i < nelmts; i++, ctx->cur_elmt++, elmt_counter++) { - /* Render the element */ - h5tools_str_reset(&buffer); - h5tools_str_sprint(&buffer, info, container, type, mem + i * size, ctx); + void* memref = mem + i * size; + if (region_output && H5Tequal(type, H5T_STD_REF_DSETREG)) { + char ref_name[1024]; + + /* region data */ + region_id = H5Rdereference(container, H5R_DATASET_REGION, memref); + if (region_id >= 0) { + region_space = H5Rget_region(container, H5R_DATASET_REGION, memref); + if (region_space >= 0) { + if (h5tools_is_zero(memref, H5Tget_size(type))) { + h5tools_str_append(&buffer, "NULL"); + } + else { + H5Rget_name(region_id, H5R_DATASET_REGION, memref, (char*) ref_name, 1024); + + /* Render the region element begin */ + h5tools_str_reset(&buffer); + + h5tools_str_append(&buffer, info->dset_format, ref_name); + + dimension_break = h5tools_render_element(stream, info, + ctx, &buffer, &curr_pos, ncols, i, elmt_counter); + + /* Print block information */ + dimension_break = h5tools_dump_region_data_blocks( + region_space, region_id, stream, info, ctx, + &buffer, &curr_pos, ncols, i, elmt_counter); + /* Print point information */ + dimension_break = h5tools_dump_region_data_points( + region_space, region_id, stream, info, ctx, + &buffer, &curr_pos, ncols, i, elmt_counter); + /* Render the region element end */ + + } /* end else to if (h5tools_is_zero(... */ + H5Sclose(region_space); + } /* end if (region_space >= 0) */ + H5Dclose(region_id); + } /* if (region_id >= 0) */ + ctx->need_prefix = TRUE; + } /* end if (region_output... */ + else { + /* Render the data element begin*/ + h5tools_str_reset(&buffer); + h5tools_str_sprint(&buffer, info, container, type, memref, ctx); - if (i + 1 < nelmts || (flags & END_OF_DATA) == 0) - h5tools_str_append(&buffer, "%s", OPT(info->elmt_suf1, ",")); + if (i + 1 < nelmts || (flags & END_OF_DATA) == 0) + h5tools_str_append(&buffer, "%s", OPT(info->elmt_suf1, ",")); - s = h5tools_str_fmt(&buffer, 0, "%s"); + dimension_break = h5tools_render_element(stream, info, ctx, &buffer, + &curr_pos, ncols, i, elmt_counter); + /* Render the data element end*/ - /* - * If the element would split on multiple lines if printed at our - * current location... - */ - if (info->line_multi_new == 1 && - (ctx->cur_column + h5tools_ncols(s) + - strlen(OPT(info->elmt_suf2, " ")) + - strlen(OPT(info->line_suf, ""))) > ncols) { - if (ctx->prev_multiline) { - /* - * ... and the previous element also occupied more than one - * line, then start this element at the beginning of a line. - */ - ctx->need_prefix = TRUE; - } else if ((ctx->prev_prefix_len + h5tools_ncols(s) + - strlen(OPT(info->elmt_suf2, " ")) + - strlen(OPT(info->line_suf, ""))) <= ncols) { - /* - * ...but *could* fit on one line otherwise, then we - * should end the current line and start this element on its - * own line. - */ - ctx->need_prefix = TRUE; - } } + if(dimension_break==0) + elmt_counter = 0; + } /* end for (i = 0; i < nelmts... */ + + h5tools_str_close(&buffer); + }/* else bin */ +} + +/*------------------------------------------------------------------------- + * Audience: Public + * Chapter: H5Tools Library + * Purpose: Render an element to output STREAM. + * Description: + * Prints the string buffer to the output STREAM. The string is + * printed according to the format described in INFO. The CTX struct + * contains context information shared between calls to this function. + * + * Return: + * False if a dimension end is reached, otherwise true + * + * In/Out: + * h5tools_context_t *ctx + * h5tools_str_t *buffer + * hsize_t *curr_pos + * + * Parameters Description: + * h5tools_str_t *buffer is the string into which to render + * hsize_t curr_pos is the total data element position + * size_t ncols + * hsize_t local_elmt_counter is the local element loop counter + * hsize_t elmt_count is the data element loop counter + *------------------------------------------------------------------------- + */ +int +h5tools_render_element(FILE *stream, const h5tool_format_t *info, + h5tools_context_t *ctx, h5tools_str_t *buffer, hsize_t *curr_pos, + size_t ncols, hsize_t local_elmt_counter, hsize_t elmt_counter) +{ + int dimension_break = 1; + char *s; + char *section; /*a section of output */ + int secnum; /*section sequence number */ + int multiline; /*datum was multiline */ + + s = h5tools_str_fmt(buffer, 0, "%s"); + /* + * If the element would split on multiple lines if printed at our + * current location... + */ + if (info->line_multi_new == 1 && + (ctx->cur_column + h5tools_ncols(s) + + strlen(OPT(info->elmt_suf2, " ")) + + strlen(OPT(info->line_suf, ""))) > ncols) { + if (ctx->prev_multiline) { + /* + * ... and the previous element also occupied more than one + * line, then start this element at the beginning of a line. + */ + ctx->need_prefix = TRUE; + } + else if ((ctx->prev_prefix_len + h5tools_ncols(s) + + strlen(OPT(info->elmt_suf2, " ")) + + strlen(OPT(info->line_suf, ""))) <= ncols) { /* - * We need to break after each row of a dimension---> we should - * break at the end of the each last dimension well that is the - * way the dumper did it before + * ...but *could* fit on one line otherwise, then we + * should end the current line and start this element on its + * own line. */ - if (info->arr_linebreak && ctx->cur_elmt) { - if (ctx->size_last_dim && (ctx->cur_elmt % ctx->size_last_dim) == 0) - ctx->need_prefix = TRUE; + ctx->need_prefix = TRUE; + } + } - if ((hsize_t)elmt_counter == ctx->size_last_dim) { - ctx->need_prefix = TRUE; - elmt_counter = 0; - } - } + /* + * We need to break after each row of a dimension---> we should + * break at the end of the each last dimension well that is the + * way the dumper did it before + */ + if (info->arr_linebreak && ctx->cur_elmt) { + if (ctx->size_last_dim && (ctx->cur_elmt % ctx->size_last_dim) == 0) + ctx->need_prefix = TRUE; - /* - * If the previous element occupied multiple lines and this element - * is too long to fit on a line then start this element at the - * beginning of the line. + if (elmt_counter == ctx->size_last_dim) { + ctx->need_prefix = TRUE; + dimension_break = 0; + } + } + + /* + * If the previous element occupied multiple lines and this element + * is too long to fit on a line then start this element at the + * beginning of the line. + */ + if (info->line_multi_new == 1 && + ctx->prev_multiline && + (ctx->cur_column + + h5tools_ncols(s) + + strlen(OPT(info->elmt_suf2, " ")) + + strlen(OPT(info->line_suf, ""))) > ncols) + ctx->need_prefix = TRUE; + + /* + * If too many elements have already been printed then we need to + * start a new line. + */ + if (info->line_per_line > 0 && ctx->cur_elmt >= info->line_per_line) + ctx->need_prefix = TRUE; + + /* + * Each OPTIONAL_LINE_BREAK embedded in the rendered string can cause + * the data to split across multiple lines. We display the sections + * one-at a time. + */ + multiline = 0; + for (secnum = 0, multiline = 0; + (section = strtok(secnum ? NULL : s, OPTIONAL_LINE_BREAK)); + secnum++) { + /* + * If the current section plus possible suffix and end-of-line + * information would cause the output to wrap then we need to + * start a new line. + */ + + /* + * Added the info->skip_first because the dumper does not want + * this check to happen for the first line + */ + if ((!info->skip_first || local_elmt_counter) && + (ctx->cur_column + + strlen(section) + + strlen(OPT(info->elmt_suf2, " ")) + + strlen(OPT(info->line_suf, ""))) > ncols) + ctx->need_prefix = 1; + + /* + * Print the prefix or separate the beginning of this element + * from the previous element. + */ + if (ctx->need_prefix) { + if (secnum) + multiline++; + + /* pass to the prefix in h5tools_simple_prefix the total + * position instead of the current stripmine position i; + * this is necessary to print the array indices */ - if (info->line_multi_new == 1 && ctx->prev_multiline && - (ctx->cur_column + h5tools_ncols(s) + - strlen(OPT(info->elmt_suf2, " ")) + - strlen(OPT(info->line_suf, ""))) > ncols) - ctx->need_prefix = TRUE; + *curr_pos = ctx->sm_pos + local_elmt_counter; + + h5tools_simple_prefix(stream, info, ctx, *curr_pos, secnum); + } + else if ((local_elmt_counter || ctx->continuation) && secnum == 0) { + fputs(OPT(info->elmt_suf2, " "), stream); + ctx->cur_column += strlen(OPT(info->elmt_suf2, " ")); + } + + /* Print the section */ + fputs(section, stream); + ctx->cur_column += strlen(section); + } + ctx->prev_multiline = multiline; + return dimension_break; +} + +/*------------------------------------------------------------------------- + * Audience: Public + * Chapter: H5Tools Library + * Purpose: Render a region element to output STREAM. + * Description: + * Prints the string buffer to the output STREAM. The string is + * printed according to the format described in INFO. The CTX struct + * contains context information shared between calls to this function. + * + * Return: + * False if a dimension end is reached, otherwise true + * + * In/Out: + * h5tools_context_t *ctx + * h5tools_str_t *buffer + * hsize_t *curr_pos + * + * Parameters Description: + * h5tools_str_t *buffer is the string into which to render + * hsize_t curr_pos is the total data element position + * size_t ncols + * hsize_t *ptdata + * hsize_t local_elmt_counter is the local element loop counter + * hsize_t elmt_count is the data element loop counter + *------------------------------------------------------------------------- + */ +int +h5tools_render_region_element(FILE *stream, const h5tool_format_t *info, + h5tools_context_t *ctx, h5tools_str_t *buffer, hsize_t *curr_pos, + size_t ncols, hsize_t *ptdata, hsize_t local_elmt_counter, hsize_t elmt_counter) +{ + int dimension_break = 1; + char *s; + char *section; /*a section of output */ + int secnum; /*section sequence number */ + int multiline; /*datum was multiline */ + + s = h5tools_str_fmt(buffer, 0, "%s"); + + /* + * If the element would split on multiple lines if printed at our + * current location... + */ + if (info->line_multi_new == 1 && + (ctx->cur_column + h5tools_ncols(s) + + strlen(OPT(info->elmt_suf2, " ")) + + strlen(OPT(info->line_suf, ""))) > ncols) { + if (ctx->prev_multiline) { /* - * If too many elements have already been printed then we need to - * start a new line. + * ... and the previous element also occupied more than one + * line, then start this element at the beginning of a line. */ - if (info->line_per_line > 0 && ctx->cur_elmt >= info->line_per_line) - ctx->need_prefix = TRUE; - + ctx->need_prefix = TRUE; + } + else if ((ctx->prev_prefix_len + h5tools_ncols(s) + + strlen(OPT(info->elmt_suf2, " ")) + + strlen(OPT(info->line_suf, ""))) <= ncols) { /* - * Each OPTIONAL_LINE_BREAK embedded in the rendered string can cause - * the data to split across multiple lines. We display the sections - * one-at a time. + * ...but *could* fit on one line otherwise, then we + * should end the current line and start this element on its + * own line. */ - for (secnum = 0, multiline = 0; - (section = strtok(secnum ? NULL : s, OPTIONAL_LINE_BREAK)); - secnum++) { - /* - * If the current section plus possible suffix and end-of-line - * information would cause the output to wrap then we need to - * start a new line. - */ - - /* - * Added the info->skip_first because the dumper does not want - * this check to happen for the first line - */ - if ((!info->skip_first || i) && - (ctx->cur_column + strlen(section) + - strlen(OPT(info->elmt_suf2, " ")) + - strlen(OPT(info->line_suf, ""))) > ncols) - ctx->need_prefix = 1; - - /* - * Print the prefix or separate the beginning of this element - * from the previous element. - */ - if (ctx->need_prefix) { - if (secnum) - multiline++; - - /* pass to the prefix in h5tools_simple_prefix the total - * position instead of the current stripmine position i; - * this is necessary to print the array indices - */ - curr_pos = ctx->sm_pos + i; - - h5tools_simple_prefix(stream, info, ctx, curr_pos, secnum); - } else if ((i || ctx->continuation) && secnum == 0) { - fputs(OPT(info->elmt_suf2, " "), stream); - ctx->cur_column += strlen(OPT(info->elmt_suf2, " ")); - } + ctx->need_prefix = TRUE; + } + } - /* Print the section */ - fputs(section, stream); - ctx->cur_column += strlen(section); - } + /* + * We need to break after each row of a dimension---> we should + * break at the end of the each last dimension well that is the + * way the dumper did it before + */ + if (info->arr_linebreak && ctx->cur_elmt) { + if (ctx->size_last_dim && (ctx->cur_elmt % ctx->size_last_dim) == 0) + ctx->need_prefix = TRUE; - ctx->prev_multiline = multiline; + if (elmt_counter == ctx->size_last_dim) { + ctx->need_prefix = TRUE; + dimension_break = 0; } + } - h5tools_str_close(&buffer); - }/* else bin */ + /* + * If the previous element occupied multiple lines and this element + * is too long to fit on a line then start this element at the + * beginning of the line. + */ + if (info->line_multi_new == 1 && + ctx->prev_multiline && + (ctx->cur_column + + h5tools_ncols(s) + + strlen(OPT(info->elmt_suf2, " ")) + + strlen(OPT(info->line_suf, ""))) > ncols) + ctx->need_prefix = TRUE; + + /* + * If too many elements have already been printed then we need to + * start a new line. + */ + if (info->line_per_line > 0 && ctx->cur_elmt >= info->line_per_line) + ctx->need_prefix = TRUE; + + /* + * Each OPTIONAL_LINE_BREAK embedded in the rendered string can cause + * the data to split across multiple lines. We display the sections + * one-at a time. + */ + multiline = 0; + for (secnum = 0, multiline = 0; (section = strtok(secnum ? NULL : s, + OPTIONAL_LINE_BREAK)); secnum++) { + /* + * If the current section plus possible suffix and end-of-line + * information would cause the output to wrap then we need to + * start a new line. + */ + + /* + * Added the info->skip_first because the dumper does not want + * this check to happen for the first line + */ + if ((!info->skip_first || local_elmt_counter) && + (ctx->cur_column + + strlen(section) + + strlen(OPT(info->elmt_suf2, " ")) + + strlen(OPT(info->line_suf, ""))) > ncols) + ctx->need_prefix = 1; + + /* + * Print the prefix or separate the beginning of this element + * from the previous element. + */ + if (ctx->need_prefix) { + if (secnum) + multiline++; + + /* pass to the prefix in h5tools_simple_prefix the total + * position instead of the current stripmine position i; + * this is necessary to print the array indices + */ + *curr_pos = ctx->sm_pos + local_elmt_counter; + + h5tools_region_simple_prefix(stream, info, ctx, local_elmt_counter, ptdata, secnum); + } + else if ((local_elmt_counter || ctx->continuation) && secnum == 0) { + fputs(OPT(info->elmt_suf2, " "), stream); + ctx->cur_column += strlen(OPT(info->elmt_suf2, " ")); + } + + /* Print the section */ + fputs(section, stream); + ctx->cur_column += strlen(section); + } + + ctx->prev_multiline = multiline; + return dimension_break; +} + +/*------------------------------------------------------------------------- + * Audience: Public + * Chapter: H5Tools Library + * Purpose: Print some values from a dataset referenced by region blocks. + * + * Description: + * This is a special case subfunction to dump a region reference using blocks. + * + * Return: + * The function returns False if the last dimension has been reached, otherwise True + * + * In/Out: + * h5tools_context_t *ctx + * hsize_t *curr_pos + * + * Parameters Description: + * h5tools_str_t *buffer is the string into which to render + * hsize_t curr_pos is the total data element position + * size_t ncols + * hsize_t region_elmt_counter is the region element loop counter + * hsize_t elmt_count is the data element loop counter + *------------------------------------------------------------------------- + */ +int +h5tools_dump_region_data_blocks(hid_t region_space, hid_t region_id, + FILE *stream, const h5tool_format_t *info, + h5tools_context_t *ctx/*in,out*/, + h5tools_str_t *buffer/*string into which to render */, + hsize_t *curr_pos/*total data element position*/, + size_t ncols, hsize_t region_elmt_counter/*element counter*/, + hsize_t elmt_counter) { + int dimension_break = 1; + hssize_t nblocks; + hsize_t alloc_size; + hsize_t *ptdata; + hsize_t *dims1; + hsize_t *start; + hsize_t *count; + size_t numelem; + hsize_t region_total_size[H5S_MAX_RANK]; + h5tools_context_t region_ctx; /* print context */ + hsize_t region_elmtno; /* elemnt index */ + int region_dimension_break = 1; + unsigned int region_flags; /* buffer extent flags */ + hsize_t region_curr_pos; + int ndims; + int jndx; + int type_size; + hid_t mem_space; + hid_t dtype; + hid_t type_id; + void *region_buf; + herr_t status; + int i; + int blkndx; + hid_t sid1; + + /* + * This function fails if the region does not have blocks. + */ + H5E_BEGIN_TRY { + nblocks = H5Sget_select_hyper_nblocks(region_space); + } H5E_END_TRY; + + if (nblocks <= 0) + return dimension_break; + + /* Print block information */ + ndims = H5Sget_simple_extent_ndims(region_space); + + /* Render the region { element begin */ + h5tools_str_reset(buffer); + + h5tools_str_append(buffer, "{"); + dimension_break = h5tools_render_element(stream, info, ctx, buffer, curr_pos, ncols, region_elmt_counter, elmt_counter); + /* Render the region { element end */ + + /* Render the region datatype info and indices element begin */ + h5tools_str_reset(buffer); + + ctx->indent_level++; + ctx->need_prefix = TRUE; + h5tools_str_append(buffer, "REGION_TYPE BLOCK "); + + alloc_size = nblocks * ndims * 2 * sizeof(ptdata[0]); + assert(alloc_size == (hsize_t) ((size_t) alloc_size)); /*check for overflow*/ + ptdata = (hsize_t*) malloc((size_t) alloc_size); + H5_CHECK_OVERFLOW(nblocks, hssize_t, hsize_t); + H5Sget_select_hyper_blocklist(region_space, (hsize_t) 0, (hsize_t) nblocks, ptdata); + + for (i = 0; i < nblocks; i++) { + int j; + + h5tools_str_append(buffer, info->dset_blockformat_pre, + i ? "," OPTIONAL_LINE_BREAK " " : "", (unsigned long) i); + + /* Start coordinates and opposite corner */ + for (j = 0; j < ndims; j++) + h5tools_str_append(buffer, "%s%lu", j ? "," : "(", + (unsigned long) ptdata[i * 2 * ndims + j]); + + for (j = 0; j < ndims; j++) + h5tools_str_append(buffer, "%s%lu", j ? "," : ")-(", + (unsigned long) ptdata[i * 2 * ndims + j + ndims]); + + h5tools_str_append(buffer, ")"); + } /* end for (i = 0; i < nblocks; i++) */ + + dimension_break = h5tools_render_element(stream, info, ctx, buffer, curr_pos, ncols, region_elmt_counter, elmt_counter); + /* Render the region datatype info and indices element end */ + + ctx->need_prefix = TRUE; + + dtype = H5Dget_type(region_id); + type_id = H5Tget_native_type(dtype, H5T_DIR_DEFAULT); + + /* Render the datatype element begin */ + h5tools_str_reset(buffer); + h5tools_str_append(buffer, "%s %s ", + h5tools_dump_header_format->datatypebegin, + h5tools_dump_header_format->datatypeblockbegin); + + h5tools_print_datatype(buffer, info, ctx, dtype); + + if (HDstrlen(h5tools_dump_header_format->datatypeblockend)) { + h5tools_str_append(buffer, "%s", h5tools_dump_header_format->datatypeblockend); + if (HDstrlen(h5tools_dump_header_format->datatypeend)) + h5tools_str_append(buffer, " "); + } + if (HDstrlen(h5tools_dump_header_format->datatypeend)) + h5tools_str_append(buffer, "%s", h5tools_dump_header_format->datatypeend); + + dimension_break = h5tools_render_element(stream, info, ctx, buffer, curr_pos, ncols, region_elmt_counter, elmt_counter); + /* Render the datatype element end */ + + ctx->need_prefix = TRUE; + + /* Render the dataspace element begin */ + h5tools_str_reset(buffer); + + ctx->need_prefix = TRUE; + h5tools_str_append(buffer, "%s ", h5tools_dump_header_format->dataspacebegin); + + h5tools_print_dataspace(buffer, info, ctx, region_space); + + if (HDstrlen(h5tools_dump_header_format->dataspaceblockend)) { + h5tools_str_append(buffer, "%s", h5tools_dump_header_format->dataspaceblockend); + if (HDstrlen(h5tools_dump_header_format->dataspaceend)) + h5tools_str_append(buffer, " "); + } + if (HDstrlen(h5tools_dump_header_format->dataspaceend)) + h5tools_str_append(buffer, "%s", h5tools_dump_header_format->dataspaceblockend); + + dimension_break = h5tools_render_element(stream, info, ctx, buffer, curr_pos, ncols, region_elmt_counter, elmt_counter); + /* Render the dataspace element end */ + + ctx->need_prefix = TRUE; + + /* Render the databegin element begin */ + h5tools_str_reset(buffer); + + h5tools_str_append(buffer, "%s %s ", + h5tools_dump_header_format->databegin, + h5tools_dump_header_format->datablockbegin); + + dimension_break = h5tools_render_element(stream, info, ctx, buffer, curr_pos, ncols, region_elmt_counter, elmt_counter); + /* Render the databegin element end */ + + ctx->need_prefix = TRUE; + + + /* Get the dataspace of the dataset */ + sid1 = H5Dget_space(region_id); + + /* Allocate space for the dimension array */ + dims1 = (hsize_t *) malloc(sizeof(hsize_t) * ndims); + + /* find the dimensions of each data space from the block coordinates */ + numelem = 1; + for (jndx = 0; jndx < ndims; jndx++) { + dims1[jndx] = ptdata[jndx + ndims] - ptdata[jndx] + 1; + numelem = dims1[jndx] * numelem; + } + + /* Create dataspace for reading buffer */ + mem_space = H5Screate_simple(ndims, dims1, NULL); + + type_size = H5Tget_size(type_id); + region_buf = malloc(type_size * numelem); + + /* Select (x , x , ..., x ) x (y , y , ..., y ) hyperslab for reading memory dataset */ + /* 1 2 n 1 2 n */ + + start = (hsize_t *) malloc(sizeof(hsize_t) * ndims); + count = (hsize_t *) malloc(sizeof(hsize_t) * ndims); + region_curr_pos = 0; + for (blkndx = 0; blkndx < nblocks; blkndx++) { + /* initialize context structure for the region loop */ + memset(®ion_ctx, 0, sizeof(region_ctx)); + region_ctx.indent_level = ctx->indent_level; + region_ctx.ndims = ndims; + region_ctx.need_prefix = TRUE; + region_ctx.cur_column = ctx->cur_column; + region_ctx.cur_elmt = 0; + region_ctx.prev_multiline = ctx->prev_multiline; + region_ctx.prev_prefix_len = ctx->prev_prefix_len; + region_ctx.continuation = ctx->continuation; + region_ctx.default_indent_level = ctx->default_indent_level; + for (jndx = 0; jndx < ndims; jndx++) { + start[jndx] = ptdata[jndx + blkndx * ndims * 2]; + count[jndx] = dims1[jndx]; + } + + status = H5Sselect_hyperslab(sid1, H5S_SELECT_SET, start, NULL, count, NULL); + + status = H5Dread(region_id, type_id, mem_space, sid1, H5P_DEFAULT, region_buf); + + region_ctx.indent_level++; + H5Sget_simple_extent_dims(mem_space, region_total_size, NULL); + + /* assume entire data space to be printed */ + for (jndx = 0; jndx < (size_t) region_ctx.ndims; jndx++) + region_ctx.p_min_idx[jndx] = start[jndx]; + init_acc_pos(®ion_ctx, region_total_size); + + /* print the data */ + region_flags = START_OF_DATA; + if (blkndx == nblocks - 1) + region_flags |= END_OF_DATA; + + for (jndx = 0; jndx < region_ctx.ndims; jndx++) + region_ctx.p_max_idx[jndx] = dims1[jndx]; + + region_curr_pos = 0; + region_ctx.sm_pos = blkndx*2*ndims; + region_ctx.size_last_dim = dims1[ndims-1]; + + h5tools_region_simple_prefix(stream, info, ®ion_ctx, region_curr_pos, ptdata, 0); + + region_elmtno = 0; + for (jndx = 0; jndx < numelem; jndx++, region_elmtno++, region_ctx.cur_elmt++) { + /* Render the region data element begin */ + h5tools_str_reset(buffer); + + h5tools_str_append(buffer, "%s", jndx ? OPTIONAL_LINE_BREAK "" : ""); + h5tools_str_sprint(buffer, info, region_id, type_id, + ((char*)region_buf + jndx * type_size), ®ion_ctx); + + if (jndx + 1 < numelem || (region_flags & END_OF_DATA) == 0) + h5tools_str_append(buffer, "%s", OPT(info->elmt_suf1, ",")); + + region_dimension_break = h5tools_render_region_element(stream, info, ®ion_ctx, buffer, ®ion_curr_pos, + ncols, ptdata, jndx, region_elmtno); + /* Render the region data element end */ + + if(region_dimension_break==0) + region_elmtno = 0; + } /* end for (jndx = 0; jndx < numelem; jndx++, region_elmtno++, region_ctx.cur_elmt++) */ + + region_ctx.indent_level--; + } /* end for (blkndx = 0; blkndx < nblocks; blkndx++) */ + + free(start); + free(count); + free(region_buf); + free(ptdata); + free(dims1); + status = H5Tclose(dtype); + status = H5Sclose(mem_space); + status = H5Sclose(sid1); + + ctx->need_prefix = TRUE; + + /* Render the dataend element begin */ + h5tools_str_reset(buffer); + h5tools_str_append(buffer, "%s %s ", + h5tools_dump_header_format->dataend, + h5tools_dump_header_format->datablockend); + dimension_break = h5tools_render_element(stream, info, ctx, buffer, curr_pos, + ncols, region_elmt_counter, elmt_counter); + /* Render the dataend element end */ + + ctx->indent_level--; + ctx->need_prefix = TRUE; + + /* Render the region } element begin */ + h5tools_str_reset(buffer); + h5tools_str_append(buffer, "}"); + dimension_break = h5tools_render_element(stream, info, ctx, buffer, curr_pos, + ncols, region_elmt_counter, elmt_counter); + /* Render the region } element end */ + + return dimension_break; } +/*------------------------------------------------------------------------- + * Audience: Public + * Chapter: H5Tools Library + * Purpose: Print some values from a dataset referenced by region points. + * + * Description: + * This is a special case subfunction to dump a region reference using points. + * + * Return: + * The function returns False if the last dimension has been reached, otherwise True + * + * In/Out: + * h5tools_context_t *ctx + * hsize_t *curr_pos + * + * Parameters Description: + * h5tools_str_t *buffer is the string into which to render + * hsize_t curr_pos is the total data element position + * size_t ncols + * hsize_t region_elmt_counter is the region element loop counter + * hsize_t elmt_count is the data element loop counter + *------------------------------------------------------------------------- + */ +int +h5tools_dump_region_data_points(hid_t region_space, hid_t region_id, + FILE *stream, const h5tool_format_t *info, h5tools_context_t *ctx, + h5tools_str_t *buffer, hsize_t *curr_pos, size_t ncols, hsize_t region_elmt_counter, + hsize_t elmt_counter) { + int dimension_break = 1; + hssize_t npoints; + hsize_t alloc_size; + hsize_t *ptdata; + hsize_t *dims1; + h5tools_context_t region_ctx; /* print context */ + hsize_t region_elmtno; /* elemnt index */ + int region_dimension_break = 1; + unsigned int region_flags; /* buffer extent flags */ + hsize_t region_curr_pos; + int ndims; + int jndx; + int type_size; + hid_t mem_space; + hid_t dtype; + hid_t type_id; + void *region_buf; + herr_t status; + + /* + * This function fails if the region does not have blocks. + */ + H5E_BEGIN_TRY { + npoints = H5Sget_select_elem_npoints(region_space); + } H5E_END_TRY; + + if (npoints > 0) { + int indx; + + /* Render the region { element begin */ + h5tools_str_reset(buffer); + + h5tools_str_append(buffer, "{"); + dimension_break = h5tools_render_element(stream, info, ctx, buffer, curr_pos, ncols, region_elmt_counter, elmt_counter); + /* Render the region { element end */ + + /* Render the region datatype info and indices element begin */ + h5tools_str_reset(buffer); + + ctx->indent_level++; + ctx->need_prefix = TRUE; + h5tools_str_append(buffer, "REGION_TYPE POINT "); + + /* Allocate space for the dimension array */ + ndims = H5Sget_simple_extent_ndims(region_space); + alloc_size = npoints * ndims * sizeof(ptdata[0]); + assert(alloc_size == (hsize_t) ((size_t) alloc_size)); /*check for overflow*/ + ptdata = malloc((size_t) alloc_size); + H5_CHECK_OVERFLOW(npoints, hssize_t, hsize_t); + H5Sget_select_elem_pointlist(region_space, (hsize_t) 0, (hsize_t) npoints, ptdata); + + for (indx = 0; indx < npoints; indx++) { + int loop_indx; + + h5tools_str_append(buffer, info->dset_ptformat_pre, + indx ? "," OPTIONAL_LINE_BREAK " " : "", (unsigned long) indx); + + for (loop_indx = 0; loop_indx < ndims; loop_indx++) + h5tools_str_append(buffer, "%s%lu", loop_indx ? "," : "(", + (unsigned long) (ptdata[indx * ndims + loop_indx])); + + h5tools_str_append(buffer, ")"); + } /* end for (indx = 0; indx < npoints; indx++) */ + + dimension_break = h5tools_render_element(stream, info, ctx, buffer, curr_pos, ncols, region_elmt_counter, elmt_counter); + /* Render the region datatype info and indices element end */ + + ctx->need_prefix = TRUE; + + dtype = H5Dget_type(region_id); + type_id = H5Tget_native_type(dtype, H5T_DIR_DEFAULT); + + /* Render the datatype element begin */ + h5tools_str_reset(buffer); + h5tools_str_append(buffer, "%s %s ", + h5tools_dump_header_format->datatypebegin, + h5tools_dump_header_format->datatypeblockbegin); + + h5tools_print_datatype(buffer, info, ctx, dtype); + + if (HDstrlen(h5tools_dump_header_format->datatypeblockend)) { + h5tools_str_append(buffer, "%s", h5tools_dump_header_format->datatypeblockend); + if (HDstrlen(h5tools_dump_header_format->datatypeend)) + h5tools_str_append(buffer, " "); + } + if (HDstrlen(h5tools_dump_header_format->datatypeend)) + h5tools_str_append(buffer, "%s", h5tools_dump_header_format->datatypeend); + + dimension_break = h5tools_render_element(stream, info, ctx, buffer, curr_pos, ncols, region_elmt_counter, elmt_counter); + /* Render the datatype element end */ + + ctx->need_prefix = TRUE; + + /* Render the dataspace element begin */ + h5tools_str_reset(buffer); + + ctx->need_prefix = TRUE; + h5tools_str_append(buffer, "%s ", h5tools_dump_header_format->dataspacebegin); + + h5tools_print_dataspace(buffer, info, ctx, region_space); + + if (HDstrlen(h5tools_dump_header_format->dataspaceblockend)) { + h5tools_str_append(buffer, "%s", h5tools_dump_header_format->dataspaceblockend); + if (HDstrlen(h5tools_dump_header_format->dataspaceend)) + h5tools_str_append(buffer, " "); + } + if (HDstrlen(h5tools_dump_header_format->dataspaceend)) + h5tools_str_append(buffer, "%s", h5tools_dump_header_format->dataspaceblockend); + + dimension_break = h5tools_render_element(stream, info, ctx, buffer, curr_pos, ncols, region_elmt_counter, elmt_counter); + /* Render the dataspace element end */ + + ctx->need_prefix = TRUE; + + /* Render the databegin element begin */ + h5tools_str_reset(buffer); + + h5tools_str_append(buffer, "%s %s ", + h5tools_dump_header_format->databegin, + h5tools_dump_header_format->datablockbegin); + + dimension_break = h5tools_render_element(stream, info, ctx, buffer, curr_pos, ncols, region_elmt_counter, elmt_counter); + /* Render the databegin element end */ + + ctx->need_prefix = TRUE; + + type_size = H5Tget_size(type_id); + + region_buf = malloc(type_size * npoints); + + /* Allocate space for the dimension array */ + dims1 = (hsize_t *) malloc(sizeof(hsize_t) * ndims); + + dims1[0] = npoints; + mem_space = H5Screate_simple(1, dims1, NULL); + + status = H5Dread(region_id, type_id, mem_space, region_space, H5P_DEFAULT, region_buf); + + region_elmtno = 0; + region_curr_pos = 0; + for (jndx = 0; jndx < npoints; jndx++, region_elmtno++) { + /* initialize context structure for the region loop */ + memset(®ion_ctx, 0, sizeof(region_ctx)); + region_ctx.indent_level = ctx->indent_level; + region_ctx.ndims = ndims; + region_ctx.need_prefix = TRUE; + region_ctx.cur_column = ctx->cur_column; + region_ctx.cur_elmt = 0; /* points are always 0 */ + region_ctx.prev_multiline = ctx->prev_multiline; + region_ctx.prev_prefix_len = ctx->prev_prefix_len; + region_ctx.continuation = ctx->continuation; + region_ctx.default_indent_level = ctx->default_indent_level; + + /* Render the point element begin */ + h5tools_str_reset(buffer); + + region_ctx.indent_level++; + + /* assume entire data space to be printed */ + for (indx = 0; indx < (size_t) region_ctx.ndims; indx++) + region_ctx.p_min_idx[indx] = 0; + H5Sget_simple_extent_dims(region_space, region_ctx.p_max_idx, NULL); + + if (region_ctx.ndims > 0) { + region_ctx.size_last_dim = (int) (region_ctx.p_max_idx[region_ctx.ndims - 1]); + } + else + region_ctx.size_last_dim = 0; + + if (region_ctx.ndims > 0) + init_acc_pos(®ion_ctx, region_ctx.p_max_idx); + + /* print the data */ + region_flags = START_OF_DATA; + if (jndx == npoints - 1) + region_flags |= END_OF_DATA; + + region_curr_pos = 0; /* points requires constant 0 */ + region_ctx.sm_pos = jndx * ndims; + + h5tools_region_simple_prefix(stream, info, ®ion_ctx, region_curr_pos, ptdata, 0); + + h5tools_str_sprint(buffer, info, region_id, type_id, + ((char*)region_buf + jndx * type_size), ®ion_ctx); + + if (jndx + 1 < npoints || (region_flags & END_OF_DATA) == 0) + h5tools_str_append(buffer, "%s", OPT(info->elmt_suf1, ",")); + + region_dimension_break = + h5tools_render_region_element(stream, info, ®ion_ctx, buffer, ®ion_curr_pos, + ncols, ptdata, 0, region_elmtno); + /* Render the point element end */ + + region_ctx.indent_level--; + if(region_dimension_break == 0) + region_elmtno = 0; + } /* end for (jndx = 0; jndx < npoints; jndx++, region_elmtno++) */ + + free(region_buf); + free(ptdata); + free(dims1); + status = H5Tclose(dtype); + status = H5Sclose(mem_space); + + ctx->need_prefix = TRUE; + + /* Render the dataend element begin */ + h5tools_str_reset(buffer); + h5tools_str_append(buffer, "%s %s ", + h5tools_dump_header_format->dataend, + h5tools_dump_header_format->datablockend); + dimension_break = h5tools_render_element(stream, info, ctx, buffer, curr_pos, + ncols, region_elmt_counter, elmt_counter); + /* Render the dataend element end*/ + + ctx->indent_level--; + ctx->need_prefix = TRUE; + + /* Render the region } element begin */ + h5tools_str_reset(buffer); + h5tools_str_append(buffer, "}"); + dimension_break = h5tools_render_element(stream, info, ctx, buffer, curr_pos, + ncols, region_elmt_counter, elmt_counter); + /* Render the region } element end */ + } /* end if (npoints > 0) */ + return dimension_break; +} /*------------------------------------------------------------------------- * Audience: Public @@ -747,8 +1828,7 @@ h5tools_dump_simple_data(FILE *stream, const h5tool_format_t *info, hid_t contai */ static herr_t h5tools_dump_simple_subset(FILE *stream, const h5tool_format_t *info, hid_t dset, - hid_t p_type, struct subset_t *sset, - int indentlevel) + hid_t p_type, struct subset_t *sset, int indentlevel) { herr_t ret; /* the value to return */ hid_t f_space; /* file data space */ @@ -785,8 +1865,7 @@ h5tools_dump_simple_subset(FILE *stream, const h5tool_format_t *info, hid_t dset hsize_t printed_points = 0; /* printed */ #endif - - ret = FAIL; /* be pessimistic */ + ret = FAIL; /* be pessimistic */ f_space = H5Dget_space(dset); if (f_space == FAIL) @@ -802,12 +1881,12 @@ h5tools_dump_simple_subset(FILE *stream, const h5tool_format_t *info, hid_t dset ctx.need_prefix = 1; ctx.ndims = H5Sget_simple_extent_ndims(f_space); - if ((size_t)ctx.ndims > NELMTS(sm_size)) + if ((size_t) ctx.ndims > NELMTS(sm_size)) goto done_close; /* assume entire data space to be printed */ if (ctx.ndims > 0) - for (i = 0; i < (size_t)ctx.ndims; i++) + for (i = 0; i < (size_t) ctx.ndims; i++) ctx.p_min_idx[i] = 0; H5Sget_simple_extent_dims(f_space, total_size, NULL); @@ -821,114 +1900,88 @@ h5tools_dump_simple_subset(FILE *stream, const h5tool_format_t *info, hid_t dset /* get the offset count */ outer_count = 1; if (ctx.ndims > 2) - for (i = 0; i < (size_t)ctx.ndims - 2; i++) - { + for (i = 0; i < (size_t) ctx.ndims - 2; i++) { /* consider block size */ - outer_count = outer_count * sset->count[ i ] * sset->block[ i ]; + outer_count = outer_count * sset->count[i] * sset->block[i]; } - if(ctx.ndims>0) - init_acc_pos(&ctx,total_size); + if (ctx.ndims > 0) + init_acc_pos(&ctx, total_size); /* calculate total number of points to print */ #if defined (SANITY_CHECK) - for (i = 0; i < (size_t)ctx.ndims; i++) - { - total_points *= sset->count[ i ] * sset->block[ i ];; + for (i = 0; i < (size_t) ctx.ndims; i++) { + total_points *= sset->count[i] * sset->block[i];; } #endif - - /* initialize temporary start, count and maximum start */ - for (i = 0; i < (size_t)ctx.ndims; i++) - { - temp_start[ i ] = sset->start[ i ]; - temp_count[ i ] = sset->count[ i ]; - temp_block[ i ] = sset->block[ i ]; - temp_stride[ i ] = sset->stride[ i ]; - max_start[ i ] = 0; + for (i = 0; i < (size_t) ctx.ndims; i++) { + temp_start[i] = sset->start[i]; + temp_count[i] = sset->count[i]; + temp_block[i] = sset->block[i]; + temp_stride[i] = sset->stride[i]; + max_start[i] = 0; } - if (ctx.ndims > 2) - { - for (i = 0; i < (size_t)ctx.ndims - 2; i++) - { - max_start[ i ] = temp_start[ i ] + sset->count[ i ]; - temp_count[ i ] = 1; + if (ctx.ndims > 2) { + for (i = 0; i < (size_t) ctx.ndims - 2; i++) { + max_start[i] = temp_start[i] + sset->count[i]; + temp_count[i] = 1; } } - /* offset loop */ - for (n = 0; n < outer_count; n++) - { + for (n = 0; n < outer_count; n++) { hsize_t row_counter = 0; /* number of read iterations in inner loop, read by rows, to match 2D display */ - if (ctx.ndims > 1) - { + if (ctx.ndims > 1) { - /* count is the number of iterations to display all the rows, - the block size count times */ - count = sset->count[ row_dim ] * sset->block[ row_dim ]; + /* count is the number of iterations to display all the rows, + the block size count times */ + count = sset->count[row_dim] * sset->block[row_dim]; /* always 1 row_counter at a time, that is a block of size 1, 1 time */ - temp_count[ row_dim ] = 1; - temp_block[ row_dim ] = 1; + temp_count[row_dim] = 1; + temp_block[row_dim] = 1; /* advance 1 row_counter at a time */ - if (sset->block[ row_dim ] > 1 ) - temp_stride[ row_dim ] = 1; - + if (sset->block[row_dim] > 1) + temp_stride[row_dim] = 1; } /* for the 1D case */ - else - { + else { count = 1; } - - size_row_block = sset->block[ row_dim ]; - + size_row_block = sset->block[row_dim]; /* display loop */ - for (; count > 0; - temp_start[ row_dim ] += temp_stride[ row_dim ], - count--) - { - - - /* jump rows if size of block exceeded - cases where block > 1 only and stride > block */ - if ( size_row_block > 1 && - row_counter == size_row_block && - sset->stride[ row_dim ] > sset->block[ row_dim ] - ) - { + for (; count > 0; temp_start[row_dim] += temp_stride[row_dim], count--) { - hsize_t increase_rows = sset->stride[ row_dim ] - - sset->block[ row_dim ]; + /* jump rows if size of block exceeded + cases where block > 1 only and stride > block */ + if (size_row_block > 1 + && row_counter == size_row_block + && sset->stride[row_dim] > sset->block[row_dim]) { - temp_start[ row_dim ] += increase_rows; + hsize_t increase_rows = sset->stride[row_dim] - sset->block[row_dim]; - row_counter = 0; + temp_start[row_dim] += increase_rows; - } + row_counter = 0; - row_counter++; + } + row_counter++; /* calculate the potential number of elements we're going to print */ - H5Sselect_hyperslab(f_space, H5S_SELECT_SET, - temp_start, - temp_stride, - temp_count, - temp_block); + H5Sselect_hyperslab(f_space, H5S_SELECT_SET, temp_start, temp_stride, temp_count, temp_block); sm_nelmts = H5Sget_select_npoints(f_space); if (sm_nelmts == 0) { @@ -938,14 +1991,13 @@ h5tools_dump_simple_subset(FILE *stream, const h5tool_format_t *info, hid_t dset } /* - * determine the strip mine size and allocate a buffer. the strip mine is - * a hyperslab whose size is manageable. - */ + * determine the strip mine size and allocate a buffer. the strip mine is + * a hyperslab whose size is manageable. + */ sm_nbytes = p_type_nbytes = H5Tget_size(p_type); if (ctx.ndims > 0) - for (i = ctx.ndims; i > 0; --i) - { + for (i = ctx.ndims; i > 0; --i) { hsize_t size = H5TOOLS_BUFSIZE / sm_nbytes; if ( size == 0) /* datum size > H5TOOLS_BUFSIZE */ size = 1; @@ -954,103 +2006,92 @@ h5tools_dump_simple_subset(FILE *stream, const h5tool_format_t *info, hid_t dset assert(sm_nbytes > 0); } - assert(sm_nbytes == (hsize_t)((size_t)sm_nbytes)); /*check for overflow*/ - sm_buf = malloc((size_t)sm_nelmts * p_type_nbytes); - sm_space = H5Screate_simple(1, &sm_nelmts, NULL); + assert(sm_nbytes == (hsize_t) ((size_t) sm_nbytes)); /*check for overflow*/ + sm_buf = malloc((size_t) sm_nelmts * p_type_nbytes); + sm_space = H5Screate_simple(1, &sm_nelmts, NULL); - H5Sselect_hyperslab(sm_space, H5S_SELECT_SET, &zero, NULL, &sm_nelmts, NULL); + H5Sselect_hyperslab(sm_space, H5S_SELECT_SET, &zero, NULL, &sm_nelmts, NULL); - /* read the data */ - if (H5Dread(dset, p_type, sm_space, f_space, H5P_DEFAULT, sm_buf) < 0) { - H5Sclose(f_space); - H5Sclose(sm_space); - free(sm_buf); - return FAIL; - } + /* read the data */ + if (H5Dread(dset, p_type, sm_space, f_space, H5P_DEFAULT, sm_buf) < 0) { + H5Sclose(f_space); + H5Sclose(sm_space); + free(sm_buf); + return FAIL; + } - /* print the data */ - flags = START_OF_DATA; - - if (count == 1) - flags |= END_OF_DATA; - - for (i = 0; i < ctx.ndims; i++) - ctx.p_max_idx[i] = ctx.p_min_idx[i] + MIN(total_size[i], sm_size[i]); - - /* print array indices. get the lower bound of the hyperslab and calulate - the element position at the start of hyperslab */ - H5Sget_select_bounds(f_space,low,high); - elmtno=0; - for (i = 0; i < (size_t)ctx.ndims-1; i++) - { - hsize_t offset = 1; /* accumulation of the previous dimensions */ - for (j = i+1; j < (size_t)ctx.ndims; j++) - offset *= total_size[j]; - elmtno+= low[i] * offset; - } - elmtno+= low[ctx.ndims - 1]; + /* print the data */ + flags = START_OF_DATA; - /* initialize the current stripmine position; this is necessary to print the array - indices */ - ctx.sm_pos = elmtno; + if (count == 1) + flags |= END_OF_DATA; - h5tools_dump_simple_data(stream, info, dset, &ctx, flags, sm_nelmts, - p_type, sm_buf); - free(sm_buf); + for (i = 0; i < ctx.ndims; i++) + ctx.p_max_idx[i] = ctx.p_min_idx[i] + MIN(total_size[i], sm_size[i]); + + /* print array indices. get the lower bound of the hyperslab and calulate + the element position at the start of hyperslab */ + H5Sget_select_bounds(f_space, low, high); + elmtno = 0; + for (i = 0; i < (size_t) ctx.ndims - 1; i++) { + hsize_t offset = 1; /* accumulation of the previous dimensions */ + for (j = i + 1; j < (size_t) ctx.ndims; j++) + offset *= total_size[j]; + elmtno += low[i] * offset; + } + elmtno += low[ctx.ndims - 1]; - /* we need to jump to next line and update the index */ - ctx.need_prefix = 1; + /* initialize the current stripmine position; this is necessary to print the array + indices */ + ctx.sm_pos = elmtno; - ctx.continuation++; + h5tools_dump_simple_data(stream, info, dset, &ctx, flags, sm_nelmts, p_type, sm_buf); + free(sm_buf); + + /* we need to jump to next line and update the index */ + ctx.need_prefix = 1; + ctx.continuation++; #if defined (SANITY_CHECK) - printed_points += sm_nelmts; + printed_points += sm_nelmts; #endif - } /* count */ - if (ctx.ndims > 2) - { + if (ctx.ndims > 2) { /* dimension for start */ - current_outer_dim = (ctx.ndims - 2) -1; + current_outer_dim = (ctx.ndims - 2) - 1; /* set start to original from current_outer_dim up */ - for (i = current_outer_dim + 1; i < ctx.ndims; i++) - { - temp_start[ i ] = sset->start[ i ]; + for (i = current_outer_dim + 1; i < ctx.ndims; i++) { + temp_start[i] = sset->start[i]; } - /* increment start dimension */ - do - { + do { reset_dim = 0; - temp_start[ current_outer_dim ]++; - if (temp_start[ current_outer_dim ] >= max_start[ current_outer_dim ]) - { - temp_start[ current_outer_dim ] = sset->start[ current_outer_dim ]; + temp_start[current_outer_dim]++; + if (temp_start[current_outer_dim] >= max_start[current_outer_dim]) { + temp_start[current_outer_dim] = sset->start[current_outer_dim]; /* consider block */ - if ( sset->block[ current_outer_dim ] > 1 ) - temp_start[ current_outer_dim ]++; + if (sset->block[current_outer_dim] > 1) + temp_start[current_outer_dim]++; current_outer_dim--; reset_dim = 1; } - } - while (current_outer_dim >= 0 && reset_dim); + } while (current_outer_dim >= 0 && reset_dim); } /* ctx.ndims > 1 */ } /* outer_count */ #if defined (SANITY_CHECK) - assert( printed_points == total_points ); + assert(printed_points == total_points); #endif - /* Terminate the output */ if (ctx.cur_column) { fputs(OPT(info->line_suf, ""), stream); @@ -1066,8 +2107,6 @@ done: return ret; } - - /*------------------------------------------------------------------------- * Audience: Public * Chapter: H5Tools Library @@ -1081,18 +2120,15 @@ done: * Return: * On success, the function returns SUCCEED. Otherwise, the function * returns FAIL. - * Programmer: - * Robb Matzke, Thursday, July 23, 1998 - * Modifications: *------------------------------------------------------------------------- */ -static int -h5tools_dump_simple_dset(FILE *stream, const h5tool_format_t *info, hid_t dset, - hid_t p_type, int indentlevel) +static int +h5tools_dump_simple_dset(FILE *stream, const h5tool_format_t *info, + hid_t dset, hid_t p_type, int indentlevel) { hid_t f_space; /* file data space */ hsize_t elmtno; /* counter */ - size_t i; /* counter */ + size_t i; /* counter */ int carry; /* counter carry value */ hsize_t zero[8]; /* vector of zeros */ unsigned int flags; /* buffer extent flags */ @@ -1107,16 +2143,16 @@ h5tools_dump_simple_dset(FILE *stream, const h5tool_format_t *info, hid_t dset, hsize_t sm_size[H5S_MAX_RANK]; /* stripmine size */ hsize_t sm_nbytes; /* bytes per stripmine */ hsize_t sm_nelmts; /* elements per stripmine*/ - unsigned char *sm_buf = NULL; /* buffer for raw data */ + unsigned char *sm_buf = NULL; /* buffer for raw data */ hid_t sm_space; /* stripmine data space */ /* Hyperslab info */ - hsize_t hs_offset[H5S_MAX_RANK]; /* starting offset */ - hsize_t hs_size[H5S_MAX_RANK]; /* size this pass */ - hsize_t hs_nelmts; /* elements in request */ + hsize_t hs_offset[H5S_MAX_RANK]; /* starting offset */ + hsize_t hs_size[H5S_MAX_RANK]; /* size this pass */ + hsize_t hs_nelmts; /* elements in request */ /* VL data special information */ - unsigned int vl_data = 0; /* contains VL datatypes */ + unsigned int vl_data = 0; /* contains VL datatypes */ f_space = H5Dget_space(dset); @@ -1129,8 +2165,6 @@ h5tools_dump_simple_dset(FILE *stream, const h5tool_format_t *info, hid_t dset, * match the dimensionality of the dataset. */ memset(&ctx, 0, sizeof(ctx)); - ctx.indent_level = indentlevel; - ctx.need_prefix = 1; ctx.ndims = H5Sget_simple_extent_ndims(f_space); if ((size_t)ctx.ndims > NELMTS(sm_size)) { @@ -1138,6 +2172,9 @@ h5tools_dump_simple_dset(FILE *stream, const h5tool_format_t *info, hid_t dset, return FAIL; } + ctx.indent_level = indentlevel; + ctx.need_prefix = 1; + /* Assume entire data space to be printed */ if (ctx.ndims > 0) for (i = 0; i < (size_t)ctx.ndims; i++) @@ -1189,8 +2226,8 @@ h5tools_dump_simple_dset(FILE *stream, const h5tool_format_t *info, hid_t dset, sm_nelmts = sm_nbytes / p_type_nbytes; sm_space = H5Screate_simple(1, &sm_nelmts, NULL); - if(ctx.ndims>0) - init_acc_pos(&ctx,total_size); + if (ctx.ndims > 0) + init_acc_pos(&ctx, total_size); /* The stripmine loop */ memset(hs_offset, 0, sizeof hs_offset); @@ -1205,11 +2242,10 @@ h5tools_dump_simple_dset(FILE *stream, const h5tool_format_t *info, hid_t dset, hs_nelmts *= hs_size[i]; } - H5Sselect_hyperslab(f_space, H5S_SELECT_SET, hs_offset, NULL, - hs_size, NULL); - H5Sselect_hyperslab(sm_space, H5S_SELECT_SET, zero, NULL, - &hs_nelmts, NULL); - } else { + H5Sselect_hyperslab(f_space, H5S_SELECT_SET, hs_offset, NULL, hs_size, NULL); + H5Sselect_hyperslab(sm_space, H5S_SELECT_SET, zero, NULL, &hs_nelmts, NULL); + } + else { H5Sselect_all(f_space); H5Sselect_all(sm_space); hs_nelmts = 1; @@ -1228,14 +2264,13 @@ h5tools_dump_simple_dset(FILE *stream, const h5tool_format_t *info, hid_t dset, flags |= ((elmtno + hs_nelmts) >= p_nelmts) ? END_OF_DATA : 0; /* initialize the current stripmine position; this is necessary to print the array - indices */ + indices */ ctx.sm_pos = elmtno; - h5tools_dump_simple_data(stream, info, dset, &ctx, flags, hs_nelmts, - p_type, sm_buf); + h5tools_dump_simple_data(stream, info, dset, &ctx, flags, hs_nelmts, p_type, sm_buf); /* Reclaim any VL memory, if necessary */ - if(vl_data) + if (vl_data) H5Dvlen_reclaim(p_type, sm_space, H5P_DEFAULT, sm_buf); /* Calculate the next hyperslab offset */ @@ -1274,13 +2309,7 @@ h5tools_dump_simple_dset(FILE *stream, const h5tool_format_t *info, hid_t dset, * This is a special case of h5tools_dump_mem(). * * Return: Success: SUCCEED - * - * Failure: FAIL - * - * Programmer: Robb Matzke - * Thursday, July 23, 1998 - * - * Modifications: + * Failure: FAIL * *------------------------------------------------------------------------- */ @@ -1288,9 +2317,9 @@ static int h5tools_dump_simple_mem(FILE *stream, const h5tool_format_t *info, hid_t obj_id, hid_t type, hid_t space, void *mem, int indentlevel) { - int i; /*counters */ - hsize_t nelmts; /*total selected elmts */ - h5tools_context_t ctx; /*printing context */ + int i; /*counters */ + hsize_t nelmts; /*total selected elmts */ + h5tools_context_t ctx; /*printing context */ /* * Check that everything looks okay. The dimensionality must not be too @@ -1300,7 +2329,7 @@ h5tools_dump_simple_mem(FILE *stream, const h5tool_format_t *info, hid_t obj_id, memset(&ctx, 0, sizeof(ctx)); ctx.ndims = H5Sget_simple_extent_ndims(space); - if ((size_t)ctx.ndims > NELMTS(ctx.p_min_idx)) + if ((size_t) ctx.ndims > NELMTS(ctx.p_min_idx)) return FAIL; ctx.indent_level = indentlevel; @@ -1317,19 +2346,18 @@ h5tools_dump_simple_mem(FILE *stream, const h5tool_format_t *info, hid_t obj_id, if (nelmts == 0) return SUCCEED; /*nothing to print*/ - if(ctx.ndims>0) { - assert(ctx.p_max_idx[ctx.ndims - 1]==(hsize_t)((int)ctx.p_max_idx[ctx.ndims - 1])); - ctx.size_last_dim = (int)(ctx.p_max_idx[ctx.ndims - 1]); + if (ctx.ndims > 0) { + assert(ctx.p_max_idx[ctx.ndims - 1] == (hsize_t) ((int) ctx.p_max_idx[ctx.ndims - 1])); + ctx.size_last_dim = (int) (ctx.p_max_idx[ctx.ndims - 1]); } /* end if */ else ctx.size_last_dim = 0; - if(ctx.ndims>0) - init_acc_pos(&ctx,ctx.p_max_idx); + if (ctx.ndims > 0) + init_acc_pos(&ctx, ctx.p_max_idx); /* Print it */ - h5tools_dump_simple_data(stream, info, obj_id, &ctx, - START_OF_DATA | END_OF_DATA, nelmts, type, mem); + h5tools_dump_simple_data(stream, info, obj_id, &ctx, START_OF_DATA | END_OF_DATA, nelmts, type, mem); /* Terminate the output */ if (ctx.cur_column) { @@ -1356,33 +2384,29 @@ h5tools_dump_simple_mem(FILE *stream, const h5tool_format_t *info, hid_t obj_id, * h5tools_dump_mem(). * * Return: Success: SUCCEED - * - * Failure: FAIL - * - * Programmer: Robb Matzke - * Thursday, July 23, 1998 + * Failure: FAIL * * Modifications: * Robb Matzke, 1999-06-07 - * If info->raw is set then the memory datatype will be the same - * as the file datatype. + * If info->raw is set then the memory datatype will be the same + * as the file datatype. * * Bill Wendling, 2001-02-27 - * Renamed to ``h5tools_dump_dset'' and added the subsetting - * parameter. + * Renamed to ``h5tools_dump_dset'' and added the subsetting + * parameter. * *------------------------------------------------------------------------- */ -int -h5tools_dump_dset(FILE *stream, const h5tool_format_t *info, hid_t dset, hid_t _p_type, - struct subset_t *sset, int indentlevel) +int +h5tools_dump_dset(FILE *stream, const h5tool_format_t *info, hid_t dset, + hid_t _p_type, struct subset_t *sset, int indentlevel) { hid_t f_space; hid_t p_type = _p_type; hid_t f_type; H5S_class_t space_type; int status = FAIL; - h5tool_format_t info_dflt; + h5tool_format_t info_dflt; /* Use default values */ if (!stream) @@ -1396,11 +2420,11 @@ h5tools_dump_dset(FILE *stream, const h5tool_format_t *info, hid_t dset, hid_t _ if (p_type < 0) { f_type = H5Dget_type(dset); - if (info->raw || bin_form == 1 ) + if (info->raw || bin_form == 1) p_type = H5Tcopy(f_type); - else if (bin_form == 2 ) + else if (bin_form == 2) p_type = h5tools_get_little_endian_type(f_type); - else if (bin_form == 3 ) + else if (bin_form == 3) p_type = h5tools_get_big_endian_type(f_type); else p_type = h5tools_get_native_type(f_type); @@ -1418,13 +2442,15 @@ h5tools_dump_dset(FILE *stream, const h5tool_format_t *info, hid_t dset, hid_t _ /* Print the data */ if (space_type == H5S_SIMPLE || space_type == H5S_SCALAR) { - if (!sset) - status = h5tools_dump_simple_dset(rawdatastream, info, dset, p_type, - indentlevel); - else - status = h5tools_dump_simple_subset(rawdatastream, info, dset, p_type, - sset, indentlevel); - } else /* space is H5S_NULL */ + if (!sset) { + status = h5tools_dump_simple_dset(rawdatastream, info, dset, p_type, indentlevel); + } + else { + status = h5tools_dump_simple_subset(rawdatastream, info, dset, p_type, sset, indentlevel); + } + } + else + /* space is H5S_NULL */ status = SUCCEED; /* Close the dataspace */ @@ -1445,13 +2471,7 @@ done: * spaces are allowed and only the `all' selection. * * Return: Success: SUCCEED - * - * Failure: FAIL - * - * Programmer: Robb Matzke - * Wednesday, January 20, 1999 - * - * Modifications: + * Failure: FAIL * *------------------------------------------------------------------------- */ @@ -1463,49 +2483,724 @@ h5tools_dump_mem(FILE *stream, const h5tool_format_t *info, hid_t obj_id, hid_t /* Use default values */ if (!stream) - stream = stdout; + stream = stdout; if (!info) { - memset(&info_dflt, 0, sizeof(info_dflt)); - info = &info_dflt; + memset(&info_dflt, 0, sizeof(info_dflt)); + info = &info_dflt; } /* Check the data space */ if (H5Sis_simple(space) <= 0) - return -1; + return -1; - return h5tools_dump_simple_mem(stream, info, obj_id, type, space, mem, - indentlevel); + return h5tools_dump_simple_mem(stream, info, obj_id, type, space, mem, indentlevel); } /*------------------------------------------------------------------------- - * Function: init_acc_pos + * Function: print_datatype * - * Purpose: initialize accumulator and matrix position + * Purpose: print the datatype. * * Return: void * - * Programmer: pvn + * In/Out: h5tools_str_t *buffer + * h5tools_context_t *ctx * - * Modifications: + *------------------------------------------------------------------------- + */ +void +h5tools_print_datatype(h5tools_str_t *buffer, const h5tool_format_t *info, + h5tools_context_t *ctx, hid_t type) +{ + char *mname; + hid_t mtype, str_type; + unsigned nmembers; + unsigned ndims; + unsigned i; + size_t size = 0; + hsize_t dims[H5TOOLS_DUMP_MAX_RANK]; + H5T_str_t str_pad; + H5T_cset_t cset; + H5T_order_t order; + hid_t super; + hid_t tmp_type; + htri_t is_vlstr = FALSE; + const char *order_s = NULL; /* byte order string */ + H5T_sign_t sign; /* sign scheme value */ + const char *sign_s = NULL; /* sign scheme string */ + + switch (H5Tget_class(type)) { + case H5T_INTEGER: + if (H5Tequal(type, H5T_STD_I8BE) == TRUE) { + h5tools_str_append(buffer, "H5T_STD_I8BE"); + } + else if (H5Tequal(type, H5T_STD_I8LE) == TRUE) { + h5tools_str_append(buffer, "H5T_STD_I8LE"); + } + else if (H5Tequal(type, H5T_STD_I16BE) == TRUE) { + h5tools_str_append(buffer, "H5T_STD_I16BE"); + } + else if (H5Tequal(type, H5T_STD_I16LE) == TRUE) { + h5tools_str_append(buffer, "H5T_STD_I16LE"); + } + else if (H5Tequal(type, H5T_STD_I32BE) == TRUE) { + h5tools_str_append(buffer, "H5T_STD_I32BE"); + } + else if (H5Tequal(type, H5T_STD_I32LE) == TRUE) { + h5tools_str_append(buffer, "H5T_STD_I32LE"); + } + else if (H5Tequal(type, H5T_STD_I64BE) == TRUE) { + h5tools_str_append(buffer, "H5T_STD_I64BE"); + } + else if (H5Tequal(type, H5T_STD_I64LE) == TRUE) { + h5tools_str_append(buffer, "H5T_STD_I64LE"); + } + else if (H5Tequal(type, H5T_STD_U8BE) == TRUE) { + h5tools_str_append(buffer, "H5T_STD_U8BE"); + } + else if (H5Tequal(type, H5T_STD_U8LE) == TRUE) { + h5tools_str_append(buffer, "H5T_STD_U8LE"); + } + else if (H5Tequal(type, H5T_STD_U16BE) == TRUE) { + h5tools_str_append(buffer, "H5T_STD_U16BE"); + } + else if (H5Tequal(type, H5T_STD_U16LE) == TRUE) { + h5tools_str_append(buffer, "H5T_STD_U16LE"); + } + else if (H5Tequal(type, H5T_STD_U32BE) == TRUE) { + h5tools_str_append(buffer, "H5T_STD_U32BE"); + } + else if (H5Tequal(type, H5T_STD_U32LE) == TRUE) { + h5tools_str_append(buffer, "H5T_STD_U32LE"); + } + else if (H5Tequal(type, H5T_STD_U64BE) == TRUE) { + h5tools_str_append(buffer, "H5T_STD_U64BE"); + } + else if (H5Tequal(type, H5T_STD_U64LE) == TRUE) { + h5tools_str_append(buffer, "H5T_STD_U64LE"); + } + else if (H5Tequal(type, H5T_NATIVE_SCHAR) == TRUE) { + h5tools_str_append(buffer, "H5T_NATIVE_SCHAR"); + } + else if (H5Tequal(type, H5T_NATIVE_UCHAR) == TRUE) { + h5tools_str_append(buffer, "H5T_NATIVE_UCHAR"); + } + else if (H5Tequal(type, H5T_NATIVE_SHORT) == TRUE) { + h5tools_str_append(buffer, "H5T_NATIVE_SHORT"); + } + else if (H5Tequal(type, H5T_NATIVE_USHORT) == TRUE) { + h5tools_str_append(buffer, "H5T_NATIVE_USHORT"); + } + else if (H5Tequal(type, H5T_NATIVE_INT) == TRUE) { + h5tools_str_append(buffer, "H5T_NATIVE_INT"); + } + else if (H5Tequal(type, H5T_NATIVE_UINT) == TRUE) { + h5tools_str_append(buffer, "H5T_NATIVE_UINT"); + } + else if (H5Tequal(type, H5T_NATIVE_LONG) == TRUE) { + h5tools_str_append(buffer, "H5T_NATIVE_LONG"); + } + else if (H5Tequal(type, H5T_NATIVE_ULONG) == TRUE) { + h5tools_str_append(buffer, "H5T_NATIVE_ULONG"); + } + else if (H5Tequal(type, H5T_NATIVE_LLONG) == TRUE) { + h5tools_str_append(buffer, "H5T_NATIVE_LLONG"); + } + else if (H5Tequal(type, H5T_NATIVE_ULLONG) == TRUE) { + h5tools_str_append(buffer, "H5T_NATIVE_ULLONG"); + } + else { + + /* byte order */ + if (H5Tget_size(type) > 1) { + order = H5Tget_order(type); + if (H5T_ORDER_LE == order) { + order_s = " little-endian"; + } + else if (H5T_ORDER_BE == order) { + order_s = " big-endian"; + } + else if (H5T_ORDER_VAX == order) { + order_s = " mixed-endian"; + } + else { + order_s = " unknown-byte-order"; + } + } + else { + order_s = ""; + } + + /* sign */ + if ((sign = H5Tget_sign(type)) >= 0) { + if (H5T_SGN_NONE == sign) { + sign_s = " unsigned"; + } + else if (H5T_SGN_2 == sign) { + sign_s = ""; + } + else { + sign_s = " unknown-sign"; + } + } + else { + sign_s = " unknown-sign"; + } + + /* print size, order, and sign */ + h5tools_str_append(buffer, "%lu-bit%s%s integer", + (unsigned long) (8 * H5Tget_size(type)), order_s, sign_s); + } + break; + + case H5T_FLOAT: + if (H5Tequal(type, H5T_IEEE_F32BE) == TRUE) { + h5tools_str_append(buffer, "H5T_IEEE_F32BE"); + } + else if (H5Tequal(type, H5T_IEEE_F32LE) == TRUE) { + h5tools_str_append(buffer, "H5T_IEEE_F32LE"); + } + else if (H5Tequal(type, H5T_IEEE_F64BE) == TRUE) { + h5tools_str_append(buffer, "H5T_IEEE_F64BE"); + } + else if (H5Tequal(type, H5T_IEEE_F64LE) == TRUE) { + h5tools_str_append(buffer, "H5T_IEEE_F64LE"); + } + else if (H5Tequal(type, H5T_VAX_F32) == TRUE) { + h5tools_str_append(buffer, "H5T_VAX_F32"); + } + else if (H5Tequal(type, H5T_VAX_F64) == TRUE) { + h5tools_str_append(buffer, "H5T_VAX_F64"); + } + else if (H5Tequal(type, H5T_NATIVE_FLOAT) == TRUE) { + h5tools_str_append(buffer, "H5T_NATIVE_FLOAT"); + } + else if (H5Tequal(type, H5T_NATIVE_DOUBLE) == TRUE) { + h5tools_str_append(buffer, "H5T_NATIVE_DOUBLE"); +#if H5_SIZEOF_LONG_DOUBLE !=0 + } + else if (H5Tequal(type, H5T_NATIVE_LDOUBLE) == TRUE) { + h5tools_str_append(buffer, "H5T_NATIVE_LDOUBLE"); +#endif + } + else { + + /* byte order */ + if (H5Tget_size(type) > 1) { + order = H5Tget_order(type); + if (H5T_ORDER_LE == order) { + order_s = " little-endian"; + } + else if (H5T_ORDER_BE == order) { + order_s = " big-endian"; + } + else if (H5T_ORDER_VAX == order) { + order_s = " mixed-endian"; + } + else { + order_s = " unknown-byte-order"; + } + } + else { + order_s = ""; + } + + /* print size and byte order */ + h5tools_str_append(buffer, "%lu-bit%s floating-point", + (unsigned long) (8 * H5Tget_size(type)), order_s); + + } + break; + + case H5T_TIME: + h5tools_str_append(buffer, "H5T_TIME: not yet implemented"); + break; + + case H5T_STRING: + /* Make a copy of type in memory in case when TYPE is on disk, the size + * will be bigger than in memory. This makes it easier to compare + * types in memory. */ + tmp_type = H5Tcopy(type); + size = H5Tget_size(tmp_type); + str_pad = H5Tget_strpad(tmp_type); + cset = H5Tget_cset(tmp_type); + is_vlstr = H5Tis_variable_str(tmp_type); + + h5tools_str_append(buffer, "H5T_STRING %s\n", h5tools_dump_header_format->strblockbegin); + ctx->indent_level++; + + if (is_vlstr) + h5tools_str_append(buffer, "%s H5T_VARIABLE;\n", STRSIZE); + else + h5tools_str_append(buffer, "%s %d;\n", STRSIZE, (int) size); + + h5tools_str_append(buffer, "%s ", STRPAD); + if (str_pad == H5T_STR_NULLTERM) + h5tools_str_append(buffer, "H5T_STR_NULLTERM;\n"); + else if (str_pad == H5T_STR_NULLPAD) + h5tools_str_append(buffer, "H5T_STR_NULLPAD;\n"); + else if (str_pad == H5T_STR_SPACEPAD) + h5tools_str_append(buffer, "H5T_STR_SPACEPAD;\n"); + else + h5tools_str_append(buffer, "H5T_STR_ERROR;\n"); + + h5tools_str_append(buffer, "%s ", CSET); + + if (cset == H5T_CSET_ASCII) + h5tools_str_append(buffer, "H5T_CSET_ASCII;\n"); + else + h5tools_str_append(buffer, "unknown_cset;\n"); + + str_type = H5Tcopy(H5T_C_S1); + if (is_vlstr) + H5Tset_size(str_type, H5T_VARIABLE); + else + H5Tset_size(str_type, size); + H5Tset_cset(str_type, cset); + H5Tset_strpad(str_type, str_pad); + + h5tools_str_append(buffer, "%s ", CTYPE); + + /* Check C variable-length string first. Are the two types equal? */ + if (H5Tequal(tmp_type, str_type)) { + h5tools_str_append(buffer, "H5T_C_S1;\n"); + goto done; + } + + /* Change the endianness and see if they're equal. */ + order = H5Tget_order(tmp_type); + if (order == H5T_ORDER_LE) + H5Tset_order(str_type, H5T_ORDER_LE); + else if (order == H5T_ORDER_BE) + H5Tset_order(str_type, H5T_ORDER_BE); + + if (H5Tequal(tmp_type, str_type)) { + h5tools_str_append(buffer, "H5T_C_S1;\n"); + goto done; + } + + /* If not equal to C variable-length string, check Fortran type. */ + H5Tclose(str_type); + str_type = H5Tcopy(H5T_FORTRAN_S1); + H5Tset_cset(str_type, cset); + H5Tset_size(str_type, size); + H5Tset_strpad(str_type, str_pad); + + /* Are the two types equal? */ + if (H5Tequal(tmp_type, str_type)) { + h5tools_str_append(buffer, "H5T_FORTRAN_S1;\n"); + goto done; + } + + /* Change the endianness and see if they're equal. */ + order = H5Tget_order(tmp_type); + if (order == H5T_ORDER_LE) + H5Tset_order(str_type, H5T_ORDER_LE); + else if (order == H5T_ORDER_BE) + H5Tset_order(str_type, H5T_ORDER_BE); + + if (H5Tequal(tmp_type, str_type)) { + h5tools_str_append(buffer, "H5T_FORTRAN_S1;\n"); + goto done; + } + + /* Type doesn't match any of above. */ + h5tools_str_append(buffer, "unknown_one_character_type;\n "); + + done: H5Tclose(str_type); + H5Tclose(tmp_type); + + ctx->indent_level--; + h5tools_str_append(buffer, "%s", h5tools_dump_header_format->strblockend); + break; + + case H5T_BITFIELD: + if (H5Tequal(type, H5T_STD_B8BE) == TRUE) { + h5tools_str_append(buffer, "H5T_STD_B8BE"); + } + else if (H5Tequal(type, H5T_STD_B8LE) == TRUE) { + h5tools_str_append(buffer, "H5T_STD_B8LE"); + } + else if (H5Tequal(type, H5T_STD_B16BE) == TRUE) { + h5tools_str_append(buffer, "H5T_STD_B16BE"); + } + else if (H5Tequal(type, H5T_STD_B16LE) == TRUE) { + h5tools_str_append(buffer, "H5T_STD_B16LE"); + } + else if (H5Tequal(type, H5T_STD_B32BE) == TRUE) { + h5tools_str_append(buffer, "H5T_STD_B32BE"); + } + else if (H5Tequal(type, H5T_STD_B32LE) == TRUE) { + h5tools_str_append(buffer, "H5T_STD_B32LE"); + } + else if (H5Tequal(type, H5T_STD_B64BE) == TRUE) { + h5tools_str_append(buffer, "H5T_STD_B64BE"); + } + else if (H5Tequal(type, H5T_STD_B64LE) == TRUE) { + h5tools_str_append(buffer, "H5T_STD_B64LE"); + } + else { + h5tools_str_append(buffer, "undefined bitfield"); + } + break; + + case H5T_OPAQUE: + h5tools_str_append(buffer, "\n"); + h5tools_str_append(buffer, "H5T_OPAQUE;\n"); + h5tools_str_append(buffer, "OPAQUE_TAG \"%s\";\n", H5Tget_tag(type)); + break; + + case H5T_COMPOUND: + nmembers = H5Tget_nmembers(type); + h5tools_str_append(buffer, "H5T_COMPOUND %s\n", h5tools_dump_header_format->structblockbegin); + + for (i = 0; i < nmembers; i++) { + mname = H5Tget_member_name(type, i); + mtype = H5Tget_member_type(type, i); + + if (H5Tget_class(mtype) == H5T_COMPOUND) + ctx->indent_level++; + + h5tools_print_datatype(buffer, info, ctx, mtype); + + if (H5Tget_class(mtype) == H5T_COMPOUND) + ctx->indent_level--; + + h5tools_str_append(buffer, " \"%s\";\n", mname); + free(mname); + } + + h5tools_str_append(buffer, "%s", h5tools_dump_header_format->structblockend); + break; + + case H5T_REFERENCE: + h5tools_str_append(buffer, "H5T_REFERENCE"); + if(region_output) { + if (H5Tequal(type, H5T_STD_REF_DSETREG) == TRUE) { + h5tools_str_append(buffer, " { H5T_STD_REF_DSETREG }"); + } + else { + h5tools_str_append(buffer, " { H5T_STD_REF_OBJECT }"); + } + } + break; + + case H5T_ENUM: + h5tools_str_append(buffer, "H5T_ENUM %s\n", h5tools_dump_header_format->enumblockbegin); + ctx->indent_level++; + super = H5Tget_super(type); + h5tools_print_datatype(buffer, info, ctx, super); + h5tools_str_append(buffer, ";\n"); + h5tools_print_enum(buffer, info, ctx, type); + ctx->indent_level--; + h5tools_str_append(buffer, "%s", h5tools_dump_header_format->enumblockend); + break; + + case H5T_VLEN: + h5tools_str_append(buffer, "H5T_VLEN %s ", h5tools_dump_header_format->vlenblockbegin); + super = H5Tget_super(type); + h5tools_print_datatype(buffer, info, ctx, super); + H5Tclose(super); + + /* Print closing */ + h5tools_str_append(buffer, "%s", h5tools_dump_header_format->vlenblockend); + break; + + case H5T_ARRAY: + /* Get array base type */ + super = H5Tget_super(type); + + /* Print lead-in */ + h5tools_str_append(buffer, "H5T_ARRAY { "); + + /* Get array information */ + ndims = H5Tget_array_ndims(type); + H5Tget_array_dims2(type, dims); + + /* Print array dimensions */ + for (i = 0; i < ndims; i++) + h5tools_str_append(buffer, "[%d]", (int) dims[i]); + + h5tools_str_append(buffer, " "); + + /* Print base type */ + h5tools_print_datatype(buffer, info, ctx, super); + + /* Close array base type */ + H5Tclose(super); + + /* Print closing */ + h5tools_str_append(buffer, " }"); + + break; + + default: + h5tools_str_append(buffer, "unknown datatype"); + break; + } +} + +/*------------------------------------------------------------------------- + * Function: print_dataspace + * + * Purpose: print the dataspace. + * + * Return: void + * + * In/Out: h5tools_str_t *buffer + * h5tools_context_t *ctx + * + *------------------------------------------------------------------------- + */ +void +h5tools_print_dataspace(h5tools_str_t *buffer, const h5tool_format_t *info, + h5tools_context_t *ctx, hid_t space) +{ + hsize_t size[H5TOOLS_DUMP_MAX_RANK]; + hsize_t maxsize[H5TOOLS_DUMP_MAX_RANK]; + int ndims = H5Sget_simple_extent_dims(space, size, maxsize); + H5S_class_t space_type = H5Sget_simple_extent_type(space); + int i; + + + switch(space_type) { + case H5S_SCALAR: + /* scalar dataspace */ + h5tools_str_append(buffer, "%s %s", h5tools_dump_header_format->dataspacedescriptionbegin, S_SCALAR); + break; + + case H5S_SIMPLE: + /* simple dataspace */ + h5tools_str_append(buffer, "%s %s { %s %" H5_PRINTF_LL_WIDTH "u", + h5tools_dump_header_format->dataspacedescriptionbegin, S_SIMPLE, + h5tools_dump_header_format->dataspacedimbegin, size[0]); + + for(i = 1; i < ndims; i++) + h5tools_str_append(buffer, ", %" H5_PRINTF_LL_WIDTH "u", size[i]); + + h5tools_str_append(buffer, " %s / ", h5tools_dump_header_format->dataspacedimend); + + if(maxsize[0] == H5S_UNLIMITED) + h5tools_str_append(buffer, "%s %s", + h5tools_dump_header_format->dataspacedimbegin, "H5S_UNLIMITED"); + else + h5tools_str_append(buffer, "%s %" H5_PRINTF_LL_WIDTH "u", + h5tools_dump_header_format->dataspacedimbegin, maxsize[0]); + + for(i = 1; i < ndims; i++) + if(maxsize[i] == H5S_UNLIMITED) + h5tools_str_append(buffer, ", %s", "H5S_UNLIMITED"); + else + h5tools_str_append(buffer, ", %" H5_PRINTF_LL_WIDTH "u", maxsize[i]); + + h5tools_str_append(buffer, " %s }", h5tools_dump_header_format->dataspacedimend); + break; + + case H5S_NULL: + /* null dataspace */ + h5tools_str_append(buffer, "%s %s", h5tools_dump_header_format->dataspacedescriptionbegin, S_NULL); + break; + + case H5S_NO_CLASS: + default: + h5tools_str_append(buffer, "%s unknown dataspace %s\n", BEGIN, END); + break; + } /* end switch */ +} + + +/*------------------------------------------------------------------------- + * Function: print_enum + * + * Purpose: prints the enum data + * + * Return: void + * + * In/Out: h5tools_str_t *buffer + * h5tools_context_t *ctx + * + *-----------------------------------------------------------------------*/ +void +h5tools_print_enum(h5tools_str_t *buffer, const h5tool_format_t *info, + h5tools_context_t *ctx, hid_t type) +{ + char **name = NULL; /*member names */ + unsigned char *value = NULL; /*value array */ + unsigned char *copy = NULL; /*a pointer to value array */ + unsigned nmembs; /*number of members */ + int nchars; /*number of output characters */ + hid_t super; /*enum base integer type */ + hid_t native = -1; /*native integer datatype */ + size_t dst_size; /*destination value type size */ + unsigned i; + + nmembs = H5Tget_nmembers(type); + assert(nmembs > 0); + super = H5Tget_super(type); + + /* + * Determine what datatype to use for the native values. To simplify + * things we entertain three possibilities: + * 1. long long -- the largest native signed integer + * 2. unsigned long long -- the largest native unsigned integer + * 3. raw format + */ + if (H5Tget_size(type) <= sizeof(long long)) { + dst_size = sizeof(long long); + + if (H5T_SGN_NONE == H5Tget_sign(type)) { + native = H5T_NATIVE_ULLONG; + } + else { + native = H5T_NATIVE_LLONG; + } + } + else { + dst_size = H5Tget_size(type); + } + + /* Get the names and raw values of all members */ + name = calloc(nmembs, sizeof(char *)); + value = calloc(nmembs, MAX(H5Tget_size(type), dst_size)); + + for (i = 0; i < nmembs; i++) { + name[i] = H5Tget_member_name(type, i); + H5Tget_member_value(type, i, value + i * H5Tget_size(type)); + } + + /* Convert values to native datatype */ + if (native > 0) + H5Tconvert(super, native, nmembs, value, NULL, H5P_DEFAULT); + + /* + * Sort members by increasing value + * ***not implemented yet*** + */ + + /* Print members */ + for (i = 0; i < nmembs; i++) { + h5tools_str_append(buffer, "\"%s\"", name[i]); + nchars = strlen(name[i]); + h5tools_str_append(buffer, "%*s ", MAX(0, 16 - nchars), ""); + + if (native < 0) { + size_t j; + + h5tools_str_append(buffer, "0x"); + + for (j = 0; j < dst_size; j++) + h5tools_str_append(buffer, "%02x", value[i * dst_size + j]); + } + else if (H5T_SGN_NONE == H5Tget_sign(native)) { + /*On SGI Altix(cobalt), wrong values were printed out with "value+i*dst_size" + *strangely, unless use another pointer "copy".*/ + copy = value + i * dst_size; + h5tools_str_append(buffer, "%" H5_PRINTF_LL_WIDTH "u", *((unsigned long long *) ((void *) copy))); + } + else { + /*On SGI Altix(cobalt), wrong values were printed out with "value+i*dst_size" + *strangely, unless use another pointer "copy".*/ + copy = value + i * dst_size; + h5tools_str_append(buffer, "%" H5_PRINTF_LL_WIDTH "d", *((long long *) ((void *) copy))); + } + + h5tools_str_append(buffer, ";\n"); + } + + /* Release resources */ + for (i = 0; i < nmembs; i++) + free(name[i]); + + free(name); + free(value); + H5Tclose(super); + + if (0 == nmembs) + h5tools_str_append(buffer, "\n<empty>"); +} + +/*------------------------------------------------------------------------- + * Function: dump_datatype + * + * Purpose: Dump the datatype. Datatype can be HDF5 predefined + * atomic datatype or committed/transient datatype. * + * Return: void + * + * In/Out: h5tools_context_t *ctx *------------------------------------------------------------------------- */ -void init_acc_pos(h5tools_context_t *ctx, hsize_t *dims) +void +h5tools_dump_datatype(FILE *stream, const h5tool_format_t *info, + h5tools_context_t *ctx, hid_t type) { - int i; + size_t ncols = 80; /* available output width */ + h5tools_str_t buffer; /* string into which to render */ + hsize_t curr_pos; /* total data element position */ + hsize_t elmt_counter = 0;/* counts the # elements printed.*/ + + /* setup */ + HDmemset(&buffer, 0, sizeof(h5tools_str_t)); + + if (info->line_ncols > 0) + ncols = info->line_ncols; + + /* pass to the prefix in h5tools_simple_prefix the total position + * instead of the current stripmine position i; this is necessary + * to print the array indices + */ + curr_pos = ctx->sm_pos; + + h5tools_simple_prefix(stream, info, ctx, curr_pos, 0); + /* Render the element */ + h5tools_str_reset(&buffer); + + ctx->indent_level++; + h5tools_str_append(&buffer, "%s %s ", + h5tools_dump_header_format->datatypebegin, + h5tools_dump_header_format->datatypeblockbegin); - assert(ctx->ndims); + h5tools_print_datatype(&buffer, info, ctx, type); - ctx->acc[ctx->ndims-1]=1; - for(i=(ctx->ndims-2); i>=0; i--) - { - ctx->acc[i]=ctx->acc[i+1] * dims[i+1]; - } - for ( i = 0; i < ctx->ndims; i++) - ctx->pos[i]=0; + if (HDstrlen(h5tools_dump_header_format->datatypeblockend)) { + h5tools_str_append(&buffer, "%s", h5tools_dump_header_format->datatypeblockend); + if (HDstrlen(h5tools_dump_header_format->datatypeend)) + h5tools_str_append(&buffer, " "); + } + if (HDstrlen(h5tools_dump_header_format->datatypeend)) + h5tools_str_append(&buffer, "%s", h5tools_dump_header_format->datatypeend); + h5tools_str_append(&buffer, "\n"); + + curr_pos = h5tools_render_element(stream, info, ctx, &buffer, curr_pos, + ncols, &elmt_counter, 0); + + ctx->need_prefix = TRUE; + ctx->indent_level--; } +/*------------------------------------------------------------------------- + * Function: init_acc_pos + * + * Purpose: initialize accumulator and matrix position + * + * Return: void + *------------------------------------------------------------------------- + */ +void +init_acc_pos(h5tools_context_t *ctx, hsize_t *dims) +{ + int i; + + assert(ctx->ndims); + + ctx->acc[ctx->ndims - 1] = 1; + for (i = (ctx->ndims - 2); i >= 0; i--) { + ctx->acc[i] = ctx->acc[i + 1] * dims[i + 1]; + } + for (i = 0; i < ctx->ndims; i++) + ctx->pos[i] = 0; +} /*------------------------------------------------------------------------- * Function: do_bin_output @@ -1514,35 +3209,26 @@ void init_acc_pos(h5tools_context_t *ctx, hsize_t *dims) * * Return: Success: SUCCEED * Failure: FAIL - * - * Programmer: Pedro Vicente Nunes - * Friday, June 2, 2006 - * - * Modifications: - * *------------------------------------------------------------------------- */ static int do_bin_output(FILE *stream, hsize_t nelmts, hid_t tid, void *_mem) { - unsigned char *mem = (unsigned char*)_mem; - size_t size; /* datum size */ - hsize_t i; /* element counter */ - - size = H5Tget_size(tid); - - for (i = 0; i < nelmts; i++) - { - if (render_bin_output(stream,tid,mem + i * size)<0) - { - printf("\nError in writing binary stream\n"); - return FAIL; - } - } - - return SUCCEED; -} + unsigned char *mem = (unsigned char*)_mem; + size_t size; /* datum size */ + hsize_t i; /* element counter */ + + size = H5Tget_size(tid); + for (i = 0; i < nelmts; i++) { + if (render_bin_output(stream, tid, mem + i * size) < 0) { + printf("\nError in writing binary stream\n"); + return FAIL; + } + } + + return SUCCEED; +} /*------------------------------------------------------------------------- * Function: render_bin_output @@ -1551,395 +3237,368 @@ int do_bin_output(FILE *stream, hsize_t nelmts, hid_t tid, void *_mem) * * Return: Success: SUCCEED * Failure: FAIL - * - * Programmer: Pedro Vicente Nunes - * Friday, June 2, 2006 - * - * Modifications: - * *------------------------------------------------------------------------- */ -static -int render_bin_output(FILE *stream, hid_t tid, void *_mem) +static int +render_bin_output(FILE *stream, hid_t tid, void *_mem) { - unsigned char *mem = (unsigned char*)_mem; - size_t size; /* datum size */ - float tempfloat; - double tempdouble; - unsigned long long tempullong; - long long templlong; - unsigned long tempulong; - long templong; - unsigned int tempuint; - int tempint; - unsigned short tempushort; - short tempshort; - unsigned char tempuchar; - char tempschar; + unsigned char *mem = (unsigned char*)_mem; + size_t size; /* datum size */ + float tempfloat; + double tempdouble; + unsigned long long tempullong; + long long templlong; + unsigned long tempulong; + long templong; + unsigned int tempuint; + int tempint; + unsigned short tempushort; + short tempshort; + unsigned char tempuchar; + char tempschar; #if H5_SIZEOF_LONG_DOUBLE !=0 - long double templdouble; + long double templdouble; #endif #ifdef DEBUG_H5DUMP_BIN - static char fmt_llong[8], fmt_ullong[8]; - if (!fmt_llong[0]) { - sprintf(fmt_llong, "%%%sd", H5_PRINTF_LL_WIDTH); - sprintf(fmt_ullong, "%%%su", H5_PRINTF_LL_WIDTH); - } + static char fmt_llong[8], fmt_ullong[8]; + if (!fmt_llong[0]) { + sprintf(fmt_llong, "%%%sd", H5_PRINTF_LL_WIDTH); + sprintf(fmt_ullong, "%%%su", H5_PRINTF_LL_WIDTH); + } #endif - size = H5Tget_size(tid); + size = H5Tget_size(tid); - if (H5Tequal(tid, H5T_NATIVE_FLOAT)) - { - memcpy(&tempfloat, mem, sizeof(float)); + if (H5Tequal(tid, H5T_NATIVE_FLOAT)) { + memcpy(&tempfloat, mem, sizeof(float)); #ifdef DEBUG_H5DUMP_BIN - fprintf(stream, "%g ", tempfloat); + fprintf(stream, "%g ", tempfloat); #else - if (1 != fwrite(&tempfloat, size, 1, stream)) - return FAIL; + if (1 != fwrite(&tempfloat, size, 1, stream)) + return FAIL; #endif - } - else if (H5Tequal(tid, H5T_NATIVE_DOUBLE)) - { - memcpy(&tempdouble, mem, sizeof(double)); + } + else if (H5Tequal(tid, H5T_NATIVE_DOUBLE)) { + memcpy(&tempdouble, mem, sizeof(double)); #ifdef DEBUG_H5DUMP_BIN - fprintf(stream, "%g ", tempdouble); + fprintf(stream, "%g ", tempdouble); #else - if (1 != fwrite(&tempdouble, size, 1, stream)) - return FAIL; + if (1 != fwrite(&tempdouble, size, 1, stream)) + return FAIL; #endif - } + } #if H5_SIZEOF_LONG_DOUBLE !=0 - else if (H5Tequal(tid, H5T_NATIVE_LDOUBLE)) - { - memcpy(&templdouble, mem, sizeof(long double)); + else if (H5Tequal(tid, H5T_NATIVE_LDOUBLE)) { + memcpy(&templdouble, mem, sizeof(long double)); #ifdef DEBUG_H5DUMP_BIN - fprintf(stream, "%Lf ", templdouble); + fprintf(stream, "%Lf ", templdouble); #else - if (1 != fwrite(&templdouble, size, 1, stream)) - return FAIL; + if (1 != fwrite(&templdouble, size, 1, stream)) + return FAIL; #endif - } + } #endif - else if (H5T_STRING == H5Tget_class(tid)) - { - unsigned int i; - H5T_str_t pad; - char *s; - - pad = H5Tget_strpad(tid); - - if(H5Tis_variable_str(tid)) - { - s = *(char**)mem; - if(s!=NULL) - size = HDstrlen(s); - } - else - { - s = (char *)mem; - size = H5Tget_size(tid); - } - for (i=0; i<size && (s[i] || pad!=H5T_STR_NULLTERM); i++) - { - memcpy(&tempuchar, &s[i], sizeof(unsigned char)); + else if (H5T_STRING == H5Tget_class(tid)) { + unsigned int i; + H5T_str_t pad; + char *s; + + pad = H5Tget_strpad(tid); + + if (H5Tis_variable_str(tid)) { + s = *(char**) mem; + if (s != NULL) + size = HDstrlen(s); + } + else { + s = (char *) mem; + size = H5Tget_size(tid); + } + for (i = 0; i < size && (s[i] || pad != H5T_STR_NULLTERM); i++) { + memcpy(&tempuchar, &s[i], sizeof(unsigned char)); #ifdef DEBUG_H5DUMP_BIN - fprintf(stream, "%d", tempuchar); + fprintf(stream, "%d", tempuchar); #else - if (1 != fwrite(&tempuchar, size, 1, stream)) - return FAIL; + if (1 != fwrite(&tempuchar, size, 1, stream)) + return FAIL; #endif - } /* i */ - } - else if (H5Tequal(tid, H5T_NATIVE_INT)) - { - memcpy(&tempint, mem, sizeof(int)); + } /* i */ + } + else if (H5Tequal(tid, H5T_NATIVE_INT)) { + memcpy(&tempint, mem, sizeof(int)); #ifdef DEBUG_H5DUMP_BIN - fprintf(stream, "%d ", tempint); + fprintf(stream, "%d ", tempint); #else - if (1 != fwrite(&tempint, size, 1, stream)) - return FAIL; + if (1 != fwrite(&tempint, size, 1, stream)) + return FAIL; #endif - } - else if (H5Tequal(tid, H5T_NATIVE_UINT)) - { - memcpy(&tempuint, mem, sizeof(unsigned int)); + } + else if (H5Tequal(tid, H5T_NATIVE_UINT)) { + memcpy(&tempuint, mem, sizeof(unsigned int)); #ifdef DEBUG_H5DUMP_BIN - fprintf(stream, "%u ", tempuint); + fprintf(stream, "%u ", tempuint); #else - if (1 != fwrite(&tempuint, size, 1, stream)) - return FAIL; + if (1 != fwrite(&tempuint, size, 1, stream)) + return FAIL; #endif - } - else if (H5Tequal(tid, H5T_NATIVE_SCHAR)) - { - memcpy(&tempschar, mem, sizeof(char)); + } + else if (H5Tequal(tid, H5T_NATIVE_SCHAR)) { + memcpy(&tempschar, mem, sizeof(char)); #ifdef DEBUG_H5DUMP_BIN - fprintf(stream, "%d ", tempschar); + fprintf(stream, "%d ", tempschar); #else - if (1 != fwrite(&tempschar, size, 1, stream)) - return FAIL; + if (1 != fwrite(&tempschar, size, 1, stream)) + return FAIL; #endif - } - else if (H5Tequal(tid, H5T_NATIVE_UCHAR)) - { - memcpy(&tempuchar, mem, sizeof(unsigned char)); + } + else if (H5Tequal(tid, H5T_NATIVE_UCHAR)) { + memcpy(&tempuchar, mem, sizeof(unsigned char)); #ifdef DEBUG_H5DUMP_BIN - fprintf(stream, "%u ", tempuchar); + fprintf(stream, "%u ", tempuchar); #else - if (1 != fwrite(&tempuchar, size, 1, stream)) - return FAIL; + if (1 != fwrite(&tempuchar, size, 1, stream)) + return FAIL; #endif - } - else if (H5Tequal(tid, H5T_NATIVE_SHORT)) - { - memcpy(&tempshort, mem, sizeof(short)); + } + else if (H5Tequal(tid, H5T_NATIVE_SHORT)) { + memcpy(&tempshort, mem, sizeof(short)); #ifdef DEBUG_H5DUMP_BIN - fprintf(stream, "%d ", tempshort); + fprintf(stream, "%d ", tempshort); #else - if (1 != fwrite(&tempshort, size, 1, stream)) - return FAIL; + if (1 != fwrite(&tempshort, size, 1, stream)) + return FAIL; #endif - } - else if (H5Tequal(tid, H5T_NATIVE_USHORT)) - { - memcpy(&tempushort, mem, sizeof(unsigned short)); + } + else if (H5Tequal(tid, H5T_NATIVE_USHORT)) { + memcpy(&tempushort, mem, sizeof(unsigned short)); #ifdef DEBUG_H5DUMP_BIN - fprintf(stream, "%u ", tempushort); + fprintf(stream, "%u ", tempushort); #else - if (1 != fwrite(&tempushort, size, 1, stream)) - return FAIL; + if (1 != fwrite(&tempushort, size, 1, stream)) + return FAIL; #endif - } - else if (H5Tequal(tid, H5T_NATIVE_LONG)) - { - memcpy(&templong, mem, sizeof(long)); + } + else if (H5Tequal(tid, H5T_NATIVE_LONG)) { + memcpy(&templong, mem, sizeof(long)); #ifdef DEBUG_H5DUMP_BIN - fprintf(stream, "%ld ", templong); + fprintf(stream, "%ld ", templong); #else - if (1 != fwrite(&templong, size, 1, stream)) - return FAIL; + if (1 != fwrite(&templong, size, 1, stream)) + return FAIL; #endif - } - else if (H5Tequal(tid, H5T_NATIVE_ULONG)) - { - memcpy(&tempulong, mem, sizeof(unsigned long)); + } + else if (H5Tequal(tid, H5T_NATIVE_ULONG)) { + memcpy(&tempulong, mem, sizeof(unsigned long)); #ifdef DEBUG_H5DUMP_BIN - fprintf(stream, "%lu ", tempulong); + fprintf(stream, "%lu ", tempulong); #else - if (1 != fwrite(&tempulong, size, 1, stream)) - return FAIL; + if (1 != fwrite(&tempulong, size, 1, stream)) + return FAIL; #endif - } - else if (H5Tequal(tid, H5T_NATIVE_LLONG)) - { - memcpy(&templlong, mem, sizeof(long long)); + } + else if (H5Tequal(tid, H5T_NATIVE_LLONG)) { + memcpy(&templlong, mem, sizeof(long long)); #ifdef DEBUG_H5DUMP_BIN - fprintf(stream, fmt_llong, templlong); + fprintf(stream, fmt_llong, templlong); #else - if (1 != fwrite(&templlong, size, 1, stream)) - return FAIL; + if (1 != fwrite(&templlong, size, 1, stream)) + return FAIL; #endif - } - else if (H5Tequal(tid, H5T_NATIVE_ULLONG)) - { - memcpy(&tempullong, mem, sizeof(unsigned long long)); + } + else if (H5Tequal(tid, H5T_NATIVE_ULLONG)) { + memcpy(&tempullong, mem, sizeof(unsigned long long)); #ifdef DEBUG_H5DUMP_BIN - fprintf(stream, fmt_ullong, tempullong); + fprintf(stream, fmt_ullong, tempullong); #else - if (1 != fwrite(&tempullong, size, 1, stream)) - return FAIL; + if (1 != fwrite(&tempullong, size, 1, stream)) + return FAIL; #endif - } - else if (H5Tequal(tid, H5T_NATIVE_HSSIZE)) - { - if (sizeof(hssize_t) == sizeof(int)) - { - memcpy(&tempint, mem, sizeof(int)); + } + else if (H5Tequal(tid, H5T_NATIVE_HSSIZE)) { + if (sizeof(hssize_t) == sizeof(int)) { + memcpy(&tempint, mem, sizeof(int)); #ifdef DEBUG_H5DUMP_BIN - fprintf(stream, "%d ", tempint); + fprintf(stream, "%d ", tempint); #else - if (1 != fwrite(&tempint, size, 1, stream)) - return FAIL; + if (1 != fwrite(&tempint, size, 1, stream)) + return FAIL; #endif - } - else if (sizeof(hssize_t) == sizeof(long)) - { - memcpy(&templong, mem, sizeof(long)); + } + else if (sizeof(hssize_t) == sizeof(long)) { + memcpy(&templong, mem, sizeof(long)); #ifdef DEBUG_H5DUMP_BIN - fprintf(stream, "%ld ", templong); + fprintf(stream, "%ld ", templong); #else - if (1 != fwrite(&templong, size, 1, stream)) - return FAIL; + if (1 != fwrite(&templong, size, 1, stream)) + return FAIL; #endif - } - else - { - memcpy(&templlong, mem, sizeof(long long)); + } + else { + memcpy(&templlong, mem, sizeof(long long)); #ifdef DEBUG_H5DUMP_BIN - fprintf(stream, fmt_llong, templlong); + fprintf(stream, fmt_llong, templlong); #else - if (1 != fwrite(&templlong, size, 1, stream)) - return FAIL; + if (1 != fwrite(&templlong, size, 1, stream)) + return FAIL; #endif - } - } - else if (H5Tequal(tid, H5T_NATIVE_HSIZE)) - { - if (sizeof(hsize_t) == sizeof(int)) - { - memcpy(&tempuint, mem, sizeof(unsigned int)); + } + } + else if (H5Tequal(tid, H5T_NATIVE_HSIZE)) { + if (sizeof(hsize_t) == sizeof(int)) { + memcpy(&tempuint, mem, sizeof(unsigned int)); #ifdef DEBUG_H5DUMP_BIN - fprintf(stream, "%u ", tempuint); + fprintf(stream, "%u ", tempuint); #else - if (1 != fwrite(&tempuint, size, 1, stream)) - return FAIL; + if (1 != fwrite(&tempuint, size, 1, stream)) + return FAIL; #endif - } - else if (sizeof(hsize_t) == sizeof(long)) - { - memcpy(&tempulong, mem, sizeof(unsigned long)); + } + else if (sizeof(hsize_t) == sizeof(long)) { + memcpy(&tempulong, mem, sizeof(unsigned long)); #ifdef DEBUG_H5DUMP_BIN - fprintf(stream, "%lu ", tempulong); + fprintf(stream, "%lu ", tempulong); #else - if (1 != fwrite(&tempulong, size, 1, stream)) - return FAIL; + if (1 != fwrite(&tempulong, size, 1, stream)) + return FAIL; #endif - } - else - { - memcpy(&tempullong, mem, sizeof(unsigned long long)); + } + else { + memcpy(&tempullong, mem, sizeof(unsigned long long)); #ifdef DEBUG_H5DUMP_BIN - fprintf(stream, fmt_ullong, tempullong); + fprintf(stream, fmt_ullong, tempullong); #else - if (1 != fwrite(&tempullong, size, 1, stream)) - return FAIL; + if (1 != fwrite(&tempullong, size, 1, stream)) + return FAIL; #endif - } - } - else if (H5Tget_class(tid) == H5T_COMPOUND) - { - unsigned j; - hid_t memb; - unsigned nmembs; - size_t offset; - - nmembs = H5Tget_nmembers(tid); - - for (j = 0; j < nmembs; j++) - { - offset = H5Tget_member_offset(tid, j); - memb = H5Tget_member_type(tid, j); - - if (render_bin_output(stream,memb,mem + offset)<0) - return FAIL; - - H5Tclose(memb); - } - } - else if (H5Tget_class(tid) == H5T_ENUM) - { - unsigned int i; - if (1==size) - { + } + } + else if (H5Tget_class(tid) == H5T_COMPOUND) { + unsigned j; + hid_t memb; + unsigned nmembs; + size_t offset; + + nmembs = H5Tget_nmembers(tid); + + for (j = 0; j < nmembs; j++) { + offset = H5Tget_member_offset(tid, j); + memb = H5Tget_member_type(tid, j); + + if (render_bin_output(stream, memb, mem + offset) < 0) + return FAIL; + + H5Tclose(memb); + } + } + else if (H5Tget_class(tid) == H5T_ENUM) { + unsigned int i; + if (1 == size) { #ifdef DEBUG_H5DUMP_BIN - fprintf(stream, "0x%02x", mem[0]); + fprintf(stream, "0x%02x", mem[0]); #else - if (1 != fwrite(&mem[0], size, 1, stream)) - return FAIL; + if (1 != fwrite(&mem[0], size, 1, stream)) + return FAIL; #endif - } - else - { - for (i = 0; i < size; i++) - { + } + else { + for (i = 0; i < size; i++) { #ifdef DEBUG_H5DUMP_BIN - fprintf(stream, "%s%02x", i?":":"", mem[i]); + fprintf(stream, "%s%02x", i?":":"", mem[i]); #else - if (1 != fwrite(&mem[i], sizeof(char), 1, stream)) - return FAIL; + if (1 != fwrite(&mem[i], sizeof(char), 1, stream)) + return FAIL; #endif - } /*i*/ - }/*else 1 */ - } - else if (H5Tget_class(tid) == H5T_ARRAY) - { - int k, ndims; - hsize_t i, dims[H5S_MAX_RANK], temp_nelmts, nelmts; - hid_t memb; - - /* get the array's base datatype for each element */ - memb = H5Tget_super(tid); - size = H5Tget_size(memb); - ndims = H5Tget_array_ndims(tid); - H5Tget_array_dims2(tid, dims); - assert(ndims >= 1 && ndims <= H5S_MAX_RANK); - - /* calculate the number of array elements */ - for (k = 0, nelmts = 1; k < ndims; k++) - { - temp_nelmts = nelmts; - temp_nelmts *= dims[k]; - nelmts = (size_t)temp_nelmts; - } - - /* dump the array element */ - for (i = 0; i < nelmts; i++) - { - if (render_bin_output(stream,memb,mem + i * size)<0) - return FAIL; - } - - H5Tclose(memb); - } - else if (H5Tget_class(tid) == H5T_VLEN) - { - unsigned int i; - hsize_t nelmts; - hid_t memb; - - /* get the VL sequences's base datatype for each element */ - memb = H5Tget_super(tid); - size = H5Tget_size(memb); - - /* Get the number of sequence elements */ - nelmts = ((hvl_t *)mem)->len; - - for (i = 0; i < nelmts; i++) - { - /* dump the array element */ - if (render_bin_output(stream,memb,((char *)(((hvl_t *)mem)->p)) + i * size)<0) - return FAIL; - } - H5Tclose(memb); - } - else - { - size_t i; - if (1==size) - { + } /*i*/ + }/*else 1 */ + } + else if (H5Tget_class(tid) == H5T_ARRAY) { + int k, ndims; + hsize_t i, dims[H5S_MAX_RANK], temp_nelmts, nelmts; + hid_t memb; + + /* get the array's base datatype for each element */ + memb = H5Tget_super(tid); + size = H5Tget_size(memb); + ndims = H5Tget_array_ndims(tid); + H5Tget_array_dims2(tid, dims); + assert(ndims >= 1 && ndims <= H5S_MAX_RANK); + + /* calculate the number of array elements */ + for (k = 0, nelmts = 1; k < ndims; k++) { + temp_nelmts = nelmts; + temp_nelmts *= dims[k]; + nelmts = (size_t) temp_nelmts; + } + + /* dump the array element */ + for (i = 0; i < nelmts; i++) { + if (render_bin_output(stream, memb, mem + i * size) < 0) + return FAIL; + } + + H5Tclose(memb); + } + else if (H5Tget_class(tid) == H5T_VLEN) { + unsigned int i; + hsize_t nelmts; + hid_t memb; + + /* get the VL sequences's base datatype for each element */ + memb = H5Tget_super(tid); + size = H5Tget_size(memb); + + /* Get the number of sequence elements */ + nelmts = ((hvl_t *) mem)->len; + + for (i = 0; i < nelmts; i++) { + /* dump the array element */ + if (render_bin_output(stream, memb, ((char *) (((hvl_t *) mem)->p)) + i * size) < 0) + return FAIL; + } + H5Tclose(memb); + } + else { + size_t i; + if (1 == size) { #ifdef DEBUG_H5DUMP_BIN - fprintf(stream, "0x%02x", mem[0]); + fprintf(stream, "0x%02x", mem[0]); #else - if (1 != fwrite(&mem[0], size, 1, stream)) - return FAIL; + if (1 != fwrite(&mem[0], size, 1, stream)) + return FAIL; #endif - } - else - { - for (i = 0; i < size; i++) - { + } + else { + for (i = 0; i < size; i++) { #ifdef DEBUG_H5DUMP_BIN - fprintf(stream, "%s%02x", i?":":"", mem[i]); + fprintf(stream, "%s%02x", i?":":"", mem[i]); #else - if (1 != fwrite(&mem[i], sizeof(char), 1, stream)) - return FAIL; + if (1 != fwrite(&mem[i], sizeof(char), 1, stream)) + return FAIL; #endif - } /*i*/ - }/*else 1 */ - } + } /*i*/ + }/*else 1 */ + } + + return SUCCEED; +} + +/*------------------------------------------------------------------------- + * Function: h5tools_is_zero + * + * Purpose: Determines if memory is initialized to all zero bytes. + * + * Return: TRUE if all bytes are zero; FALSE otherwise + *------------------------------------------------------------------------- + */ +static +hbool_t h5tools_is_zero(const void *_mem, size_t size) +{ + const unsigned char *mem = (const unsigned char *) _mem; + while (size-- > 0) + if (mem[size]) + return FALSE; - return SUCCEED; + return TRUE; } diff --git a/tools/lib/h5tools.h b/tools/lib/h5tools.h index fb24f76..bc29009 100644 --- a/tools/lib/h5tools.h +++ b/tools/lib/h5tools.h @@ -50,6 +50,147 @@ /* format for hsize_t */ #define HSIZE_T_FORMAT "%"H5_PRINTF_LL_WIDTH"u" +#define H5TOOLS_DUMP_MAX_RANK H5S_MAX_RANK + +/* + * Strings for output - these were duplicated from the h5dump.h + * file in order to support region reference data display + */ +#define ATTRIBUTE "ATTRIBUTE" +#define BLOCK "BLOCK" +#define SUPER_BLOCK "SUPER_BLOCK" +#define COMPRESSION "COMPRESSION" +#define CONCATENATOR "//" +#define COMPLEX "COMPLEX" +#define COUNT "COUNT" +#define CSET "CSET" +#define CTYPE "CTYPE" +#define DATA "DATA" +#define DATASPACE "DATASPACE" +#define EXTERNAL "EXTERNAL" +#define FILENO "FILENO" +#define HARDLINK "HARDLINK" +#define NLINK "NLINK" +#define OBJID "OBJECTID" +#define OBJNO "OBJNO" +#define S_SCALAR "SCALAR" +#define S_SIMPLE "SIMPLE" +#define S_NULL "NULL" +#define SOFTLINK "SOFTLINK" +#define EXTLINK "EXTERNAL_LINK" +#define UDLINK "USERDEFINED_LINK" +#define START "START" +#define STRIDE "STRIDE" +#define STRSIZE "STRSIZE" +#define STRPAD "STRPAD" +#define SUBSET "SUBSET" +#define FILTERS "FILTERS" +#define DEFLATE "COMPRESSION DEFLATE" +#define DEFLATE_LEVEL "LEVEL" +#define SHUFFLE "PREPROCESSING SHUFFLE" +#define FLETCHER32 "CHECKSUM FLETCHER32" +#define SZIP "COMPRESSION SZIP" +#define NBIT "COMPRESSION NBIT" +#define SCALEOFFSET "COMPRESSION SCALEOFFSET" +#define SCALEOFFSET_MINBIT "MIN BITS" +#define STORAGE_LAYOUT "STORAGE_LAYOUT" +#define CONTIGUOUS "CONTIGUOUS" +#define COMPACT "COMPACT" +#define CHUNKED "CHUNKED" +#define EXTERNAL_FILE "EXTERNAL_FILE" +#define FILLVALUE "FILLVALUE" +#define FILE_CONTENTS "FILE_CONTENTS" + +#define BEGIN "{" +#define END "}" + +/* + * dump structure for output - this was duplicated from the h5dump.h + * file in order to support region reference data display + */ +typedef struct h5tools_dump_header_t { + const char *name; + const char *filebegin; + const char *fileend; + const char *bootblockbegin; + const char *bootblockend; + const char *groupbegin; + const char *groupend; + const char *datasetbegin; + const char *datasetend; + const char *attributebegin; + const char *attributeend; + const char *datatypebegin; + const char *datatypeend; + const char *dataspacebegin; + const char *dataspaceend; + const char *databegin; + const char *dataend; + const char *softlinkbegin; + const char *softlinkend; + const char *extlinkbegin; + const char *extlinkend; + const char *udlinkbegin; + const char *udlinkend; + const char *subsettingbegin; + const char *subsettingend; + const char *startbegin; + const char *startend; + const char *stridebegin; + const char *strideend; + const char *countbegin; + const char *countend; + const char *blockbegin; + const char *blockend; + + const char *fileblockbegin; + const char *fileblockend; + const char *bootblockblockbegin; + const char *bootblockblockend; + const char *groupblockbegin; + const char *groupblockend; + const char *datasetblockbegin; + const char *datasetblockend; + const char *attributeblockbegin; + const char *attributeblockend; + const char *datatypeblockbegin; + const char *datatypeblockend; + const char *dataspaceblockbegin; + const char *dataspaceblockend; + const char *datablockbegin; + const char *datablockend; + const char *softlinkblockbegin; + const char *softlinkblockend; + const char *extlinkblockbegin; + const char *extlinkblockend; + const char *udlinkblockbegin; + const char *udlinkblockend; + const char *strblockbegin; + const char *strblockend; + const char *enumblockbegin; + const char *enumblockend; + const char *structblockbegin; + const char *structblockend; + const char *vlenblockbegin; + const char *vlenblockend; + const char *subsettingblockbegin; + const char *subsettingblockend; + const char *startblockbegin; + const char *startblockend; + const char *strideblockbegin; + const char *strideblockend; + const char *countblockbegin; + const char *countblockend; + const char *blockblockbegin; + const char *blockblockend; + + const char *dataspacedescriptionbegin; + const char *dataspacedescriptionend; + const char *dataspacedimbegin; + const char *dataspacedimend; + +} h5tools_dump_header_t; + /* * Information about how to format output. */ @@ -373,11 +514,16 @@ struct subset_t { hsize_t *block; }; +/* The following include, h5tools_str.h, must be after the + * above stucts are defined. There is a dependency in the following + * include that hasn't been identified yet. */ + +#include "h5tools_str.h" + extern FILE *rawdatastream; /* output stream for raw data */ extern int bin_output; /* binary output */ extern int bin_form; /* binary form */ - - +extern int region_output; /* region output */ /* Strings for output */ #define H5_TOOLS_GROUP "GROUP" @@ -407,6 +553,19 @@ extern int h5tools_canreadf(const char* name, extern int h5tools_can_encode(H5Z_filter_t filtn); void init_acc_pos(h5tools_context_t *ctx, hsize_t *dims); - +/* + * new functions needed to display region reference data + */ +void h5tools_dump_datatype(FILE *stream, const h5tool_format_t *info, + h5tools_context_t *ctx/*in,out*/, hid_t type); +void h5tools_print_dataspace(h5tools_str_t *buffer/*in,out*/, + const h5tool_format_t *info, h5tools_context_t *ctx/*in,out*/, + hid_t space); +void h5tools_print_datatype(h5tools_str_t *buffer/*in,out*/, + const h5tool_format_t *info, h5tools_context_t *ctx/*in,out*/, + hid_t type); +void h5tools_print_enum(h5tools_str_t *buffer/*in,out*/, + const h5tool_format_t *info, h5tools_context_t *ctx/*in,out*/, + hid_t type); #endif /* H5TOOLS_H__ */ diff --git a/tools/lib/h5tools_str.c b/tools/lib/h5tools_str.c index 08ec5d7..200fa9e 100644 --- a/tools/lib/h5tools_str.c +++ b/tools/lib/h5tools_str.c @@ -29,7 +29,6 @@ #include "h5tools_ref.h" #include "h5tools_str.h" /*function prototypes */ - /* * If REPEAT_VERBOSE is defined then character strings will be printed so * that repeated character sequences like "AAAAAAAAAA" are displayed as @@ -47,7 +46,7 @@ #define STR_INIT_LEN 4096 /*initial length */ static char *h5tools_escape(char *s, size_t size); -static hbool_t h5tools_is_zero(const void *_mem, size_t size); +static hbool_t h5tools_str_is_zero(const void *_mem, size_t size); static void h5tools_print_char(h5tools_str_t *str, const h5tool_format_t *info, char ch); /*------------------------------------------------------------------------- @@ -161,7 +160,7 @@ h5tools_str_append(h5tools_str_t *str/*in,out*/, const char *fmt, ...) * something other than "%s" * Alocate at least twice as much space and try again. */ - size_t newsize = MAX(str->len+nchars+1, 2*str->nalloc); + size_t newsize = MAX(str->len + nchars + 1, 2 * str->nalloc); assert(newsize > str->nalloc); /*overflow*/ str->s = realloc(str->s, newsize); assert(str->s); @@ -198,9 +197,9 @@ char * h5tools_str_reset(h5tools_str_t *str/*in,out*/) { if (!str->s || str->nalloc <= 0) { - str->nalloc = STR_INIT_LEN; - str->s = malloc(str->nalloc); - assert(str->s); + str->nalloc = STR_INIT_LEN; + str->s = malloc(str->nalloc); + assert(str->s); } str->s[0] = '\0'; @@ -228,8 +227,8 @@ char * h5tools_str_trunc(h5tools_str_t *str/*in,out*/, size_t size) { if (size < str->len) { - str->len = size; - str->s[size] = '\0'; + str->len = size; + str->s[size] = '\0'; } return str->s; @@ -270,7 +269,7 @@ h5tools_str_fmt(h5tools_str_t *str/*in,out*/, size_t start, const char *fmt) */ if (strchr(fmt, '%')) { if (str->len - start + 1 > sizeof(_temp)) { - temp = malloc(str->len-start + 1); + temp = malloc(str->len - start + 1); assert(temp); } @@ -309,6 +308,59 @@ h5tools_str_prefix(h5tools_str_t *str/*in,out*/, const h5tool_format_t *info, hsize_t elmtno, unsigned ndims, hsize_t min_idx[], hsize_t max_idx[], h5tools_context_t *ctx) { + size_t i = 0; + hsize_t curr_pos = elmtno; + + h5tools_str_reset(str); + + if (ndims > 0) { + /* + * Calculate the number of elements represented by a unit change in a + * certain index position. + */ + for (i = 0; i < (size_t) ndims; i++) { + ctx->pos[i] = curr_pos / ctx->acc[i]; + curr_pos -= ctx->acc[i] * ctx->pos[i]; + } + assert(curr_pos == 0); + + /* Print the index values */ + for (i = 0; i < (size_t) ndims; i++) { + if (i) + h5tools_str_append(str, "%s", OPT(info->idx_sep, ",")); + + h5tools_str_append(str, OPT(info->idx_n_fmt, HSIZE_T_FORMAT), + (hsize_t) ctx->pos[i]); + + } + } + else { + /* Scalar */ + h5tools_str_append(str, OPT(info->idx_n_fmt, HSIZE_T_FORMAT), (hsize_t) 0); + } + + /* Add prefix and suffix to the index */ + return h5tools_str_fmt(str, 0, OPT(info->idx_fmt, "%s: ")); +} + +/*------------------------------------------------------------------------- + * Function: h5tools_str_region_prefix + * + * Purpose: Renders the line prefix value into string STR. Region reference specific. + * + * Return: Success: Pointer to the prefix. + * Failure: NULL + * + * In/Out: + * h5tools_context_t *ctx + * h5tools_str_t *str + *------------------------------------------------------------------------- + */ +char * +h5tools_str_region_prefix(h5tools_str_t *str, const h5tool_format_t *info, + hsize_t elmtno, hsize_t *ptdata, unsigned ndims, hsize_t min_idx[], hsize_t max_idx[], + h5tools_context_t *ctx) +{ hsize_t p_prod[H5S_MAX_RANK]; size_t i = 0; hsize_t curr_pos = elmtno; @@ -321,26 +373,26 @@ h5tools_str_prefix(h5tools_str_t *str/*in,out*/, const h5tool_format_t *info, * certain index position. */ for (i = ndims - 1, p_prod[ndims - 1] = 1; i > 0; --i) - p_prod[i - 1] = (max_idx[i] - min_idx[i]) * p_prod[i]; + p_prod[i - 1] = (max_idx[i]) * p_prod[i]; - for ( i = 0; i < (size_t)ndims; i++) { - ctx->pos[i] = curr_pos/ctx->acc[i]; - curr_pos -= ctx->acc[i]*ctx->pos[i]; + for (i = 0; i < (size_t) ndims; i++) { + ctx->pos[i] = curr_pos / p_prod[i]; + curr_pos -= p_prod[i] * ctx->pos[i]; + ctx->pos[i] += (unsigned long) ptdata[ctx->sm_pos+i]; } - assert( curr_pos == 0 ); /* Print the index values */ - for (i = 0; i < (size_t)ndims; i++) { + for (i = 0; i < (size_t) ndims; i++) { if (i) h5tools_str_append(str, "%s", OPT(info->idx_sep, ",")); - h5tools_str_append(str, OPT(info->idx_n_fmt, HSIZE_T_FORMAT), - (hsize_t)ctx->pos[i]); + h5tools_str_append(str, OPT(info->idx_n_fmt, HSIZE_T_FORMAT), (hsize_t) ctx->pos[i]); } - } else { + } /* if (ndims > 0) */ + else { /* Scalar */ - h5tools_str_append(str, OPT(info->idx_n_fmt, HSIZE_T_FORMAT), (hsize_t)0); + h5tools_str_append(str, OPT(info->idx_n_fmt, HSIZE_T_FORMAT), (hsize_t) 0); } /* Add prefix and suffix to the index */ @@ -348,103 +400,128 @@ h5tools_str_prefix(h5tools_str_t *str/*in,out*/, const h5tool_format_t *info, } /*------------------------------------------------------------------------- - * Function: h5tools_str_dump_region + * Function: h5tools_str_dump_region_blocks * * Purpose: Prints information about a dataspace region by appending - * the information to the specified string. - * - * Return: Success: 0 - * - * Failure: NULL - * - * Programmer: Robb Matzke - * Monday, June 7, 1999 - * - * Modifications: + * the information to the specified string. * + * Return: none + * + * In/Out: + * h5tools_context_t *ctx + * h5tools_str_t *str *------------------------------------------------------------------------- */ -int -h5tools_str_dump_region(h5tools_str_t *str, hid_t region, const h5tool_format_t *info) +void +h5tools_str_dump_region_blocks(h5tools_str_t *str, hid_t region, + const h5tool_format_t *info, h5tools_context_t *ctx) { - hssize_t nblocks, npoints; - hsize_t alloc_size; - hsize_t *ptdata; - int ndims = H5Sget_simple_extent_ndims(region); + hssize_t nblocks; + hsize_t alloc_size; + hsize_t *ptdata; + int ndims = H5Sget_simple_extent_ndims(region); /* - * These two functions fail if the region does not have blocks or points, - * respectively. They do not currently know how to translate from one to - * the other. + * This function fails if the region does not have blocks. */ H5E_BEGIN_TRY { nblocks = H5Sget_select_hyper_nblocks(region); - npoints = H5Sget_select_elem_npoints(region); } H5E_END_TRY; - h5tools_str_append(str, "{"); - /* Print block information */ if (nblocks > 0) { int i; + h5tools_str_append(str, "{"); + alloc_size = nblocks * ndims * 2 * sizeof(ptdata[0]); - assert(alloc_size == (hsize_t)((size_t)alloc_size)); /*check for overflow*/ - ptdata = malloc((size_t)alloc_size); + assert(alloc_size == (hsize_t) ((size_t) alloc_size)); /*check for overflow*/ + ptdata = malloc((size_t) alloc_size); H5_CHECK_OVERFLOW(nblocks, hssize_t, hsize_t); H5Sget_select_hyper_blocklist(region, (hsize_t)0, (hsize_t)nblocks, ptdata); for (i = 0; i < nblocks; i++) { int j; - h5tools_str_append(str, info->dset_blockformat_pre, - i ? "," OPTIONAL_LINE_BREAK " " : "", + h5tools_str_append(str, info->dset_blockformat_pre, i ? "," OPTIONAL_LINE_BREAK " " : "", (unsigned long)i); /* Start coordinates and opposite corner */ for (j = 0; j < ndims; j++) h5tools_str_append(str, "%s%lu", j ? "," : "(", - (unsigned long)ptdata[i * 2 * ndims + j]); + (unsigned long) ptdata[i * 2 * ndims + j]); for (j = 0; j < ndims; j++) h5tools_str_append(str, "%s%lu", j ? "," : ")-(", - (unsigned long)ptdata[i * 2 * ndims + j + ndims]); + (unsigned long) ptdata[i * 2 * ndims + j + ndims]); h5tools_str_append(str, ")"); } free(ptdata); - } + + h5tools_str_append(str, "}"); + } /* end if (nblocks > 0) */ +} + +/*------------------------------------------------------------------------- + * Function: h5tools_str_dump_region_points + * + * Purpose: Prints information about a dataspace region by appending + * the information to the specified string. + * + * Return: none + * + * In/Out: + * h5tools_context_t *ctx + * h5tools_str_t *str + *------------------------------------------------------------------------- + */ +void +h5tools_str_dump_region_points(h5tools_str_t *str, hid_t region, + const h5tool_format_t *info, h5tools_context_t *ctx) +{ + hssize_t npoints; + hsize_t alloc_size; + hsize_t *ptdata; + int ndims = H5Sget_simple_extent_ndims(region); + + /* + * This function fails if the region does not have points. + */ + H5E_BEGIN_TRY { + npoints = H5Sget_select_elem_npoints(region); + } H5E_END_TRY; /* Print point information */ if (npoints > 0) { int i; + h5tools_str_append(str, "{"); + alloc_size = npoints * ndims * sizeof(ptdata[0]); - assert(alloc_size == (hsize_t)((size_t)alloc_size)); /*check for overflow*/ - ptdata = malloc((size_t)alloc_size); - H5_CHECK_OVERFLOW(npoints,hssize_t,hsize_t); + assert(alloc_size == (hsize_t) ((size_t) alloc_size)); /*check for overflow*/ + ptdata = malloc((size_t) alloc_size); + H5_CHECK_OVERFLOW(npoints, hssize_t, hsize_t); H5Sget_select_elem_pointlist(region, (hsize_t)0, (hsize_t)npoints, ptdata); for (i = 0; i < npoints; i++) { int j; - h5tools_str_append(str, info->dset_ptformat_pre , - i ? "," OPTIONAL_LINE_BREAK " " : "", + h5tools_str_append(str, info->dset_ptformat_pre, i ? "," OPTIONAL_LINE_BREAK " " : "", (unsigned long)i); for (j = 0; j < ndims; j++) h5tools_str_append(str, "%s%lu", j ? "," : "(", - (unsigned long)(ptdata[i * ndims + j])); + (unsigned long) (ptdata[i * ndims + j])); h5tools_str_append(str, ")"); } free(ptdata); - } - h5tools_str_append(str, "}"); - return 0; + h5tools_str_append(str, "}"); + } /* end if (npoints > 0) */ } /*------------------------------------------------------------------------- @@ -454,11 +531,6 @@ h5tools_str_dump_region(h5tools_str_t *str, hid_t region, const h5tool_format_t * * Return: Nothing * - * Programmer: Bill Wendling - * Tuesday, 20. February 2001 - * - * Modifications: - * *------------------------------------------------------------------------- */ static void @@ -469,66 +541,66 @@ h5tools_print_char(h5tools_str_t *str, const h5tool_format_t *info, char ch) h5tools_str_append(str, "%%%02x", ch); else h5tools_str_append(str, "%c", ch); - } else { + } + else { switch (ch) { - case '"': - if (!info->do_escape) + case '"': + if (!info->do_escape) h5tools_str_append(str, "\""); - else + else h5tools_str_append(str, "\\\""); - break; - case '\\': - if (!info->do_escape) + break; + case '\\': + if (!info->do_escape) h5tools_str_append(str, "\\"); - else + else h5tools_str_append(str, "\\\\"); - break; - case '\b': - if (!info->do_escape) + break; + case '\b': + if (!info->do_escape) h5tools_str_append(str, "\b"); - else + else h5tools_str_append(str, "\\b"); - break; - case '\f': - if (!info->do_escape) - h5tools_str_append(str, "\f"); - else - h5tools_str_append(str, "\\f"); - break; - case '\n': - if (!info->do_escape) { - h5tools_str_append(str, "\n"); - h5tools_str_append(str, " "); - } - else + break; + case '\f': + if (!info->do_escape) + h5tools_str_append(str, "\f"); + else + h5tools_str_append(str, "\\f"); + break; + case '\n': + if (!info->do_escape) { + h5tools_str_append(str, "\n"); + h5tools_str_append(str, " "); + } + else h5tools_str_append(str, "\\n"); - break; - case '\r': - if (!info->do_escape) { - h5tools_str_append(str, "\r"); - h5tools_str_append(str, " "); - } - else + break; + case '\r': + if (!info->do_escape) { + h5tools_str_append(str, "\r"); + h5tools_str_append(str, " "); + } + else h5tools_str_append(str, "\\r"); - break; - case '\t': - if (!info->do_escape) - h5tools_str_append(str, "\t"); - else - h5tools_str_append(str, "\\t"); - break; - default: - if (isprint(ch)) - h5tools_str_append(str, "%c", ch); - else - h5tools_str_append(str, "\\%03o", ch); + break; + case '\t': + if (!info->do_escape) + h5tools_str_append(str, "\t"); + else + h5tools_str_append(str, "\\t"); + break; + default: + if (isprint(ch)) + h5tools_str_append(str, "%c", ch); + else + h5tools_str_append(str, "\\%03o", ch); - break; + break; } } } - /*------------------------------------------------------------------------- * Function: h5tools_str_sprint * @@ -592,7 +664,7 @@ h5tools_str_sprint(h5tools_str_t *str, const h5tool_format_t *info, hid_t contai int tempint; /* Build default formats for long long types */ - if(!fmt_llong[0]) { + if (!fmt_llong[0]) { sprintf(fmt_llong, "%%%sd", H5_PRINTF_LL_WIDTH); sprintf(fmt_ullong, "%%%su", H5_PRINTF_LL_WIDTH); } @@ -600,63 +672,70 @@ h5tools_str_sprint(h5tools_str_t *str, const h5tool_format_t *info, hid_t contai /* Append value depending on data type */ start = h5tools_str_len(str); - if(info->raw) { + if (info->raw) { size_t i; n = H5Tget_size(type); - if (1==n) { + if (1 == n) { h5tools_str_append(str, OPT(info->fmt_raw, "0x%02x"), ucp_vp[0]); - } else { - for(i = 0; i < n; i++) { - if(i) + } + else { + for (i = 0; i < n; i++) { + if (i) h5tools_str_append(str, ":"); h5tools_str_append(str, OPT(info->fmt_raw, "%02x"), ucp_vp[i]); } } - } else if (H5Tequal(type, H5T_NATIVE_FLOAT)) { - float tempfloat; + } + else if (H5Tequal(type, H5T_NATIVE_FLOAT)) { + float tempfloat; HDmemcpy(&tempfloat, vp, sizeof(float)); h5tools_str_append(str, OPT(info->fmt_float, "%g"), tempfloat); - } else if (H5Tequal(type, H5T_NATIVE_DOUBLE)) { - double tempdouble; + } + else if (H5Tequal(type, H5T_NATIVE_DOUBLE)) { + double tempdouble; HDmemcpy(&tempdouble, vp, sizeof(double)); h5tools_str_append(str, OPT(info->fmt_double, "%g"), tempdouble); #if H5_SIZEOF_LONG_DOUBLE !=0 - } else if (H5Tequal(type, H5T_NATIVE_LDOUBLE)) { - long double templdouble; + } + else if (H5Tequal(type, H5T_NATIVE_LDOUBLE)) { + long double templdouble; HDmemcpy(&templdouble, vp, sizeof(long double)); h5tools_str_append(str, "%Lf", templdouble); #endif - } else if (info->ascii && (H5Tequal(type, H5T_NATIVE_SCHAR) || - H5Tequal(type, H5T_NATIVE_UCHAR))) { - h5tools_print_char(str, info, (char)(*ucp_vp)); - } else if (H5T_STRING == H5Tget_class(type)) { + } + else if (info->ascii && (H5Tequal(type, H5T_NATIVE_SCHAR) || + H5Tequal(type, H5T_NATIVE_UCHAR))) { + h5tools_print_char(str, info, (char) (*ucp_vp)); + } + else if (H5T_STRING == H5Tget_class(type)) { unsigned int i; char quote = '\0'; char *s; quote = '\0'; - if(H5Tis_variable_str(type)) { + if (H5Tis_variable_str(type)) { /* cp_vp is the pointer into the struct where a `char*' is stored. So we have * to dereference the pointer to get the `char*' to pass to HDstrlen(). */ - s = *(char**)cp_vp; - if(s!=NULL) + s = *(char**) cp_vp; + if (s != NULL) size = HDstrlen(s); - } else { + } + else { s = cp_vp; size = H5Tget_size(type); } pad = H5Tget_strpad(type); /* Check for NULL pointer for string */ - if(s==NULL) { + if (s == NULL) { h5tools_str_append(str, "NULL"); } else { - for (i=0; i<size && (s[i] || pad!=H5T_STR_NULLTERM); i++) { + for (i = 0; i < size && (s[i] || pad != H5T_STR_NULLTERM); i++) { int j = 1; /* @@ -680,7 +759,8 @@ h5tools_str_sprint(h5tools_str_t *str, const h5tool_format_t *info, hid_t contai quote = '\''; h5tools_str_append(str, "%s%c", i ? " " : "", quote); - } else if (!quote) { + } + else if (!quote) { quote = '"'; h5tools_str_append(str, "%s%c", i ? " " : "", quote); } @@ -708,61 +788,78 @@ h5tools_str_sprint(h5tools_str_t *str, const h5tool_format_t *info, hid_t contai /*empty string*/ h5tools_str_append(str, "\"\""); } /* end else */ - } else if (H5Tequal(type, H5T_NATIVE_INT)) { + } + else if (H5Tequal(type, H5T_NATIVE_INT)) { HDmemcpy(&tempint, vp, sizeof(int)); h5tools_str_append(str, OPT(info->fmt_int, "%d"), tempint); - } else if (H5Tequal(type, H5T_NATIVE_UINT)) { + } + else if (H5Tequal(type, H5T_NATIVE_UINT)) { HDmemcpy(&tempuint, vp, sizeof(unsigned int)); h5tools_str_append(str, OPT(info->fmt_uint, "%u"), tempuint); - } else if (H5Tequal(type, H5T_NATIVE_SCHAR)) { + } + else if (H5Tequal(type, H5T_NATIVE_SCHAR)) { h5tools_str_append(str, OPT(info->fmt_schar, "%d"), *cp_vp); - } else if (H5Tequal(type, H5T_NATIVE_UCHAR)) { + } + else if (H5Tequal(type, H5T_NATIVE_UCHAR)) { h5tools_str_append(str, OPT(info->fmt_uchar, "%u"), *ucp_vp); - } else if (H5Tequal(type, H5T_NATIVE_SHORT)) { - short tempshort; + } + else if (H5Tequal(type, H5T_NATIVE_SHORT)) { + short tempshort; HDmemcpy(&tempshort, vp, sizeof(short)); h5tools_str_append(str, OPT(info->fmt_short, "%d"), tempshort); - } else if (H5Tequal(type, H5T_NATIVE_USHORT)) { - unsigned short tempushort; + } + else if (H5Tequal(type, H5T_NATIVE_USHORT)) { + unsigned short tempushort; HDmemcpy(&tempushort, vp, sizeof(unsigned short)); h5tools_str_append(str, OPT(info->fmt_ushort, "%u"), tempushort); - } else if (H5Tequal(type, H5T_NATIVE_LONG)) { + } + else if (H5Tequal(type, H5T_NATIVE_LONG)) { HDmemcpy(&templong, vp, sizeof(long)); h5tools_str_append(str, OPT(info->fmt_long, "%ld"), templong); - } else if (H5Tequal(type, H5T_NATIVE_ULONG)) { + } + else if (H5Tequal(type, H5T_NATIVE_ULONG)) { HDmemcpy(&tempulong, vp, sizeof(unsigned long)); h5tools_str_append(str, OPT(info->fmt_ulong, "%lu"), tempulong); - } else if (H5Tequal(type, H5T_NATIVE_LLONG)) { + } + else if (H5Tequal(type, H5T_NATIVE_LLONG)) { HDmemcpy(&templlong, vp, sizeof(long long)); h5tools_str_append(str, OPT(info->fmt_llong, fmt_llong), templlong); - } else if (H5Tequal(type, H5T_NATIVE_ULLONG)) { + } + else if (H5Tequal(type, H5T_NATIVE_ULLONG)) { HDmemcpy(&tempullong, vp, sizeof(unsigned long long)); h5tools_str_append(str, OPT(info->fmt_ullong, fmt_ullong), tempullong); - } else if (H5Tequal(type, H5T_NATIVE_HSSIZE)) { + } + else if (H5Tequal(type, H5T_NATIVE_HSSIZE)) { if (sizeof(hssize_t) == sizeof(int)) { memcpy(&tempint, vp, sizeof(int)); h5tools_str_append(str, OPT(info->fmt_int, "%d"), tempint); - } else if (sizeof(hssize_t) == sizeof(long)) { + } + else if (sizeof(hssize_t) == sizeof(long)) { memcpy(&templong, vp, sizeof(long)); h5tools_str_append(str, OPT(info->fmt_long, "%ld"), templong); - } else { + } + else { memcpy(&templlong, vp, sizeof(long long)); h5tools_str_append(str, OPT(info->fmt_llong, fmt_llong), templlong); } - } else if (H5Tequal(type, H5T_NATIVE_HSIZE)) { + } + else if (H5Tequal(type, H5T_NATIVE_HSIZE)) { if (sizeof(hsize_t) == sizeof(int)) { memcpy(&tempuint, vp, sizeof(unsigned int)); h5tools_str_append(str, OPT(info->fmt_uint, "%u"), tempuint); - } else if (sizeof(hsize_t) == sizeof(long)) { + } + else if (sizeof(hsize_t) == sizeof(long)) { memcpy(&tempulong, vp, sizeof(long)); h5tools_str_append(str, OPT(info->fmt_ulong, "%lu"), tempulong); - } else { + } + else { memcpy(&tempullong, vp, sizeof(unsigned long long)); h5tools_str_append(str, OPT(info->fmt_ullong, fmt_ullong), tempullong); } - } else if (H5Tget_class(type) == H5T_COMPOUND) { + } + else if (H5Tget_class(type) == H5T_COMPOUND) { unsigned j; nmembs = H5Tget_nmembers(type); @@ -797,7 +894,7 @@ h5tools_str_sprint(h5tools_str_t *str, const h5tool_format_t *info, hid_t contai memb = H5Tget_member_type(type, j); ctx->indent_level++; - h5tools_str_sprint(str, info, container, memb, cp_vp + offset , ctx); + h5tools_str_sprint(str, info, container, memb, cp_vp + offset, ctx); ctx->indent_level--; H5Tclose(memb); @@ -821,51 +918,42 @@ h5tools_str_sprint(h5tools_str_t *str, const h5tool_format_t *info, hid_t contai } h5tools_str_append(str, "%s", OPT(info->cmpd_suf, "}")); - } else if (H5Tget_class(type) == H5T_ENUM) { + } + else if (H5Tget_class(type) == H5T_ENUM) { char enum_name[1024]; if (H5Tenum_nameof(type, vp, enum_name, sizeof enum_name) >= 0) { h5tools_str_append(str, h5tools_escape(enum_name, sizeof(enum_name))); - } else { + } + else { size_t i; n = H5Tget_size(type); - if (1==n) { + if (1 == n) { h5tools_str_append(str, "0x%02x", ucp_vp[0]); - } else { - for (i = 0; i < n; i++) - h5tools_str_append(str, "%s%02x", i?":":"", ucp_vp[i]); + } + else { + for (i = 0; i < n; i++) + h5tools_str_append(str, "%s%02x", i ? ":" : "", ucp_vp[i]); } } - } else if (H5Tequal(type, H5T_STD_REF_DSETREG)) { - /* - * Dataset region reference -- show the type and OID of the referenced - * object, but we are unable to show the region yet because there - * isn't enough support in the data space layer. - rpm 19990604 - */ - if (h5tools_is_zero(vp, H5Tget_size(type))) { + } + else if (H5Tequal(type, H5T_STD_REF_DSETREG)) { + if (h5tools_str_is_zero(vp, H5Tget_size(type))) { h5tools_str_append(str, "NULL"); - } else { - char ref_name[1024]; - - obj = H5Rdereference(container, H5R_DATASET_REGION, vp); - region = H5Rget_region(container, H5R_DATASET_REGION, vp); - - /* get name of the dataset the region reference points to using H5Rget_name */ - H5Rget_name(obj, H5R_DATASET_REGION, vp, (char*)ref_name, 1024); - h5tools_str_append(str, info->dset_format, ref_name); - - h5tools_str_dump_region(str, region, info); - H5Sclose(region); - H5Dclose(obj); } - } else if (H5Tequal(type, H5T_STD_REF_OBJ)) { + else { + h5tools_str_sprint_region(str, info, container, vp, ctx); + } + } + else if (H5Tequal(type, H5T_STD_REF_OBJ)) { /* * Object references -- show the type and OID of the referenced * object. */ - if (h5tools_is_zero(vp, H5Tget_size(type))) { + if (h5tools_str_is_zero(vp, H5Tget_size(type))) { h5tools_str_append(str, "NULL"); - } else { + } + else { H5O_info_t oi; const char *path; @@ -873,42 +961,43 @@ h5tools_str_sprint(h5tools_str_t *str, const h5tool_format_t *info, hid_t contai H5Oget_info(obj, &oi); /* Print object type and close object */ - switch(oi.type) { - case H5O_TYPE_GROUP: - h5tools_str_append(str, H5_TOOLS_GROUP); - break; - - case H5O_TYPE_DATASET: - h5tools_str_append(str, H5_TOOLS_DATASET); - break; - - case H5O_TYPE_NAMED_DATATYPE: - h5tools_str_append(str, H5_TOOLS_DATATYPE); - break; - - default: - h5tools_str_append(str, "%u-", (unsigned)oi.type); - break; + switch (oi.type) { + case H5O_TYPE_GROUP: + h5tools_str_append(str, H5_TOOLS_GROUP); + break; + + case H5O_TYPE_DATASET: + h5tools_str_append(str, H5_TOOLS_DATASET); + break; + + case H5O_TYPE_NAMED_DATATYPE: + h5tools_str_append(str, H5_TOOLS_DATATYPE); + break; + + default: + h5tools_str_append(str, "%u-", (unsigned) oi.type); + break; } /* end switch */ H5Oclose(obj); /* Print OID */ - if(info->obj_hidefileno) + if (info->obj_hidefileno) h5tools_str_append(str, info->obj_format, oi.addr); else h5tools_str_append(str, info->obj_format, oi.fileno, oi.addr); - /* Print name */ - path = lookup_ref_path(*(haddr_t *)vp); + /* Print name */ + path = lookup_ref_path(*(haddr_t *) vp); if (path) { h5tools_str_append(str, " "); h5tools_str_append(str, path); h5tools_str_append(str, " "); } /* end if */ } /* end else */ - } else if (H5Tget_class(type) == H5T_ARRAY) { + } + else if (H5Tget_class(type) == H5T_ARRAY) { int k, ndims; - hsize_t i, dims[H5S_MAX_RANK],temp_nelmts; + hsize_t i, dims[H5S_MAX_RANK], temp_nelmts; /* Get the array's base datatype for each element */ memb = H5Tget_super(type); @@ -918,34 +1007,33 @@ h5tools_str_sprint(h5tools_str_t *str, const h5tool_format_t *info, hid_t contai assert(ndims >= 1 && ndims <= H5S_MAX_RANK); /* Calculate the number of array elements */ - for (k = 0, nelmts = 1; k < ndims; k++){ + for (k = 0, nelmts = 1; k < ndims; k++) { temp_nelmts = nelmts; temp_nelmts *= dims[k]; - assert(temp_nelmts==(hsize_t)((size_t)temp_nelmts)); - nelmts = (size_t)temp_nelmts; + assert(temp_nelmts == (hsize_t) ((size_t) temp_nelmts)); + nelmts = (size_t) temp_nelmts; } /* Print the opening bracket */ h5tools_str_append(str, "%s", OPT(info->arr_pre, "[")); - for(i = 0; i < nelmts; i++) { - if(i) - h5tools_str_append(str, "%s", - OPT(info->arr_sep, "," OPTIONAL_LINE_BREAK)); + for (i = 0; i < nelmts; i++) { + if (i) + h5tools_str_append(str, "%s", OPT(info->arr_sep, "," OPTIONAL_LINE_BREAK)); - if(info->arr_linebreak && i && i % dims[ndims - 1] == 0) { + if (info->arr_linebreak && i && i % dims[ndims - 1] == 0) { int x; h5tools_str_append(str, "%s", "\n"); /* need to indent some more here*/ - if(ctx->indent_level >= 0) - if(!info->pindex) + if (ctx->indent_level >= 0) + if (!info->pindex) h5tools_str_append(str, "%s", OPT(info->line_pre, "")); - for(x = 0; x < ctx->indent_level + 1; x++) + for (x = 0; x < ctx->indent_level + 1; x++) h5tools_str_append(str, "%s", OPT(info->line_indent, "")); } /* end if */ - else if(i && info->arr_sep) + else if (i && info->arr_sep) h5tools_str_append(str, " "); ctx->indent_level++; @@ -959,7 +1047,8 @@ h5tools_str_sprint(h5tools_str_t *str, const h5tool_format_t *info, hid_t contai /* Print the closing bracket */ h5tools_str_append(str, "%s", OPT(info->arr_suf, "]")); H5Tclose(memb); - } else if (H5Tget_class(type) == H5T_VLEN) { + } + else if (H5Tget_class(type) == H5T_VLEN) { unsigned int i; /* Get the VL sequences's base datatype for each element */ @@ -970,15 +1059,14 @@ h5tools_str_sprint(h5tools_str_t *str, const h5tool_format_t *info, hid_t contai h5tools_str_append(str, "%s", OPT(info->vlen_pre, "(")); /* Get the number of sequence elements */ - nelmts = ((hvl_t *)cp_vp)->len; + nelmts = ((hvl_t *) cp_vp)->len; for (i = 0; i < nelmts; i++) { if (i) - h5tools_str_append(str, "%s", - OPT(info->vlen_sep, "," OPTIONAL_LINE_BREAK)); + h5tools_str_append(str, "%s", OPT(info->vlen_sep, "," OPTIONAL_LINE_BREAK)); #ifdef LATER -/* Need to fix so VL data breaks at correct location on end of line -QAK */ + /* Need to fix so VL data breaks at correct location on end of line -QAK */ if (info->arr_linebreak && h5tools_str_len(str)>=info->line_ncols) { int x; @@ -997,28 +1085,62 @@ h5tools_str_sprint(h5tools_str_t *str, const h5tool_format_t *info, hid_t contai /* Dump the array element */ h5tools_str_sprint(str, info, container, memb, - ((char *)(((hvl_t *)cp_vp)->p)) + i * size, ctx); + ((char *) (((hvl_t *) cp_vp)->p)) + i * size, ctx); ctx->indent_level--; } /* end for */ h5tools_str_append(str, "%s", OPT(info->vlen_suf, ")")); H5Tclose(memb); - } else { + } + else { /* All other types get printed as hexadecimal */ size_t i; n = H5Tget_size(type); - if (1==n) { + if (1 == n) { h5tools_str_append(str, "0x%02x", ucp_vp[0]); - } else { + } + else { for (i = 0; i < n; i++) - h5tools_str_append(str, "%s%02x", i?":":"", ucp_vp[i]); + h5tools_str_append(str, "%s%02x", i ? ":" : "", ucp_vp[i]); } } return h5tools_str_fmt(str, start, OPT(info->elmt_fmt, "%s")); } + +/*------------------------------------------------------------------------- + * Function: h5tools_str_sprint_region + * + * Purpose: Dataset region reference -- show the type and data of the referenced object. + * + * Return: Nothing + *------------------------------------------------------------------------- + */ +void +h5tools_str_sprint_region(h5tools_str_t *str, const h5tool_format_t *info, + hid_t container, void *vp, h5tools_context_t *ctx) +{ + hid_t obj, region; + char ref_name[1024]; + + obj = H5Rdereference(container, H5R_DATASET_REGION, vp); + if (obj >= 0) { + region = H5Rget_region(container, H5R_DATASET_REGION, vp); + if (region >= 0) { + H5Rget_name(obj, H5R_DATASET_REGION, vp, (char*) ref_name, 1024); + + h5tools_str_append(str, info->dset_format, ref_name); + h5tools_str_dump_region_blocks(str, region, info, ctx); + h5tools_str_dump_region_points(str, region, info, ctx); + + H5Sclose(region); + } /* end if (region >= 0) */ + H5Dclose(obj); + } /* end if (obj >= 0) */ +} + /*------------------------------------------------------------------------- * Function: h5tools_escape * @@ -1047,70 +1169,71 @@ h5tools_escape(char *s/*in,out*/, size_t size) char octal[8]; for (i = 0; i < n; i++) { - switch (s[i]) { - case '\'': - escape = "\\\'"; - break; - case '\"': - escape = "\\\""; - break; - case '\\': - escape = "\\\\"; - break; - case '\?': - escape = "\\\?"; - break; - case '\a': - escape = "\\a"; - break; - case '\b': - escape = "\\b"; - break; - case '\f': - escape = "\\f"; - break; - case '\n': - escape = "\\n"; - break; - case '\r': - escape = "\\r"; - break; - case '\t': - escape = "\\t"; - break; - case '\v': - escape = "\\v"; - break; - default: - if (!isprint(s[i])) { - sprintf(octal, "\\%03o", (unsigned char)s[i]); - escape = octal; - } else { - escape = NULL; - } + switch (s[i]) { + case '\'': + escape = "\\\'"; + break; + case '\"': + escape = "\\\""; + break; + case '\\': + escape = "\\\\"; + break; + case '\?': + escape = "\\\?"; + break; + case '\a': + escape = "\\a"; + break; + case '\b': + escape = "\\b"; + break; + case '\f': + escape = "\\f"; + break; + case '\n': + escape = "\\n"; + break; + case '\r': + escape = "\\r"; + break; + case '\t': + escape = "\\t"; + break; + case '\v': + escape = "\\v"; + break; + default: + if (!isprint(s[i])) { + sprintf(octal, "\\%03o", (unsigned char) s[i]); + escape = octal; + } + else { + escape = NULL; + } - break; - } + break; + } - if (escape) { - size_t esc_size = strlen(escape); + if (escape) { + size_t esc_size = strlen(escape); - if (n + esc_size + 1 > size) - /*would overflow*/ - return NULL; + if (n + esc_size + 1 > size) + /*would overflow*/ + return NULL; - memmove(s + i + esc_size, s + i + 1, n - i); /*make room*/ - memcpy(s + i, escape, esc_size); /*insert*/ - n += esc_size - 1; /* adjust total string size */ - i += esc_size; /* adjust string position */ - } + memmove(s + i + esc_size, s + i + 1, n - i); /*make room*/ + memcpy(s + i, escape, esc_size); /*insert*/ + n += esc_size - 1; /* adjust total string size */ + i += esc_size; /* adjust string position */ + } } return s; } /*------------------------------------------------------------------------- - * Function: h5tools_is_zero + * Function: h5tools_str_is_zero * * Purpose: Determines if memory is initialized to all zero bytes. * @@ -1124,13 +1247,13 @@ h5tools_escape(char *s/*in,out*/, size_t size) *------------------------------------------------------------------------- */ static hbool_t -h5tools_is_zero(const void *_mem, size_t size) +h5tools_str_is_zero(const void *_mem, size_t size) { - const unsigned char *mem = (const unsigned char *)_mem; + const unsigned char *mem = (const unsigned char *) _mem; while (size-- > 0) - if (mem[size]) - return FALSE; + if (mem[size]) + return FALSE; return TRUE; } diff --git a/tools/lib/h5tools_str.h b/tools/lib/h5tools_str.h index 607d412..61b7905 100644 --- a/tools/lib/h5tools_str.h +++ b/tools/lib/h5tools_str.h @@ -35,7 +35,18 @@ extern char *h5tools_str_fmt(h5tools_str_t *str, size_t start, const char *fm extern char *h5tools_str_prefix(h5tools_str_t *str, const h5tool_format_t *info, hsize_t elmtno, unsigned ndims, hsize_t min_idx[], hsize_t max_idx[], h5tools_context_t *ctx); -extern int h5tools_str_dump_region(h5tools_str_t *, hid_t, const h5tool_format_t *); +/* + * new functions needed to display region reference data + */ +extern char *h5tools_str_region_prefix(h5tools_str_t *str, const h5tool_format_t *info, + hsize_t elmtno, hsize_t *ptdata, unsigned ndims, hsize_t min_idx[], + hsize_t max_idx[], h5tools_context_t *ctx); +extern void h5tools_str_dump_region_blocks(h5tools_str_t *, hid_t, const h5tool_format_t *, + h5tools_context_t *ctx); +extern void h5tools_str_dump_region_points(h5tools_str_t *, hid_t, const h5tool_format_t *, + h5tools_context_t *ctx); +extern void h5tools_str_sprint_region(h5tools_str_t *str, const h5tool_format_t *info, hid_t container, + void *vp, h5tools_context_t *ctx); extern char *h5tools_str_sprint(h5tools_str_t *str, const h5tool_format_t *info, hid_t container, hid_t type, void *vp, h5tools_context_t *ctx); |