summaryrefslogtreecommitdiffstats
path: root/tools/lib
diff options
context:
space:
mode:
authorAllen Byrne <byrn@hdfgroup.org>2009-09-04 14:50:13 (GMT)
committerAllen Byrne <byrn@hdfgroup.org>2009-09-04 14:50:13 (GMT)
commitc7590ca38eb81dccfffa8e7132e0d1df0734cf44 (patch)
treee99ca501ec34b6303b5f85a5ecc77e9a476fb3c2 /tools/lib
parent4978a681f9a98016a829b8353fafb0acb5cdf1d4 (diff)
downloadhdf5-c7590ca38eb81dccfffa8e7132e0d1df0734cf44.zip
hdf5-c7590ca38eb81dccfffa8e7132e0d1df0734cf44.tar.gz
hdf5-c7590ca38eb81dccfffa8e7132e0d1df0734cf44.tar.bz2
[svn-r17450] Bring h5dump single subsetting selection and region reference changes from NPOESS
Tested: local linux smirom
Diffstat (limited to 'tools/lib')
-rw-r--r--tools/lib/h5tools.c3179
-rw-r--r--tools/lib/h5tools.h165
-rw-r--r--tools/lib/h5tools_str.c687
-rw-r--r--tools/lib/h5tools_str.h13
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(&region_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(&region_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, &region_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), &region_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, &region_ctx, buffer, &region_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(&region_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(&region_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, &region_ctx, region_curr_pos, ptdata, 0);
+
+ h5tools_str_sprint(buffer, info, region_id, type_id,
+ ((char*)region_buf + jndx * type_size), &region_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, &region_ctx, buffer, &region_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);