summaryrefslogtreecommitdiffstats
path: root/tools/h5dump
diff options
context:
space:
mode:
Diffstat (limited to 'tools/h5dump')
-rw-r--r--tools/h5dump/Dependencies0
-rw-r--r--tools/h5dump/Makefile.in65
-rw-r--r--tools/h5dump/h5dump.c4680
-rw-r--r--tools/h5dump/h5dump.h22
-rw-r--r--tools/h5dump/h5dumptst.c2577
-rwxr-xr-xtools/h5dump/testh5dump.sh197
6 files changed, 7541 insertions, 0 deletions
diff --git a/tools/h5dump/Dependencies b/tools/h5dump/Dependencies
new file mode 100644
index 0000000..e69de29
--- /dev/null
+++ b/tools/h5dump/Dependencies
diff --git a/tools/h5dump/Makefile.in b/tools/h5dump/Makefile.in
new file mode 100644
index 0000000..6de1b7c
--- /dev/null
+++ b/tools/h5dump/Makefile.in
@@ -0,0 +1,65 @@
+## HDF5 Library Makefile(.in)
+##
+## Copyright (C) 2001 National Center for Supercomputing Applications.
+## All rights reserved.
+##
+##
+top_srcdir=@top_srcdir@
+top_builddir=../..
+srcdir=@srcdir@
+SUBDIRS=
+@COMMENCE@
+
+## Add include directory to the C preprocessor flags, add -lh5tools and
+## -lhdf5 to the list of libraries.
+##
+CPPFLAGS=-I. -I$(srcdir) -I$(top_builddir)/src -I$(top_srcdir)/src \
+ -I$(top_srcdir)/tools/lib @CPPFLAGS@
+
+## Test programs and scripts.
+##
+TEST_PROGS=
+TEST_SCRIPTS=$(srcdir)/testh5dump.sh
+
+## These are our main targets: library and tools.
+##
+LIBTOOLS=../lib/libh5tools.la
+LIBHDF5=$(top_builddir)/src/libhdf5.la
+
+PUB_PROGS=h5dump
+PROGS=$(PUB_PROGS) $(TEST_PROGS) h5dumptst
+
+## Source and object files for the library; do not install
+##
+LIB_SRC=
+LIB_OBJ=$(LIB_SRC:.c=.lo)
+PUB_LIB=
+
+## Source and object files for programs...
+##
+PROG_SRC=h5dump.c h5dumptst.c
+PROG_OBJ=$(PROG_SRC:.c=.lo)
+
+PRIVATE_HDR=h5dump.h
+
+## Source and object files for the tests
+##
+TEST_SRC=
+TEST_OBJ=$(TEST_SRC:.c=.lo)
+
+## Programs have to be built before they can be tested!
+##
+check test _test: $(PROGS)
+
+## How to build the programs...They all depend on the hdf5 library and
+## the tools library compiled in this directory.
+##
+$(PROGS): $(LIBTOOLS) $(LIBHDF5)
+
+h5dump: h5dump.lo
+ @$(LT_LINK_EXE) $(CFLAGS) -o $@ h5dump.lo $(LIBTOOLS) $(LIBHDF5) $(LDFLAGS) $(LIBS)
+
+h5dumptst: h5dumptst.lo
+ @$(LT_LINK_EXE) $(CFLAGS) -o $@ h5dumptst.lo $(LIBTOOLS) $(LIBHDF5) $(LDFLAGS) $(LIBS)
+
+@CONCLUDE@
diff --git a/tools/h5dump/h5dump.c b/tools/h5dump/h5dump.c
new file mode 100644
index 0000000..23c3bd2
--- /dev/null
+++ b/tools/h5dump/h5dump.c
@@ -0,0 +1,4680 @@
+/*
+ * Copyright (C) 1998-2001 National Center for Supercomputing Applications
+ * All rights reserved.
+ *
+ */
+#include <stdio.h>
+#include <stdlib.h>
+
+#include "h5dump.h"
+#include "H5private.h"
+#include "h5tools.h"
+
+/* module-scoped variables */
+static const char *progname = "h5dump";
+
+static int d_status = EXIT_SUCCESS;
+static int unamedtype = 0; /* shared data type with no name */
+static int prefix_len = 1024;
+static table_t *group_table = NULL, *dset_table = NULL, *type_table = NULL;
+static char *prefix;
+
+static const dump_header *dump_header_format;
+
+/* things to display or which are set via command line parameters */
+static int display_all = TRUE;
+static int display_bb = FALSE;
+static int display_oid = FALSE;
+static int display_data = TRUE;
+static int usingdasho = FALSE;
+
+/**
+ ** Added for XML **
+ **/
+
+/* fill_ref_path_table is called to inialize the object reference paths. */
+static herr_t fill_ref_path_table(hid_t, const char *, void UNUSED *);
+
+/* module-scoped variables for XML option */
+#define DEFAULT_DTD "http://hdf.ncsa.uiuc.edu/DTDs/HDF5-File.dtd"
+
+static int doxml = 0;
+static const char *xml_dtd_uri = NULL;
+static hid_t thefile = -1;
+/** end XML **/
+
+/* internal functions */
+static void dump_oid(hid_t oid);
+static void print_enum(hid_t type);
+static herr_t dump_all(hid_t group, const char *name, void *op_data);
+static char *lookup_ref_path(hobj_ref_t *);
+static void check_compression(hid_t);
+static struct ref_path_table_entry_t *ref_path_table_lookup(const char *);
+
+/* external functions */
+extern int print_data(hid_t, hid_t, int);
+
+static h5dump_t 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 */
+ " %lu:%lu", /*obj_format */
+
+ 1, /*dset_hidefileno */
+ "DATASET %lu:%lu ", /*dset_format */
+ "%s", /*dset_blockformat_pre */
+ "%s", /*dset_ptformat_pre */
+ "%s", /*dset_ptformat */
+};
+
+/**
+ ** Added for XML **
+ **/
+/*
+ * Alternative formating for data dumped to XML
+ * In general, the numbers are the same, but separators
+ * except spaces are not used.
+ *
+ * Some of these are not used, as some kinds of data are
+ * dumped in completely new subroutines.
+ *
+ * Some of this formatting may yet need to change.
+ *
+ * This table only affects XML output.
+ */
+static h5dump_t xml_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 */
+ " ", /*cmpd_sep */
+ "", /*cmpd_pre */
+ "", /*cmpd_suf */
+ "", /*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 */
+ " %lu:%lu", /*obj_format */
+
+ 1, /*dset_hidefileno */
+ "DATASET %lu:%lu ", /*dset_format */
+ "%s", /*dset_blockformat_pre */
+ "%s", /*dset_ptformat_pre */
+ "%s", /*dset_ptformat */
+};
+
+/** XML **/
+
+static const dump_header standardformat = {
+ "standardformat", /*name */
+ "HDF5", /*fileebgin */
+ "", /*fileend */
+ BOOT_BLOCK, /*bootblockbegin */
+ "", /*bootblockend */
+ GROUPNAME, /*groupbegin */
+ "", /*groupend */
+ DATASET, /*datasetbegin */
+ "", /*datasetend */
+ ATTRIBUTE, /*attributebegin */
+ "", /*attributeend */
+ DATATYPE, /*datatypebegin */
+ "", /*datatypeend */
+ DATASPACE, /*dataspacebegin */
+ "", /*dataspaceend */
+ DATA, /*databegin */
+ "", /*dataend */
+ SOFTLINK, /*softlinkbegin */
+ "", /*softlinkend */
+
+ "{", /*fileblockbegin */
+ "}", /*fileblockend */
+ "{", /*bootblockblockbegin */
+ "}", /*bootblockblockend */
+ "{", /*groupblockbegin */
+ "}", /*groupblockend */
+ "{", /*datasetblockbegin */
+ "}", /*datasetblockend */
+ "{", /*attributeblockbegin */
+ "}", /*attributeblockend */
+ "", /*datatypeblockbegin */
+ "", /*datatypeblockend */
+ "", /*dataspaceblockbegin */
+ "", /*dataspaceblockend */
+ "{", /*datablockbegin */
+ "}", /*datablockend */
+ "{", /*softlinkblockbegin */
+ "}", /*softlinkblockend */
+ "{", /*strblockbegin */
+ "}", /*strblockend */
+ "{", /*enumblockbegin */
+ "}", /*enumblockend */
+ "{", /*structblockbegin */
+ "}", /*structblockend */
+ "{", /*vlenblockbegin */
+ "}", /*vlenblockend */
+
+ "", /*dataspacedescriptionbegin */
+ "", /*dataspacedescriptionend */
+ "(", /*dataspacedimbegin */
+ ")", /*dataspacedimend */
+};
+
+/**
+ ** Added for XML **
+ **/
+/* The 'header' formats for XML -- mostly null
+ *
+ * XML output has values embedded in the 'headers', so
+ * all the XML headers are done on a case by case basis.
+ */
+static const dump_header xmlformat = {
+ "xml", /*name */
+ "", /*filebegin */
+ "</HDF5-File>", /*fileend */
+ "", /*bootblockbegin */
+ "", /*bootblockend */
+ "", /*groupbegin */
+ "</Group>", /*groupend */
+ "", /*datasetbegin */
+ "</Dataset>", /*datasetend */
+ "", /*attributebegin */
+ "</Attribute>", /*attributeend */
+ "<DataType>", /*datatypeend */
+ "</DataType>", /*datatypeend */
+ "<Dataspace>", /*dataspacebegin */
+ "</Dataspace>", /*dataspaceend */
+ "<Data>", /*databegin */
+ "</Data>", /*dataend */
+ "", /*softlinkbegin */
+ "", /*softlinkend */
+
+ "", /*fileblockbegin */
+ "", /*fileblockend */
+ "", /*bootblockblockbegin */
+ "", /*bootblockblockend */
+ "", /*groupblockbegin */
+ "", /*groupblockend */
+ "", /*datasetblockbegin */
+ "", /*datasetblockend */
+ "", /*attributeblockbegin */
+ "", /*attributeblockend */
+ "", /*datatypeblockbegin */
+ "", /*datatypeblockend */
+ "", /*dataspaceblockbegin */
+ "", /*dataspaceblockend */
+ "", /*datablockbegin */
+ "", /*datablockend */
+ "", /*softlinkblockbegin */
+ "", /*softlinkblockend */
+ "", /*strblockbegin */
+ "", /*strblockend */
+ "", /*enumblockbegin */
+ "", /*enumblockend */
+ "", /*structblockbegin */
+ "", /*structblockend */
+ "", /*vlenblockbegin */
+ "", /*vlenblockend */
+
+ "", /*dataspacedescriptionbegin */
+ "", /*dataspacedescriptionend */
+ "", /*dataspacedimbegin */
+ "", /*dataspacedimend */
+};
+
+/** XML **/
+
+/**
+ ** Added for XML **
+ **/
+/* internal functions used by XML option */
+static void xml_print_datatype(hid_t);
+static void xml_print_enum(hid_t);
+static int xml_print_refs(hid_t, int);
+static int xml_print_strs(hid_t, int);
+static hobj_ref_t *ref_path_table_put(hid_t, const char *);
+static char *xml_escape_the_string(const char *, int);
+static char *xml_escape_the_name(const char *);
+
+/**
+ ** Change for XML **
+ **
+ ** The 'dump_xxx' functions have two versions, standard and XML.
+ **
+ ** They are called indirectly through the 'dump_function_table'.
+ ** e.g., dump_group(...) becomes dump_functions->dump_group(...);
+ **
+ ** The standard functions are unchanged except for the way
+ ** they are called
+ **/
+
+/* The dump functions of the dump_function_table */
+
+/* standard format: no change */
+static void dump_group(hid_t, const char *);
+static void dump_dataset(hid_t, const char *);
+static void dump_data(hid_t, int);
+static void dump_named_datatype(hid_t, const char *);
+static void dump_dataspace(hid_t space);
+static void dump_datatype(hid_t type);
+static herr_t dump_attr(hid_t attr, const char *attr_name,
+ void UNUSED * op_data);
+
+/* XML format: same interface, alternative output */
+
+static void xml_dump_group(hid_t, const char *);
+static void xml_dump_dataset(hid_t ds, const char *dsname);
+static void xml_dump_data(hid_t, int);
+static void xml_dump_named_datatype(hid_t, const char *);
+static void xml_dump_dataspace(hid_t space);
+static void xml_dump_datatype(hid_t type);
+static herr_t xml_dump_attr(hid_t attr, const char *attr_name,
+ void UNUSED * op_data);
+
+/**
+ ** Added for XML **
+ **
+ ** This is the global dispatch table for the dump functions.
+ **/
+/* the table of dump functions */
+typedef struct dump_functions_t {
+ void (*dump_group_function) (hid_t, const char *);
+ void (*dump_named_datatype_function) (hid_t, const char *);
+ void (*dump_dataset_function) (hid_t, const char *);
+ void (*dump_dataspace_function) (hid_t);
+ void (*dump_datatype_function) (hid_t);
+ herr_t (*dump_attribute_function) (hid_t, const char *, void *);
+ void (*dump_data_function) (hid_t, int);
+} dump_functions;
+
+/* Standard DDL output */
+static const dump_functions ddl_function_table = {
+ dump_group,
+ dump_named_datatype,
+ dump_dataset,
+ dump_dataspace,
+ dump_datatype,
+ dump_attr,
+ dump_data
+};
+
+/* XML output */
+static const dump_functions xml_function_table = {
+ xml_dump_group,
+ xml_dump_named_datatype,
+ xml_dump_dataset,
+ xml_dump_dataspace,
+ xml_dump_datatype,
+ xml_dump_attr,
+ xml_dump_data
+};
+
+/*
+ * The global table is set to either ddl_function_table or
+ * xml_function_table in the initialization.
+ */
+static const dump_functions *dump_function_table;
+
+/* a structure to hold the subsetting particulars for a dataset */
+struct subset_t {
+ hsize_t *start;
+ hsize_t *stride;
+ hsize_t *count;
+ hsize_t *block;
+};
+
+/* a structure for handling the order command-line parameters come in */
+struct handler_t {
+ void (*func)(hid_t, char *, void *);
+ char *obj;
+ struct subset_t *subset_info;
+};
+
+/*
+ * Command-line options: The user can specify short or long-named
+ * parameters. The long-named ones can be partially spelled. When
+ * adding more, make sure that they don't clash with each other.
+ */
+#if 0
+ /* binary: not implemented yet */
+static const char *s_opts = "hbBHvVa:d:g:l:t:w:xD:o:s:T:c:k:";
+#else
+static const char *s_opts = "hBHvVa:d:g:l:t:w:xD:o:s:T:c:k:";
+#endif /* 0 */
+static struct long_options l_opts[] = {
+ { "help", no_arg, 'h' },
+ { "hel", no_arg, 'h' },
+#if 0
+ /* binary: not implemented yet */
+ { "binary", no_arg, 'b' },
+ { "binar", no_arg, 'b' },
+ { "bina", no_arg, 'b' },
+ { "bin", no_arg, 'b' },
+ { "bi", no_arg, 'b' },
+#endif /* 0 */
+ { "boot-block", no_arg, 'B' },
+ { "boot-bloc", no_arg, 'B' },
+ { "boot-blo", no_arg, 'B' },
+ { "boot-bl", no_arg, 'B' },
+ { "boot-b", no_arg, 'B' },
+ { "boot", no_arg, 'B' },
+ { "boo", no_arg, 'B' },
+ { "bo", no_arg, 'B' },
+ { "header", no_arg, 'H' },
+ { "heade", no_arg, 'H' },
+ { "head", no_arg, 'H' },
+ { "hea", no_arg, 'H' },
+ { "object-ids", no_arg, 'i' },
+ { "object-id", no_arg, 'i' },
+ { "object-i", no_arg, 'i' },
+ { "object", no_arg, 'i' },
+ { "objec", no_arg, 'i' },
+ { "obje", no_arg, 'i' },
+ { "obj", no_arg, 'i' },
+ { "ob", no_arg, 'i' },
+ { "version", no_arg, 'V' },
+ { "versio", no_arg, 'V' },
+ { "versi", no_arg, 'V' },
+ { "vers", no_arg, 'V' },
+ { "ver", no_arg, 'V' },
+ { "ve", no_arg, 'V' },
+ { "attribute", require_arg, 'a' },
+ { "attribut", require_arg, 'a' },
+ { "attribu", require_arg, 'a' },
+ { "attrib", require_arg, 'a' },
+ { "attri", require_arg, 'a' },
+ { "attr", require_arg, 'a' },
+ { "att", require_arg, 'a' },
+ { "at", require_arg, 'a' },
+ { "block", require_arg, 'k' },
+ { "bloc", require_arg, 'k' },
+ { "blo", require_arg, 'k' },
+ { "bl", require_arg, 'k' },
+ { "count", require_arg, 'c' },
+ { "coun", require_arg, 'c' },
+ { "cou", require_arg, 'c' },
+ { "co", require_arg, 'c' },
+ { "dataset", require_arg, 'd' },
+ { "datase", require_arg, 'd' },
+ { "datas", require_arg, 'd' },
+ { "datatype", require_arg, 't' },
+ { "datatyp", require_arg, 't' },
+ { "dataty", require_arg, 't' },
+ { "datat", require_arg, 't' },
+ { "group", require_arg, 'g' },
+ { "grou", require_arg, 'g' },
+ { "gro", require_arg, 'g' },
+ { "gr", require_arg, 'g' },
+ { "output", require_arg, 'o' },
+ { "outpu", require_arg, 'o' },
+ { "outp", require_arg, 'o' },
+ { "out", require_arg, 'o' },
+ { "ou", require_arg, 'o' },
+ { "soft-link", require_arg, 'l' },
+ { "soft-lin", require_arg, 'l' },
+ { "soft-li", require_arg, 'l' },
+ { "soft-l", require_arg, 'l' },
+ { "soft", require_arg, 'l' },
+ { "sof", require_arg, 'l' },
+ { "so", require_arg, 'l' },
+ { "start", require_arg, 's' },
+ { "star", require_arg, 's' },
+ { "sta", require_arg, 's' },
+ { "stride", require_arg, 'T' },
+ { "strid", require_arg, 'T' },
+ { "stri", require_arg, 'T' },
+ { "str", require_arg, 'T' },
+ { "width", require_arg, 'w' },
+ { "widt", require_arg, 'w' },
+ { "wid", require_arg, 'w' },
+ { "wi", require_arg, 'w' },
+ { "xml", no_arg, 'x' },
+ { "xm", no_arg, 'x' },
+ { "xml-dtd", require_arg, 'D' },
+ { "xml-dt", require_arg, 'D' },
+ { "xml-d", require_arg, 'D' },
+ { NULL, 0, '\0' }
+};
+
+/*-------------------------------------------------------------------------
+ * Function: usage
+ *
+ * Purpose: Print the usage message about dumper
+ *
+ * Return: void
+ *
+ * Programmer: Ruey-Hsia Li
+ *
+ * Modifications:
+ *
+ *-------------------------------------------------------------------------
+ */
+static void
+usage(const char *prog)
+{
+ fflush(stdout);
+ fprintf(stdout, "\
+usage: %s [OPTIONS] file\n\
+ OPTIONS\n\
+ -h, --help Print a usage message and exit\n\
+ -B, --bootblock Print the content of the boot block\n\
+ -H, --header Print the header only; no data is displayed\n\
+ -i, --object-ids Print the object ids\n\
+ -V, --version Print version number and exit\n\
+ -a P, --attribute=P Print the specified attribute\n\
+ -d P, --dataset=P Print the specified dataset\n\
+ -g P, --group=P Print the specified group and all members\n\
+ -l P, --soft-link=P Print the value(s) of the specified soft link\n\
+ -o F, --output=F Output raw data into file F\n\
+ -t T, --datatype=T Print the specified named data type\n\
+ -w N, --width=N Set the number of columns of output\n\
+ -x, --xml Output in XML\n\
+ -D U, --xml-dtd=U Use the DTD at U\n\
+\n\
+ P - is the full path from the root group to the object.\n\
+ T - is the name of the data type.\n\
+ F - is a filename.\n\
+ N - is an integer greater than 1.\n\
+ U - is a URI reference (as defined in [IETF RFC 2396],\n\
+ updated by [IETF RFC 2732])\n\
+\n\
+ Example:\n\
+\n\
+ Attribute foo of the group /bar_none in file quux.h5\n\
+\n\
+ h5dump -a /bar_none/foo quux.h5\n\
+\n", prog);
+}
+
+/*-------------------------------------------------------------------------
+ * Function: print_datatype
+ *
+ * Purpose: print the data type.
+ *
+ * Return: void
+ *
+ * Programmer: Ruey-Hsia Li
+ *
+ * Modifications:
+ *
+ *-------------------------------------------------------------------------
+ */
+static void
+print_datatype(hid_t type)
+{
+ char *fname;
+ hid_t nmembers, mtype, str_type;
+ int i, j, ndims, perm[H5DUMP_MAX_RANK];
+ size_t size;
+ hsize_t dims[H5DUMP_MAX_RANK];
+ H5T_str_t str_pad;
+ H5T_cset_t cset;
+ H5G_stat_t statbuf;
+ hid_t super;
+
+ switch (H5Tget_class(type)) {
+ case H5T_INTEGER:
+ if (H5Tequal(type, H5T_STD_I8BE)) {
+ printf("H5T_STD_I8BE");
+ } else if (H5Tequal(type, H5T_STD_I8LE)) {
+ printf("H5T_STD_I8LE");
+ } else if (H5Tequal(type, H5T_STD_I16BE)) {
+ printf("H5T_STD_I16BE");
+ } else if (H5Tequal(type, H5T_STD_I16LE)) {
+ printf("H5T_STD_I16LE");
+ } else if (H5Tequal(type, H5T_STD_I32BE)) {
+ printf("H5T_STD_I32BE");
+ } else if (H5Tequal(type, H5T_STD_I32LE)) {
+ printf("H5T_STD_I32LE");
+ } else if (H5Tequal(type, H5T_STD_I64BE)) {
+ printf("H5T_STD_I64BE");
+ } else if (H5Tequal(type, H5T_STD_I64LE)) {
+ printf("H5T_STD_I64LE");
+ } else if (H5Tequal(type, H5T_STD_U8BE)) {
+ printf("H5T_STD_U8BE");
+ } else if (H5Tequal(type, H5T_STD_U8LE)) {
+ printf("H5T_STD_U8LE");
+ } else if (H5Tequal(type, H5T_STD_U16BE)) {
+ printf("H5T_STD_U16BE");
+ } else if (H5Tequal(type, H5T_STD_U16LE)) {
+ printf("H5T_STD_U16LE");
+ } else if (H5Tequal(type, H5T_STD_U32BE)) {
+ printf("H5T_STD_U32BE");
+ } else if (H5Tequal(type, H5T_STD_U32LE)) {
+ printf("H5T_STD_U32LE");
+ } else if (H5Tequal(type, H5T_STD_U64BE)) {
+ printf("H5T_STD_U64BE");
+ } else if (H5Tequal(type, H5T_STD_U64LE)) {
+ printf("H5T_STD_U64LE");
+ } else if (H5Tequal(type, H5T_NATIVE_SCHAR)) {
+ printf("H5T_NATIVE_SCHAR");
+ } else if (H5Tequal(type, H5T_NATIVE_UCHAR)) {
+ printf("H5T_NATIVE_UCHAR");
+ } else if (H5Tequal(type, H5T_NATIVE_SHORT)) {
+ printf("H5T_NATIVE_SHORT");
+ } else if (H5Tequal(type, H5T_NATIVE_USHORT)) {
+ printf("H5T_NATIVE_USHORT");
+ } else if (H5Tequal(type, H5T_NATIVE_INT)) {
+ printf("H5T_NATIVE_INT");
+ } else if (H5Tequal(type, H5T_NATIVE_UINT)) {
+ printf("H5T_NATIVE_UINT");
+ } else if (H5Tequal(type, H5T_NATIVE_LONG)) {
+ printf("H5T_NATIVE_LONG");
+ } else if (H5Tequal(type, H5T_NATIVE_ULONG)) {
+ printf("H5T_NATIVE_ULONG");
+ } else if (H5Tequal(type, H5T_NATIVE_LLONG)) {
+ printf("H5T_NATIVE_LLONG");
+ } else if (H5Tequal(type, H5T_NATIVE_ULLONG)) {
+ printf("H5T_NATIVE_ULLONG");
+ } else {
+ printf("undefined integer");
+ d_status = EXIT_FAILURE;
+ }
+ break;
+
+ case H5T_FLOAT:
+ if (H5Tequal(type, H5T_IEEE_F32BE)) {
+ printf("H5T_IEEE_F32BE");
+ } else if (H5Tequal(type, H5T_IEEE_F32LE)) {
+ printf("H5T_IEEE_F32LE");
+ } else if (H5Tequal(type, H5T_IEEE_F64BE)) {
+ printf("H5T_IEEE_F64BE");
+ } else if (H5Tequal(type, H5T_IEEE_F64LE)) {
+ printf("H5T_IEEE_F64LE");
+ } else if (H5Tequal(type, H5T_NATIVE_FLOAT)) {
+ printf("H5T_NATIVE_FLOAT");
+ } else if (H5Tequal(type, H5T_NATIVE_DOUBLE)) {
+ printf("H5T_NATIVE_DOUBLE");
+ } else if (H5Tequal(type, H5T_NATIVE_LDOUBLE)) {
+ printf("H5T_NATIVE_LDOUBLE");
+ } else {
+ printf("undefined float");
+ d_status = EXIT_FAILURE;
+ }
+ break;
+
+ case H5T_TIME:
+ printf("H5T_TIME: not yet implemented");
+ break;
+
+ case H5T_STRING:
+ size = H5Tget_size(type);
+ str_pad = H5Tget_strpad(type);
+ cset = H5Tget_cset(type);
+
+ printf("H5T_STRING %s\n", dump_header_format->strblockbegin);
+ indent += COL;
+
+ indentation(indent + COL);
+ printf("%s %d;\n", STRSIZE, (int) size);
+
+ indentation(indent + COL);
+ printf("%s ", STRPAD);
+ if (str_pad == H5T_STR_NULLTERM)
+ printf("H5T_STR_NULLTERM;\n");
+ else if (str_pad == H5T_STR_NULLPAD)
+ printf("H5T_STR_NULLPAD;\n");
+ else if (str_pad == H5T_STR_SPACEPAD)
+ printf("H5T_STR_SPACEPAD;\n");
+ else
+ printf("H5T_STR_ERROR;\n");
+
+ indentation(indent + COL);
+ printf("%s ", CSET);
+
+ if (cset == H5T_CSET_ASCII)
+ printf("H5T_CSET_ASCII;\n");
+ else
+ printf("unknown_cset;\n");
+
+ str_type = H5Tcopy(H5T_C_S1);
+ H5Tset_cset(str_type, cset);
+ H5Tset_size(str_type, size);
+ H5Tset_strpad(str_type, str_pad);
+
+ indentation(indent + COL);
+ printf("%s ", CTYPE);
+
+ if (H5Tequal(type, str_type)) {
+ printf("H5T_C_S1;\n");
+ H5Tclose(str_type);
+ } else {
+ 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);
+
+ if (H5Tequal(type, str_type)) {
+ printf("H5T_FORTRAN_S1;\n");
+ } else {
+ printf("unknown_one_character_type;\n ");
+ d_status = EXIT_FAILURE;
+ }
+
+ H5Tclose(str_type);
+ }
+
+ indent -= COL;
+ indentation(indent + COL);
+ printf("%s", dump_header_format->strblockend);
+ break;
+
+ case H5T_BITFIELD:
+ if (H5Tequal(type, H5T_STD_B8BE)) {
+ printf("H5T_STD_B8BE");
+ } else if (H5Tequal(type, H5T_STD_B8LE)) {
+ printf("H5T_STD_B8LE");
+ } else if (H5Tequal(type, H5T_STD_B16BE)) {
+ printf("H5T_STD_B16BE");
+ } else if (H5Tequal(type, H5T_STD_B16LE)) {
+ printf("H5T_STD_B16LE");
+ } else if (H5Tequal(type, H5T_STD_B32BE)) {
+ printf("H5T_STD_B32BE");
+ } else if (H5Tequal(type, H5T_STD_B32LE)) {
+ printf("H5T_STD_B32LE");
+ } else if (H5Tequal(type, H5T_STD_B64BE)) {
+ printf("H5T_STD_B64BE");
+ } else if (H5Tequal(type, H5T_STD_B64LE)) {
+ printf("H5T_STD_B64LE");
+ } else {
+ printf("undefined bitfield");
+ d_status = EXIT_FAILURE;
+ }
+ break;
+
+ case H5T_OPAQUE:
+ printf("\n");
+ indentation(indent + COL);
+ printf("H5T_OPAQUE;\n");
+ indentation(indent + COL);
+ printf("OPAQUE_TAG \"%s\";\n", H5Tget_tag(type));
+ indentation(indent);
+ break;
+
+ case H5T_COMPOUND:
+ if (H5Tcommitted(type) > 0) {
+ H5Gget_objinfo(type, ".", TRUE, &statbuf);
+ i = search_obj(type_table, statbuf.objno);
+
+ if (i >= 0) {
+ if (!type_table->objs[i].recorded)
+ printf("\"/#%lu:%lu\"\n", type_table->objs[i].objno[0],
+ type_table->objs[i].objno[1]);
+ else
+ printf("\"%s\"", type_table->objs[i].objname);
+ } else {
+ error_msg(progname, "unknown committed type.\n");
+ d_status = EXIT_FAILURE;
+ }
+ } else {
+ nmembers = H5Tget_nmembers(type);
+ printf("H5T_COMPOUND %s\n", dump_header_format->structblockbegin);
+
+ for (i = 0; i < nmembers; i++) {
+ fname = H5Tget_member_name(type, i);
+ mtype = H5Tget_member_type(type, i);
+
+ indentation(indent + COL);
+
+ if (H5Tget_class(mtype) == H5T_COMPOUND)
+ indent += COL;
+
+ print_datatype(mtype);
+
+ if (H5Tget_class(mtype) == H5T_COMPOUND)
+ indent -= COL;
+
+ printf(" \"%s\";\n", fname);
+ free(fname);
+ }
+
+ indentation(indent);
+ printf("%s", dump_header_format->structblockend);
+ }
+
+ break;
+
+ case H5T_REFERENCE:
+ printf("H5T_REFERENCE");
+ break;
+
+ case H5T_ENUM:
+ printf("H5T_ENUM %s\n", dump_header_format->enumblockbegin);
+ indent += COL;
+ indentation(indent + COL);
+ super = H5Tget_super(type);
+ print_datatype(super);
+ printf(";\n");
+ print_enum(type);
+ indent -= COL;
+ indentation(indent + COL);
+ printf("%s", dump_header_format->enumblockend);
+ break;
+
+ case H5T_VLEN:
+ printf("H5T_VLEN %s ", dump_header_format->vlenblockbegin);
+ super = H5Tget_super(type);
+ print_datatype(super);
+ H5Tclose(super);
+
+ /* Print closing */
+ printf("%s", dump_header_format->vlenblockend);
+ break;
+
+ case H5T_ARRAY:
+ /* Get array base type */
+ super = H5Tget_super(type);
+
+ /* Print lead-in */
+ printf("H5T_ARRAY { ");
+
+ /* Get array information */
+ ndims = H5Tget_array_ndims(type);
+ H5Tget_array_dims(type, dims, perm);
+
+ /* Print array dimensions */
+ for (j = 0; j < ndims; j++)
+ printf("[%d]", (int) dims[j]);
+
+ printf(" ");
+
+ /* Print base type */
+ print_datatype(super);
+
+ /* Close array base type */
+ H5Tclose(super);
+
+ /* Print closing */
+ printf(" }");
+
+ break;
+
+ default:
+ printf("unknown data type");
+ d_status = EXIT_FAILURE;
+ break;
+ }
+}
+
+/*-------------------------------------------------------------------------
+ * Function: dump_bb
+ *
+ * Purpose: Dump the boot block
+ *
+ * Return: void
+ *
+ * Programmer: Ruey-Hsia Li
+ *
+ * Modifications:
+ *
+ *-------------------------------------------------------------------------
+ */
+static void
+dump_bb(void)
+{
+ printf("%s %s boot block not yet implemented %s\n",
+ BOOT_BLOCK, BEGIN, END);
+}
+
+/*-------------------------------------------------------------------------
+ * Function: dump_datatype
+ *
+ * Purpose: Dump the data type. Data type can be HDF5 predefined
+ * atomic data type or committed/transient data type.
+ *
+ * Return: void
+ *
+ * Programmer: Ruey-Hsia Li
+ *
+ * Modifications:
+ *
+ *-------------------------------------------------------------------------
+ */
+static void
+dump_datatype(hid_t type)
+{
+ indent += COL;
+
+ indentation(indent);
+ printf("%s %s ", dump_header_format->datatypebegin,
+ dump_header_format->datatypeblockbegin);
+
+ print_datatype(type);
+
+ if (H5Tget_class(type) == H5T_COMPOUND || H5Tget_class(type) == H5T_STRING)
+ indentation(indent);
+
+ printf(" %s %s\n", dump_header_format->datatypeblockend,
+ dump_header_format->datatypeend);
+ indent -= COL;
+}
+
+/*-------------------------------------------------------------------------
+ * Function: dump_dataspace
+ *
+ * Purpose: Dump the data space. Data space can be named data space,
+ * array, or others.
+ *
+ * Return: void
+ *
+ * Programmer: Ruey-Hsia Li
+ *
+ * Modifications:
+ *
+ *-------------------------------------------------------------------------
+ */
+static void
+dump_dataspace(hid_t space)
+{
+ hsize_t size[H5DUMP_MAX_RANK];
+ hsize_t maxsize[H5DUMP_MAX_RANK];
+ int ndims = H5Sget_simple_extent_dims(space, size, maxsize);
+ int i;
+
+ indentation(indent + COL);
+ printf("%s ", dump_header_format->dataspacebegin);
+
+ if (H5Sis_simple(space)) {
+ if (ndims == 0) {
+ /* scalar dataspace */
+ HDfprintf(stdout, "%s %s ",
+ dump_header_format->dataspacedescriptionbegin, SCALAR);
+ } else {
+ /* simple dataspace */
+ HDfprintf(stdout, "%s %s { %s %Hu",
+ dump_header_format->dataspacedescriptionbegin, SIMPLE,
+ dump_header_format->dataspacedimbegin, size[0]);
+
+ for (i = 1; i < ndims; i++)
+ HDfprintf(stdout, ", %Hu", size[i]);
+
+ printf(" %s / ", dump_header_format->dataspacedimend);
+
+ if (maxsize[0] == H5S_UNLIMITED)
+ HDfprintf(stdout, "%s %s",
+ dump_header_format->dataspacedimbegin,
+ "H5S_UNLIMITED");
+ else
+ HDfprintf(stdout, "%s %Hu",
+ dump_header_format->dataspacedimbegin, maxsize[0]);
+
+ for (i = 1; i < ndims; i++)
+ if (maxsize[i] == H5S_UNLIMITED)
+ HDfprintf(stdout, ", %s", "H5S_UNLIMITED");
+ else
+ HDfprintf(stdout, ", %Hu", maxsize[i]);
+
+ printf(" %s }", dump_header_format->dataspacedimend);
+ }
+ } else {
+ printf("%s not yet implemented %s\n", BEGIN, END);
+ }
+
+ end_obj(dump_header_format->dataspaceend,
+ dump_header_format->dataspaceblockend);
+}
+
+/*-------------------------------------------------------------------------
+ * Function: dump_attr
+ *
+ * Purpose: dump the attribute
+ *
+ * Return: Success: SUCCEED
+ *
+ * Failure: FAIL
+ *
+ * Programmer: Ruey-Hsia Li
+ *
+ * Modifications:
+ *
+ *-------------------------------------------------------------------------
+ */
+static herr_t
+dump_attr(hid_t attr, const char *attr_name, void UNUSED * op_data)
+{
+ hid_t attr_id, type, space;
+ herr_t ret = SUCCEED;
+
+ indentation(indent);
+ begin_obj(dump_header_format->attributebegin, attr_name,
+ dump_header_format->attributeblockbegin);
+
+ if ((attr_id = H5Aopen_name(attr, attr_name)) < 0) {
+ indentation(indent + COL);
+ error_msg(progname, "unable to open attribute \"%s\"\n", attr_name);
+ indentation(indent);
+ end_obj(dump_header_format->attributeend,
+ dump_header_format->attributeblockend);
+ d_status = EXIT_FAILURE;
+ ret = FAIL;
+ } else {
+ type = H5Aget_type(attr_id);
+ space = H5Aget_space(attr_id);
+ dump_datatype(type);
+ dump_dataspace(space);
+
+ if (display_oid)
+ dump_oid(attr_id);
+
+ if (display_data)
+ dump_data(attr_id, ATTRIBUTE_DATA);
+
+ H5Tclose(type);
+ H5Sclose(space);
+ H5Aclose(attr_id);
+ indentation(indent);
+ end_obj(dump_header_format->attributeend,
+ dump_header_format->attributeblockend);
+ }
+
+ return ret;
+}
+
+/*-------------------------------------------------------------------------
+ * Function: dump_selected_attr
+ *
+ * Purpose: dump the selected attribute
+ *
+ * Return: Success: SUCCEED
+ *
+ * Failure: FAIL
+ *
+ * Programmer: Ruey-Hsia Li
+ *
+ * Modifications:
+ *
+ *-------------------------------------------------------------------------
+ */
+static herr_t
+dump_selected_attr(hid_t loc_id, const char *name)
+{
+ int j;
+ char *obj_name;
+ const char *attr_name;
+ hid_t oid, attr_id, type, space;
+ H5G_stat_t statbuf;
+
+ j = (int)strlen(name) - 1;
+ obj_name = malloc((size_t)j + 2);
+
+ /* find the last / */
+ while (name[j] != '/' && j >= 0)
+ j--;
+
+ /* object name */
+ if (j == -1) {
+ strcpy(obj_name, "/");
+ } else {
+ strncpy(obj_name, name, (size_t)j + 1);
+ obj_name[j + 1] = '\0';
+ }
+
+ attr_name = name + j + 1;
+ begin_obj(dump_header_format->attributebegin, name,
+ dump_header_format->attributeblockbegin);
+ H5Gget_objinfo(loc_id, obj_name, FALSE, &statbuf);
+
+ switch (statbuf.type) {
+ case H5G_GROUP:
+ if ((oid = H5Gopen(loc_id, obj_name)) < 0) {
+ indentation(COL);
+ error_msg(progname, "unable to open group \"%s\"\n", obj_name);
+ end_obj(dump_header_format->attributeend,
+ dump_header_format->attributeblockend);
+ d_status = EXIT_FAILURE;
+ return FAIL;
+ }
+ break;
+
+ case H5G_DATASET:
+ if ((oid = H5Dopen(loc_id, obj_name)) < 0) {
+ indentation(COL);
+ error_msg(progname, "unable to open dataset \"%s\"\n", obj_name);
+ end_obj(dump_header_format->attributeend,
+ dump_header_format->attributeblockend);
+ d_status = EXIT_FAILURE;
+ return FAIL;
+ }
+ break;
+
+ case H5G_TYPE:
+ if ((oid = H5Topen(loc_id, obj_name)) < 0) {
+ indentation(COL);
+ error_msg(progname, "unable to open datatype \"%s\"\n", obj_name);
+ end_obj(dump_header_format->attributeend,
+ dump_header_format->attributeblockend);
+ d_status = EXIT_FAILURE;
+ return FAIL;
+ }
+ break;
+
+ default:
+ indentation(COL);
+ error_msg(progname, "unable to open unknown \"%s\"\n", obj_name);
+ end_obj(dump_header_format->attributeend,
+ dump_header_format->attributeblockend);
+ d_status = EXIT_FAILURE;
+ return FAIL;
+ }
+
+ if ((attr_id = H5Aopen_name(oid, attr_name)) >= 0) {
+ type = H5Aget_type(attr_id);
+ space = H5Aget_space(attr_id);
+ dump_datatype(type);
+ dump_dataspace(space);
+
+ if (display_oid)
+ dump_oid(attr_id);
+
+ if (display_data)
+ dump_data(attr_id, ATTRIBUTE_DATA);
+
+ H5Tclose(type);
+ H5Sclose(space);
+ H5Aclose(attr_id);
+ end_obj(dump_header_format->attributeend,
+ dump_header_format->attributeblockend);
+ } else {
+ indentation(COL);
+ error_msg(progname, "unable to open attribute \"%s\"\n", obj_name);
+ end_obj(dump_header_format->attributeend,
+ dump_header_format->attributeblockend);
+ d_status = EXIT_FAILURE;
+ }
+
+ switch (statbuf.type) {
+ case H5G_GROUP:
+ if (H5Gclose(oid) < 0) {
+ d_status = EXIT_FAILURE;
+ return FAIL;
+ }
+ break;
+
+ case H5G_DATASET:
+ if (H5Dclose(oid) < 0) {
+ d_status = EXIT_FAILURE;
+ return FAIL;
+ }
+ break;
+
+ case H5G_TYPE:
+ if (H5Tclose(oid) < 0) {
+ d_status = EXIT_FAILURE;
+ return FAIL;
+ }
+ break;
+ default:
+ d_status = EXIT_FAILURE;
+ return FAIL;
+ }
+
+ free(obj_name);
+ return SUCCEED;
+}
+
+/*-------------------------------------------------------------------------
+ * Function: dump_all
+ *
+ * Purpose: Dump everything in the specified object
+ *
+ * Return: Success: SUCCEED
+ *
+ * Failure: FAIL
+ *
+ * Programmer: Ruey-Hsia Li
+ *
+ * Modifications:
+ * RMcG, November 2000
+ * Added XML support. Also, optionally checks the op_data
+ * argument.
+ *
+ *-------------------------------------------------------------------------
+ */
+static herr_t
+dump_all(hid_t group, const char *name, void * op_data)
+{
+ hid_t obj;
+ char *buf, *tmp = NULL;
+ H5G_stat_t statbuf;
+ int i;
+ herr_t ret = SUCCEED;
+
+ H5Gget_objinfo(group, name, FALSE, &statbuf);
+
+ if (*(int *)op_data != H5G_UNKNOWN && statbuf.type != *(int *) op_data)
+ goto done;
+
+ tmp = malloc(strlen(prefix) + strlen(name) + 1);
+ strcpy(tmp, prefix);
+
+ switch (statbuf.type) {
+ case H5G_LINK:
+ indentation(indent);
+ buf = malloc(statbuf.linklen);
+
+ if (!doxml) {
+ begin_obj(dump_header_format->softlinkbegin, name,
+ dump_header_format->softlinkblockbegin);
+ indentation(indent + COL);
+ }
+
+ if (H5Gget_linkval(group, name, statbuf.linklen, buf) < 0) {
+ error_msg(progname, "unable to get link value\n");
+ d_status = EXIT_FAILURE;
+ ret = FAIL;
+ } else {
+ /* print the value of a soft link */
+ if (!doxml) {
+ /* Standard DDL: no modification */
+ printf("LINKTARGET \"%s\"\n", buf);
+ } else {
+ /* XML */
+ char *t_name = xml_escape_the_name(name);
+ char *t_buf = xml_escape_the_name(buf);
+ char *t_prefix = xml_escape_the_name(prefix);
+ char *tmp2, *t_tmp2, *t_tmp;
+
+ tmp2 = malloc(strlen(prefix) + statbuf.linklen + 1);
+ strcpy(tmp2, prefix);
+
+ if (buf && buf[0] == '/')
+ strcat(tmp2, buf);
+ else
+ strcat(strcat(tmp2, "/"), buf);
+
+ t_tmp = xml_escape_the_name(strcat(strcat(tmp, "/"), name));
+ t_tmp2 = xml_escape_the_name(tmp2);
+
+ printf("<SoftLink LinkName=\"%s\" Target=\"%s\" "
+ "TargetObj=\"%s\" OBJ-XID=\"%s\" Source=\"%s\"/>\n",
+ t_name, t_buf, t_tmp2, t_tmp,
+ (strcmp(prefix, "") ? t_prefix : "root"));
+
+ free(t_name);
+ free(t_buf);
+ free(t_prefix);
+ free(t_tmp);
+ free(t_tmp2);
+ free(tmp2);
+ }
+ }
+
+ if (!doxml) {
+ indentation(indent);
+ end_obj(dump_header_format->softlinkend,
+ dump_header_format->softlinkblockend);
+ }
+
+ free(buf);
+ break;
+
+ case H5G_GROUP:
+ if ((obj = H5Gopen(group, name)) < 0) {
+ error_msg(progname, "unable to dump group \"%s\"\n", name);
+ d_status = EXIT_FAILURE;
+ ret = FAIL;
+ } else {
+ strcat(strcat(prefix, "/"), name);
+ dump_function_table->dump_group_function(obj, name);
+ strcpy(prefix, tmp);
+ H5Gclose(obj);
+ }
+
+ break;
+
+ case H5G_DATASET:
+ if ((obj = H5Dopen(group, name)) >= 0) {
+ /* hard link */
+ H5Gget_objinfo(obj, ".", TRUE, &statbuf);
+
+ if (statbuf.nlink > 1) {
+ i = search_obj(dset_table, statbuf.objno);
+
+ if (i < 0) {
+ indentation(indent);
+ begin_obj(dump_header_format->datasetbegin, name,
+ dump_header_format->datasetblockbegin);
+ indentation(indent + COL);
+ error_msg(progname,
+ "internal error (file %s:line %d)\n",
+ __FILE__, __LINE__);
+ indentation(indent);
+ end_obj(dump_header_format->datasetend,
+ dump_header_format->datasetblockend);
+ d_status = EXIT_FAILURE;
+ ret = FAIL;
+ H5Dclose(obj);
+ goto done;
+ } else if (dset_table->objs[i].displayed) {
+ indentation(indent);
+ if (!doxml) {
+ begin_obj(dump_header_format->datasetbegin, name,
+ dump_header_format->datasetblockbegin);
+ indentation(indent + COL);
+ printf("%s \"%s\"\n", HARDLINK,
+ dset_table->objs[i].objname);
+ indentation(indent);
+ end_obj(dump_header_format->datasetend,
+ dump_header_format->datasetblockend);
+ } else {
+ /* the XML version */
+ char *t_name = xml_escape_the_name(name);
+ char *t_tmp = xml_escape_the_name(strcat(strcat(tmp, "/"), name));
+ char *t_prefix = xml_escape_the_name(prefix);
+ char *t_objname = xml_escape_the_name(dset_table->objs[i].objname);
+
+ printf("<Dataset Name=\"%s\" OBJ-XID=\"%s\" Parents=\"%s\">\n",
+ t_name, t_tmp,
+ (strcmp(prefix, "") ? t_prefix : "root"));
+
+ indentation(indent + COL);
+ printf("<DatasetPtr OBJ-XID=\"%s\"/>\n", t_objname);
+ indentation(indent);
+ printf("%s\n", dump_header_format->datasetend);
+
+ free(t_name);
+ free(t_tmp);
+ free(t_prefix);
+ free(t_objname);
+ }
+
+ H5Dclose(obj);
+ goto done;
+ } else {
+ dset_table->objs[i].displayed = 1;
+ strcat(tmp, "/");
+ strcat(tmp, name);
+ strcpy(dset_table->objs[i].objname, tmp);
+ }
+ }
+
+ dump_function_table->dump_dataset_function(obj, name);
+ H5Dclose(obj);
+ } else {
+ error_msg(progname, "unable to dump dataset \"%s\"\n", name);
+ d_status = EXIT_FAILURE;
+ ret = FAIL;
+ }
+
+ break;
+
+ case H5G_TYPE:
+ if ((obj = H5Topen(group, name)) < 0) {
+ error_msg(progname, "unable to dump data type \"%s\"\n", name);
+ d_status = EXIT_FAILURE;
+ ret = FAIL;
+ } else {
+ dump_function_table->dump_named_datatype_function(obj, name);
+ H5Tclose(obj);
+ }
+
+ break;
+
+ default:
+ error_msg(progname, "unknown object \"%s\"\n", name);
+ d_status = EXIT_FAILURE;
+ ret = FAIL;
+ }
+
+done:
+ free(tmp);
+ return ret;
+}
+
+/*-------------------------------------------------------------------------
+ * Function: dump_named_datatype
+ *
+ * Purpose: Dump named data type
+ *
+ * Return: void
+ *
+ * Programmer: Ruey-Hsia Li
+ *
+ * Modifications: Comments: not yet implemented.
+ *
+ *-------------------------------------------------------------------------
+ */
+static void
+dump_named_datatype(hid_t type, const char *name)
+{
+ indentation(indent);
+ printf("%s \"%s\" %s", dump_header_format->datatypebegin, name,
+ dump_header_format->datatypeblockbegin);
+
+ if (H5Tget_class(type) == H5T_COMPOUND) {
+ hid_t temp_type = H5Tcopy(type);
+
+ print_datatype(temp_type);
+ H5Tclose(temp_type);
+ } else {
+ indentation(indent + COL);
+ print_datatype(type);
+ printf(";\n");
+ }
+
+ indentation(indent);
+ end_obj(dump_header_format->datatypeend,
+ dump_header_format->datatypeblockend);
+}
+
+/*-------------------------------------------------------------------------
+ * Function: dump_group
+ *
+ * Purpose: Dump everything within the specified group
+ *
+ * Return: void
+ *
+ * Programmer: Ruey-Hsia Li
+ *
+ * Modifications:
+ *
+ * Call to dump_all -- add parameter to select everything.
+ *
+ *-------------------------------------------------------------------------
+ */
+static void
+dump_group(hid_t gid, const char *name)
+{
+ H5G_stat_t statbuf;
+ hid_t dset, type;
+ char typename[1024], *tmp;
+ int i, xtype = H5G_UNKNOWN; /* dump all */
+
+ tmp = malloc(strlen(prefix) + strlen(name) + 2);
+ strcpy(tmp, prefix);
+ indentation(indent);
+ begin_obj(dump_header_format->groupbegin, name,
+ dump_header_format->groupblockbegin);
+ indent += COL;
+
+ if (display_oid)
+ dump_oid(gid);
+
+ if (!strcmp(name, "/") && unamedtype)
+ /* dump unamed type in root group */
+ for (i = 0; i < type_table->nobjs; i++)
+ if (!type_table->objs[i].recorded) {
+ dset = H5Dopen(gid, type_table->objs[i].objname);
+ type = H5Dget_type(dset);
+ sprintf(typename, "#%lu:%lu",
+ type_table->objs[i].objno[0],
+ type_table->objs[i].objno[1]);
+ dump_named_datatype(type, typename);
+ H5Tclose(type);
+ H5Dclose(dset);
+ }
+
+ H5Gget_objinfo(gid, ".", TRUE, &statbuf);
+
+ if (statbuf.nlink > 1) {
+ i = search_obj(group_table, statbuf.objno);
+
+ if (i < 0) {
+ indentation(indent);
+ error_msg(progname, "internal error (file %s:line %d)\n",
+ __FILE__, __LINE__);
+ d_status = EXIT_FAILURE;
+ } else if (group_table->objs[i].displayed) {
+ indentation(indent);
+ printf("%s \"%s\"\n", HARDLINK, group_table->objs[i].objname);
+ } else {
+ strcpy(group_table->objs[i].objname, prefix);
+ group_table->objs[i].displayed = 1;
+ H5Aiterate(gid, NULL, dump_attr, NULL);
+ H5Giterate(gid, ".", NULL, dump_all, (void *) &xtype);
+ }
+ } else {
+ H5Aiterate(gid, NULL, dump_attr, NULL);
+ H5Giterate(gid, ".", NULL, dump_all, (void *) &xtype);
+ }
+
+ indent -= COL;
+ indentation(indent);
+ end_obj(dump_header_format->groupend, dump_header_format->groupblockend);
+ free(tmp);
+}
+
+/*-------------------------------------------------------------------------
+ * Function: dump_dataset
+ *
+ * Purpose: Dump the specified data set
+ *
+ * Return: void
+ *
+ * Programmer: Ruey-Hsia Li
+ *
+ * Modifications:
+ *
+ *-------------------------------------------------------------------------
+ */
+static void
+dump_dataset(hid_t did, const char *name)
+{
+ hid_t type, space;
+
+ indentation(indent);
+ begin_obj(dump_header_format->datasetbegin, name,
+ dump_header_format->datasetblockbegin);
+ type = H5Dget_type(did);
+ space = H5Dget_space(did);
+ dump_datatype(type);
+ dump_dataspace(space);
+
+ if (display_oid)
+ dump_oid(did);
+
+ if (display_data)
+ switch (H5Tget_class(type)) {
+ case H5T_TIME:
+ indentation(indent + COL);
+ printf("DATA{ not yet implemented.}\n");
+ break;
+
+ case H5T_INTEGER:
+ case H5T_FLOAT:
+ case H5T_STRING:
+ case H5T_BITFIELD:
+ case H5T_OPAQUE:
+ case H5T_COMPOUND:
+ case H5T_REFERENCE:
+ case H5T_ENUM:
+ case H5T_VLEN:
+ case H5T_ARRAY:
+ dump_data(did, DATASET_DATA);
+ break;
+
+ default:
+ break;
+ }
+
+ indent += COL;
+ H5Aiterate(did, NULL, dump_attr, NULL);
+ indent -= COL;
+ H5Tclose(type);
+ H5Sclose(space);
+ indentation(indent);
+ end_obj(dump_header_format->datasetend,
+ dump_header_format->datasetblockend);
+}
+
+/*-------------------------------------------------------------------------
+ * Function: dump_tables
+ *
+ * Purpose: display the contents of tables for debugging purposes
+ *
+ * Return: void
+ *
+ * Programmer: Ruey-Hsia Li
+ *
+ * Modifications:
+ *
+ *-------------------------------------------------------------------------
+ */
+static void
+dump_tables(void)
+{
+#ifdef H5DUMP_DEBUG
+ register int i;
+
+ printf("group_table: # of entries = %d\n", group_table->nobjs);
+
+ for (i = 0; i < group_table->nobjs; i++)
+ printf("%lu %lu %s %d %d\n", group_table->objs[i].objno[0],
+ group_table->objs[i].objno[1],
+ group_table->objs[i].objname,
+ group_table->objs[i].displayed, group_table->objs[i].recorded);
+
+ printf("\ndset_table: # of entries = %d\n", dset_table->nobjs);
+
+ for (i = 0; i < dset_table->nobjs; i++)
+ printf("%lu %lu %s %d %d\n", dset_table->objs[i].objno[0],
+ dset_table->objs[i].objno[1],
+ dset_table->objs[i].objname,
+ dset_table->objs[i].displayed, dset_table->objs[i].recorded);
+
+ printf("\ntype_table: # of entries = %d\n", type_table->nobjs);
+
+ for (i = 0; i < type_table->nobjs; i++)
+ printf("%lu %lu %s %d %d\n", type_table->objs[i].objno[0],
+ type_table->objs[i].objno[1],
+ type_table->objs[i].objname,
+ type_table->objs[i].displayed, type_table->objs[i].recorded);
+#else
+ return;
+#endif /* H5DUMP_DEBUG */
+}
+
+/*-------------------------------------------------------------------------
+ * Function: dump_data
+ *
+ * Purpose: Dump attribute or dataset data
+ *
+ * Return: void
+ *
+ * Programmer: Ruey-Hsia Li
+ *
+ * Modifications:
+ *
+ *-------------------------------------------------------------------------
+ */
+static void
+dump_data(hid_t obj_id, int obj_data)
+{
+ h5dump_t *outputformat = &dataformat;
+ int status = -1;
+ void *buf;
+ hid_t space, type, p_type;
+ int ndims, i;
+ hsize_t size[64], nelmts = 1, alloc_size;
+ int depth;
+ int stdindent = COL; /* should be 3 */
+
+ outputformat->line_ncols = nCols;
+ indent += COL;
+
+ /*
+ * the depth will tell us how far we need to indent extra. we use to just
+ * use indent but with the merging of the tools lib we have to do
+ * something different for the lib funtions... the normal indentation is 6
+ * so when we don't need any extra indentation, depth will be 0.
+ */
+ depth = indent / stdindent + 1;
+ indentation(indent);
+ begin_obj(dump_header_format->databegin, (const char *) NULL,
+ dump_header_format->datablockbegin);
+
+ /* Print all the values. */
+ if (obj_data == DATASET_DATA) {
+ status = h5dump_dset(stdout, outputformat, obj_id, -1, depth);
+ } else {
+ /* need to call h5dump_mem for the attribute data */
+ type = H5Aget_type(obj_id);
+ p_type = h5dump_fixtype(type);
+ space = H5Aget_space(obj_id);
+ ndims = H5Sget_simple_extent_dims(space, size, NULL);
+
+ for (i = 0; i < ndims; i++)
+ nelmts *= size[i];
+
+ alloc_size = nelmts * MAX(H5Tget_size(type), H5Tget_size(p_type));
+ assert(alloc_size == (hsize_t)((size_t)alloc_size)); /*check for overflow*/
+ buf = malloc((size_t)alloc_size);
+ assert(buf);
+
+ if (H5Aread(obj_id, p_type, buf) >= 0)
+ status = h5dump_mem(stdout, outputformat, obj_id, p_type, space, buf, depth);
+
+ free(buf);
+ H5Tclose(p_type);
+ H5Sclose(space);
+ H5Tclose(type);
+ }
+
+ if (status < 0) {
+ indentation(indent + COL);
+ error_msg(progname, "unable to print data\n");
+ d_status = EXIT_FAILURE;
+ }
+
+ indentation(indent);
+ end_obj(dump_header_format->dataend, dump_header_format->datablockend);
+ indent -= COL;
+}
+
+/*-------------------------------------------------------------------------
+ * Function: dump_oid
+ *
+ * Purpose: Prints the object ids
+ *
+ * Return: void
+ *
+ * Programmer: Patrick Lu
+ *
+ * Modifications:
+ *
+ *-------------------------------------------------------------------------
+ */
+static void
+dump_oid(hid_t oid)
+{
+ indentation(indent + COL);
+ printf("%s %s %d %s\n", OBJID, BEGIN, oid, END);
+}
+
+/*-------------------------------------------------------------------------
+ * Function: set_output_file
+ *
+ * Purpose: Open fname as the output file for dataset raw data.
+ * Set rawdatastream as its file stream.
+ *
+ * Return: 0 -- succeeded
+ * negative -- failed
+ *
+ * Programmer: Albert Cheng, 2000/09/30
+ *
+ * Modifications:
+ *
+ *-------------------------------------------------------------------------
+ */
+static int
+set_output_file(const char *fname)
+{
+ FILE *f; /* temporary holding place for the stream pointer
+ * so that rawdatastream is changed only when succeeded */
+
+ if ((f = fopen(fname, "w")) != NULL) {
+ rawdatastream = f;
+ return 0;
+ }
+
+ return -1;
+}
+
+/*-------------------------------------------------------------------------
+ * Function: handle_attributes
+ *
+ * Purpose: Handle the attributes from the command.
+ *
+ * Return: void
+ *
+ * Programmer: Bill Wendling
+ * Tuesday, 9. January 2001
+ *
+ * Modifications:
+ *
+ *-------------------------------------------------------------------------
+ */
+static void
+handle_attributes(hid_t fid, char *attr, void UNUSED *data)
+{
+ dump_selected_attr(fid, attr);
+}
+
+/*-------------------------------------------------------------------------
+ * Function: parse_hsize_list
+ *
+ * Purpose: Parse a list of comma or space separated integers and return
+ * them in a list. The string being passed into this function
+ * should be at the start of the list you want to parse. You are
+ * responsible for freeing the array returned from here.
+ *
+ * Lists in the so-called "terse" syntax are separated by
+ * semicolons (;). The lists themselves can be separated by
+ * either commas (,) or white spaces.
+ *
+ * Return: Success: hsize_t array. NULL is a valid return type if
+ * there aren't any elements in the array.
+ *
+ * Programmer: Bill Wendling
+ * Tuesday, 6. February 2001
+ *
+ * Modifications:
+ *
+ *-------------------------------------------------------------------------
+ */
+static hsize_t *
+parse_hsize_list(const char *h_list)
+{
+ hsize_t *p_list;
+ const char *ptr;
+ unsigned int size_count = 0, i = 0, last_digit = 0;
+
+ if (!h_list || !*h_list || *h_list == ';')
+ return NULL;
+
+ /* count how many integers do we have */
+ for (ptr = h_list; ptr && *ptr && *ptr != ';' && *ptr != ']'; ptr++)
+ if (isdigit(*ptr)) {
+ if (!last_digit)
+ /* the last read character wasn't a digit */
+ size_count++;
+
+ last_digit = 1;
+ } else {
+ last_digit = 0;
+ }
+
+ if (size_count == 0)
+ /* there aren't any integers to read */
+ return NULL;
+
+ /* allocate an array for the integers in the list */
+ p_list = calloc(size_count, sizeof(hsize_t));
+
+ for (ptr = h_list; i < size_count && ptr && *ptr && *ptr != ';' && *ptr != ']'; ptr++)
+ if (isdigit(*ptr)) {
+ /* we should have an integer now */
+ p_list[i++] = (hsize_t)atoi(ptr);
+
+ while (isdigit(*ptr))
+ /* scroll to end of integer */
+ ptr++;
+ }
+
+ return p_list;
+}
+
+/*-------------------------------------------------------------------------
+ * Function: parse_subset_params
+ *
+ * Purpose: Parse the so-called "terse" syntax for specifying subsetting
+ * parameters.
+ *
+ * Return: Success: struct subset_t object
+ * Failure: NULL
+ *
+ * Programmer: Bill Wendling
+ * Tuesday, 6. February 2001
+ *
+ * Modifications:
+ *
+ *-------------------------------------------------------------------------
+ */
+static struct subset_t *
+parse_subset_params(char *dset)
+{
+ struct subset_t *s = NULL;
+ register char *brace;
+
+ if ((brace = strrchr(dset, '[')) != NULL) {
+ char *slash = strrchr(dset, '/');
+
+ /* sanity check to make sure the [ isn't part of the dataset name */
+ if (brace > slash) {
+ *brace++ = '\0';
+ s = calloc(1, sizeof(struct subset_t));
+
+ printf("start\n");
+ s->start = parse_hsize_list(brace);
+
+ while (*brace && *brace != ';')
+ brace++;
+
+ if (*brace)
+ brace++;
+
+ printf("stride\n");
+ s->stride = parse_hsize_list(brace);
+
+ while (*brace && *brace != ';')
+ brace++;
+
+ if (*brace)
+ brace++;
+
+ printf("count\n");
+ s->count = parse_hsize_list(brace);
+
+ while (*brace && *brace != ';')
+ brace++;
+
+ if (*brace)
+ brace++;
+
+ printf("block\n");
+ s->block = parse_hsize_list(brace);
+ }
+ }
+
+ return s;
+}
+
+/*-------------------------------------------------------------------------
+ * Function: handle_datasets
+ *
+ * Purpose: Handle the datasets from the command.
+ *
+ * Return: void
+ *
+ * Programmer: Bill Wendling
+ * Tuesday, 9. January 2001
+ *
+ * Modifications:
+ *
+ *-------------------------------------------------------------------------
+ */
+static void
+handle_datasets(hid_t fid, char *dset, void *data)
+{
+ H5G_stat_t statbuf;
+ hid_t dsetid;
+ struct subset_t *sset = (struct subset_t *)data;
+
+ if ((dsetid = H5Dopen(fid, dset)) < 0) {
+ begin_obj(dump_header_format->datasetbegin, dset,
+ dump_header_format->datasetblockbegin);
+ indentation(COL);
+ error_msg(progname, "unable to open dataset \"%s\"\n", dset);
+ end_obj(dump_header_format->datasetend,
+ dump_header_format->datasetblockend);
+ d_status = EXIT_FAILURE;
+ } else {
+ H5Gget_objinfo(dsetid, ".", TRUE, &statbuf);
+
+ if (statbuf.nlink > 1) {
+ int index = search_obj(dset_table, statbuf.objno);
+
+ if (index >= 0) {
+ if (dset_table->objs[index].displayed) {
+ begin_obj(dump_header_format->datasetbegin, dset,
+ dump_header_format->datasetblockbegin);
+ indentation(indent + COL);
+ printf("%s \"%s\"\n", HARDLINK,
+ dset_table->objs[index].objname);
+ indentation(indent);
+ end_obj(dump_header_format->datasetend,
+ dump_header_format->datasetblockend);
+ } else {
+ strcpy(dset_table->objs[index].objname, dset);
+ dset_table->objs[index].displayed = 1;
+ dump_dataset(dsetid, dset);
+ }
+ } else {
+ d_status = EXIT_FAILURE;
+ }
+ } else {
+ dump_dataset(dsetid, dset);
+ }
+
+ if (H5Dclose(dsetid) < 1)
+ d_status = EXIT_FAILURE;
+ }
+}
+
+/*-------------------------------------------------------------------------
+ * Function: handle_groups
+ *
+ * Purpose: Handle the groups from the command.
+ *
+ * Return: void
+ *
+ * Programmer: Bill Wendling
+ * Tuesday, 9. January 2001
+ *
+ * Modifications:
+ *
+ *-------------------------------------------------------------------------
+ */
+static void
+handle_groups(hid_t fid, char *group, void UNUSED *data)
+{
+ H5G_stat_t statbuf;
+ hid_t gid;
+
+ if ((gid = H5Gopen(fid, group)) < 0) {
+ begin_obj(dump_header_format->groupbegin, group,
+ dump_header_format->groupblockbegin);
+ indentation(COL);
+ error_msg(progname, "unable to open group \"%s\"\n", group);
+ end_obj(dump_header_format->groupend,
+ dump_header_format->groupblockend);
+ d_status = EXIT_FAILURE;
+ } else {
+ H5Gget_objinfo(gid, ".", TRUE, &statbuf);
+ strcpy(prefix, group);
+ dump_group(gid, group);
+
+ if (H5Gclose(gid) < 0)
+ d_status = EXIT_FAILURE;
+ }
+}
+
+/*-------------------------------------------------------------------------
+ * Function: handle_links
+ *
+ * Purpose: Handle the links from the command.
+ *
+ * Return: void
+ *
+ * Programmer: Bill Wendling
+ * Tuesday, 9. January 2001
+ *
+ * Modifications:
+ *
+ *-------------------------------------------------------------------------
+ */
+static void
+handle_links(hid_t fid, char *links, void UNUSED *data)
+{
+ H5G_stat_t statbuf;
+
+ if (H5Gget_objinfo(fid, links, FALSE, &statbuf) < 0) {
+ begin_obj(dump_header_format->softlinkbegin, links,
+ dump_header_format->softlinkblockbegin);
+ indentation(COL);
+ error_msg(progname, "unable to get obj info from \"%s\"\n", links);
+ end_obj(dump_header_format->softlinkend,
+ dump_header_format->softlinkblockend);
+ d_status = EXIT_FAILURE;
+ } else if (statbuf.type == H5G_LINK) {
+ char *buf = malloc(statbuf.linklen);
+
+ begin_obj(dump_header_format->softlinkbegin, links,
+ dump_header_format->softlinkblockbegin);
+ indentation(COL);
+
+ if (H5Gget_linkval(fid, links, statbuf.linklen, buf) >= 0) {
+ printf("LINKTARGET \"%s\"\n", buf);
+ } else {
+ error_msg(progname, "h5dump error: unable to get link value for \"%s\"\n",
+ links);
+ d_status = EXIT_FAILURE;
+ }
+
+ end_obj(dump_header_format->softlinkend,
+ dump_header_format->softlinkblockend);
+ free(buf);
+ } else {
+ begin_obj(dump_header_format->softlinkbegin, links,
+ dump_header_format->softlinkblockbegin);
+ indentation(COL);
+ error_msg(progname, "\"%s\" is not a link\n", links);
+ end_obj(dump_header_format->softlinkend,
+ dump_header_format->softlinkblockend);
+ d_status = EXIT_FAILURE;
+ }
+}
+
+/*-------------------------------------------------------------------------
+ * Function: handle_datatypes
+ *
+ * Purpose: Handle the datatypes from the command.
+ *
+ * Return: void
+ *
+ * Programmer: Bill Wendling
+ * Tuesday, 9. January 2001
+ *
+ * Modifications:
+ *
+ *-------------------------------------------------------------------------
+ */
+static void
+handle_datatypes(hid_t fid, char *type, void UNUSED *data)
+{
+ hid_t typeid;
+
+ if ((typeid = H5Topen(fid, type)) < 0) {
+ /* check if type is unamed data type */
+ int index = 0;
+
+ while (index < type_table->nobjs ) {
+ char name[128], name1[128];
+
+ if (!type_table->objs[index].recorded) {
+ /* unamed data type */
+ sprintf(name, "#%lu:%lu\n",
+ type_table->objs[index].objno[0],
+ type_table->objs[index].objno[1]);
+ sprintf(name1, "/#%lu:%lu\n",
+ type_table->objs[index].objno[0],
+ type_table->objs[index].objno[1]);
+
+ if (!strncmp(name, type, strlen(type)) ||
+ !strncmp(name1, type, strlen(type)))
+ break;
+ }
+
+ index++;
+ }
+
+ if (index == type_table->nobjs) {
+ /* unknown type */
+ begin_obj(dump_header_format->datatypebegin, type,
+ dump_header_format->datatypeblockbegin);
+ indentation(COL);
+ error_msg(progname, "unable to open datatype \"%s\"\n", type);
+ end_obj(dump_header_format->datatypeend,
+ dump_header_format->datatypeblockend);
+ d_status = EXIT_FAILURE;
+ } else {
+ hid_t dsetid = H5Dopen(fid, type_table->objs[index].objname);
+ typeid = H5Dget_type(dsetid);
+ dump_named_datatype(typeid, type);
+ H5Tclose(typeid);
+ H5Dclose(dsetid);
+ }
+ } else {
+ dump_named_datatype(typeid, type);
+
+ if (H5Tclose(typeid) < 0)
+ d_status = EXIT_FAILURE;
+ }
+}
+
+
+/*-------------------------------------------------------------------------
+ * Function: parse_command_line
+ *
+ * Purpose: Parse the command line for the h5dumper.
+ *
+ * Return: Success: A pointer to an array of handler_t structures.
+ * These contain all the information needed to dump
+ * the necessary object.
+ *
+ * Failure: Exits program with EXIT_FAILURE value.
+ *
+ * Programmer: Bill Wendling
+ * Tuesday, 20. February 2001
+ *
+ * Modifications:
+ *
+ *-------------------------------------------------------------------------
+ */
+static struct handler_t *
+parse_command_line(int argc, const char *argv[])
+{
+ struct handler_t *hand, *last_dset;
+ int i, opt, last_was_dset = FALSE;
+
+ if (argc < 2) {
+ usage(progname);
+ exit(EXIT_FAILURE);
+ }
+
+ /* this will be plenty big enough to hold the info */
+ hand = calloc((size_t)argc, sizeof(struct handler_t));
+
+ /* parse command line options */
+ while ((opt = get_option(argc, argv, s_opts, l_opts)) != EOF) {
+parse_start:
+ switch ((char)opt) {
+ case 'B':
+ display_bb = TRUE;
+ last_was_dset = FALSE;
+ break;
+ case 'H':
+ display_data = FALSE;
+ last_was_dset = FALSE;
+ break;
+ case 'v':
+ display_oid = TRUE;
+ last_was_dset = FALSE;
+ break;
+ case 'V':
+ print_version(progname);
+ exit(EXIT_SUCCESS);
+ break;
+ case 'w':
+ nCols = atoi(opt_arg);
+ last_was_dset = FALSE;
+ break;
+ case 'a':
+ display_all = 0;
+
+ for (i = 0; i < argc; i++)
+ if (!hand[i].func) {
+ hand[i].func = handle_attributes;
+ hand[i].obj = strdup(opt_arg);
+ break;
+ }
+
+ last_was_dset = FALSE;
+ break;
+ case 'd':
+ display_all = 0;
+
+ for (i = 0; i < argc; i++)
+ if (!hand[i].func) {
+ hand[i].func = handle_datasets;
+ hand[i].obj = strdup(opt_arg);
+ hand[i].subset_info = parse_subset_params(hand[i].obj);
+ last_dset = hand;
+ break;
+ }
+
+ last_was_dset = TRUE;
+ break;
+ case 'g':
+ display_all = 0;
+
+ for (i = 0; i < argc; i++)
+ if (!hand[i].func) {
+ hand[i].func = handle_groups;
+ hand[i].obj = strdup(opt_arg);
+ break;
+ }
+
+ last_was_dset = FALSE;
+ break;
+ case 'l':
+ display_all = 0;
+
+ for (i = 0; i < argc; i++)
+ if (!hand[i].func) {
+ hand[i].func = handle_links;
+ hand[i].obj = strdup(opt_arg);
+ break;
+ }
+
+ last_was_dset = FALSE;
+ break;
+ case 't':
+ display_all = 0;
+
+ for (i = 0; i < argc; i++)
+ if (!hand[i].func) {
+ hand[i].func = handle_datatypes;
+ hand[i].obj = strdup(opt_arg);
+ break;
+ }
+
+ last_was_dset = FALSE;
+ break;
+ case 'o':
+ if (set_output_file(opt_arg) < 0){
+ /* failed to set output file */
+ usage(progname);
+ exit(EXIT_FAILURE);
+ }
+
+ usingdasho = TRUE;
+ last_was_dset = FALSE;
+ break;
+
+ /** XML parameters **/
+ case 'x':
+ /* select XML output */
+ doxml = TRUE;
+ dump_header_format = &xmlformat;
+ dump_function_table = &xml_function_table;
+ break;
+ case 'D':
+ /* specify alternative XML DTD */
+ xml_dtd_uri = opt_arg;
+ break;
+ /** end XML parameters **/
+
+ /** subsetting parameters **/
+ case 's':
+ case 'T':
+ case 'c':
+ case 'k': {
+ struct subset_t *s;
+
+ if (!last_was_dset) {
+ error_msg(progname,
+ "option `-%c' can only be used after --dataset option\n",
+ opt);
+ exit(EXIT_FAILURE);
+ }
+
+ if (last_dset->subset_info) {
+ /*
+ * This overrides the "terse" syntax if they actually mixed
+ * the two.
+ */
+ s = last_dset->subset_info;
+ } else {
+ last_dset->subset_info = s = calloc(1, sizeof(struct subset_t));
+ }
+
+ /*
+ * slightly convoluted, but...we are only interested in options
+ * for subsetting: "--start", "--stride", "--count", and "--block"
+ * which can come in any order. If we run out of parameters (EOF)
+ * or run into one which isn't a subsetting parameter (NOT s, T,
+ * c, or K), then we exit the do-while look, set the subset_info
+ * to the structure we've been filling. If we've reached the end
+ * of the options, we exit the parsing (goto parse_end) otherwise,
+ * since we've "read" the next option, we need to parse it. So we
+ * jump to the beginning of the switch statement (goto parse_start).
+ */
+ do {
+ switch ((char)opt) {
+ case 's': free(s->start); s->start = parse_hsize_list(opt_arg); break;
+ case 'T': free(s->stride); s->stride = parse_hsize_list(opt_arg); break;
+ case 'c': free(s->count); s->count = parse_hsize_list(opt_arg); break;
+ case 'k': free(s->block); s->block = parse_hsize_list(opt_arg); break;
+ default: goto end_collect;
+ }
+ } while ((opt = get_option(argc, argv, s_opts, l_opts)) != EOF);
+
+end_collect:
+ last_was_dset = FALSE;
+
+ if (opt != EOF)
+ goto parse_start;
+ else
+ goto parse_end;
+ }
+ /** end subsetting parameters **/
+
+ case 'h':
+ usage(progname);
+ exit(EXIT_SUCCESS);
+ case '?':
+ default:
+ usage(progname);
+ exit(EXIT_FAILURE);
+ }
+ }
+
+parse_end:
+ return hand;
+}
+
+
+/*-------------------------------------------------------------------------
+ * Function: free_handler
+ *
+ * Purpose: Convenience function to free the handler_t structures. Needs a
+ * length variable (LEN) to know how many in the array it needs
+ * to free
+ *
+ * Return: Nothing
+ *
+ * Programmer: Bill Wendling
+ * Tuesday, 20. February 2001
+ *
+ * Modifications:
+ *
+ *-------------------------------------------------------------------------
+ */
+static void
+free_handler(struct handler_t *hand, int len)
+{
+ register int i;
+
+ for (i = 0; i < len; i++) {
+ free(hand[i].obj);
+
+ if (hand[i].subset_info) {
+ free(hand[i].subset_info->start);
+ free(hand[i].subset_info->stride);
+ free(hand[i].subset_info->count);
+ free(hand[i].subset_info->block);
+ free(hand[i].subset_info);
+ }
+ }
+
+ free(hand);
+}
+
+/*-------------------------------------------------------------------------
+ * Function: main
+ *
+ * Purpose: HDF5 dumper
+ *
+ * Return: Success: 0
+ * Failure: 1
+ *
+ * Programmer: Ruey-Hsia Li
+ *
+ * Modifications:
+ * Albert Cheng
+ * 30. September 2000
+ * Add the -o option--output file for datasets raw data
+ *
+ * REMcG
+ * November 2000
+ * Changes to support XML.
+ *
+ * Bill Wendling
+ * Wednesday, 10. January 2001
+ * Modified the way command line parameters are interpreted. They go
+ * through one function call now (get_option).
+ *
+ * Bill Wendling
+ * Tuesday, 20. February 2001
+ * Moved command line parsing to separate function. Made various
+ * "display_*" flags global.
+ *
+ *-------------------------------------------------------------------------
+ */
+int
+main(int argc, const char *argv[])
+{
+ hid_t fid, gid;
+ const char *fname = NULL;
+ void *edata;
+ hid_t (*func)(void*);
+ find_objs_t info;
+ struct handler_t *hand;
+ int i;
+
+ if (argc < 2) {
+ usage(progname);
+ exit(EXIT_FAILURE);
+ }
+
+ dump_header_format = &standardformat;
+ dump_function_table = &ddl_function_table;
+
+ /* Disable error reporting */
+ H5Eget_auto(&func, &edata);
+ H5Eset_auto(NULL, NULL);
+
+ /* Initialize h5tools lib */
+ h5tools_init();
+ hand = parse_command_line(argc, argv);
+
+ /* Check for conflicting options */
+ if (doxml) {
+ if (!display_all) {
+ error_msg(progname, "option \"%s\" not available for XML\n",
+ "to display selected objects");
+ exit(EXIT_FAILURE);
+ } else if (display_bb) {
+ error_msg(progname, "option \"%s\" not available for XML\n",
+ "--boot-block");
+ exit(EXIT_FAILURE);
+ } else if (!display_data) {
+ error_msg(progname, "option \"%s\" not available for XML\n",
+ "--header");
+ exit(EXIT_FAILURE);
+ } else if (display_oid == 1) {
+ error_msg(progname, "option \"%s\" not available for XML\n",
+ "--object-ids");
+ exit(EXIT_FAILURE);
+ } else if (usingdasho) {
+ error_msg(progname, "option \"%s\" not available for XML\n",
+ "--output");
+ exit(EXIT_FAILURE);
+ }
+ } else {
+ if (xml_dtd_uri) {
+ warn_msg(progname, "option \"%s\" only applies with XML: %s\n",
+ "--xml-dtd", xml_dtd_uri);
+ }
+ }
+
+ if (argv[opt_ind][0] == '\\')
+ fname = &argv[opt_ind][1];
+ else
+ fname = argv[opt_ind];
+
+ fid = h5dump_fopen(fname, NULL, 0);
+
+ if (fid < 0) {
+ error_msg(progname, "unable to open file \"%s\"\n", fname);
+ exit(EXIT_FAILURE);
+ }
+
+ /* allocate and initialize internal data structure */
+ init_table(&group_table);
+ init_table(&type_table);
+ init_table(&dset_table);
+ init_prefix(&prefix, prefix_len);
+
+ /* init the find_objs_t */
+ info.threshold = 0;
+ info.prefix_len = prefix_len;
+ info.prefix = calloc((size_t)info.prefix_len, 1);
+ info.group_table = group_table;
+ info.type_table = type_table;
+ info.dset_table = dset_table;
+ info.status = d_status;
+
+ if (doxml) {
+ /* initialize XML */
+ thefile = fid;
+
+ /* find all objects that might be targets of a refernce */
+ if ((gid = H5Gopen(fid, "/")) < 0) {
+ error_msg(progname, "unable to open root group\n");
+ d_status = EXIT_FAILURE;
+ goto done;
+ }
+
+ ref_path_table_put(gid, "/");
+ H5Giterate(fid, "/", NULL, fill_ref_path_table, NULL);
+ H5Gclose(gid);
+
+ /* reset prefix! */
+ strcpy(prefix, "");
+
+ /* make sure the URI is initialized to something */
+ if (xml_dtd_uri == NULL)
+ xml_dtd_uri = DEFAULT_DTD;
+ }
+
+ /* find all shared objects */
+ H5Giterate(fid, "/", NULL, find_objs, (void *)&info);
+
+ /* does there exist unamed committed data type */
+ for (i = 0; i < type_table->nobjs; i++)
+ if (type_table->objs[i].recorded == 0)
+ unamedtype = 1;
+
+ dump_tables();
+
+ if (info.status) {
+ error_msg(progname, "internal error (file %s:line %d)\n",
+ __FILE__, __LINE__);
+ d_status = EXIT_FAILURE;
+ goto done;
+ }
+
+ /* start to dump */
+ if (!doxml) {
+ begin_obj(dump_header_format->filebegin, fname,
+ dump_header_format->fileblockbegin);
+ } else {
+ printf("<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n");
+ printf("<!DOCTYPE HDF5-File PUBLIC \"HDF5-File.dtd\" \"%s\">\n",
+ xml_dtd_uri);
+ printf("<HDF5-File>\n");
+ }
+
+ if (display_bb)
+ dump_bb();
+
+ if (display_all) {
+ if ((gid = H5Gopen(fid, "/")) < 0) {
+ error_msg(progname, "unable to open root group\n");
+ d_status = EXIT_FAILURE;
+ } else {
+ dump_function_table->dump_group_function(gid, "/");
+ }
+
+ if (H5Gclose(gid) < 0) {
+ error_msg(progname, "unable to close root group\n");
+ d_status = EXIT_FAILURE;
+ }
+ } else {
+ if (doxml) {
+ /* Note: this option is not supported for XML */
+ error_msg(progname, "internal error (file %s:line %d)\n",
+ __FILE__, __LINE__);
+ d_status = EXIT_FAILURE;
+ goto done;
+ }
+
+ for (i = 0; i < argc; i++)
+ if (hand[i].func)
+ hand[i].func(fid, hand[i].obj, hand[i].subset_info);
+ }
+
+ if (!doxml) {
+ end_obj(dump_header_format->fileend,
+ dump_header_format->fileblockend);
+ } else {
+ printf("%s\n", dump_header_format->fileend);
+ }
+
+done:
+ if (H5Fclose(fid) < 0)
+ d_status = EXIT_FAILURE;
+
+ free_handler(hand, argc);
+
+ free(group_table->objs);
+ free(dset_table->objs);
+ free(type_table->objs);
+ free(prefix);
+ free(info.prefix);
+
+ /* To Do: clean up XML table */
+
+ h5tools_close();
+ H5Eset_auto(func, edata);
+ return d_status;
+}
+
+/*-------------------------------------------------------------------------
+ * Function: print_enum
+ *
+ * Purpose: prints the enum data -
+ *
+ * Return: void
+ *
+ * Programmer: Patrick Lu
+ *
+ * Modifications:
+ *
+ * NOTE: this function was taken from h5ls. should be moved into the toolslib
+ *
+ *-----------------------------------------------------------------------*/
+static void
+print_enum(hid_t type)
+{
+ char **name = NULL; /*member names */
+ unsigned char *value = NULL; /*value array */
+ int nmembs; /*number of members */
+ int nchars; /*number of output characters */
+ hid_t super; /*enum base integer type */
+ hid_t native = -1; /*native integer data type */
+ size_t dst_size; /*destination value type size */
+ int i;
+
+ nmembs = H5Tget_nmembers(type);
+ super = H5Tget_super(type);
+
+ /*
+ * Determine what data type 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 */
+ assert(nmembs>0);
+ name = calloc((size_t)nmembs, sizeof(char *));
+ value = calloc((size_t)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 data type */
+ if (native > 0)
+ H5Tconvert(super, native, (hsize_t)nmembs, value, NULL, H5P_DEFAULT);
+
+ /*
+ * Sort members by increasing value
+ * ***not implemented yet***
+ */
+
+ /* Print members */
+ for (i = 0; i < nmembs; i++) {
+ indentation(indent + COL);
+ nchars = printf("\"%s\"", name[i]);
+ printf("%*s ", MAX(0, 16 - nchars), "");
+
+ if (native < 0) {
+ size_t j;
+
+ printf("0x");
+
+ for (j = 0; j < dst_size; j++)
+ printf("%02x", value[i * dst_size + j]);
+ } else if (H5T_SGN_NONE == H5Tget_sign(native)) {
+ printf("%" PRINTF_LL_WIDTH "u", *((unsigned long_long *)
+ ((void *) (value + i * dst_size))));
+ } else {
+ printf("%" PRINTF_LL_WIDTH "d",
+ *((long_long *) ((void *) (value + i * dst_size))));
+ }
+
+ printf(";\n");
+ }
+
+ /* Release resources */
+ for (i = 0; i < nmembs; i++)
+ free(name[i]);
+
+ free(name);
+ free(value);
+ H5Tclose(super);
+
+ if (0 == nmembs)
+ printf("\n%*s <empty>", indent + 4, "");
+}
+
+/*
+ * XML support
+ */
+
+/*
+ * XML needs a table to look up a path name for an object
+ * reference.
+ *
+ * This table stores mappings of reference -> path
+ * for all objects in the file that may be the target of
+ * an object reference.
+ *
+ * The 'path' is an absolute path by which the object
+ * can be accessed. When an object has > 1 such path,
+ * only one will be used in the table, with no particular
+ * method of selecting which one.
+ */
+
+struct ref_path_table_entry_t {
+ hsize_t obj;
+ hobj_ref_t *obj_ref;
+ char *apath;
+ struct ref_path_table_entry_t *next;
+};
+
+struct ref_path_table_entry_t *ref_path_table = NULL; /* the table */
+int npte = 0; /* number of entries in the table */
+
+/*-------------------------------------------------------------------------
+ * Function: ref_path_table_lookup
+ *
+ * Purpose: Looks up a table entry given a path name.
+ * Used during construction of the table.
+ *
+ * Return: The table entre (pte) or NULL if not in the
+ * table.
+ *
+ * Programmer: REMcG
+ *
+ * Modifications:
+ *
+ *-------------------------------------------------------------------------
+ */
+static struct ref_path_table_entry_t *
+ref_path_table_lookup(const char *thepath)
+{
+ int i;
+ hobj_ref_t *ref;
+ herr_t status;
+ struct ref_path_table_entry_t *pte = ref_path_table;
+
+ if (ref_path_table == NULL)
+ return NULL;
+
+ ref = (hobj_ref_t *) malloc(sizeof(hobj_ref_t));
+
+ if (ref == NULL) {
+ /* fatal error ? */
+ return NULL;
+ }
+
+ status = H5Rcreate(ref, thefile, thepath, H5R_OBJECT, -1);
+
+ if (status < 0) {
+ /* fatal error ? */
+ return NULL;
+ }
+
+ for (i = 0; i < npte; i++) {
+ if (memcmp(ref, pte->obj_ref, sizeof(hobj_ref_t)) == 0) {
+ return pte;
+ }
+
+ pte = pte->next;
+ }
+
+ return NULL;
+}
+
+/*-------------------------------------------------------------------------
+ * Function: ref_path_table_put
+ *
+ * Purpose: Enter the 'obj' with 'path' in the table if
+ * not already there.
+ * Create an object reference, pte, and store them
+ * in the table.
+ *
+ * Return: The object reference for the object.
+ *
+ * Programmer: REMcG
+ *
+ * Modifications:
+ *
+ *-------------------------------------------------------------------------
+ */
+static hobj_ref_t *
+ref_path_table_put(hid_t obj, const char *path)
+{
+ hobj_ref_t *ref;
+ herr_t status;
+ struct ref_path_table_entry_t *pte;
+
+ /* look up 'obj'. If already in table, return */
+ pte = ref_path_table_lookup(path);
+ if (pte != NULL)
+ return pte->obj_ref;
+
+ /* if not found, then make new entry */
+
+ pte = (struct ref_path_table_entry_t *)
+ malloc(sizeof(struct ref_path_table_entry_t));
+ if (pte == NULL) {
+ /* fatal error? */
+ return NULL;
+ }
+
+ pte->obj = obj;
+ ref = (hobj_ref_t *) malloc(sizeof(hobj_ref_t));
+ if (ref == NULL) {
+ /* fatal error? */
+ free(pte);
+ return NULL;
+ }
+
+ status = H5Rcreate(ref, thefile, path, H5R_OBJECT, -1);
+ if (status < 0) {
+ /* fatal error? */
+ free(ref);
+ free(pte);
+ return NULL;
+ }
+
+ pte->obj_ref = ref;
+
+ pte->apath = strdup(path);
+
+ pte->next = ref_path_table;
+ ref_path_table = pte;
+
+ npte++;
+
+ return ref;
+}
+
+/*-------------------------------------------------------------------------
+ * Function: lookup_ref_path
+ *
+ * Purpose: Lookup the path to the object with refernce 'ref'.
+ *
+ * Return: Return a path to the object, or NULL if not found.
+ *
+ * Programmer: REMcG
+ *
+ * Modifications:
+ *
+ *-------------------------------------------------------------------------
+ */
+static char *
+lookup_ref_path(hobj_ref_t * ref)
+{
+ int i;
+ struct ref_path_table_entry_t *pte = NULL;
+
+ if (ref_path_table == NULL)
+ return NULL;
+
+ pte = ref_path_table;
+ if (pte == NULL) {
+ /* fatal -- not initialized? */
+ return NULL;
+ }
+ for (i = 0; i < npte; i++) {
+ if (memcmp(ref, pte->obj_ref, sizeof(hobj_ref_t)) == 0) {
+ return pte->apath;
+ }
+ pte = pte->next;
+ }
+ return NULL;
+}
+
+/*-------------------------------------------------------------------------
+ * Function: fill_ref_path_table
+ *
+ * Purpose: Called by interator to create references for
+ * all objects and enter them in the table.
+ *
+ * Return: Error status.
+ *
+ * Programmer: REMcG
+ *
+ * Modifications:
+ *
+ *-------------------------------------------------------------------------
+ */
+static herr_t
+fill_ref_path_table(hid_t group, const char *name, void UNUSED * op_data)
+{
+ hid_t obj;
+ char *tmp;
+ H5G_stat_t statbuf;
+ struct ref_path_table_entry_t *pte;
+ char *thepath;
+
+ H5Gget_objinfo(group, name, FALSE, &statbuf);
+ tmp = (char *) malloc(strlen(prefix) + strlen(name) + 2);
+
+ if (tmp == NULL)
+ return FAIL;
+
+ thepath = (char *) malloc(strlen(prefix) + strlen(name) + 2);
+
+ if (thepath == NULL) {
+ free(tmp);
+ return FAIL;
+ }
+
+ strcpy(tmp, prefix);
+
+ strcpy(thepath, prefix);
+ strcat(thepath, "/");
+ strcat(thepath, name);
+
+ switch (statbuf.type) {
+ case H5G_DATASET:
+ if ((obj = H5Dopen(group, name)) >= 0) {
+ pte = ref_path_table_lookup(thepath);
+ if (pte == NULL) {
+ ref_path_table_put(obj, thepath);
+ }
+ H5Dclose(obj);
+ } else {
+ error_msg(progname, "unable to get dataset \"%s\"\n", name);
+ d_status = EXIT_FAILURE;
+ }
+ break;
+ case H5G_GROUP:
+ if ((obj = H5Gopen(group, name)) >= 0) {
+ strcat(strcat(prefix, "/"), name);
+ pte = ref_path_table_lookup(thepath);
+ if (pte == NULL) {
+ ref_path_table_put(obj, thepath);
+ H5Giterate(obj, ".", NULL, fill_ref_path_table, NULL);
+ strcpy(prefix, tmp);
+ }
+ H5Gclose(obj);
+ } else {
+ error_msg(progname, "unable to dump group \"%s\"\n", name);
+ d_status = EXIT_FAILURE;
+ }
+ break;
+ case H5G_TYPE:
+ if ((obj = H5Topen(group, name)) >= 0) {
+ pte = ref_path_table_lookup(thepath);
+ if (pte == NULL) {
+ ref_path_table_put(obj, thepath);
+ }
+ H5Tclose(obj);
+ } else {
+ error_msg(progname, "unable to get dataset \"%s\"\n", name);
+ d_status = EXIT_FAILURE;
+ }
+ break;
+ default:;
+ }
+
+ free(tmp);
+ free(thepath);
+ return 0;
+}
+
+static const char *quote = "&quot;";
+static const char *amp = "&amp;";
+static const char *lt = "&lt;";
+static const char *gt = "&gt;";
+static const char *apos = "&apos;";
+
+/*-------------------------------------------------------------------------
+ * Function: xml_escape_the_name
+ *
+ * Purpose: Escape XML reserved chars in a name, so HDF5 strings
+ * and paths can be correctly read back in XML element.
+ *
+ * Return: The revised string.
+ *
+ * Programmer: REMcG
+ *
+ * Modifications:
+ *
+ *-------------------------------------------------------------------------
+ */
+static char *
+xml_escape_the_name(const char *str)
+{
+ int extra;
+ int len;
+ int i;
+ const char *cp;
+ char *ncp;
+ char *rcp;
+
+ if (!str)
+ return NULL;
+
+ cp = str;
+ len = strlen(str);
+ extra = 0;
+
+ for (i = 0; i < len; i++) {
+ if (*cp == '\"') {
+ extra += (strlen(quote) - 1);
+ } else if (*cp == '\'') {
+ extra += (strlen(apos) - 1);
+ } else if (*cp == '<') {
+ extra += (strlen(lt) - 1);
+ } else if (*cp == '>') {
+ extra += (strlen(gt) - 1);
+ } else if (*cp == '&') {
+ extra += (strlen(amp) - 1);
+ }
+
+ cp++;
+ }
+
+ if (extra == 0)
+ return strdup(str);
+
+ cp = str;
+ rcp = ncp = calloc((size_t)(len + extra + 1), sizeof(char));
+
+ if (!ncp)
+ return NULL; /* ?? */
+
+ for (i = 0; i < len; i++) {
+ if (*cp == '\'') {
+ strncpy(ncp, apos, strlen(apos));
+ ncp += strlen(apos);
+ cp++;
+ } else if (*cp == '<') {
+ strncpy(ncp, lt, strlen(lt));
+ ncp += strlen(lt);
+ cp++;
+ } else if (*cp == '>') {
+ strncpy(ncp, gt, strlen(gt));
+ ncp += strlen(gt);
+ cp++;
+ } else if (*cp == '\"') {
+ strncpy(ncp, quote, strlen(quote));
+ ncp += strlen(quote);
+ cp++;
+ } else if (*cp == '&') {
+ strncpy(ncp, amp, strlen(amp));
+ ncp += strlen(amp);
+ cp++;
+ } else {
+ *ncp++ = *cp++;
+ }
+ }
+
+ *ncp = '\0';
+ return rcp;
+}
+
+/*-------------------------------------------------------------------------
+ * Function: xml_escape_the_string
+ *
+ * Purpose: Escape XML reserved chars in a string, so HDF5 strings
+ * and paths can be correctly read back in XML CDATA.
+ *
+ * Return: The revised string.
+ *
+ * Programmer: REMcG
+ *
+ * Modifications:
+ *
+ *-------------------------------------------------------------------------
+ */
+static char *
+xml_escape_the_string(const char *str, int slen)
+{
+ int extra;
+ int len;
+ int i;
+ const char *cp;
+ char *ncp;
+ char *rcp;
+
+ if (!str)
+ return NULL;
+
+ cp = str;
+
+ if (slen < 0)
+ len = strlen(str);
+ else
+ len = slen;
+
+ extra = 0;
+
+ for (i = 0; i < len; i++) {
+ if (*cp == '\\') {
+ extra++;
+ } else if (*cp == '\"') {
+ extra++;
+ } else if (*cp == '\'') {
+ extra += (strlen(apos) - 1);
+ } else if (*cp == '<') {
+ extra += (strlen(lt) - 1);
+ } else if (*cp == '>') {
+ extra += (strlen(gt) - 1);
+ } else if (*cp == '&') {
+ extra += (strlen(amp) - 1);
+ }
+ cp++;
+ }
+
+ cp = str;
+ rcp = ncp = calloc((size_t)(len + extra + 1), sizeof(char));
+
+ if (ncp == NULL)
+ return NULL; /* ?? */
+
+ for (i = 0; i < len; i++) {
+ if (*cp == '\\') {
+ *ncp++ = '\\';
+ *ncp++ = *cp++;
+ } else if (*cp == '\"') {
+ *ncp++ = '\\';
+ *ncp++ = *cp++;
+ } else if (*cp == '\'') {
+ strncpy(ncp, apos, strlen(apos));
+ ncp += strlen(apos);
+ cp++;
+ } else if (*cp == '<') {
+ strncpy(ncp, lt, strlen(lt));
+ ncp += strlen(lt);
+ cp++;
+ } else if (*cp == '>') {
+ strncpy(ncp, gt, strlen(gt));
+ ncp += strlen(gt);
+ cp++;
+ } else if (*cp == '&') {
+ strncpy(ncp, amp, strlen(amp));
+ ncp += strlen(amp);
+ cp++;
+ } else {
+ *ncp++ = *cp++;
+ }
+ }
+
+ *ncp = '\0';
+ return rcp;
+}
+
+/**
+ ** XML print functions--these replace some functions in the
+ ** h5tools.c suite.
+ **/
+
+/*-------------------------------------------------------------------------
+ * Function: xml_print_datatype
+ *
+ * Purpose: Print description of a datatype in XML.
+ * Note: this is called inside a <DataType> element.
+ *
+ * Return: void
+ *
+ * Programmer: REMcG
+ *
+ * Modifications:
+ *
+ *-------------------------------------------------------------------------
+ */
+static void
+xml_print_datatype(hid_t type)
+{
+ char *fname;
+ hid_t nmembers, mtype;
+ int i, j, ndims, perm[H5DUMP_MAX_RANK];
+ size_t size;
+ hsize_t dims[H5DUMP_MAX_RANK];
+ H5T_str_t str_pad;
+ H5T_cset_t cset;
+ H5G_stat_t statbuf;
+ hid_t super;
+ H5T_order_t ord;
+ H5T_sign_t sgn;
+ size_t sz;
+ size_t spos;
+ size_t epos;
+ size_t esize;
+ size_t mpos;
+ size_t msize;
+ int nmembs;
+
+ switch (H5Tget_class(type)) {
+ case H5T_INTEGER:
+ indentation(indent);
+ printf("<AtomicType>\n");
+ indent += COL;
+ /* <IntegerType ByteOrder="bo" Sign="torf" Size="bytes"/> */
+ ord = H5Tget_order(type);
+ sgn = H5Tget_sign(type);
+ indentation(indent);
+ printf("<IntegerType ByteOrder=\"");
+ switch (ord) {
+ case H5T_ORDER_LE:
+ printf("LE");
+ break;
+ case H5T_ORDER_BE:
+ printf("BE");
+ break;
+ case H5T_ORDER_VAX:
+ default:
+ printf("ERROR_UNKNOWN");
+ }
+ printf("\" Sign=\"");
+ switch (sgn) {
+ case H5T_SGN_NONE:
+ printf("false");
+ break;
+ case H5T_SGN_2:
+ printf("true");
+ break;
+ default:
+ printf("ERROR_UNKNOWN");
+ }
+ printf("\" Size=\"");
+ sz = H5Tget_size(type);
+ printf("%d", sz);
+ printf("\" />\n");
+ indent -= COL;
+ indentation(indent);
+ printf("</AtomicType>\n");
+ break;
+
+ case H5T_FLOAT:
+ /* <FloatType ByteOrder="bo" Size="bytes"
+ SignBitLocation="bytes"
+ ExponentBits="eb" ExponentLocation="el"
+ MantissaBits="mb" MantissaLocation="ml" /> */
+ ord = H5Tget_order(type);
+ indentation(indent);
+ printf("<AtomicType>\n");
+ indent += COL;
+ indentation(indent);
+ printf("<FloatType ByteOrder=\"");
+ switch (ord) {
+ case H5T_ORDER_LE:
+ printf("LE");
+ break;
+ case H5T_ORDER_BE:
+ printf("BE");
+ break;
+ case H5T_ORDER_VAX:
+ default:
+ printf("ERROR_UNKNOWN");
+ }
+ printf("\" Size=\"");
+ sz = H5Tget_size(type);
+ printf("%d", sz);
+ H5Tget_fields(type, &spos, &epos, &esize, &mpos, &msize);
+ printf("\" SignBitLocation=\"%d\" ", spos);
+ printf("ExponentBits=\"%d\" ExponentLocation=\"%d\" ", esize, epos);
+ printf("MantissaBits=\"%d\" MantissaLocation=\"%d\" />\n",
+ msize, mpos);
+ indent -= COL;
+ indentation(indent);
+ printf("</AtomicType>\n");
+ break;
+
+ case H5T_TIME:
+ indentation(indent);
+ printf("<AtomicType>\n");
+ indent += COL;
+ indentation(indent);
+ printf("<TimeType />\n");
+ printf("<!-- H5T_TIME: not yet implemented -->");
+ indent -= COL;
+ indentation(indent);
+ printf("</AtomicType>\n");
+ break;
+
+ case H5T_STRING:
+ /* <StringType Cset="cs" StrSize="chars" StrPad="pad" /> */
+ size = H5Tget_size(type);
+ str_pad = H5Tget_strpad(type);
+ cset = H5Tget_cset(type);
+
+ indentation(indent);
+ printf("<AtomicType>\n");
+ indent += COL;
+ indentation(indent);
+ printf("<StringType Cset=\"");
+ if (cset == H5T_CSET_ASCII) {
+ printf("H5T_CSET_ASCII\" ");
+ } else {
+ printf("unknown_cset\" ");
+ }
+ printf("StrSize=\"%d\" StrPad=\"", (int) size);
+ if (str_pad == H5T_STR_NULLTERM) {
+ printf("H5T_STR_NULLTERM\"/>\n");
+ } else if (str_pad == H5T_STR_NULLPAD) {
+ printf("H5T_STR_NULLPAD\"/>\n");
+ } else if (str_pad == H5T_STR_SPACEPAD) {
+ printf("H5T_STR_SPACEPAD\"/>\n");
+ } else {
+ printf("H5T_STR_ERROR\"/>\n");
+ }
+ indent -= COL;
+ indentation(indent);
+ printf("</AtomicType>\n");
+ break;
+
+ case H5T_BITFIELD:
+ /* <BitfieldType ByteOrder="bo" Size="bytes"/> */
+ ord = H5Tget_order(type);
+ indentation(indent);
+ printf("<AtomicType>\n");
+ indent += COL;
+ indentation(indent);
+ printf("<BitfieldType ByteOrder=\"");
+ switch (ord) {
+ case H5T_ORDER_LE:
+ printf("LE");
+ break;
+ case H5T_ORDER_BE:
+ printf("BE");
+ break;
+ case H5T_ORDER_VAX:
+ default:
+ printf("ERROR_UNKNOWN");
+ }
+ size = H5Tget_size(type);
+ printf("\" Size=\"%d\"/>\n", size);
+ indent -= COL;
+ indentation(indent);
+ printf("</AtomicType>\n");
+ break;
+
+ case H5T_OPAQUE:
+ /* <OpaqueType Tag="tag" Size="bytes" /> */
+
+ indentation(indent);
+ printf("<AtomicType>\n");
+ indent += COL;
+ indentation(indent);
+ printf("<OpaqueType Tag=\"%s\" ", H5Tget_tag(type));
+ size = H5Tget_size(type);
+ printf("Size=\"%d\"/>\n", size);
+ indent -= COL;
+ indentation(indent);
+ printf("</AtomicType>\n");
+ break;
+
+ case H5T_COMPOUND:
+ /* recursively describe the components of a compound datatype */
+ if (H5Tcommitted(type) > 0) {
+ /* detect a shared datatype, output only once */
+ H5Gget_objinfo(type, ".", TRUE, &statbuf);
+ i = search_obj(type_table, statbuf.objno);
+
+ if (i >= 0) {
+ /* This should be defined somewhere else */
+ if (!type_table->objs[i].recorded) {
+ /* 'anonymous' NDT. Use it's object num.
+ as it's name. */
+ printf("<NamedDataTypePtr OBJ-XID=\"/#%lu:%lu\"/>\n",
+ type_table->objs[i].objno[0],
+ type_table->objs[i].objno[1]);
+ } else {
+ /* point to the NDT by name */
+ char *t_objname = xml_escape_the_name(type_table->objs[i].objname);
+
+ printf("<NamedDataTypePtr OBJ-XID=\"%s\"/>\n", t_objname);
+ free(t_objname);
+ }
+ } else {
+ printf("<!-- h5dump error: unknown committed type. -->\n");
+ d_status = EXIT_FAILURE;
+ }
+
+ } else {
+ /* type of a dataset */
+ nmembers = H5Tget_nmembers(type);
+
+ indentation(indent);
+ printf("<CompoundType>\n");
+
+ /* List each member Field of the type */
+ /* <Field FieldName="name" > */
+ /* <DataType > */
+ indent += COL;
+ for (i = 0; i < nmembers; i++) {
+ char *t_fname;
+
+ fname = H5Tget_member_name(type, i);
+ mtype = H5Tget_member_type(type, i);
+ indentation(indent);
+ t_fname = xml_escape_the_name(fname);
+ printf("<Field FieldName=\"%s\">\n", t_fname);
+
+ free(fname);
+ free(t_fname);
+ indent += COL;
+ indentation(indent);
+ printf("<DataType>\n");
+ indent += COL;
+ xml_print_datatype(mtype);
+ indent -= COL;
+ indentation(indent);
+ printf("%s\n", dump_header_format->datatypeend);
+ indent -= COL;
+
+ indentation(indent);
+ printf("</Field>\n");
+ }
+ indent -= COL;
+ indentation(indent);
+ printf("</CompoundType>\n");
+ }
+ break;
+
+ case H5T_REFERENCE:
+ indentation(indent);
+ printf("<AtomicType>\n");
+ indent += COL;
+ indentation(indent);
+ /* Only Object references supported at this time */
+ printf("<ReferenceType>\n");
+ indentation(indent + COL);
+ printf("<ObjectReferenceType />\n");
+ indentation(indent);
+ printf("</ReferenceType>\n");
+ indent -= COL;
+ indentation(indent);
+ printf("</AtomicType>\n");
+ break;
+
+ case H5T_ENUM:
+ /* <EnumType Nelems="ne" >
+ list Name, values of enum
+ */
+ nmembs = H5Tget_nmembers(type);
+ indentation(indent);
+ printf("<AtomicType>\n");
+ indent += COL;
+ indentation(indent);
+ printf("<EnumType Nelems=\"%d\">\n", nmembs);
+ xml_print_enum(type);
+ indentation(indent);
+ printf("</EnumType>\n");
+ indent -= COL;
+ indentation(indent);
+ printf("</AtomicType>\n");
+ break;
+
+ case H5T_VLEN:
+ indentation(indent);
+ printf("<VLType>\n");
+ super = H5Tget_super(type);
+ indent += COL;
+ indentation(indent);
+ printf("<DataType>\n");
+ indent += COL;
+ xml_print_datatype(super);
+ indent -= COL;
+ indentation(indent);
+ printf("%s\n", dump_header_format->datatypeend);
+ indent -= COL;
+ indentation(indent);
+ printf("</VLType>\n");
+ H5Tclose(super);
+
+ break;
+
+ case H5T_ARRAY:
+ /* Get array base type */
+ super = H5Tget_super(type);
+
+ /* Print lead-in */
+ indentation(indent);
+ printf("<ArrayType Ndims=\"");
+ ndims = H5Tget_array_ndims(type);
+ printf("%d\">\n", ndims);
+
+ /* Get array information */
+ H5Tget_array_dims(type, dims, perm);
+
+ /* list of dimensions */
+ indent += COL;
+ if (perm != NULL) {
+ /* for each dimension, list */
+ for (j = 0; j < ndims; j++) {
+ indentation(indent);
+ printf("<ArrayDimension DimSize=\"%u\" DimPerm=\"%u\"/>\n",
+ (int) dims[j], (int) perm[j]);
+ }
+ } else {
+ for (j = 0; j < ndims; j++) {
+ indentation(indent);
+ printf("<ArrayDimension DimSize=\"%u\" DimPerm=\"0\"/>\n",
+ (int) dims[j]);
+ }
+ }
+ indent -= COL;
+
+ indent += COL;
+ indentation(indent);
+ printf("<DataType>\n");
+ indent += COL;
+ xml_print_datatype(super);
+ indent -= COL;
+ indentation(indent);
+ printf("%s\n", dump_header_format->datatypeend);
+ indent -= COL;
+ indentation(indent);
+ printf("</ArrayType>\n");
+ /* Close array base type */
+ H5Tclose(super);
+ break;
+
+ default:
+ printf("<!-- unknown data type -->");
+ d_status = EXIT_FAILURE;
+ break;
+ }
+}
+
+/*-------------------------------------------------------------------------
+ * Function: xml_dump_datatype
+ *
+ * Purpose: Dump description of a datatype in XML.
+ *
+ * Return: void
+ *
+ * Programmer: REMcG
+ *
+ * Modifications:
+ *
+ *-------------------------------------------------------------------------
+ */
+static void
+xml_dump_datatype(hid_t type)
+{
+ int i;
+ H5G_stat_t statbuf;
+
+ indent += COL;
+ indentation(indent);
+
+ if (H5Tcommitted(type) > 0) {
+ /* Data type is a shared or named data type */
+ H5Gget_objinfo(type, ".", TRUE, &statbuf);
+ i = search_obj(type_table, statbuf.objno);
+
+ if (i >= 0) {
+ /* Shared data type, must be entered as an object */
+ if (!type_table->objs[i].recorded) {
+ /* anonymous stored data type:
+ following the dumper's current
+ practice:
+ use it's object ref as its name
+ */
+ printf("<NamedDataTypePtr OBJ-XID=\"/#%lu:%lu\"/>\n",
+ type_table->objs[i].objno[0],
+ type_table->objs[i].objno[1]);
+ } else {
+ /* pointer to a named data type already in XML */
+ char *t_objname = xml_escape_the_name(type_table->objs[i].objname);
+
+ printf("<NamedDataTypePtr OBJ-XID=\"%s\"/>\n", t_objname);
+ free(t_objname);
+ }
+ } else {
+ printf("<!-- h5dump error: unknown committed type. -->\n");
+ }
+ indent -= COL;
+ return;
+ }
+ printf("%s %s\n", dump_header_format->datatypebegin,
+ dump_header_format->datatypeblockbegin);
+ indent += COL;
+ xml_print_datatype(type);
+ indent -= COL;
+ indentation(indent);
+ printf("%s\n", dump_header_format->datatypeend);
+ indent -= COL;
+}
+
+/*-------------------------------------------------------------------------
+ * Function: xml_dump_dataspace
+ *
+ * Purpose: Dump description of a dataspace in XML.
+ *
+ * Return: void
+ *
+ * Programmer: REMcG
+ *
+ * Modifications:
+ *
+ *-------------------------------------------------------------------------
+ */
+static void
+xml_dump_dataspace(hid_t space)
+{
+ hsize_t size[H5DUMP_MAX_RANK];
+ hsize_t maxsize[H5DUMP_MAX_RANK];
+ int ndims =
+ H5Sget_simple_extent_dims(space, size, maxsize);
+ int i;
+
+ indentation(indent + COL);
+ printf("%s\n", dump_header_format->dataspacebegin);
+ if (H5Sis_simple(space)) {
+ indentation(indent + COL + COL);
+
+ if (ndims == 0) {
+ /* scalar dataspace (just a tag, no XML attrs. defined */
+ printf("<ScalarDataspace />\n");
+ } else {
+ /* simple dataspace */
+ /* <SimpleDataspace Ndims="nd"> */
+ printf("<SimpleDataspace Ndims=\"%d\">\n", ndims);
+
+ /* print the <Dimension> elements */
+ for (i = 0; i < ndims; i++) {
+ indentation(indent + COL + COL + COL);
+ if (maxsize[i] == H5S_UNLIMITED) {
+ HDfprintf(stdout,
+ "<Dimension DimSize=\"%Hu\" MaxDimSize=\"UNLIMITED\"/>\n",
+ size[i]);
+ } else if (maxsize[i] == (hsize_t) 0) {
+ HDfprintf(stdout,
+ "<Dimension DimSize=\"%Hu\" MaxDimSize=\"%Hu\"/>\n",
+ size[i], size[i]);
+ } else {
+ HDfprintf(stdout,
+ "<Dimension DimSize=\"%Hu\" MaxDimSize=\"%Hu\"/>\n",
+ size[i], maxsize[i]);
+ }
+ }
+ indentation(indent + COL + COL);
+ printf("</SimpleDataspace>\n");
+ }
+ } else {
+ printf("<!-- not yet implemented -->\n");
+ }
+
+ indentation(indent + COL);
+ printf("%s\n", dump_header_format->dataspaceend);
+
+}
+
+/*-------------------------------------------------------------------------
+ * Function: xml_dump_data
+ *
+ * Purpose: Dump description of data in XML.
+ * Note that this calls the h5dump_xxx calls in
+ * the h5tools library.
+ *
+ * Return: void
+ *
+ * Programmer: REMcG
+ *
+ * Modifications:
+ *
+ *-------------------------------------------------------------------------
+ */
+static void
+xml_dump_data(hid_t obj_id, int obj_data)
+{
+ h5dump_t *outputformat = &xml_dataformat;
+ int status = -1;
+ void *buf;
+ hid_t space, type, p_type;
+ int ndims, i;
+ hsize_t size[64], nelmts = 1;
+ int depth;
+ int stdindent = COL; /* should be 3 */
+
+ outputformat->line_ncols = nCols;
+ indent += COL;
+
+ /*
+ * the depth will tell us how far we need to indent extra. we use to just
+ * use indent but with the merging of the tools lib we have to do
+ * something different for the lib funtions... the normal indentation is 6
+ * so when we don't need any extra indentation, depth will be 0.
+ */
+ depth = indent / stdindent + 1;
+
+ /* Print all the values. */
+ indentation(indent);
+ printf("%s\n", dump_header_format->databegin);
+ indentation(indent + COL);
+ printf("<DataFromFile>\n");
+ if (obj_data == DATASET_DATA) {
+ type = H5Dget_type(obj_id);
+ if (H5Tget_class(type) == H5T_REFERENCE) {
+ status = xml_print_refs(obj_id, DATASET_DATA);
+ } else if (H5Tget_class(type) == H5T_STRING) {
+ status = xml_print_strs(obj_id, DATASET_DATA);
+ } else {
+ status = h5dump_dset(stdout, outputformat, obj_id, -1, depth);
+ }
+ } else {
+ /* Attribute data */
+ type = H5Aget_type(obj_id);
+
+ if (H5Tget_class(type) == H5T_REFERENCE) {
+ /* references are done differently than
+ the standard output:
+ XML dumps a path to the object
+ referenced.
+ */
+ status = xml_print_refs(obj_id, ATTRIBUTE_DATA);
+ H5Tclose(type);
+ } else if (H5Tget_class(type) == H5T_STRING) {
+ status = xml_print_strs(obj_id, ATTRIBUTE_DATA);
+ } else {
+ /* all other data */
+ p_type = h5dump_fixtype(type);
+ H5Tclose(type);
+
+ space = H5Aget_space(obj_id);
+
+ ndims = H5Sget_simple_extent_dims(space, size, NULL);
+
+ for (i = 0; i < ndims; i++)
+ nelmts *= size[i];
+
+ buf =
+ malloc((size_t)(nelmts * MAX(H5Tget_size(type), H5Tget_size(p_type))));
+ assert(buf);
+
+ if (H5Aread(obj_id, p_type, buf) >= 0) {
+ status =
+ h5dump_mem(stdout, outputformat, obj_id, p_type, space,
+ buf, depth);
+ }
+ free(buf);
+ H5Tclose(p_type);
+ H5Sclose(space);
+ H5Tclose(type);
+ }
+ }
+
+ if (status < 0) {
+ indentation(indent + COL);
+ printf("Unable to print data.\n");
+ status = 1;
+ }
+
+ indentation(indent + COL);
+ printf("</DataFromFile>\n");
+ indentation(indent);
+ printf("%s\n", dump_header_format->dataend);
+ indent -= COL;
+}
+
+/*-------------------------------------------------------------------------
+ * Function: xml_dump_attr
+ *
+ * Purpose: Dump a description of an HDF5 attribute in XML.
+ *
+ * Return: herr_t
+ *
+ * Programmer: REMcG
+ *
+ * Modifications:
+ *
+ *-------------------------------------------------------------------------
+ */
+static herr_t
+xml_dump_attr(hid_t attr, const char *attr_name, void UNUSED * op_data)
+{
+ hid_t attr_id, type, space;
+ char *t_aname = xml_escape_the_name(attr_name);
+
+ indentation(indent);
+ printf("<Attribute Name=\"%s\">\n", t_aname);
+ free(t_aname);
+
+ if ((attr_id = H5Aopen_name(attr, attr_name)) >= 0) {
+ type = H5Aget_type(attr_id);
+ space = H5Aget_space(attr_id);
+
+ dump_function_table->dump_dataspace_function(space);
+ dump_function_table->dump_datatype_function(type);
+
+ if (display_data) {
+ switch (H5Tget_class(type)) {
+ case H5T_INTEGER:
+ case H5T_FLOAT:
+ case H5T_STRING:
+ case H5T_BITFIELD:
+ case H5T_OPAQUE:
+ case H5T_ENUM:
+ case H5T_ARRAY:
+ dump_function_table->dump_data_function(attr_id, ATTRIBUTE_DATA);
+ break;
+
+ case H5T_TIME:
+ indent += COL;
+ indentation(indent);
+ printf("<Data>\n");
+ indentation(indent);
+ printf("<!-- Time data not yet implemented. -->\n");
+ indentation(indent);
+ printf("<NoData />\n");
+ indentation(indent);
+ printf("<Data>\n");
+ indent -= COL;
+ break;
+
+ case H5T_COMPOUND:
+ indentation(indent);
+ printf("<!-- Note: format of compound data not specified -->\n");
+ dump_function_table->dump_data_function(attr_id, ATTRIBUTE_DATA);
+ break;
+
+ case H5T_REFERENCE:
+ indentation(indent);
+ printf("<Data>\n");
+ indentation(indent);
+ printf("<DataFromFile>\n");
+ xml_print_refs(attr_id, ATTRIBUTE_DATA);
+ indentation(indent);
+ printf("</DataFromFile>\n");
+ indentation(indent);
+ printf("</Data>\n");
+ break;
+
+ case H5T_VLEN:
+ printf("<!-- Note: format of VL data not specified -->\n");
+ dump_function_table->dump_data_function(attr_id, ATTRIBUTE_DATA);
+ break;
+ default:
+ indentation(indent);
+ printf("<Data>\n");
+ indentation(indent);
+ printf("<!-- Unknown datatype: %d -->\n", H5Tget_class(type));
+ indentation(indent);
+ printf("<NoData/>\n");
+ indentation(indent);
+ printf("</Data>\n");
+ break;
+ }
+ } else {
+ /* The case of an attribute never yet written ?? */
+ indentation(indent);
+ printf("<Data>\n");
+ indentation(indent + COL);
+ printf("<NoData/>\n");
+ indentation(indent);
+ printf("</Data>\n");
+ }
+
+ H5Tclose(type);
+ H5Sclose(space);
+ H5Aclose(attr_id);
+ indentation(indent);
+ printf("%s\n", dump_header_format->attributeend);
+ return SUCCEED;
+
+ } else {
+ /* ?? failed */
+ indentation(indent + COL);
+ printf("<!-- h5dump error: unable to open attribute. -->\n");
+ indentation(indent);
+ printf("%s\n", dump_header_format->attributeend);
+ d_status = EXIT_FAILURE;
+ return FAIL;
+ }
+}
+
+/*-------------------------------------------------------------------------
+ * Function: xml_dump_named_datatype
+ *
+ * Purpose: Dump a description of an HDF5 NDT in XML.
+ *
+ * Return: herr_t
+ *
+ * Programmer: REMcG
+ *
+ * Modifications:
+ *
+ *-------------------------------------------------------------------------
+ */
+static void
+xml_dump_named_datatype(hid_t type, const char *name)
+{
+ int nmembers = 1, x;
+ hid_t mtype;
+ char *fname;
+ char *tmp;
+
+ tmp = malloc(strlen(prefix) + strlen(name) + 2);
+ strcpy(tmp, prefix);
+ strcat(tmp, "/");
+ strcat(tmp, name);
+
+ indentation(indent);
+ if (strncmp(name, "#", 1) == 0) {
+ /* Special: this is an 'anonymous' NDT, deleted but
+ still in use.
+ We follow the dumper's undocumented practice, and
+ use its object id as its name.
+ Exactly the same as normal, but a separate case
+ in the event we want to do something else in
+ the future.
+ */
+ char *t_tmp = xml_escape_the_name(tmp);
+ char *t_prefix = xml_escape_the_name(prefix);
+
+ printf("<NamedDataType Name=\"%s\" OBJ-XID=\"%s\" Parents=\"%s\">\n",
+ name, t_tmp, (strcmp(prefix, "") ? t_prefix : "root"));
+ free(t_tmp);
+ free(t_prefix);
+ } else {
+ char *t_name = xml_escape_the_name(name);
+ char *t_prefix = xml_escape_the_name(prefix);
+ char *t_tmp = xml_escape_the_name(tmp);
+
+ printf("<NamedDataType Name=\"%s\" OBJ-XID=\"%s\" Parents=\"%s\">\n",
+ t_name, t_tmp, (strcmp(prefix, "") ? t_prefix : "root"));
+
+ free(t_name);
+ free(t_prefix);
+ free(t_tmp);
+ }
+
+ indent += COL;
+
+ if (H5Tget_class(type) == H5T_COMPOUND) {
+ /* Dump this here for sure. */
+ nmembers = H5Tget_nmembers(type);
+
+ indentation(indent);
+ printf("<CompoundType>\n");
+
+ indent += COL;
+ for (x = 0; x < nmembers; x++) {
+ char *t_fname;
+
+ fname = H5Tget_member_name(type, x);
+ mtype = H5Tget_member_type(type, x);
+ indentation(indent);
+ t_fname = xml_escape_the_name(fname);
+ printf("<Field FieldName=\"%s\">\n", t_fname);
+ free(fname);
+ free(t_fname);
+
+ if ((H5Tget_class(mtype) == H5T_COMPOUND)
+ || (H5Tget_class(mtype) == H5T_VLEN)
+ || (H5Tget_class(mtype) == H5T_ARRAY)) {
+ indent += COL;
+
+ /* Nested compound type: recur */
+ indentation(indent);
+ printf("%s %s\n", dump_header_format->datatypebegin,
+ dump_header_format->datatypeblockbegin);
+ indent += COL;
+ xml_print_datatype(mtype);
+ indent -= COL;
+ indentation(indent);
+ printf("%s\n", dump_header_format->datatypeend);
+ indent -= COL;
+ } else {
+ indent += COL;
+ indentation(indent);
+ printf("%s %s\n", dump_header_format->datatypebegin,
+ dump_header_format->datatypeblockbegin);
+ indent += COL;
+ xml_print_datatype(mtype);
+ indent -= COL;
+ indentation(indent);
+ printf("%s\n", dump_header_format->datatypeend);
+ indent -= COL;
+ }
+
+ indentation(indent);
+ printf("</Field>\n");
+ }
+
+ indent -= COL;
+ indentation(indent);
+ printf("</CompoundType>\n");
+ } else {
+ /* Other data types: call print_datatype */
+ indent += COL;
+ xml_print_datatype(type);
+ indent -= COL;
+ }
+
+ indent -= COL;
+ indentation(indent);
+ printf("</NamedDataType>\n");
+}
+
+/*-------------------------------------------------------------------------
+ * Function: xml_dump_group
+ *
+ * Purpose: Dump a description of an HDF5 Group (and its members) in XML.
+ *
+ * Return: void
+ *
+ * Programmer: REMcG
+ *
+ * Modifications:
+ *
+ *-------------------------------------------------------------------------
+ */
+static void
+xml_dump_group(hid_t gid, const char *name)
+{
+ H5G_stat_t statbuf;
+ char *cp;
+ hid_t dset, type;
+ char typename[1024], *tmp;
+ char *par;
+ int i;
+ int isRoot = 0;
+ int xtype;
+
+ if (strcmp(name, "/") == 0) {
+ isRoot = 1;
+ } else {
+ tmp = malloc(strlen(prefix) + strlen(name) + 2);
+ strcpy(tmp, prefix);
+ par = strdup(tmp);
+ cp = strrchr(par, '/');
+ if (cp != NULL) {
+ if ((cp == par) && strlen(par) > 1) {
+ *(cp + 1) = '\0';
+ } else {
+ *cp = '\0';
+ }
+ }
+ }
+
+ indentation(indent);
+
+ if (isRoot) {
+ printf("<RootGroup OBJ-XID=\"root\">\n");
+ } else {
+ char *t_name = xml_escape_the_name(name);
+ char *t_tmp = xml_escape_the_name(tmp);
+ char *t_par = xml_escape_the_name(par);
+
+ printf("<Group Name=\"%s\" OBJ-XID=\"%s\" Parents=\"%s\" >\n",
+ t_name, t_tmp, (strcmp(prefix, "") ? t_par : "root"));
+ free(t_name);
+ free(t_tmp);
+ free(t_par);
+ }
+
+ indent += COL;
+ H5Gget_objinfo(gid, ".", TRUE, &statbuf);
+
+ if (statbuf.nlink > 1) {
+ /* Group with more than one link to it... */
+ i = search_obj(group_table, statbuf.objno);
+
+ if (i < 0) {
+ indentation(indent);
+ error_msg(progname, "internal error (file %s:line %d)\n",
+ __FILE__, __LINE__);
+ d_status = EXIT_FAILURE;
+ } else if (group_table->objs[i].displayed) {
+ /* already seen: enter a groupptr */
+ char *t_objname = xml_escape_the_name(group_table->objs[i].objname);
+
+ indentation(indent + COL);
+ printf("<GroupPtr OBJ-XID=\"%s\"/>\n", t_objname);
+ free(t_objname);
+ } else {
+ /* first time this group has been seen -- describe it */
+ strcpy(group_table->objs[i].objname, prefix);
+ group_table->objs[i].displayed = 1;
+
+ /* 1. do all the attributes of the group */
+ H5Aiterate(gid, NULL,
+ dump_function_table->dump_attribute_function, NULL);
+
+ if (!strcmp(name, "/") && unamedtype) {
+ /* Very special case: dump unamed type in root group */
+ for (i = 0; i < type_table->nobjs; i++) {
+ if (!type_table->objs[i].recorded) {
+ dset = H5Dopen(gid, type_table->objs[i].objname);
+ type = H5Dget_type(dset);
+ sprintf(typename, "#%lu:%lu",
+ type_table->objs[i].objno[0],
+ type_table->objs[i].objno[1]);
+ dump_function_table->dump_named_datatype_function(type, typename);
+ H5Tclose(type);
+ H5Dclose(dset);
+ }
+ }
+ }
+
+ /* iterate through all the members */
+ xtype = H5G_TYPE;
+ H5Giterate(gid, ".", NULL, dump_all, (void *) &xtype);
+ xtype = H5G_DATASET;
+ H5Giterate(gid, ".", NULL, dump_all, (void *) &xtype);
+ xtype = H5G_LINK;
+ H5Giterate(gid, ".", NULL, dump_all, (void *) &xtype);
+ xtype = H5G_GROUP;
+ H5Giterate(gid, ".", NULL, dump_all, (void *) &xtype);
+ }
+ } else {
+ /* 1. do all the attributes of the group */
+ H5Aiterate(gid, NULL, dump_function_table->dump_attribute_function,
+ NULL);
+
+ if (!strcmp(name, "/") && unamedtype) {
+ /* Very special case: dump unamed type in root group */
+ for (i = 0; i < type_table->nobjs; i++) {
+ if (!type_table->objs[i].recorded) {
+ dset = H5Dopen(gid, type_table->objs[i].objname);
+ type = H5Dget_type(dset);
+ sprintf(typename, "#%lu:%lu",
+ type_table->objs[i].objno[0],
+ type_table->objs[i].objno[1]);
+ dump_function_table->dump_named_datatype_function(type, typename);
+ H5Tclose(type);
+ H5Dclose(dset);
+ }
+ }
+ }
+
+ /* iterate through all the members */
+ xtype = H5G_TYPE;
+ H5Giterate(gid, ".", NULL, dump_all, (void *) &xtype);
+ xtype = H5G_DATASET;
+ H5Giterate(gid, ".", NULL, dump_all, (void *) &xtype);
+ xtype = H5G_LINK;
+ H5Giterate(gid, ".", NULL, dump_all, (void *) &xtype);
+ xtype = H5G_GROUP;
+ H5Giterate(gid, ".", NULL, dump_all, (void *) &xtype);
+ }
+
+ indent -= COL;
+ indentation(indent);
+ if (isRoot) {
+ printf("</RootGroup>\n");
+ } else {
+ printf("%s\n", dump_header_format->groupend);
+ }
+/* don't free this!!!
+ free(tmp);
+*/
+}
+
+/*-------------------------------------------------------------------------
+ * Function: xml_print_refs
+ *
+ * Purpose: Print a path to the objects referenced by HDF5 Referneces.
+ *
+ * Return: void
+ *
+ * Programmer: REMcG
+ *
+ * Modifications:
+ *
+ *-------------------------------------------------------------------------
+ */
+static int
+xml_print_refs(hid_t did, int source)
+{
+ herr_t e;
+ hid_t type, space;
+ char *buf;
+ hobj_ref_t *refbuf;
+ char *path;
+ hsize_t ssiz;
+ hsize_t i;
+
+ if (source == DATASET_DATA) {
+ type = H5Dget_type(did);
+ } else if (source == ATTRIBUTE_DATA) {
+ type = H5Aget_type(did);
+ } else {
+ /* return an error */
+ return FAIL;
+ }
+ if (H5Tget_class(type) != H5T_REFERENCE) {
+ /* return an error */
+ return FAIL;
+ }
+ if (!H5Tequal(type, H5T_STD_REF_OBJ)) {
+ /* region ref not supported yet... */
+ /* return an error */
+ return FAIL;
+ }
+ if (source == DATASET_DATA) {
+ space = H5Dget_space(did);
+ ssiz = H5Sget_simple_extent_npoints(space);
+ ssiz *= H5Tget_size(type);
+
+ buf = calloc((size_t)ssiz, sizeof(char));
+ if (buf == NULL) {
+ return FAIL;
+ }
+ e = H5Dread(did, H5T_STD_REF_OBJ, H5S_ALL, H5S_ALL, H5P_DEFAULT, buf);
+ /* need to check result here */
+ if (e < 0) {
+ free(buf);
+ return FAIL;
+ }
+
+ } else if (source == ATTRIBUTE_DATA) {
+ space = H5Aget_space(did);
+ ssiz = H5Sget_simple_extent_npoints(space);
+ ssiz *= H5Tget_size(type);
+
+ buf = calloc((size_t)ssiz, sizeof(char));
+ if (buf == NULL) {
+ free(buf);
+ return FAIL;
+ }
+ e = H5Aread(did, H5T_STD_REF_OBJ, buf);
+ /* need to check the result here */
+ } else {
+ /* error */
+ return FAIL;
+ }
+
+ refbuf = (hobj_ref_t *) buf;
+ ssiz = H5Sget_simple_extent_npoints(space);
+
+ for (i = 0; i < ssiz; i++) {
+ path = lookup_ref_path(refbuf);
+ indentation(indent + COL);
+
+ if (!path) {
+ printf("\"%s\"\n", "NULL");
+ } else {
+ char *t_path = xml_escape_the_string(path, -1);
+
+ printf("\"%s\"\n", t_path);
+ free(t_path);
+ }
+
+ refbuf++;
+ }
+
+ return SUCCEED;
+}
+
+/*-------------------------------------------------------------------------
+ * Function: xml_print_strs
+ *
+ * Purpose: Print strings.
+ *
+ * Return: void
+ *
+ * Programmer: REMcG
+ *
+ * Modifications:
+ *
+ *-------------------------------------------------------------------------
+ */
+static int
+xml_print_strs(hid_t did, int source)
+{
+ herr_t e;
+ hid_t type, space;
+ char *buf;
+ char *bp;
+ char *onestring;
+ hsize_t ssiz;
+ size_t tsiz;
+ size_t i;
+ if (source == DATASET_DATA) {
+ type = H5Dget_type(did);
+ } else if (source == ATTRIBUTE_DATA) {
+ type = H5Aget_type(did);
+ } else {
+ /* return an error */
+ return FAIL;
+ }
+ if (H5Tget_class(type) != H5T_STRING) {
+ /* return an error */
+ return FAIL;
+ }
+ if (source == DATASET_DATA) {
+ space = H5Dget_space(did);
+ ssiz = H5Sget_simple_extent_npoints(space);
+ ssiz *= H5Tget_size(type);
+
+ buf = calloc((size_t)ssiz, sizeof(char));
+ if (buf == NULL) {
+ return FAIL;
+ }
+ e = H5Dread(did, type, H5S_ALL, H5S_ALL, H5P_DEFAULT, buf);
+ if (e < 0) {
+ free(buf);
+ return FAIL;
+ }
+
+ } else if (source == ATTRIBUTE_DATA) {
+ space = H5Aget_space(did);
+ ssiz = H5Sget_simple_extent_npoints(space);
+ ssiz *= H5Tget_size(type);
+
+ buf = calloc((size_t)ssiz, sizeof(char));
+ if (buf == NULL) {
+ return FAIL;
+ }
+ e = H5Aread(did, type, buf);
+ if (e < 0) {
+ free(buf);
+ return FAIL;
+ }
+ } else {
+ /* error */
+ return FAIL;
+ }
+
+/* pull out each string... */
+ ssiz = H5Sget_simple_extent_npoints(space);
+
+ tsiz = H5Tget_size(type);
+ onestring = (char *) calloc((size_t)tsiz, sizeof(char));
+ bp = buf;
+
+ for (i = 0; i < ssiz; i++) {
+ strncpy(onestring, bp, tsiz);
+ indentation(indent + COL);
+
+ if (!onestring) {
+ printf("\"%s\"\n", "NULL");
+ } else {
+ char *t_onestring = xml_escape_the_string(onestring, (int)tsiz);
+
+ printf("\"%s\"\n", xml_escape_the_string(onestring, (int)tsiz));
+ free(t_onestring);
+ }
+
+ bp += tsiz;
+ }
+ return SUCCEED;
+}
+
+/*-------------------------------------------------------------------------
+ * Function: check_compression
+ *
+ * Purpose: private function to check for compression and
+ * put a comment in the XML. (Not fully implemented.)
+ *
+ * Return: void
+ *
+ * Programmer: REMcG
+ *
+ * Modifications:
+ *
+ *-------------------------------------------------------------------------
+ */
+static void
+check_compression(hid_t dcpl)
+{
+ int nfilt;
+ int i;
+ H5Z_filter_t filter;
+ char namebuf[20];
+ size_t cd_nelmts = 1;
+ unsigned int cd_values;
+ unsigned int flags;
+/* not used yet: will need to do somehting more elaborate to handle future
+ * compression methods.
+ char *t1 = "H5Z_FILTER_DEFLATE";
+*/
+
+ nfilt = H5Pget_nfilters(dcpl);
+ if (nfilt <= 0)
+ return;
+ for (i = 0; i < nfilt; i++) {
+ filter = H5Pget_filter(dcpl, i, &flags,
+ (size_t *) &cd_nelmts,
+ &cd_values, 20, namebuf);
+ if (filter == H5Z_FILTER_DEFLATE) {
+ indentation(indent + COL);
+ printf("<Compression />\n");
+ indentation(indent + COL);
+ printf("<!-- Compression parameter %d -->\n", cd_values);
+ }
+ }
+}
+
+/*-------------------------------------------------------------------------
+ * Function: xml_dump_group
+ *
+ * Purpose: Dump a description of an HDF5 Group (and its members) in XML.
+ *
+ * Return: void
+ *
+ * Programmer: REMcG
+ *
+ * Modifications:
+ *
+ *-------------------------------------------------------------------------
+ */
+static void
+xml_dump_dataset(hid_t did, const char *name)
+{
+ hid_t type, space;
+ hid_t dcpl;
+ int maxdims;
+ hsize_t *chsize;
+ int ndims;
+ int i;
+ char *tmp;
+ char *t_name, *t_tmp, *t_prefix;
+
+ tmp = malloc(strlen(prefix) + strlen(name) + 2);
+ strcpy(tmp, prefix);
+ strcat(tmp, "/");
+ strcat(tmp, name);
+ indentation(indent);
+
+ t_name = xml_escape_the_name(name);
+ t_tmp = xml_escape_the_name(tmp);
+ t_prefix = xml_escape_the_name(prefix);
+
+ printf("<Dataset Name=\"%s\" OBJ-XID=\"%s\" Parents=\"%s\">\n",
+ t_name, t_tmp, (strcmp(prefix, "") ? t_prefix : "root"));
+
+ free(t_name);
+ free(t_tmp);
+ free(t_prefix);
+
+ dcpl = H5Dget_create_plist(did);
+ type = H5Dget_type(did);
+ space = H5Dget_space(did);
+
+ /* Print information about chunked storage */
+ if (H5D_CHUNKED == H5Pget_layout(dcpl)) {
+ maxdims = H5Sget_simple_extent_ndims(space);
+ chsize = (hsize_t *) malloc(maxdims * sizeof(hsize_t));
+ indent += COL;
+ indentation(indent);
+ printf("<StorageLayout>\n");
+ indent += COL;
+ indentation(indent);
+ printf("<ChunkedLayout ");
+ ndims = H5Pget_chunk(dcpl, maxdims, chsize);
+ printf("Ndims=\"%d\">\n", ndims);
+ /* check for compression and tell about it... */
+
+ check_compression(dcpl);
+
+ indent += COL;
+
+ for (i = 0; i < ndims; i++) {
+ indentation(indent);
+ HDfprintf(stdout, "<ChunkDimension DimSize=\"%Hu\" />\n", chsize[i]);
+ }
+
+ indent -= COL;
+
+ indentation(indent);
+ printf("</ChunkedLayout>\n");
+ indent -= COL;
+ indentation(indent);
+ printf("</StorageLayout>\n");
+ indent -= COL;
+ free(chsize);
+ }
+ /* and check for external.... */
+
+ dump_function_table->dump_dataspace_function(space);
+ dump_function_table->dump_datatype_function(type);
+
+ indent += COL;
+ H5Aiterate(did, NULL, dump_function_table->dump_attribute_function, NULL);
+ indent -= COL;
+ i = H5Dget_storage_size(did);
+
+ if (display_data && (i > 0)) {
+ switch (H5Tget_class(type)) {
+ case H5T_INTEGER:
+ case H5T_FLOAT:
+ case H5T_STRING:
+ case H5T_BITFIELD:
+ case H5T_OPAQUE:
+ case H5T_ENUM:
+ case H5T_ARRAY:
+ dump_function_table->dump_data_function(did, DATASET_DATA);
+ break;
+
+ case H5T_TIME:
+ indent += COL;
+ indentation(indent);
+ printf("<Data>\n");
+ indentation(indent);
+ printf("<!-- Time data not yet implemented. -->\n");
+ indentation(indent);
+ printf("<NoData />\n");
+ indentation(indent);
+ printf("<Data>\n");
+ indent -= COL;
+ break;
+
+ case H5T_COMPOUND:
+ indentation(indent);
+ printf("<!-- Note: format of compound data not specified -->\n");
+ dump_function_table->dump_data_function(did, DATASET_DATA);
+ break;
+
+ case H5T_REFERENCE:
+ indentation(indent);
+ printf("<Data>\n");
+ indentation(indent);
+ printf("<DataFromFile>\n");
+ xml_print_refs(did, DATASET_DATA);
+ indentation(indent);
+ printf("</DataFromFile>\n");
+ indentation(indent);
+ printf("</Data>\n");
+ break;
+
+ case H5T_VLEN:
+ printf("<!-- Note: format of VL data not specified -->\n");
+ dump_function_table->dump_data_function(did, DATASET_DATA);
+ break;
+ default:
+ indentation(indent);
+ printf("<Data>\n");
+ indentation(indent);
+ printf("<!-- Unknown datatype: %d -->\n", H5Tget_class(type));
+ indentation(indent);
+ printf("<NoData/>\n");
+ indentation(indent);
+ printf("</Data>\n");
+ break;
+ }
+ } else {
+ /* no data written */
+ indentation(indent);
+ printf("<Data>\n");
+ indentation(indent);
+ printf("<NoData/>\n");
+ indentation(indent);
+ printf("</Data>\n");
+ }
+
+/*
+ free(tmp);
+*/
+ H5Tclose(type);
+ H5Sclose(space);
+ indentation(indent);
+ printf("%s\n", dump_header_format->datasetend);
+}
+
+/*-------------------------------------------------------------------------
+ * Function: xml_print_enum
+ *
+ * Purpose: Print the values of an HDF5 ENUM in XML.
+ * Very similar to regular DDL output.
+ *
+ * Return: void
+ *
+ * Programmer: REMcG
+ *
+ * Modifications:
+ *
+ *-------------------------------------------------------------------------
+ */
+static void
+xml_print_enum(hid_t type)
+{
+ char **name = NULL; /*member names */
+ unsigned char *value = NULL; /*value array */
+ int nmembs; /*number of members */
+ hid_t super; /*enum base integer type */
+ hid_t native = -1; /*native integer data type */
+ size_t dst_size; /*destination value type size */
+ int i; /*miscellaneous counters */
+ size_t j;
+
+ nmembs = H5Tget_nmembers(type);
+ super = H5Tget_super(type);
+
+ /*
+ * Determine what data type 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((size_t)nmembs, sizeof(char *));
+ value = calloc((size_t)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 data type */
+ if (native > 0)
+ H5Tconvert(super, native, (hsize_t)nmembs, value, NULL, H5P_DEFAULT);
+
+ /* Sort members by increasing value */
+ /*not implemented yet */
+
+ /* Print members */
+ indent += COL;
+ for (i = 0; i < nmembs; i++) {
+ char *t_name = xml_escape_the_name(name[i]);
+
+ indentation(indent);
+ printf("<EnumElement>\n");
+ indentation(indent + COL);
+ printf("%s\n", t_name);
+ free(t_name);
+ indentation(indent);
+ printf("</EnumElement>\n");
+ indentation(indent);
+ printf("<EnumValue>\n");
+ indentation(indent + COL);
+ if (native < 0) {
+ printf("0x");
+
+ for (j = 0; j < dst_size; j++)
+ printf("%02x", value[i * dst_size + j]);
+ } else if (H5T_SGN_NONE == H5Tget_sign(native)) {
+ printf("%" PRINTF_LL_WIDTH "u", *((unsigned long_long *)
+ ((void *) (value + i * dst_size))));
+ } else {
+ printf("%" PRINTF_LL_WIDTH "d",
+ *((long_long *) ((void *) (value + i * dst_size))));
+ }
+ printf("\n");
+ indentation(indent);
+ printf("</EnumValue>\n");
+
+ }
+ indent -= COL;
+
+ /* Release resources */
+ for (i = 0; i < nmembs; i++)
+ free(name[i]);
+
+ free(name);
+ free(value);
+ H5Tclose(super);
+}
diff --git a/tools/h5dump/h5dump.h b/tools/h5dump/h5dump.h
new file mode 100644
index 0000000..70c4178
--- /dev/null
+++ b/tools/h5dump/h5dump.h
@@ -0,0 +1,22 @@
+/*
+ * Copyright (C) 1998-2001 National Center for Supercomputing Applications
+ * All rights reserved.
+ *
+ */
+#ifndef H5DUMP_H__
+#define H5DUMP_H__
+
+#include "hdf5.h"
+
+#define H5DUMP_MAX_RANK H5S_MAX_RANK
+
+#define begin_obj(obj,name,begin) \
+ if (name) \
+ printf("%s \"%s\" %s\n", (obj), (name), (begin)); \
+ else \
+ printf("%s %s\n", (obj), (begin));
+
+#define end_obj(obj,end) \
+ printf("%s %s\n", (end), (obj));
+
+#endif /* !H5DUMP_H__ */
diff --git a/tools/h5dump/h5dumptst.c b/tools/h5dump/h5dumptst.c
new file mode 100644
index 0000000..4e01627
--- /dev/null
+++ b/tools/h5dump/h5dumptst.c
@@ -0,0 +1,2577 @@
+/*
+ * Generate the binary hdf5 files for the h5dump tests.
+ * Usage: just execute the program without any arguments will
+ * generate all the binary hdf5 files in the local directory.
+ *
+ * If you regenerate the test files (e.g., changing some code,
+ * trying it on a new platform, ...), you need to verify the correctness
+ * of the expected output and update the corresponding *.ddl files.
+ */
+#include <limits.h>
+#include "hdf5.h"
+#include <H5private.h>
+
+#define FILE1 "tgroup.h5"
+#define FILE2 "tdset.h5"
+#define FILE3 "tattr.h5"
+#define FILE4 "tslink.h5"
+#define FILE5 "thlink.h5"
+#define FILE6 "tcompound.h5"
+#define FILE7 "tall.h5"
+#define FILE8 "tdset2.h5"
+#define FILE9 "tcompound2.h5"
+#define FILE10 "tloop.h5"
+#define FILE11 "tloop2.h5"
+#define FILE12 "tmany.h5"
+#define FILE13 "tstr.h5"
+#define FILE14 "tstr2.h5"
+#define FILE15 "tenum.h5"
+#define FILE16 "tobjref.h5"
+#define FILE17 "tdatareg.h5"
+#define FILE18 "tnestedcomp.h5"
+#define FILE19 "topaque.h5"
+#define FILE20 "tbitfields.h5"
+#define FILE21 "tvldtypes1.h5"
+#define FILE22 "tvldtypes2.h5"
+#define FILE23 "tvldtypes3.h5"
+#define FILE24 "tvldtypes4.h5"
+#define FILE25 "tarray1.h5"
+#define FILE26 "tarray2.h5"
+#define FILE27 "tarray3.h5"
+#define FILE28 "tarray4.h5"
+#define FILE29 "tarray5.h5"
+#define FILE30 "tarray6.h5"
+#define FILE31 "tarray7.h5"
+#define FILE32 "tempty.h5"
+
+#define LENSTR 50
+#define LENSTR2 11
+
+#define SPACE2_RANK 2
+#define SPACE2_DIM1 10
+#define SPACE2_DIM2 10
+
+#define SPACE1_RANK 1
+#define SPACE1_DIM1 4
+
+/* Element selection information */
+#define POINT1_NPOINTS 10
+
+typedef enum{
+ RED,
+ GREEN,
+ BLUE,
+ WHITE,
+ BLACK
+} enumtype;
+
+/* Compound datatype */
+typedef struct s1_t {
+ unsigned int a;
+ unsigned int b;
+ float c;
+} s1_t;
+
+
+/* 1-D array datatype */
+#define ARRAY1_RANK 1
+#define ARRAY1_DIM1 4
+
+/* 3-D array datatype */
+#define ARRAY2_RANK 3
+#define ARRAY2_DIM1 3
+#define ARRAY2_DIM2 4
+#define ARRAY2_DIM3 5
+
+/* 2-D array datatype */
+#define ARRAY3_RANK 2
+#define ARRAY3_DIM1 6
+#define ARRAY3_DIM2 3
+
+static void test_group(void)
+{
+ hid_t fid, group;
+
+ fid = H5Fcreate(FILE1, H5F_ACC_TRUNC, H5P_DEFAULT, H5P_DEFAULT);
+
+ /* / */
+ group = H5Gcreate (fid, "/g1", 0);
+ H5Gclose(group);
+ group = H5Gcreate (fid, "/g2", 0);
+ H5Gclose(group);
+ group = H5Gcreate (fid, "/g3", 0);
+ H5Gclose(group);
+
+ /* /g1 */
+ group = H5Gcreate (fid, "/g1/g1.1", 0);
+ H5Gclose(group);
+ group = H5Gcreate (fid, "/g1/g1.2", 0);
+ H5Gclose(group);
+
+ /* /g2 */
+ group = H5Gcreate (fid, "/g2/g2.1", 0);
+ H5Gclose(group);
+
+ /* /g3 */
+ group = H5Gcreate (fid, "/g3/g3.1", 0);
+ H5Gclose(group);
+ group = H5Gcreate (fid, "/g3/g3.2", 0);
+ H5Gclose(group);
+ group = H5Gcreate (fid, "/g3/g3.3", 0);
+ H5Gclose(group);
+ group = H5Gcreate (fid, "/g3/g3.4", 0);
+ H5Gclose(group);
+
+ /* /g2/g2.1 */
+ group = H5Gcreate (fid, "/g2/g2.1/g2.1.1", 0);
+ H5Gclose(group);
+ group = H5Gcreate (fid, "/g2/g2.1/g2.1.2", 0);
+ H5Gclose(group);
+ group = H5Gcreate (fid, "/g2/g2.1/g2.1.3", 0);
+ H5Gclose(group);
+
+ H5Fclose(fid);
+}
+
+static void test_dataset(void)
+{
+ hid_t fid, dataset, space;
+ hsize_t dims[2];
+ int dset1[10][20];
+ double dset2[30][20];
+ int i, j;
+
+ fid = H5Fcreate(FILE2, H5F_ACC_TRUNC, H5P_DEFAULT, H5P_DEFAULT);
+
+ /* dset1 */
+ dims[0] = 10; dims[1] = 20;
+ space = H5Screate_simple(2, dims, NULL);
+ dataset = H5Dcreate(fid, "/dset1", H5T_STD_I32BE, space, H5P_DEFAULT);
+
+ for (i = 0; i < 10; i++)
+ for (j = 0; j < 20; j++)
+ dset1[i][j] = j+i;
+
+ H5Dwrite(dataset, H5T_NATIVE_INT, H5S_ALL, H5S_ALL, H5P_DEFAULT, dset1);
+ H5Sclose(space);
+ H5Dclose(dataset);
+
+ /* dset2 */
+ dims[0] = 30; dims[1] = 20;
+ space = H5Screate_simple(2, dims, NULL);
+ dataset = H5Dcreate(fid, "/dset2", H5T_IEEE_F64BE, space, H5P_DEFAULT);
+
+ for (i = 0; i < 30; i++)
+ for (j = 0; j < 20; j++)
+ dset2[i][j] = 0.0001*j+i;
+
+ H5Dwrite(dataset, H5T_NATIVE_DOUBLE, H5S_ALL, H5S_ALL, H5P_DEFAULT, dset2);
+
+ H5Sclose(space);
+ H5Dclose(dataset);
+ H5Fclose(fid);
+}
+
+static void test_dataset2(void)
+{
+ hid_t fid, dataset, space, create_plist;
+ hsize_t dims[2];
+ hsize_t maxdims[2];
+ int dset1[10][20];
+ double dset2[30][10];
+ int i, j;
+
+ fid = H5Fcreate(FILE8, H5F_ACC_TRUNC, H5P_DEFAULT, H5P_DEFAULT);
+ create_plist = H5Pcreate(H5P_DATASET_CREATE);
+ dims[0] = 5; dims[1] = 5;
+ H5Pset_chunk(create_plist, 2, dims);
+
+ /* dset1 */
+ dims[0] = 10; dims[1] = 20;
+ maxdims[0] = H5S_UNLIMITED; maxdims[1] = 20;
+ space = H5Screate_simple(2, dims, maxdims);
+ dataset = H5Dcreate(fid, "/dset1", H5T_STD_I32BE, space, create_plist);
+
+ for (i = 0; i < 10; i++)
+ for (j = 0; j < 20; j++)
+ dset1[i][j] = j;
+
+ H5Dwrite(dataset, H5T_NATIVE_INT, H5S_ALL, H5S_ALL, H5P_DEFAULT, dset1);
+ H5Sclose(space);
+ H5Dclose(dataset);
+
+ /* dset2 */
+ dims[0] = 30; dims[1] = 10;
+ maxdims[0] = 30; maxdims[1] = H5S_UNLIMITED;
+ space = H5Screate_simple(2, dims, maxdims);
+ dataset = H5Dcreate(fid, "/dset2", H5T_IEEE_F64BE, space, create_plist);
+
+ for (i = 0; i < 30; i++)
+ for (j = 0; j < 10; j++)
+ dset2[i][j] = j;
+
+ H5Dwrite(dataset, H5T_NATIVE_DOUBLE, H5S_ALL, H5S_ALL, H5P_DEFAULT, dset2);
+
+ H5Sclose(space);
+ H5Dclose(dataset);
+ H5Fclose(fid);
+}
+
+
+static void test_attribute(void)
+{
+ hid_t fid, root, space, attr, type;
+ hsize_t dims[2];
+ char buf[60];
+ int i, data[10];
+ double d[10];
+ char string[]= "string attribute";
+ int point = 100;
+
+ fid = H5Fcreate(FILE3, H5F_ACC_TRUNC, H5P_DEFAULT, H5P_DEFAULT);
+ root = H5Gopen (fid, "/");
+
+ /* attribute 1 */
+ dims[0] = 24;
+ space = H5Screate_simple(1, dims, NULL);
+ attr = H5Acreate (root, "attr1", H5T_STD_I8BE, space, H5P_DEFAULT);
+ sprintf(buf, "attribute of root group");
+ H5Awrite(attr, H5T_NATIVE_SCHAR, buf);
+ H5Sclose(space);
+ H5Aclose(attr);
+
+ /* attribute 2 */
+ dims[0] = 10;
+ space = H5Screate_simple(1, dims, NULL);
+ attr = H5Acreate (root, "attr2", H5T_STD_I32BE, space, H5P_DEFAULT);
+
+ for (i = 0; i < 10; i++) data[i] = i+1;
+
+ H5Awrite(attr, H5T_NATIVE_INT, data);
+ H5Sclose(space);
+ H5Aclose(attr);
+
+ /* attribute 3 */
+ dims[0] = 10;
+ space = H5Screate_simple(1, dims, NULL);
+ attr = H5Acreate (root, "attr3", H5T_IEEE_F64BE, space, H5P_DEFAULT);
+
+ for (i = 0; i < 10; i++) d[i] = 0.1 * i;
+
+ H5Awrite(attr, H5T_NATIVE_DOUBLE, d);
+ H5Sclose(space);
+ H5Aclose(attr);
+
+ /* attribute 4 */
+ space = H5Screate(H5S_SCALAR);
+ attr = H5Acreate (root, "attr4", H5T_STD_I32BE, space, H5P_DEFAULT);
+ H5Awrite(attr, H5T_NATIVE_INT, &point);
+ H5Sclose(space);
+ H5Aclose(attr);
+
+ /* attribute 5 */
+ space = H5Screate(H5S_SCALAR);
+ type = H5Tcopy(H5T_C_S1);
+ H5Tset_size(type, 17);
+ attr = H5Acreate (root, "attr5", type, space, H5P_DEFAULT);
+ H5Awrite(attr, type, string);
+
+ H5Tclose(type);
+ H5Sclose(space);
+ H5Aclose(attr);
+ H5Gclose(root);
+ H5Fclose(fid);
+}
+
+static void test_softlink(void)
+{
+ hid_t fid, root;
+
+ fid = H5Fcreate(FILE4, H5F_ACC_TRUNC, H5P_DEFAULT, H5P_DEFAULT);
+ root = H5Gopen (fid, "/");
+ H5Glink (root, H5G_LINK_SOFT, "somevalue", "slink1");
+ H5Glink (root, H5G_LINK_SOFT, "linkvalue", "slink2");
+
+ H5Gclose(root);
+ H5Fclose(fid);
+}
+
+/*
+ /
+
+ / | \ the dataset is hardlinked to three names
+ /dset1, /g1/dset2, and /g1/g1.1/dset3
+ dset1 g1 g2
+ /g2 and /g1/g1.1 are hardlinked to the same object.
+ / \
+ dset2 g1.1
+ |
+ dset3
+*/
+
+static void test_hardlink(void)
+{
+ hid_t fid, group, dataset, space;
+ hsize_t dim = 5;
+ int i, dset[5];
+
+ fid = H5Fcreate(FILE5, H5F_ACC_TRUNC, H5P_DEFAULT, H5P_DEFAULT);
+
+ space = H5Screate_simple(1, &dim, NULL);
+ dataset = H5Dcreate(fid, "/dset1", H5T_STD_I32BE, space, H5P_DEFAULT);
+
+ for (i = 0; i < 5; i++) dset[i] = i;
+
+ H5Dwrite(dataset, H5T_NATIVE_INT, H5S_ALL, H5S_ALL, H5P_DEFAULT, dset);
+ H5Sclose(space);
+ H5Dclose(dataset);
+
+ group = H5Gcreate (fid, "/g1", 0);
+ H5Glink (group, H5G_LINK_HARD, "/dset1", "dset2");
+ H5Gclose(group);
+
+ group = H5Gcreate (fid, "/g2", 0);
+ H5Glink (group, H5G_LINK_HARD, "/dset1", "dset3");
+ H5Gclose(group);
+
+ group = H5Gopen(fid, "/g1");
+ H5Glink (group, H5G_LINK_HARD, "/g2", "g1.1");
+ H5Gclose(group);
+ H5Fclose(fid);
+}
+
+/*
+ /
+ / | \ \
+ dset1 group1 type1 type2
+ |
+ dset2
+
+*/
+static void test_compound_dt(void) { /* test compound data type */
+ hid_t fid, group, dataset, space, space3, type, type2;
+ hid_t array_dt;
+ typedef struct {
+ int a;
+ float b;
+ double c;
+ } dset1_t;
+ dset1_t dset1[5];
+
+ typedef struct {
+ int a;
+ float b;
+ } dset2_t;
+ dset2_t dset2[5];
+
+ typedef struct {
+ int a[4];
+ float b[5][6];
+ } dset3_t;
+ dset3_t dset3[3][6];
+
+ typedef struct {
+ int a;
+ float b;
+ } dset4_t;
+ dset4_t dset4[5];
+
+ typedef struct {
+ int a;
+ float b;
+ } dset5_t;
+ dset5_t dset5[5];
+
+ int i, j, k, l, ndims;
+ hsize_t dim[2];
+
+ hsize_t sdim = 5;
+ hsize_t dset3_dim[2];
+
+
+ for (i = 0; i < (int)sdim; i++) {
+ dset1[i].a = i;
+ dset1[i].b = i*i;
+ dset1[i].c = 1./(i+1);
+
+ dset2[i].a = i;
+ dset2[i].b = i+ i*0.1;
+
+ dset4[i].a = i;
+ dset4[i].b = i+3;
+
+ dset5[i].a = i;
+ dset5[i].b = i*0.1;
+ }
+
+
+ fid = H5Fcreate(FILE6, H5F_ACC_TRUNC, H5P_DEFAULT, H5P_DEFAULT);
+
+ space = H5Screate_simple(1, &sdim, NULL);
+
+ type = H5Tcreate (H5T_COMPOUND, sizeof(dset1[0]));
+ type2 = H5Tcreate(H5T_COMPOUND, sizeof(dset1[0]));
+ H5Tinsert(type, "a_name", HOFFSET(dset1_t, a), H5T_STD_I32BE);
+ H5Tinsert(type, "b_name", HOFFSET(dset1_t, b), H5T_IEEE_F32BE);
+ H5Tinsert(type, "c_name", HOFFSET(dset1_t, c), H5T_IEEE_F64BE);
+ H5Tinsert(type2, "a_name", HOFFSET(dset1_t, a), H5T_NATIVE_INT);
+ H5Tinsert(type2, "b_name", HOFFSET(dset1_t, b), H5T_NATIVE_FLOAT);
+ H5Tinsert(type2, "c_name", HOFFSET(dset1_t, c), H5T_NATIVE_DOUBLE);
+ dataset = H5Dcreate(fid, "/dset1", type, space, H5P_DEFAULT);
+ H5Dwrite(dataset, type2, H5S_ALL, H5S_ALL, H5P_DEFAULT, dset1);
+ H5Tclose(type2);
+ H5Tclose(type);
+ H5Dclose(dataset);
+
+ /* shared data type 1 */
+ type = H5Tcreate (H5T_COMPOUND, sizeof(dset2_t));
+ H5Tinsert(type, "int_name", HOFFSET(dset2_t, a), H5T_STD_I32BE);
+ H5Tinsert(type, "float_name", HOFFSET(dset2_t, b), H5T_IEEE_F32BE);
+ H5Tcommit(fid, "type1", type);
+ type2 = H5Tcreate (H5T_COMPOUND, sizeof(dset2_t));
+ H5Tinsert(type2, "int_name", HOFFSET(dset2_t, a), H5T_NATIVE_INT);
+ H5Tinsert(type2, "float_name", HOFFSET(dset2_t, b), H5T_NATIVE_FLOAT);
+ group = H5Gcreate (fid, "/group1", 0);
+
+ dataset = H5Dcreate(group, "dset2", type, space, H5P_DEFAULT);
+ H5Dwrite(dataset, type2, H5S_ALL, H5S_ALL, H5P_DEFAULT, dset2);
+ H5Tclose(type2);
+ H5Tclose(type);
+ H5Dclose(dataset);
+
+
+ /* shared data type 2 */
+ type = H5Tcreate (H5T_COMPOUND, sizeof(dset3_t));
+ type2 = H5Tcreate (H5T_COMPOUND, sizeof(dset3_t));
+
+ ndims = 1; dim[0] = 4;
+
+ array_dt=H5Tarray_create(H5T_STD_I32BE,ndims,dim,NULL);
+ H5Tinsert(type, "int_array", HOFFSET(dset3_t, a), array_dt);
+ H5Tclose(array_dt);
+
+ array_dt=H5Tarray_create(H5T_NATIVE_INT,ndims,dim,NULL);
+ H5Tinsert(type2, "int_array", HOFFSET(dset3_t, a), array_dt);
+ H5Tclose(array_dt);
+
+ ndims = 2; dim[0] = 5; dim[1] = 6;
+
+ array_dt=H5Tarray_create(H5T_IEEE_F32BE,ndims,dim,NULL);
+ H5Tinsert(type, "float_array", HOFFSET(dset3_t, b), array_dt);
+ H5Tclose(array_dt);
+
+ array_dt=H5Tarray_create(H5T_NATIVE_FLOAT,ndims,dim,NULL);
+ H5Tinsert(type2, "float_array", HOFFSET(dset3_t, b), array_dt);
+ H5Tclose(array_dt);
+
+ H5Tcommit(fid, "type2", type);
+
+
+ dset3_dim[0] = 3; dset3_dim[1] = 6;
+ space3 = H5Screate_simple(2, dset3_dim, NULL);
+ dataset = H5Dcreate(group, "dset3", type, space3, H5P_DEFAULT);
+ for (i = 0; i < (int)dset3_dim[0]; i++) {
+ for (j = 0; j < (int)dset3_dim[1]; j++) {
+ for (k = 0; k < 4; k++)
+ dset3[i][j].a[k] = k+j+i;
+ for (k = 0; k < 5; k++)
+ for (l = 0; l < 6; l++)
+ dset3[i][j].b[k][l] = (k+1)+l+j+i;
+ }
+ }
+ H5Dwrite(dataset, type2, H5S_ALL, H5S_ALL, H5P_DEFAULT, dset3);
+ H5Sclose(space3);
+ H5Tclose(type);
+ H5Tclose(type2);
+ H5Dclose(dataset);
+
+ /* shared data type 3 */
+ type = H5Tcreate (H5T_COMPOUND, sizeof(dset4_t));
+ type2 = H5Tcreate (H5T_COMPOUND, sizeof(dset4_t));
+ H5Tinsert(type, "int", HOFFSET(dset4_t, a), H5T_STD_I32BE);
+ H5Tinsert(type, "float", HOFFSET(dset4_t, b), H5T_IEEE_F32BE);
+ H5Tcommit(group, "type3", type);
+ H5Tinsert(type2, "int", HOFFSET(dset4_t, a), H5T_NATIVE_INT);
+ H5Tinsert(type2, "float", HOFFSET(dset4_t, b), H5T_NATIVE_FLOAT);
+ dataset = H5Dcreate(group, "dset4", type, space, H5P_DEFAULT);
+ H5Dwrite(dataset, type2, H5S_ALL, H5S_ALL, H5P_DEFAULT, dset4);
+
+ H5Tclose(type);
+ H5Tclose(type2);
+ H5Dclose(dataset);
+ H5Gclose(group);
+
+
+ /* unamed data type */
+ group = H5Gcreate (fid, "/group2", 0);
+
+ type = H5Tcreate (H5T_COMPOUND, sizeof(dset5_t));
+ H5Tinsert(type, "int", HOFFSET(dset5_t, a), H5T_STD_I32BE);
+ H5Tinsert(type, "float", HOFFSET(dset5_t, b), H5T_IEEE_F32BE);
+ H5Tcommit(group, "type4", type);
+ type2 = H5Tcreate (H5T_COMPOUND, sizeof(dset5_t));
+ H5Tinsert(type2, "int", HOFFSET(dset5_t, a), H5T_NATIVE_INT);
+ H5Tinsert(type2, "float", HOFFSET(dset5_t, b), H5T_NATIVE_FLOAT);
+ dataset = H5Dcreate(group, "dset5", type, space, H5P_DEFAULT);
+ H5Dwrite(dataset, type2, H5S_ALL, H5S_ALL, H5P_DEFAULT, dset5);
+
+ H5Gunlink(group,"type4");
+
+ H5Tclose(type);
+ H5Tclose(type2);
+ H5Dclose(dataset);
+ H5Sclose(space);
+ H5Gclose(group);
+
+ H5Fclose(fid);
+
+}
+
+/*
+ /
+ / | \ \
+ dset1 group1 type1 type2
+ |
+ dset2
+
+*/
+static void test_compound_dt2(void) { /* test compound data type */
+ hid_t fid, group, dataset, space, type, create_plist, type2;
+ hid_t array_dt;
+
+ typedef struct {
+ int a;
+ float b;
+ double c;
+ } dset1_t;
+ dset1_t dset1[10];
+
+ typedef struct {
+ int a;
+ float b;
+ } dset2_t;
+ dset2_t dset2[10];
+
+ typedef struct {
+ int a[4];
+ float b[5][6];
+ } dset3_t;
+
+ typedef struct {
+ int a;
+ float b;
+ } dset4_t;
+ dset4_t dset4[10];
+
+ typedef struct {
+ int a;
+ float b;
+ } dset5_t;
+ dset5_t dset5[10];
+
+ int i, ndims;
+ const int perm[2]={0,1};
+ hsize_t dim[2];
+
+ hsize_t sdim, maxdim;
+
+ sdim = 10;
+ for (i = 0; i < (int)sdim; i++) {
+ dset1[i].a = i;
+ dset1[i].b = i*i;
+ dset1[i].c = 1./(i+1);
+
+ dset2[i].a = i;
+ dset2[i].b = i+ i*0.1;
+
+ dset4[i].a = i;
+ dset4[i].b = i*1.0;
+
+ dset5[i].a = i;
+ dset5[i].b = i*1.0;
+ }
+
+ fid = H5Fcreate(FILE9, H5F_ACC_TRUNC, H5P_DEFAULT, H5P_DEFAULT);
+
+ create_plist = H5Pcreate(H5P_DATASET_CREATE);
+
+ sdim = 2;
+ H5Pset_chunk(create_plist, 1, &sdim);
+
+ sdim = 6;
+ maxdim = H5S_UNLIMITED;
+
+ space = H5Screate_simple(1, &sdim, &maxdim);
+
+ type = H5Tcreate (H5T_COMPOUND, sizeof(dset1[0]));
+
+ H5Tinsert(type, "a_name", HOFFSET(dset1_t, a), H5T_STD_I32BE);
+ H5Tinsert(type, "b_name", HOFFSET(dset1_t, b), H5T_IEEE_F32BE);
+ H5Tinsert(type, "c_name", HOFFSET(dset1_t, c), H5T_IEEE_F64BE);
+
+ dataset = H5Dcreate(fid, "/dset1", type, space, create_plist);
+
+ type2 = H5Tcreate (H5T_COMPOUND, sizeof(dset1[0]));
+
+ H5Tinsert(type2, "a_name", HOFFSET(dset1_t, a), H5T_NATIVE_INT);
+ H5Tinsert(type2, "b_name", HOFFSET(dset1_t, b), H5T_NATIVE_FLOAT);
+ H5Tinsert(type2, "c_name", HOFFSET(dset1_t, c), H5T_NATIVE_DOUBLE);
+
+ H5Dwrite(dataset, type2, H5S_ALL, H5S_ALL, H5P_DEFAULT, dset1);
+
+ H5Tclose(type);
+ H5Tclose(type2);
+ H5Sclose(space);
+ H5Dclose(dataset);
+
+ sdim = 6;
+ maxdim = 10;
+
+ space = H5Screate_simple(1, &sdim, &maxdim);
+
+ /* shared data type 1 */
+ type = H5Tcreate (H5T_COMPOUND, sizeof(dset2_t));
+ H5Tinsert(type, "int_name", HOFFSET(dset2_t, a), H5T_STD_I32BE);
+ H5Tinsert(type, "float_name", HOFFSET(dset2_t, b), H5T_IEEE_F32BE);
+ H5Tcommit(fid, "type1", type);
+
+ group = H5Gcreate (fid, "/group1", 0);
+
+ dataset = H5Dcreate(group, "dset2", type, space, create_plist);
+
+ type2 = H5Tcreate (H5T_COMPOUND, sizeof(dset2_t));
+ H5Tinsert(type2, "int_name", HOFFSET(dset2_t, a), H5T_NATIVE_INT);
+ H5Tinsert(type2, "float_name", HOFFSET(dset2_t, b), H5T_NATIVE_FLOAT);
+ H5Dwrite(dataset, type2, H5S_ALL, H5S_ALL, H5P_DEFAULT, dset2);
+
+ H5Tclose(type);
+ H5Tclose(type2);
+ H5Dclose(dataset);
+
+
+ /* shared data type 2 */
+ type = H5Tcreate (H5T_COMPOUND, sizeof(dset3_t));
+
+ ndims = 1; dim[0] = 4;
+ array_dt=H5Tarray_create(H5T_STD_I32BE,ndims,dim,perm);
+ H5Tinsert(type, "int_array", HOFFSET(dset3_t, a), array_dt);
+ H5Tclose(array_dt);
+
+ ndims = 2; dim[0] = 5; dim[1] = 6;
+ array_dt=H5Tarray_create(H5T_IEEE_F32BE,ndims,dim,perm);
+ H5Tinsert(type, "float_array", HOFFSET(dset3_t, b), array_dt);
+ H5Tclose(array_dt);
+
+ H5Tcommit(fid, "type2", type);
+ H5Tclose(type);
+
+ /* shared data type 3 */
+ type = H5Tcreate (H5T_COMPOUND, sizeof(dset4_t));
+ H5Tinsert(type, "int", HOFFSET(dset4_t, a), H5T_STD_I32BE);
+ H5Tinsert(type, "float", HOFFSET(dset4_t, b), H5T_IEEE_F32BE);
+ H5Tcommit(group, "type3", type);
+
+ dataset = H5Dcreate(group, "dset4", type, space, create_plist);
+
+ type2 = H5Tcreate (H5T_COMPOUND, sizeof(dset4_t));
+ H5Tinsert(type2, "int", HOFFSET(dset4_t, a), H5T_NATIVE_INT);
+ H5Tinsert(type2, "float", HOFFSET(dset4_t, b), H5T_NATIVE_FLOAT);
+ H5Dwrite(dataset, type2, H5S_ALL, H5S_ALL, H5P_DEFAULT, dset4);
+
+ H5Tclose(type);
+ H5Tclose(type2);
+ H5Dclose(dataset);
+ H5Gclose(group);
+
+
+ /* unamed data type */
+ group = H5Gcreate (fid, "/group2", 0);
+
+ type = H5Tcreate (H5T_COMPOUND, sizeof(dset5_t));
+ H5Tinsert(type, "int", HOFFSET(dset5_t, a), H5T_STD_I32BE);
+ H5Tinsert(type, "float", HOFFSET(dset5_t, b), H5T_IEEE_F32BE);
+ H5Tcommit(group, "type4", type);
+ dataset = H5Dcreate(group, "dset5", type, space, create_plist);
+ type2 = H5Tcreate (H5T_COMPOUND, sizeof(dset5_t));
+ H5Tinsert(type2, "int", HOFFSET(dset5_t, a), H5T_NATIVE_INT);
+ H5Tinsert(type2, "float", HOFFSET(dset5_t, b), H5T_NATIVE_FLOAT);
+ H5Dwrite(dataset, type2, H5S_ALL, H5S_ALL, H5P_DEFAULT, dset5);
+
+ H5Gunlink(group,"type4");
+
+ H5Tclose(type);
+ H5Tclose(type2);
+ H5Dclose(dataset);
+ H5Sclose(space);
+ H5Gclose(group);
+
+ H5Fclose(fid);
+
+}
+
+
+/*
+
+/ : g1 g2 attr1 attr2
+g1 : g1.1 g1.2
+g1.1 : dset1.1.1(attr1, attr2) dset1.1.2
+g1.2 : g1.2.1
+g1.2.1 : slink
+g2 : dset2.1 dset2.2
+
+*/
+
+static void test_all(void) {
+hid_t fid, group, attr, dataset, space;
+hsize_t dims[2];
+int data[2][2], dset1[10][10], dset2[20];
+char buf[60];
+int i, j;
+float dset2_1[10], dset2_2[3][5];
+
+ fid = H5Fcreate(FILE7, H5F_ACC_TRUNC, H5P_DEFAULT, H5P_DEFAULT);
+
+ /* create groups */
+ group = H5Gcreate (fid, "/g1", 0);
+ H5Gclose(group);
+
+ group = H5Gcreate (fid, "/g2", 0);
+ H5Gclose(group);
+
+ group = H5Gcreate (fid, "/g1/g1.1", 0);
+ H5Gclose(group);
+
+ group = H5Gcreate (fid, "/g1/g1.2", 0);
+ H5Gclose(group);
+
+ group = H5Gcreate (fid, "/g1/g1.2/g1.2.1", 0);
+ H5Gclose(group);
+
+ /* root attributes */
+ group = H5Gopen (fid, "/");
+
+ dims[0] = 10;
+ space = H5Screate_simple(1, dims, NULL);
+ attr = H5Acreate (group, "attr1", H5T_STD_I8BE, space, H5P_DEFAULT);
+ sprintf(buf, "abcdefghi");
+ H5Awrite(attr, H5T_NATIVE_SCHAR, buf);
+ H5Sclose(space);
+ H5Aclose(attr);
+
+ dims[0] = 2; dims[1] = 2;
+ space = H5Screate_simple(2, dims, NULL);
+ attr = H5Acreate (group, "attr2", H5T_STD_I32BE, space, H5P_DEFAULT);
+ data[0][0] = 0; data[0][1] = 1; data[1][0] = 2; data[1][1] = 3;
+ H5Awrite(attr, H5T_NATIVE_INT, data);
+ H5Sclose(space);
+ H5Aclose(attr);
+
+ H5Gclose(group);
+
+ group = H5Gopen (fid, "/g1/g1.1");
+
+ /* dset1.1.1 */
+ dims[0] = 10; dims[1] = 10;
+ space = H5Screate_simple(2, dims, NULL);
+ dataset = H5Dcreate(group, "dset1.1.1", H5T_STD_I32BE, space, H5P_DEFAULT);
+ for (i = 0; i < 10; i++)
+ for (j = 0; j < 10; j++)
+ dset1[i][j] = j*i;
+ H5Dwrite(dataset, H5T_NATIVE_INT, H5S_ALL, H5S_ALL, H5P_DEFAULT, dset1);
+ H5Sclose(space);
+
+ /* attributes of dset1.1.1 */
+ dims[0] = 27;
+ space = H5Screate_simple(1, dims, NULL);
+ attr = H5Acreate (dataset, "attr1", H5T_STD_I8BE, space, H5P_DEFAULT);
+ sprintf(buf, "1st attribute of dset1.1.1");
+ H5Awrite(attr, H5T_NATIVE_SCHAR, buf);
+ H5Sclose(space);
+ H5Aclose(attr);
+
+ dims[0] = 27;
+ space = H5Screate_simple(1, dims, NULL);
+ attr = H5Acreate (dataset, "attr2", H5T_STD_I8BE, space, H5P_DEFAULT);
+ sprintf(buf, "2nd attribute of dset1.1.1");
+ H5Awrite(attr, H5T_NATIVE_SCHAR, buf);
+ H5Sclose(space);
+ H5Aclose(attr);
+
+ H5Dclose(dataset);
+
+ /* dset1.1.2 */
+ dims[0] = 20;
+ space = H5Screate_simple(1, dims, NULL);
+ dataset = H5Dcreate(group, "dset1.1.2", H5T_STD_I32BE, space, H5P_DEFAULT);
+ for (i = 0; i < 20; i++)
+ dset2[i] = i;
+ H5Dwrite(dataset, H5T_NATIVE_INT, H5S_ALL, H5S_ALL, H5P_DEFAULT, dset2);
+ H5Sclose(space);
+ H5Dclose(dataset);
+
+ H5Gclose(group);
+
+ /* soft link */
+ group = H5Gopen (fid, "/g1/g1.2/g1.2.1");
+ H5Glink (group, H5G_LINK_SOFT, "somevalue", "slink");
+ H5Gclose(group);
+
+ group = H5Gopen (fid, "/g2");
+
+ /* dset2.1 */
+ dims[0] = 10;
+ space = H5Screate_simple(1, dims, NULL);
+ dataset = H5Dcreate(group, "dset2.1", H5T_IEEE_F32BE, space, H5P_DEFAULT);
+ for (i = 0; i < 10; i++)
+ dset2_1[i] = i*0.1+1;
+ H5Dwrite(dataset, H5T_NATIVE_FLOAT, H5S_ALL, H5S_ALL, H5P_DEFAULT, dset2_1);
+ H5Sclose(space);
+ H5Dclose(dataset);
+
+ /* dset2.2 */
+ dims[0] = 3; dims[1] = 5;
+ space = H5Screate_simple(2, dims, NULL);
+ dataset = H5Dcreate(group, "dset2.2", H5T_IEEE_F32BE, space, H5P_DEFAULT);
+ for (i = 0; i < 3; i++)
+ for (j = 0; j < 5; j++)
+ dset2_2[i][j] = (i+1)*j*0.1;
+ H5Dwrite(dataset, H5T_NATIVE_FLOAT, H5S_ALL, H5S_ALL, H5P_DEFAULT, dset2_2);
+ H5Sclose(space);
+ H5Dclose(dataset);
+
+ H5Gclose(group);
+
+ H5Fclose(fid);
+
+}
+
+/*
+ o
+ /___\
+ g1 o/ \o g2
+ \___/
+
+
+o - group objects
+
+*/
+
+static void test_loop(void) {
+hid_t fid, group;
+
+ fid = H5Fcreate(FILE10, H5F_ACC_TRUNC, H5P_DEFAULT, H5P_DEFAULT);
+
+ group = H5Gcreate (fid, "/g1", 0);
+ H5Gclose(group);
+ group = H5Gcreate (fid, "/g2", 0);
+ H5Gclose(group);
+
+ H5Glink(fid, H5G_LINK_HARD, "/g2", "/g1/g1.1");
+ H5Glink(fid, H5G_LINK_HARD, "/g1", "/g2/g2.1");
+
+ H5Fclose(fid);
+}
+
+static void test_loop2(void) {
+hid_t fid, group;
+
+ fid = H5Fcreate(FILE11, H5F_ACC_TRUNC, H5P_DEFAULT, H5P_DEFAULT);
+
+ /* create group object g1 and implcit path from root object */
+ group = H5Gcreate (fid, "/g1", 0);
+ H5Gclose(group);
+
+ /* create group object g2 and implcit path from root object */
+ group = H5Gcreate (fid, "/g2", 0);
+ H5Gclose(group);
+
+ /* create path from object at /g1 to object at /g2 and name it g1.1 */
+ H5Glink (fid, H5G_LINK_HARD, "/g2", "/g1/g1.1");
+
+ /* create path from object at /g2 to object at /g1 and name it g2.1 */
+ H5Glink (fid, H5G_LINK_SOFT, "/g1", "/g2/g2.1");
+
+ H5Fclose(fid);
+
+}
+
+/*
+ /
+ | | | \ \ \
+ g1 g2 g3 g4 g5 g6
+ / \ | | \ \ \
+ g1.1 g1.2 slink2 link3 dset2 slink4 dset3
+ | | (g1) (dset2) (dset3)
+ dset1 link1
+ (dset1)
+*/
+
+static void test_many(void) {
+ hid_t fid, group, attr, dataset, space, space2, type, create_plist, type2;
+ hid_t array_dt;
+ hsize_t dims[2];
+ int data[2][2], dset2[10][10], dset3[10][10];
+ double d[10];
+
+ char buf[60];
+ int i, j;
+ int i0, i1, i2, i3;
+ hsize_t sdim, maxdim;
+
+ typedef struct { /* compound type has members with rank > 1 */
+ int a[2][2][2][2]; /* arrays are 2x2x2x2 */
+ double b[2][2][2][2];
+ double c[2][2][2][2];
+ } dset1_t;
+ dset1_t dset1[6];
+
+ hsize_t dim[4];
+ int index[4] = {0,1,2,3}; /* normal indicies */
+ const int perm[4] = {0,1,2,3}; /* the 0'th and the 3'rd indices are permuted */
+
+ fid = H5Fcreate(FILE12, H5F_ACC_TRUNC, H5P_DEFAULT, H5P_DEFAULT);
+
+ group = H5Gcreate (fid, "/g1", 0);
+ H5Gclose(group);
+
+ create_plist = H5Pcreate(H5P_DATASET_CREATE);
+
+ sdim = 2;
+ H5Pset_chunk(create_plist, 1, &sdim);
+
+ group = H5Gcreate (fid, "/g1/g1.1", 0);
+
+ type = H5Tcreate (H5T_COMPOUND, sizeof(dset1[0]));
+
+ dim[0] = dim[1] = dim[2] = dim[3] = 2;
+ array_dt=H5Tarray_create(H5T_STD_I32BE,4,dim,perm);
+ H5Tinsert(type, "a_array", HOFFSET(dset1_t, a), array_dt);
+ H5Tclose(array_dt);
+
+ array_dt=H5Tarray_create(H5T_IEEE_F64BE,4,dim,perm);
+ H5Tinsert(type, "b_array", HOFFSET(dset1_t, b), array_dt);
+ H5Tclose(array_dt);
+
+ array_dt=H5Tarray_create(H5T_IEEE_F64BE,4,dim,perm);
+ H5Tinsert(type, "c_array", HOFFSET(dset1_t, c), array_dt);
+ H5Tclose(array_dt);
+
+ type2 = H5Tcreate (H5T_COMPOUND, sizeof(dset1[0]));
+
+ array_dt=H5Tarray_create(H5T_NATIVE_INT,4,dim,perm);
+ H5Tinsert(type2, "a_array", HOFFSET(dset1_t, a), array_dt);
+ H5Tclose(array_dt);
+
+ array_dt=H5Tarray_create(H5T_NATIVE_DOUBLE,4,dim,perm);
+ H5Tinsert(type2, "b_array", HOFFSET(dset1_t, b), array_dt);
+ H5Tclose(array_dt);
+
+ array_dt=H5Tarray_create(H5T_NATIVE_DOUBLE,4,dim,perm);
+ H5Tinsert(type2, "c_array", HOFFSET(dset1_t, c), array_dt);
+ H5Tclose(array_dt);
+
+
+ /* dset1 */
+ sdim = 6;
+ maxdim = H5S_UNLIMITED;
+ space = H5Screate_simple(1, &sdim, &maxdim);
+ dataset = H5Dcreate(group, "dset1", type, space, create_plist);
+
+ /* add attributes to dset1 */
+ dims[0] = 10;
+ space2 = H5Screate_simple(1, dims, NULL);
+ attr = H5Acreate (dataset, "attr1", H5T_STD_I8BE, space2, H5P_DEFAULT);
+ sprintf(buf, "abcdefghi");
+ H5Awrite(attr, H5T_NATIVE_CHAR, buf);
+ H5Sclose(space2);
+ H5Aclose(attr);
+
+ dims[0] = 2; dims[1] = 2;
+ space2 = H5Screate_simple(2, dims, NULL);
+ attr = H5Acreate (dataset, "attr2", H5T_STD_I32BE, space2, H5P_DEFAULT);
+ data[0][0] = 0; data[0][1] = 1; data[1][0] = 2; data[1][1] = 3;
+ H5Awrite(attr, H5T_NATIVE_INT, data);
+ H5Sclose(space2);
+ H5Aclose(attr);
+
+ dims[0] = 10;
+ space2 = H5Screate_simple(1, dims, NULL);
+ attr = H5Acreate (dataset, "attr3", H5T_IEEE_F64BE, space2, H5P_DEFAULT);
+ for (i = 0; i < 10; i++) d[i] = 0.1 * i;
+ H5Awrite(attr, H5T_NATIVE_DOUBLE, d);
+ H5Sclose(space2);
+ H5Aclose(attr);
+
+ for (j=0; j<(int)sdim; j++) {
+ for (i3 = 0; i3 < 2; i3++) {
+ index[perm[3]] = i3;
+ for (i2 = 0; i2 < 2; i2++) {
+ index[perm[2]] = i2;
+ for (i1 = 0; i1 < 2; i1++) {
+ index[perm[1]] = i1;
+ for (i0 = 0; i0 < 2; i0++) {
+ index[perm[0]] = i0;
+
+ dset1[j].a[index[3]][index[2]][index[1]][index[0]] = i0+j;
+ dset1[j].b[index[3]][index[2]][index[1]][index[0]] = (double)(i0+j);
+#if WIN32
+ dset1[j].c[index[3]][index[2]][index[1]][index[0]] = (double)(i0+j+(signed __int64)sdim);
+#else
+ dset1[j].c[index[3]][index[2]][index[1]][index[0]] = (double)(i0+j+sdim);
+#endif
+ }
+ }
+ }
+ }
+ }
+
+ H5Dwrite(dataset, type2, H5S_ALL, H5S_ALL, H5P_DEFAULT, dset1);
+
+ H5Dclose(dataset);
+ H5Sclose(space);
+
+ H5Tclose(type);
+ H5Tclose(type2);
+ H5Gclose(group);
+
+ group = H5Gcreate (fid, "/g1/g1.2", 0);
+ H5Glink (group, H5G_LINK_HARD, "/g1/g1.1/dset1", "link1");
+ H5Gclose(group);
+
+ group = H5Gcreate (fid, "/g2", 0);
+ H5Glink (group, H5G_LINK_SOFT, "/g1", "slink2");
+ H5Gclose(group);
+
+ group = H5Gcreate (fid, "/g3", 0);
+ H5Gclose(group);
+
+ group = H5Gcreate (fid, "/g4", 0);
+
+ /* dset2 */
+ dims[0] = 10; dims[1] = 10;
+ space = H5Screate_simple(2, dims, NULL);
+
+ dataset = H5Dcreate(group, "dset2", H5T_STD_I32BE, space, H5P_DEFAULT);
+ for (i = 0; i < 10; i++)
+ for (j = 0; j < 10; j++)
+ dset2[i][j] = j;
+ H5Dwrite(dataset, H5T_NATIVE_INT, H5S_ALL, H5S_ALL, H5P_DEFAULT, dset2);
+
+ H5Dclose(dataset);
+
+ H5Sclose(space);
+ H5Gclose(group);
+
+ group = H5Gopen(fid, "/g3");
+ H5Glink (group, H5G_LINK_HARD, "/g4/dset2", "link3");
+ H5Gclose(group);
+
+ group = H5Gcreate (fid, "/g5", 0);
+ H5Gclose(group);
+
+ group = H5Gcreate (fid, "/g6", 0);
+ /* dset3 */
+ dims[0] = 10; dims[1] = 10;
+ space = H5Screate_simple(2, dims, NULL);
+
+ dataset = H5Dcreate(group, "dset3", H5T_STD_I32BE, space, H5P_DEFAULT);
+ for (i = 0; i < 10; i++)
+ for (j = 0; j < 10; j++)
+ dset3[i][j] = i;
+ H5Dwrite(dataset, H5T_NATIVE_INT, H5S_ALL, H5S_ALL, H5P_DEFAULT, dset3);
+
+ H5Dclose(dataset);
+
+ H5Sclose(space);
+ H5Gclose(group);
+
+ group = H5Gopen(fid, "/g5");
+ H5Glink (group, H5G_LINK_SOFT, "/g6/dset3", "slink4");
+ H5Gclose(group);
+
+ H5Fclose(fid);
+
+}
+static hid_t mkstr(int size, H5T_str_t pad) {
+hid_t type;
+
+ if ((type=H5Tcopy(H5T_C_S1))<0) return -1;
+ if (H5Tset_size(type, (size_t)size)<0) return -1;
+ if (H5Tset_strpad(type, pad)<0) return -1;
+
+ return type;
+}
+
+static void test_str(void) {
+ hid_t fid, dataset, space, f_type, m_type, str_type, f_type2;
+ hid_t array_dt;
+
+ hsize_t dims1[] = { 3, 4};
+ char string1[12][2] = {"s1","s2","s3","s4","s5","s6","s7","s8","s9",
+ "s0","s1","s2"};
+
+ hsize_t dims2[]={20};
+ char string2[20][9] = {"ab cd ef1", "ab cd ef2", "ab cd ef3", "ab cd ef4",
+ "ab cd ef5", "ab cd ef6", "ab cd ef7", "ab cd ef8",
+ "ab cd ef9", "ab cd ef0", "ab cd ef1", "ab cd ef2",
+ "ab cd ef3", "ab cd ef4", "ab cd ef5", "ab cd ef6",
+ "ab cd ef7", "ab cd ef8", "ab cd ef9", "ab cd ef0"};
+
+ hsize_t dims3[] = { 27};
+ char string3[27][5] = {"abcd0", "abcd1", "abcd2", "abcd3",
+ "abcd4", "abcd5", "abcd6", "abcd7",
+ "abcd8", "abcd9", "abcd0", "abcd1",
+ "abcd2", "abcd3", "abcd4", "abcd5",
+ "abcd6", "abcd7", "abcd8", "abcd9",
+ "abcd0", "abcd1", "abcd2", "abcd3",
+ "abcd4", "abcd5", "abcd6"};
+
+ int i, j, k, l;
+
+ hsize_t dims4[] = { 3 };
+ char string4[3][20] = { "s1234567890123456789", "s1234567890123456789",
+ "s1234567890123456789"};
+
+ hsize_t dims5[] = { 3, 6};
+ typedef struct {
+ int a[8][10];
+ char s[12][32];
+ } compound_t;
+ compound_t comp1[3][6];
+ hsize_t mdims[2];
+
+ fid = H5Fcreate(FILE13, H5F_ACC_TRUNC, H5P_DEFAULT, H5P_DEFAULT);
+
+ /* string 1 : nullterm string */
+ space = H5Screate_simple(2, dims1, NULL);
+ f_type = mkstr(5, H5T_STR_NULLTERM);
+ m_type = mkstr(2, H5T_STR_NULLTERM);
+ dataset = H5Dcreate(fid, "/string1", f_type, space, H5P_DEFAULT);
+ H5Dwrite(dataset, m_type, H5S_ALL, H5S_ALL, H5P_DEFAULT, string1);
+ H5Tclose(m_type);
+ H5Tclose(f_type);
+ H5Sclose(space);
+ H5Dclose(dataset);
+
+ /* string 2 : space pad string */
+ space = H5Screate_simple(1, dims2, NULL);
+ f_type = mkstr(11, H5T_STR_SPACEPAD);
+ m_type = mkstr(9, H5T_STR_NULLTERM);
+ dataset = H5Dcreate(fid, "/string2", f_type, space, H5P_DEFAULT);
+ H5Dwrite(dataset, m_type, H5S_ALL, H5S_ALL, H5P_DEFAULT, string2);
+ H5Tclose(m_type);
+ H5Tclose(f_type);
+ H5Sclose(space);
+ H5Dclose(dataset);
+
+ /* string 3 : null pad string */
+ space = H5Screate_simple(1, dims3, NULL);
+ f_type = mkstr(8, H5T_STR_NULLPAD);
+ m_type = mkstr(5, H5T_STR_NULLTERM);
+ dataset = H5Dcreate(fid, "/string3", f_type, space, H5P_DEFAULT);
+ H5Dwrite(dataset, m_type, H5S_ALL, H5S_ALL, H5P_DEFAULT, string3);
+ H5Tclose(m_type);
+ H5Tclose(f_type);
+ H5Sclose(space);
+ H5Dclose(dataset);
+
+ /* string 4 : space pad long string */
+ space = H5Screate_simple(1, dims4, NULL);
+ f_type = mkstr(168, H5T_STR_SPACEPAD);
+ m_type = mkstr(20, H5T_STR_NULLTERM);
+ dataset = H5Dcreate(fid, "/string4", f_type, space, H5P_DEFAULT);
+ H5Dwrite(dataset, m_type, H5S_ALL, H5S_ALL, H5P_DEFAULT, string4);
+ H5Tclose(m_type);
+ H5Tclose(f_type);
+ H5Sclose(space);
+ H5Dclose(dataset);
+
+ /* compound data */
+ space = H5Screate_simple(2, dims5, NULL);
+ f_type = H5Tcreate (H5T_COMPOUND, sizeof(compound_t));
+ f_type2 = H5Tcreate (H5T_COMPOUND, sizeof(compound_t));
+
+ mdims[0] = 8; mdims[1] = 10;
+
+ array_dt=H5Tarray_create(H5T_STD_I32BE,2,mdims,NULL);
+ H5Tinsert(f_type, "int_array", HOFFSET(compound_t, a), array_dt);
+ H5Tclose(array_dt);
+
+ array_dt=H5Tarray_create(H5T_NATIVE_INT,2,mdims,NULL);
+ H5Tinsert(f_type2, "int_array", HOFFSET(compound_t, a), array_dt);
+ H5Tclose(array_dt);
+
+ str_type = mkstr(32, H5T_STR_SPACEPAD);
+ mdims[0] = 3; mdims[1] = 4;
+
+ array_dt=H5Tarray_create(str_type,2,mdims,NULL);
+ H5Tinsert(f_type, "string", HOFFSET(compound_t, s), array_dt);
+ H5Tclose(array_dt);
+
+ array_dt=H5Tarray_create(str_type,2,mdims,NULL);
+ H5Tinsert(f_type2, "string", HOFFSET(compound_t, s), array_dt);
+ H5Tclose(array_dt);
+
+ for (i = 0; i < 3; i++)
+ for (j = 0; j < 6; j++) {
+ for (k = 0 ; k < 8; k++)
+ for (l = 0; l < 10; l++)
+ comp1[i][j].a[k][l] = (l+j+k) * (l+j+k);
+ for (k = 0 ; k < 12; k++)
+ sprintf(comp1[i][j].s[k], "abcdefgh12345678abcdefgh12345678");
+ }
+
+ dataset = H5Dcreate(fid, "/comp1", f_type, space, H5P_DEFAULT);
+ H5Dwrite(dataset, f_type2, H5S_ALL, H5S_ALL, H5P_DEFAULT, comp1);
+
+ H5Tclose(str_type);
+ H5Tclose(f_type);
+ H5Tclose(f_type2);
+ H5Sclose(space);
+ H5Dclose(dataset);
+
+ H5Fclose(fid);
+}
+
+/*
+ /
+ / / | \ \ \
+ g1 g2 g3 g4 g5 g6
+ | | | | \ \
+ string1 string3 string5
+ string2 string4 string6
+*/
+
+static void test_str2(void)
+{
+hid_t fid, group, attr, dataset, space, space2, mem_space, hyper_space;
+hid_t fxdlenstr, fxdlenstr2, memtype;
+hsize_t dims[1], size[1], stride[1], count[1], block[1];
+hssize_t start[1];
+
+
+int i;
+char buf[LENSTR+10];
+char buf2[3*LENSTR2];
+hsize_t sdim;
+
+ fid = H5Fcreate(FILE14, H5F_ACC_TRUNC, H5P_DEFAULT, H5P_DEFAULT);
+
+ fxdlenstr = H5Tcopy(H5T_C_S1);
+ H5Tset_size(fxdlenstr, LENSTR);
+ H5Tset_cset(fxdlenstr, H5T_CSET_ASCII);
+ H5Tset_strpad(fxdlenstr, H5T_STR_NULLTERM);
+
+ memtype = H5Tcopy(H5T_C_S1);
+ H5Tset_size(memtype, LENSTR);
+ H5Tset_cset(memtype, H5T_CSET_ASCII);
+ H5Tset_strpad(memtype, H5T_STR_NULLTERM);
+
+ sdim = 10;
+ size[0] = sdim;
+ space = H5Screate_simple(1, size, NULL);
+ size[0] = 1;
+ mem_space = H5Screate_simple(1,size,NULL);
+ hyper_space = H5Scopy(space);
+
+ /* dset1 */
+
+ group = H5Gcreate (fid, "/g1", 0);
+ dataset = H5Dcreate(group, "dset1", fxdlenstr, space, H5P_DEFAULT);
+
+ /* add attributes to dset1 */
+
+ fxdlenstr2 = H5Tcopy(H5T_C_S1);
+ H5Tset_size(fxdlenstr2, LENSTR2);
+ H5Tset_cset(fxdlenstr2, H5T_CSET_ASCII);
+ H5Tset_strpad(fxdlenstr2, H5T_STR_NULLTERM);
+
+ dims[0] = 3;
+ space2 = H5Screate_simple(1, dims, NULL);
+ attr = H5Acreate (dataset, "attr1", fxdlenstr2, space2, H5P_DEFAULT);
+ sprintf(&(buf2[0*LENSTR2]), "0123456789");
+ sprintf(&(buf2[1*LENSTR2]), "abcdefghij");
+ sprintf(&(buf2[2*LENSTR2]), "ABCDEFGHIJ");
+ H5Awrite(attr, fxdlenstr2, buf2);
+ H5Sclose(space2);
+ H5Tclose(fxdlenstr2);
+ H5Aclose(attr);
+
+ stride[0]=1;
+ count[0]=1;
+ block[0]=1;
+
+ for (i = 0; (hsize_t)i < sdim; i++) {
+ start[0] = i;
+ sprintf(buf,"This is row %1d of type H5T_STR_NULLTERM of",i);
+ H5Tset_size(memtype, HDstrlen(buf)+1);
+ H5Sselect_hyperslab(hyper_space, H5S_SELECT_SET, start, stride, count, block);
+ H5Dwrite(dataset, memtype, mem_space, hyper_space, H5P_DEFAULT, buf);
+ }
+ H5Dclose(dataset);
+ H5Gclose(group);
+
+ group = H5Gcreate (fid, "/g2", 0);
+ dataset = H5Dcreate(group, "dset2", fxdlenstr, space, H5P_DEFAULT);
+
+ for (i = 0; (hsize_t)i < sdim; i++) {
+ start[0] = i;
+ sprintf(buf,"This is row %1d of type H5T_STR_NULLTERM of string array",i);
+ H5Tset_size(memtype, HDstrlen(buf)+1);
+ H5Sselect_hyperslab(hyper_space, H5S_SELECT_SET, start, stride, count, block);
+ H5Dwrite(dataset, memtype, mem_space, hyper_space, H5P_DEFAULT, buf);
+ }
+ H5Dclose(dataset);
+ H5Gclose(group);
+
+
+ H5Tclose(fxdlenstr);
+ fxdlenstr = H5Tcopy(H5T_C_S1);
+ H5Tset_size(fxdlenstr, LENSTR);
+ H5Tset_cset(fxdlenstr, H5T_CSET_ASCII);
+ H5Tset_strpad(fxdlenstr, H5T_STR_NULLPAD);
+
+ group = H5Gcreate (fid, "/g3", 0);
+ dataset = H5Dcreate(group, "dset3", fxdlenstr, space, H5P_DEFAULT);
+
+ for (i = 0;(hsize_t) i < sdim; i++) {
+ start[0] = i;
+ sprintf(buf,"This is row %1d of type H5T_STR_NULLPAD of",i);
+ H5Tset_size(memtype, HDstrlen(buf)+1);
+ H5Sselect_hyperslab(hyper_space, H5S_SELECT_SET, start, stride, count, block);
+ H5Dwrite(dataset, memtype, mem_space, hyper_space, H5P_DEFAULT, buf);
+ }
+ H5Dclose(dataset);
+ H5Gclose(group);
+
+
+ group = H5Gcreate (fid, "/g4", 0);
+ dataset = H5Dcreate(group, "dset4", fxdlenstr, space, H5P_DEFAULT);
+
+ for (i = 0; (hsize_t)i < sdim; i++) {
+ start[0] = i;
+ sprintf(buf,"This is row %1d of type H5T_STR_NULLPAD of string array",i);
+ H5Tset_size(memtype, HDstrlen(buf)+1);
+ H5Sselect_hyperslab(hyper_space, H5S_SELECT_SET, start, stride, count, block);
+ H5Dwrite(dataset, memtype, mem_space, hyper_space, H5P_DEFAULT, buf);
+ }
+ H5Dclose(dataset);
+ H5Gclose(group);
+
+ H5Tclose(fxdlenstr);
+ fxdlenstr = H5Tcopy(H5T_C_S1);
+ H5Tset_size(fxdlenstr, LENSTR);
+ H5Tset_cset(fxdlenstr, H5T_CSET_ASCII);
+ H5Tset_strpad(fxdlenstr, H5T_STR_SPACEPAD);
+
+ group = H5Gcreate (fid, "/g5", 0);
+ dataset = H5Dcreate(group, "dset5", fxdlenstr, space, H5P_DEFAULT);
+
+ for (i = 0; (hsize_t)i < sdim; i++) {
+ start[0] = i;
+ sprintf(buf,"This is row %1d of type H5T_STR_SPACEPAD of",i);
+ H5Tset_size(memtype, HDstrlen(buf)+1);
+ H5Sselect_hyperslab(hyper_space, H5S_SELECT_SET, start, stride, count, block);
+ H5Dwrite(dataset, memtype, mem_space, hyper_space, H5P_DEFAULT, buf);
+ }
+ H5Dclose(dataset);
+ H5Gclose(group);
+
+
+ group = H5Gcreate (fid, "/g6", 0);
+ dataset = H5Dcreate(group, "dset6", fxdlenstr, space, H5P_DEFAULT);
+
+ for (i = 0; (hsize_t)i < sdim; i++) {
+ start[0] = i;
+ sprintf(buf,"This is row %1d of type H5T_STR_SPACEPAD of string array",i);
+ H5Tset_size(memtype, HDstrlen(buf)+1);
+ H5Sselect_hyperslab(hyper_space, H5S_SELECT_SET, start, stride, count, block);
+ H5Dwrite(dataset, memtype, mem_space, hyper_space, H5P_DEFAULT, buf);
+ }
+
+ H5Dclose(dataset);
+ H5Tclose(fxdlenstr);
+ H5Tclose(memtype);
+ H5Sclose(mem_space);
+ H5Sclose(hyper_space);
+ H5Sclose(space);
+ H5Fclose(fid);
+}
+
+static void test_enum(void)
+{
+ /*some code is taken from enum.c in the test dir */
+ hid_t file, type, space, dset;
+ int val;
+ enumtype data[] = {RED, GREEN, BLUE, GREEN, WHITE,
+ WHITE, BLACK, GREEN, BLUE, RED,
+ RED, BLUE, GREEN, BLACK, WHITE,
+ RED, WHITE, GREEN, GREEN, BLUE};
+ hsize_t size[1] = {NELMTS(data)};
+
+ file = H5Fcreate(FILE15,H5F_ACC_TRUNC, H5P_DEFAULT, H5P_DEFAULT);
+
+
+ type = H5Tcreate(H5T_ENUM, sizeof(enumtype));
+ H5Tenum_insert(type, "RED", (val = 0, &val));
+ H5Tenum_insert(type, "GREEN", (val = 1, &val));
+ H5Tenum_insert(type, "BLUE", (val = 2, &val));
+ H5Tenum_insert(type, "WHITE", (val = 3, &val));
+ H5Tenum_insert(type, "BLACK", (val = 4, &val));
+ H5Tcommit(file, "enum normal", type);
+
+ space = H5Screate_simple(1,size,NULL);
+ dset = H5Dcreate(file,"table",type, space, H5P_DEFAULT);
+ H5Dwrite(dset,type,space,space,H5P_DEFAULT,data);
+
+ H5Dclose(dset);
+ H5Sclose(space);
+ H5Fclose(file);
+}
+
+static void test_objref(void)
+{
+/*some code is taken from enum.c in the test dir */
+ hid_t fid1; /* HDF5 File IDs */
+ hid_t dataset; /* Dataset ID */
+
+ hid_t group; /* Group ID */
+ hid_t sid1; /* Dataspace ID */
+ hid_t tid1; /* Datatype ID */
+ hsize_t dims1[] = {SPACE1_DIM1};
+ hobj_ref_t *wbuf, /* buffer to write to disk */
+ *rbuf, /* buffer read from disk */
+ *tbuf; /* temp. buffer read from disk */
+ uint32_t *tu32; /* Temporary pointer to uint32 data */
+ intn i; /* counting variables */
+ const char *write_comment="Foo!"; /* Comments for group */
+
+ /* Allocate write & read buffers */
+ wbuf=malloc(sizeof(hobj_ref_t)*SPACE1_DIM1);
+ rbuf=malloc(sizeof(hobj_ref_t)*SPACE1_DIM1);
+ tbuf=malloc(sizeof(hobj_ref_t)*SPACE1_DIM1);
+
+ /* Create file */
+ fid1 = H5Fcreate(FILE16, H5F_ACC_TRUNC, H5P_DEFAULT, H5P_DEFAULT);
+
+ /* Create dataspace for datasets */
+ sid1 = H5Screate_simple(SPACE1_RANK, dims1, NULL);
+
+ /* Create a group */
+ group=H5Gcreate(fid1,"Group1",(size_t)-1);
+
+ /* Set group's comment */
+ H5Gset_comment(group,".",write_comment);
+
+ /* Create a dataset (inside Group1) */
+ dataset=H5Dcreate(group,"Dataset1",H5T_STD_U32BE,sid1,H5P_DEFAULT);
+
+ for(tu32=(uint32_t *)((void*)wbuf),i=0; i<SPACE1_DIM1; i++)
+ *tu32++=i*3;
+
+ /* Write selection to disk */
+ H5Dwrite(dataset,H5T_NATIVE_UINT,H5S_ALL,H5S_ALL,H5P_DEFAULT,wbuf);
+
+ /* Close Dataset */
+ H5Dclose(dataset);
+
+ /* Create another dataset (inside Group1) */
+ dataset=H5Dcreate(group,"Dataset2",H5T_STD_U8BE,sid1,H5P_DEFAULT);
+
+ /* Close Dataset */
+ H5Dclose(dataset);
+
+ /* Create a datatype to refer to */
+ tid1 = H5Tcreate (H5T_COMPOUND, sizeof(s1_t));
+
+ /* Insert fields */
+ H5Tinsert (tid1, "a", HOFFSET(s1_t,a), H5T_STD_I32BE);
+
+ H5Tinsert (tid1, "b", HOFFSET(s1_t,b), H5T_IEEE_F32BE);
+
+ H5Tinsert (tid1, "c", HOFFSET(s1_t,c), H5T_IEEE_F32BE);
+
+ /* Save datatype for later */
+ H5Tcommit (group, "Datatype1", tid1);
+
+ /* Close datatype */
+ H5Tclose(tid1);
+
+ /* Close group */
+ H5Gclose(group);
+
+ /* Create a dataset */
+ dataset=H5Dcreate(fid1,"Dataset3",H5T_STD_REF_OBJ,sid1,H5P_DEFAULT);
+
+ /* Create reference to dataset */
+ H5Rcreate(&wbuf[0],fid1,"/Group1/Dataset1",H5R_OBJECT,-1);
+ H5Rget_object_type(dataset,&wbuf[0]);
+
+ /* Create reference to dataset */
+ H5Rcreate(&wbuf[1],fid1,"/Group1/Dataset2",H5R_OBJECT,-1);
+
+ H5Rget_object_type(dataset,&wbuf[1]);
+
+ /* Create reference to group */
+ H5Rcreate(&wbuf[2],fid1,"/Group1",H5R_OBJECT,-1);
+
+ H5Rget_object_type(dataset,&wbuf[2]);
+
+
+ /* Create reference to named datatype */
+ H5Rcreate(&wbuf[3],fid1,"/Group1/Datatype1",H5R_OBJECT,-1);
+
+ H5Rget_object_type(dataset,&wbuf[3]);
+
+
+ /* Write selection to disk */
+ H5Dwrite(dataset,H5T_STD_REF_OBJ,H5S_ALL,H5S_ALL,H5P_DEFAULT,wbuf);
+
+
+ /* Close disk dataspace */
+ H5Sclose(sid1);
+
+ /* Close Dataset */
+ H5Dclose(dataset);
+
+ /* Close file */
+ H5Fclose(fid1);
+
+ /* Free memory buffers */
+ free(wbuf);
+ free(rbuf);
+ free(tbuf);
+
+}
+
+static void test_datareg(void)
+{
+ /*some code is taken from enum.c in the test dir */
+
+ hid_t fid1; /* HDF5 File IDs */
+ hid_t dset1, /* Dataset ID */
+ dset2; /* Dereferenced dataset ID */
+ hid_t sid1, /* Dataspace ID #1 */
+ sid2; /* Dataspace ID #2 */
+ hsize_t dims1[] = {SPACE1_DIM1},
+ dims2[] = {SPACE2_DIM1, SPACE2_DIM2};
+ hssize_t start[SPACE2_RANK]; /* Starting location of hyperslab */
+ hsize_t stride[SPACE2_RANK]; /* Stride of hyperslab */
+ hsize_t count[SPACE2_RANK]; /* Element count of hyperslab */
+ hsize_t block[SPACE2_RANK]; /* Block size of hyperslab */
+ hssize_t coord1[POINT1_NPOINTS][SPACE2_RANK]; /* Coordinates for point selection */
+ hdset_reg_ref_t *wbuf, /* buffer to write to disk */
+ *rbuf; /* buffer read from disk */
+ uint8_t *dwbuf, /* Buffer for writing numeric data to disk */
+ *drbuf; /* Buffer for reading numeric data from disk */
+ uint8_t *tu8; /* Temporary pointer to uint8 data */
+ intn i; /* counting variables */
+
+ /* Allocate write & read buffers */
+ wbuf=calloc(sizeof(hdset_reg_ref_t), SPACE1_DIM1);
+ rbuf=malloc(sizeof(hdset_reg_ref_t)*SPACE1_DIM1);
+ dwbuf=malloc(sizeof(uint8_t)*SPACE2_DIM1*SPACE2_DIM2);
+ drbuf=calloc(sizeof(uint8_t),SPACE2_DIM1*SPACE2_DIM2);
+
+ /* Create file */
+ fid1 = H5Fcreate(FILE17, H5F_ACC_TRUNC, H5P_DEFAULT, H5P_DEFAULT);
+
+ /* Create dataspace for datasets */
+ sid2 = H5Screate_simple(SPACE2_RANK, dims2, NULL);
+
+ /* Create a dataset */
+ dset2=H5Dcreate(fid1,"Dataset2",H5T_STD_U8BE,sid2,H5P_DEFAULT);
+
+ for(tu8=dwbuf,i=0; i<SPACE2_DIM1*SPACE2_DIM2; i++)
+ *tu8++=i*3;
+
+ /* Write selection to disk */
+ H5Dwrite(dset2,H5T_NATIVE_UCHAR,H5S_ALL,H5S_ALL,H5P_DEFAULT,dwbuf);
+
+ /* Close Dataset */
+ H5Dclose(dset2);
+
+ /* Create dataspace for the reference dataset */
+ sid1 = H5Screate_simple(SPACE1_RANK, dims1, NULL);
+
+ /* Create a dataset */
+ dset1=H5Dcreate(fid1,"Dataset1",H5T_STD_REF_DSETREG,sid1,H5P_DEFAULT);
+
+ /* Create references */
+
+ /* Select 6x6 hyperslab for first reference */
+ start[0]=2; start[1]=2;
+ stride[0]=1; stride[1]=1;
+ count[0]=6; count[1]=6;
+ block[0]=1; block[1]=1;
+ H5Sselect_hyperslab(sid2,H5S_SELECT_SET,start,stride,count,block);
+
+ H5Sget_select_npoints(sid2);
+
+ /* Store first dataset region */
+ H5Rcreate(&wbuf[0],fid1,"/Dataset2",H5R_DATASET_REGION,sid2);
+
+ /* Select sequence of ten points for second reference */
+ coord1[0][0]=6; coord1[0][1]=9;
+ coord1[1][0]=2; coord1[1][1]=2;
+ coord1[2][0]=8; coord1[2][1]=4;
+ coord1[3][0]=1; coord1[3][1]=6;
+ coord1[4][0]=2; coord1[4][1]=8;
+ coord1[5][0]=3; coord1[5][1]=2;
+ coord1[6][0]=0; coord1[6][1]=4;
+ coord1[7][0]=9; coord1[7][1]=0;
+ coord1[8][0]=7; coord1[8][1]=1;
+ coord1[9][0]=3; coord1[9][1]=3;
+ H5Sselect_elements(sid2,H5S_SELECT_SET,POINT1_NPOINTS,(const hssize_t **)coord1);
+
+ H5Sget_select_npoints(sid2);
+
+ /* Store second dataset region */
+ H5Rcreate(&wbuf[1],fid1,"/Dataset2",H5R_DATASET_REGION,sid2);
+
+ /* Write selection to disk */
+ H5Dwrite(dset1,H5T_STD_REF_DSETREG,H5S_ALL,H5S_ALL,H5P_DEFAULT,wbuf);
+
+ /* Close disk dataspace */
+ H5Sclose(sid1);
+
+ /* Close Dataset */
+ H5Dclose(dset1);
+
+ /* Close uint8 dataset dataspace */
+ H5Sclose(sid2);
+
+ /* Close file */
+ H5Fclose(fid1);
+
+ /* Free memory buffers */
+ free(wbuf);
+ free(rbuf);
+ free(dwbuf);
+ free(drbuf);
+}
+
+/*taken from Elena's compound test file*/
+static void test_nestcomp(void)
+{
+ /* Compound memeber of the compound datatype*/
+ typedef struct cmp_t {
+ char a;
+ float b[2];
+ } cmp_t;
+
+ /* First structure and dataset*/
+ typedef struct s1_t {
+ int a;
+ float b;
+ double c;
+ cmp_t d;
+ } s1_t;
+ hid_t cmp_tid; /* Handle for the compound datatype */
+ hid_t char_id; /* Handle for the string datatype */
+ hid_t array_dt;
+ hsize_t array_dims[] = {2}; /* Dataspace dimensions */
+ int ndims = 1; /* Number of dimensions in the array field */
+
+ s1_t s1[10];
+ hid_t s1_tid; /* File datatype identifier */
+
+ int i;
+ hid_t file, dataset, space; /* Handles */
+ herr_t status;
+ hsize_t dim[] = {10}; /* Dataspace dimensions */
+
+ char datasetname[] = "ArrayOfStructures";
+
+
+ /*
+ * Initialize the data
+ */
+ for (i = 0; i< 10; i++) {
+ s1[i].a = i;
+ s1[i].b = i*i;
+ s1[i].c = 1./(i+1);
+ s1[i].d.a = 65 + i;
+ s1[i].d.b[0] = -100.;
+ s1[i].d.b[1] = 100.;
+ }
+
+ /*
+ * Create the data space.
+ */
+ space = H5Screate_simple(1, dim, NULL);
+
+ /*
+ * Create the file.
+ */
+ file = H5Fcreate(FILE18, H5F_ACC_TRUNC, H5P_DEFAULT, H5P_DEFAULT);
+
+ /*
+ * Create the memory data type.
+ */
+ /*
+ * Create a datatype for compound field first.
+ */
+ cmp_tid = H5Tcreate (H5T_COMPOUND, sizeof(cmp_t));
+
+ /* We are using C string of length one to represent "real" character */
+ char_id = H5Tcopy(H5T_C_S1);
+ H5Tset_strpad(char_id, H5T_STR_NULLTERM);
+ H5Tinsert(cmp_tid, "char_name", HOFFSET(cmp_t, a), char_id);
+
+ array_dt=H5Tarray_create(H5T_NATIVE_FLOAT,ndims,array_dims,NULL);
+ H5Tinsert(cmp_tid, "array_name", HOFFSET(cmp_t, b), array_dt);
+ H5Tclose(array_dt);
+
+ s1_tid = H5Tcreate (H5T_COMPOUND, sizeof(s1_t));
+ H5Tinsert(s1_tid, "a_name", HOFFSET(s1_t, a), H5T_NATIVE_INT);
+ H5Tinsert(s1_tid, "c_name", HOFFSET(s1_t, c), H5T_NATIVE_DOUBLE);
+ H5Tinsert(s1_tid, "b_name", HOFFSET(s1_t, b), H5T_NATIVE_FLOAT);
+
+ /* Insert compound memeber created above */
+ H5Tinsert(s1_tid, "d_name", HOFFSET(s1_t, d), cmp_tid);
+
+ /*
+ * Create the dataset.
+ */
+ dataset = H5Dcreate(file, datasetname, s1_tid, space, H5P_DEFAULT);
+
+ /*
+ * Wtite data to the dataset;
+ */
+ status = H5Dwrite(dataset, s1_tid, H5S_ALL, H5S_ALL, H5P_DEFAULT, s1);
+ if (status < 0)
+ fprintf(stderr, "test_nestcomp H5Dwrite failed\n");
+
+ /*
+ * Release resources
+ */
+ H5Tclose(s1_tid);
+ H5Tclose(cmp_tid);
+ H5Tclose(char_id);
+ H5Sclose(space);
+ H5Dclose(dataset);
+ H5Fclose(file);
+}
+
+static void test_opaque(void)
+{
+ hid_t file, type, dataset, space;
+ char test[100][2];
+ int x;
+ hsize_t dim = 2;
+
+ for (x = 0; x < 100; x++){
+ test[x][0] = x;
+ test[x][1] = 99 - x;
+ }
+
+ /*
+ * Create the data space.
+ */
+ space = H5Screate_simple(1, &dim, NULL);
+
+ /*
+ * Create the file.
+ */
+ file = H5Fcreate(FILE19, H5F_ACC_TRUNC, H5P_DEFAULT, H5P_DEFAULT);
+
+ /*
+ * Create the memory datatype.
+ */
+ type = H5Tcreate (H5T_OPAQUE, sizeof(char)*100*2);
+ H5Tset_tag(type, "test opaque type");
+
+ /*
+ * Create the dataset.
+ */
+ dataset = H5Dcreate(file, "opaque test", type, space, H5P_DEFAULT);
+
+ /*
+ * Write data to the dataset;
+ */
+ H5Dwrite(dataset, type, H5S_ALL, H5S_ALL, H5P_DEFAULT, test);
+
+ H5Tclose(type);
+ H5Sclose(space);
+ H5Dclose(dataset);
+ H5Fclose(file);
+}
+
+static void test_bitfields(void)
+{
+ hid_t file, grp=-1, type=-1, space=-1, dset=-1;
+ size_t i;
+ hsize_t nelmts;
+ unsigned char buf[32];
+
+ file = H5Fcreate(FILE20, H5F_ACC_TRUNC, H5P_DEFAULT, H5P_DEFAULT);
+
+ if ((grp=H5Gcreate(file, "typetests", 0))<0) goto error;
+
+ /* bitfield_1 */
+ nelmts = sizeof(buf);
+ if ((type=H5Tcopy(H5T_STD_B8LE))<0 ||
+ (space=H5Screate_simple(1, &nelmts, NULL))<0 ||
+ (dset=H5Dcreate(grp, "bitfield_1", type, space, H5P_DEFAULT))<0)
+ goto error;
+
+ for (i=0; i<sizeof buf; i++) buf[i] = (unsigned char)0xff ^ (unsigned char)i;
+ if (H5Dwrite(dset, type, H5S_ALL, H5S_ALL, H5P_DEFAULT, buf)<0)
+ goto error;
+ if (H5Sclose(space)<0) goto error;
+ if (H5Tclose(type)<0) goto error;
+ if (H5Dclose(dset)<0) goto error;
+
+ /* bitfield_2 */
+ nelmts = sizeof(buf)/2;
+ if ((type=H5Tcopy(H5T_STD_B16LE))<0 ||
+ (space=H5Screate_simple(1, &nelmts, NULL))<0 ||
+ (dset=H5Dcreate(grp, "bitfield_2", type, space, H5P_DEFAULT))<0)
+ goto error;
+ for (i=0; i<sizeof buf; i++) buf[i] = (unsigned char)0xff ^ (unsigned char)i;
+ if (H5Dwrite(dset, type, H5S_ALL, H5S_ALL, H5P_DEFAULT, buf)<0)
+ goto error;
+ if (H5Sclose(space)<0) goto error;
+ if (H5Tclose(type)<0) goto error;
+ if (H5Dclose(dset)<0) goto error;
+ if (H5Gclose(grp)<0) goto error;
+ H5Fclose(file);
+
+ error:
+ H5E_BEGIN_TRY {
+ H5Gclose(grp);
+ H5Tclose(type);
+ H5Sclose(space);
+ H5Dclose(dset);
+ } H5E_END_TRY;
+}
+
+static void test_vldatatypes(void)
+{
+ hvl_t adata, wdata[SPACE1_DIM1];
+ hid_t file, dset, space, type;
+ hsize_t dims[] = { SPACE1_DIM1 };
+ int i;
+ herr_t ret=0;
+
+ ret = ret; /* so that compiler won't complain "is set but never used" */
+ file = H5Fcreate(FILE21, H5F_ACC_TRUNC, H5P_DEFAULT, H5P_DEFAULT);
+
+ /* Allocate and initialize VL dataset to write */
+ for(i = 0; i < SPACE1_DIM1; i++) {
+ int j;
+
+ wdata[i].p = malloc((i + 1) * sizeof(int));
+ wdata[i].len = i + 1;
+
+ for (j = 0; j < i + 1; j++)
+ ((int *)wdata[i].p)[j] = i * 10 + j;
+ }
+
+ /* write out the integers in little-endian format */
+ space = H5Screate_simple(SPACE1_RANK, dims, NULL);
+ type = H5Tvlen_create(H5T_NATIVE_INT);
+ dset = H5Dcreate(file, "Dataset1.0", type, space, H5P_DEFAULT);
+ ret = H5Dwrite(dset, type, H5S_ALL, H5S_ALL, H5P_DEFAULT, wdata);
+ ret = H5Dvlen_reclaim(type, space, H5P_DEFAULT, wdata);
+
+ ret = H5Dclose(dset);
+ ret = H5Tclose(type);
+ ret = H5Sclose(space);
+
+ /* Allocate and initialize VL dataset to write */
+ for(i = 0; i < SPACE1_DIM1; i++) {
+ int j;
+
+ wdata[i].p = malloc((i + 1) * sizeof(float));
+ wdata[i].len = i + 1;
+
+ for (j = 0; j < i + 1; j++)
+ ((float *)wdata[i].p)[j] = i * 10 + ((float)j) / 10.0;
+ }
+
+ /* write out the floats in little-endian format */
+ space = H5Screate_simple(SPACE1_RANK, dims, NULL);
+ type = H5Tvlen_create(H5T_NATIVE_FLOAT);
+ dset = H5Dcreate(file, "Dataset2.0", type, space, H5P_DEFAULT);
+ ret = H5Dwrite(dset, type, H5S_ALL, H5S_ALL, H5P_DEFAULT, wdata);
+ ret = H5Dvlen_reclaim(type, space, H5P_DEFAULT, wdata);
+
+ ret = H5Dclose(dset);
+ ret = H5Tclose(type);
+ ret = H5Sclose(space);
+
+ /* Allocate and initialize a scalar VL dataset to write */
+ adata.p = malloc(37 * sizeof(int));
+ adata.len = 37;
+
+ for (i = 0; i < 37; i++)
+ ((int *)adata.p)[i] = i * 2;
+
+ /* write out scalar VL dataset in little-endian format */
+ space = H5Screate_simple(0, NULL, NULL);
+ type = H5Tvlen_create(H5T_NATIVE_INT);
+ dset = H5Dcreate(file, "Dataset3.0", type, space, H5P_DEFAULT);
+ ret = H5Dwrite(dset, type, H5S_ALL, H5S_ALL, H5P_DEFAULT, &adata);
+ ret = H5Dvlen_reclaim(type, space, H5P_DEFAULT, &adata);
+
+ ret = H5Dclose(dset);
+ ret = H5Tclose(type);
+ ret = H5Sclose(space);
+ ret = H5Fclose(file);
+}
+
+static void test_vldatatypes2(void)
+{
+ hvl_t wdata[SPACE1_DIM1]; /* Information to write */
+ hvl_t *t1; /* Temporary pointer to VL information */
+ hid_t fid1; /* HDF5 File IDs */
+ hid_t dataset; /* Dataset ID */
+ hid_t sid1; /* Dataspace ID */
+ hid_t tid1, tid2; /* Datatype IDs */
+ hsize_t dims1[] = {SPACE1_DIM1};
+ uintn i,j,k; /* counting variables */
+ herr_t ret; /* Generic return value */
+
+ ret = ret; /* so that compiler won't complain "is set but never used" */
+
+ /* Allocate and initialize VL data to write */
+ for(i=0; i<SPACE1_DIM1; i++) {
+ wdata[i].p=malloc((i+1)*sizeof(hvl_t));
+ if(wdata[i].p==NULL) {
+ printf("Cannot allocate memory for VL data! i=%u\n",i);
+ return;
+ } /* end if */
+ wdata[i].len=i+1;
+ for(t1=wdata[i].p,j=0; j<(i+1); j++, t1++) {
+ t1->p=malloc((j+1)*sizeof(unsigned int));
+ if(t1->p==NULL) {
+ printf("Cannot allocate memory for VL data! i=%u, j=%u\n",i,j);
+ return;
+ } /* end if */
+ t1->len=j+1;
+ for(k=0; k<(j+1); k++)
+ ((unsigned int *)t1->p)[k]=i*100+j*10+k;
+ } /* end for */
+ } /* end for */
+
+ /* Create file */
+ fid1 = H5Fcreate(FILE22, H5F_ACC_TRUNC, H5P_DEFAULT, H5P_DEFAULT);
+
+ /* Create dataspace for datasets */
+ sid1 = H5Screate_simple(SPACE1_RANK, dims1, NULL);
+
+ /* Create a VL datatype to refer to */
+ tid1 = H5Tvlen_create (H5T_NATIVE_UINT);
+
+ /* Create the base VL type */
+ tid2 = H5Tvlen_create (tid1);
+
+ /* Create a dataset */
+ dataset=H5Dcreate(fid1,"Dataset1",tid2,sid1,H5P_DEFAULT);
+
+ /* Write dataset to disk */
+ ret=H5Dwrite(dataset,tid2,H5S_ALL,H5S_ALL,H5P_DEFAULT,wdata);
+
+ /* Reclaim the write VL data */
+ ret=H5Dvlen_reclaim(tid2,sid1,H5P_DEFAULT,wdata);
+
+ /* Close Dataset */
+ ret = H5Dclose(dataset);
+ ret = H5Tclose(tid2);
+ ret = H5Tclose(tid1);
+ ret = H5Sclose(sid1);
+ ret = H5Fclose(fid1);
+
+}
+
+static void test_vldatatypes3(void)
+{
+ typedef struct { /* Struct that the VL sequences are composed of */
+ int i;
+ float f;
+ hvl_t v;
+ } s1;
+ s1 wdata[SPACE1_DIM1]; /* Information to write */
+ hid_t fid1; /* HDF5 File IDs */
+ hid_t dataset; /* Dataset ID */
+ hid_t sid1; /* Dataspace ID */
+ hid_t tid1, tid2; /* Datatype IDs */
+ hsize_t dims1[] = {SPACE1_DIM1};
+ uintn i,j; /* counting variables */
+ herr_t ret; /* Generic return value */
+
+ ret = ret; /* so that compiler won't complain "is set but never used" */
+
+ /* Allocate and initialize VL data to write */
+ for(i=0; i<SPACE1_DIM1; i++) {
+ wdata[i].i=i*10;
+ wdata[i].f=(i*20)/3.0;
+ wdata[i].v.p=malloc((i+1)*sizeof(unsigned int));
+ wdata[i].v.len=i+1;
+ for(j=0; j<(i+1); j++)
+ ((unsigned int *)wdata[i].v.p)[j]=i*10+j;
+ } /* end for */
+
+ /* Create file */
+ fid1 = H5Fcreate(FILE23, H5F_ACC_TRUNC, H5P_DEFAULT, H5P_DEFAULT);
+
+ /* Create dataspace for datasets */
+ sid1 = H5Screate_simple(SPACE1_RANK, dims1, NULL);
+
+ /* Create a VL datatype to refer to */
+ tid1 = H5Tvlen_create (H5T_NATIVE_UINT);
+
+ /* Create the base compound type */
+ tid2 = H5Tcreate(H5T_COMPOUND, sizeof(s1));
+
+ /* Insert fields */
+ ret=H5Tinsert(tid2, "i", HOFFSET(s1, i), H5T_NATIVE_INT);
+ ret=H5Tinsert(tid2, "f", HOFFSET(s1, f), H5T_NATIVE_FLOAT);
+ ret=H5Tinsert(tid2, "v", HOFFSET(s1, v), tid1);
+
+ /* Create a dataset */
+ dataset=H5Dcreate(fid1,"Dataset1",tid2,sid1,H5P_DEFAULT);
+
+ /* Write dataset to disk */
+ ret=H5Dwrite(dataset,tid2,H5S_ALL,H5S_ALL,H5P_DEFAULT,wdata);
+
+ /* Reclaim the write VL data */
+ ret=H5Dvlen_reclaim(tid2,sid1,H5P_DEFAULT,wdata);
+
+ /* Close Dataset */
+ ret = H5Dclose(dataset);
+ ret = H5Tclose(tid2);
+ ret = H5Tclose(tid1);
+ ret = H5Sclose(sid1);
+ ret = H5Fclose(fid1);
+}
+
+static void test_vldatatypes4(void)
+{
+ typedef struct { /* Struct that the VL sequences are composed of */
+ int i;
+ float f;
+ } s1;
+ hvl_t wdata[SPACE1_DIM1]; /* Information to write */
+ hid_t fid1; /* HDF5 File IDs */
+ hid_t dataset; /* Dataset ID */
+ hid_t sid1; /* Dataspace ID */
+ hid_t tid1, tid2; /* Datatype IDs */
+ hsize_t dims1[] = {SPACE1_DIM1};
+ uintn i,j; /* counting variables */
+ herr_t ret; /* Generic return value */
+
+ ret = ret; /* so that compiler won't complain "is set but never used" */
+
+ /* Allocate and initialize VL data to write */
+ for(i=0; i<SPACE1_DIM1; i++) {
+ wdata[i].p=malloc((i+1)*sizeof(s1));
+ wdata[i].len=i+1;
+ for(j=0; j<(i+1); j++) {
+ ((s1 *)wdata[i].p)[j].i=i*10+j;
+ ((s1 *)wdata[i].p)[j].f=(i*20+j)/3.0;
+ } /* end for */
+ } /* end for */
+
+ /* Create file */
+ fid1 = H5Fcreate(FILE24, H5F_ACC_TRUNC, H5P_DEFAULT, H5P_DEFAULT);
+
+ /* Create dataspace for datasets */
+ sid1 = H5Screate_simple(SPACE1_RANK, dims1, NULL);
+
+ /* Create the base compound type */
+ tid2 = H5Tcreate(H5T_COMPOUND, sizeof(s1));
+
+ /* Insert fields */
+ ret=H5Tinsert(tid2, "i", HOFFSET(s1, i), H5T_NATIVE_INT);
+ ret=H5Tinsert(tid2, "f", HOFFSET(s1, f), H5T_NATIVE_FLOAT);
+
+ /* Create a datatype to refer to */
+ tid1 = H5Tvlen_create (tid2);
+
+ /* Create a dataset */
+ dataset=H5Dcreate(fid1,"Dataset1",tid1,sid1,H5P_DEFAULT);
+
+ /* Write dataset to disk */
+ ret=H5Dwrite(dataset,tid1,H5S_ALL,H5S_ALL,H5P_DEFAULT,wdata);
+
+ /* Reclaim the write VL data */
+ ret=H5Dvlen_reclaim(tid1,sid1,H5P_DEFAULT,wdata);
+
+ /* Close Dataset */
+ ret = H5Dclose(dataset);
+ ret = H5Tclose(tid1);
+ ret = H5Tclose(tid2);
+ ret = H5Sclose(sid1);
+ ret = H5Fclose(fid1);
+}
+
+static void test_array1(void)
+{
+ int wdata[SPACE1_DIM1][ARRAY1_DIM1]; /* Information to write */
+ hid_t fid1; /* HDF5 File IDs */
+ hid_t dataset; /* Dataset ID */
+ hid_t sid1; /* Dataspace ID */
+ hid_t tid1; /* Datatype ID */
+ hsize_t sdims1[] = {SPACE1_DIM1};
+ hsize_t tdims1[] = {ARRAY1_DIM1};
+ intn i,j; /* counting variables */
+ herr_t ret; /* Generic return value */
+
+ /* Allocate and initialize array data to write */
+ for(i=0; i<SPACE1_DIM1; i++)
+ for(j=0; j<ARRAY1_DIM1; j++)
+ wdata[i][j]=i*10+j;
+
+ /* Create file */
+ fid1 = H5Fcreate(FILE25, H5F_ACC_TRUNC, H5P_DEFAULT, H5P_DEFAULT);
+
+ /* Create dataspace for datasets */
+ sid1 = H5Screate_simple(SPACE1_RANK, sdims1, NULL);
+
+ /* Create a datatype to refer to */
+ tid1 = H5Tarray_create (H5T_NATIVE_INT,ARRAY1_RANK,tdims1,NULL);
+
+ /* Create a dataset */
+ dataset=H5Dcreate(fid1,"Dataset1",tid1,sid1,H5P_DEFAULT);
+
+ /* Write dataset to disk */
+ ret=H5Dwrite(dataset,tid1,H5S_ALL,H5S_ALL,H5P_DEFAULT,wdata);
+
+ /* Close Dataset */
+ ret = H5Dclose(dataset);
+ ret = H5Tclose(tid1);
+ ret = H5Sclose(sid1);
+ ret = H5Fclose(fid1);
+}
+
+static void test_array2(void)
+{
+ int wdata[SPACE1_DIM1][ARRAY2_DIM1][ARRAY2_DIM2][ARRAY2_DIM3]; /* Information to write */
+ hid_t fid; /* HDF5 File IDs */
+ hid_t dataset; /* Dataset ID */
+ hid_t sid; /* Dataspace ID */
+ hid_t tid; /* Datatype ID */
+ hsize_t sdims1[] = {SPACE1_DIM1};
+ hsize_t tdims2[] = {ARRAY2_DIM1,ARRAY2_DIM2,ARRAY2_DIM3};
+ intn i,j,k,l; /* counting variables */
+ herr_t ret; /* Generic return value */
+
+ /* Allocate and initialize array data to write */
+ for(i=0; i<SPACE1_DIM1; i++)
+ for(j=0; j<ARRAY2_DIM1; j++)
+ for(k=0; k<ARRAY2_DIM2; k++)
+ for(l=0; l<ARRAY2_DIM3; l++)
+ wdata[i][j][k][l]=i*1000+j*100+k*10+l;
+
+ /* Create file */
+ fid = H5Fcreate(FILE26, H5F_ACC_TRUNC, H5P_DEFAULT, H5P_DEFAULT);
+
+ /* Create dataspace for datasets */
+ sid = H5Screate_simple(SPACE1_RANK, sdims1, NULL);
+
+ /* Create a datatype to refer to */
+ tid = H5Tarray_create (H5T_NATIVE_INT,ARRAY2_RANK,tdims2,NULL);
+
+ /* Create a dataset */
+ dataset=H5Dcreate(fid,"Dataset1",tid,sid,H5P_DEFAULT);
+
+ /* Write dataset to disk */
+ ret=H5Dwrite(dataset,tid,H5S_ALL,H5S_ALL,H5P_DEFAULT,wdata);
+
+ /* Close Dataset */
+ ret = H5Dclose(dataset);
+ ret = H5Tclose(tid);
+ ret = H5Sclose(sid);
+ ret = H5Fclose(fid);
+}
+
+static void test_array3(void)
+{
+ int wdata[SPACE1_DIM1][ARRAY1_DIM1][ARRAY3_DIM1][ARRAY3_DIM2]; /* Information to write */
+ hid_t fid; /* HDF5 File IDs */
+ hid_t dataset; /* Dataset ID */
+ hid_t sid; /* Dataspace ID */
+ hid_t tid1; /* 1-D array Datatype ID */
+ hid_t tid2; /* 2-D array Datatype ID */
+ hsize_t sdims1[] = {SPACE1_DIM1};
+ hsize_t tdims1[] = {ARRAY1_DIM1};
+ hsize_t tdims2[] = {ARRAY3_DIM1,ARRAY3_DIM2};
+ intn i,j,k,l; /* counting variables */
+ herr_t ret; /* Generic return value */
+
+ /* Allocate and initialize array data to write */
+ for(i=0; i<SPACE1_DIM1; i++)
+ for(j=0; j<ARRAY1_DIM1; j++)
+ for(k=0; k<ARRAY3_DIM1; k++)
+ for(l=0; l<ARRAY3_DIM2; l++)
+ wdata[i][j][k][l]=i*1000+j*100+k*10+l;
+
+ /* Create file */
+ fid = H5Fcreate(FILE27, H5F_ACC_TRUNC, H5P_DEFAULT, H5P_DEFAULT);
+
+ /* Create dataspace for datasets */
+ sid = H5Screate_simple(SPACE1_RANK, sdims1, NULL);
+
+ /* Create a 2-D datatype to refer to */
+ tid2 = H5Tarray_create (H5T_NATIVE_INT,ARRAY3_RANK,tdims2,NULL);
+
+ /* Create a 1-D datatype to refer to */
+ tid1 = H5Tarray_create (tid2,ARRAY1_RANK,tdims1,NULL);
+
+ /* Create a dataset */
+ dataset=H5Dcreate(fid,"Dataset1",tid1,sid,H5P_DEFAULT);
+
+ /* Write dataset to disk */
+ ret=H5Dwrite(dataset,tid1,H5S_ALL,H5S_ALL,H5P_DEFAULT,wdata);
+
+ /* Close Dataset */
+ ret = H5Dclose(dataset);
+ ret = H5Tclose(tid1);
+ ret = H5Tclose(tid2);
+ ret = H5Sclose(sid);
+ ret = H5Fclose(fid);
+}
+
+static void test_array4(void)
+{
+ typedef struct { /* Typedef for compound datatype */
+ int i;
+ float f;
+ } s1_t;
+ s1_t wdata[SPACE1_DIM1][ARRAY1_DIM1]; /* Information to write */
+ hid_t fid1; /* HDF5 File IDs */
+ hid_t dataset; /* Dataset ID */
+ hid_t sid1; /* Dataspace ID */
+ hid_t tid1; /* Array Datatype ID */
+ hid_t tid2; /* Compound Datatype ID */
+ hsize_t sdims1[] = {SPACE1_DIM1};
+ hsize_t tdims1[] = {ARRAY1_DIM1};
+ intn i,j; /* counting variables */
+ herr_t ret; /* Generic return value */
+
+ /* Initialize array data to write */
+ for(i=0; i<SPACE1_DIM1; i++)
+ for(j=0; j<ARRAY1_DIM1; j++) {
+ wdata[i][j].i=i*10+j;
+ wdata[i][j].f=i*2.5+j;
+ } /* end for */
+
+ /* Create file */
+ fid1 = H5Fcreate(FILE28, H5F_ACC_TRUNC, H5P_DEFAULT, H5P_DEFAULT);
+
+ /* Create dataspace for datasets */
+ sid1 = H5Screate_simple(SPACE1_RANK, sdims1, NULL);
+
+ /* Create a compound datatype to refer to */
+ tid2 = H5Tcreate(H5T_COMPOUND, sizeof(s1_t));
+
+ /* Insert integer field */
+ ret = H5Tinsert (tid2, "i", HOFFSET(s1_t,i), H5T_NATIVE_INT);
+
+ /* Insert float field */
+ ret = H5Tinsert (tid2, "f", HOFFSET(s1_t,f), H5T_NATIVE_FLOAT);
+
+ /* Create an array datatype to refer to */
+ tid1 = H5Tarray_create (tid2,ARRAY1_RANK,tdims1,NULL);
+
+ /* Close compound datatype */
+ ret=H5Tclose(tid2);
+
+ /* Create a dataset */
+ dataset=H5Dcreate(fid1,"Dataset1",tid1,sid1,H5P_DEFAULT);
+
+ /* Write dataset to disk */
+ ret=H5Dwrite(dataset,tid1,H5S_ALL,H5S_ALL,H5P_DEFAULT,wdata);
+
+ /* Close Dataset */
+ ret = H5Dclose(dataset);
+ ret = H5Tclose(tid1);
+ ret = H5Sclose(sid1);
+ ret = H5Fclose(fid1);
+}
+
+static void test_array5(void)
+{
+ typedef struct { /* Typedef for compound datatype */
+ int i;
+ float f[ARRAY1_DIM1];
+ } s1_t;
+ s1_t wdata[SPACE1_DIM1][ARRAY1_DIM1]; /* Information to write */
+ hid_t fid1; /* HDF5 File IDs */
+ hid_t dataset; /* Dataset ID */
+ hid_t sid1; /* Dataspace ID */
+ hid_t tid1; /* Array Datatype ID */
+ hid_t tid2; /* Compound Datatype ID */
+ hid_t tid3; /* Nested Array Datatype ID */
+ hsize_t sdims1[] = {SPACE1_DIM1};
+ hsize_t tdims1[] = {ARRAY1_DIM1};
+ intn i,j,k; /* counting variables */
+ herr_t ret; /* Generic return value */
+
+ /* Initialize array data to write */
+ for(i=0; i<SPACE1_DIM1; i++)
+ for(j=0; j<ARRAY1_DIM1; j++) {
+ wdata[i][j].i=i*10+j;
+ for(k=0; k<ARRAY1_DIM1; k++)
+ wdata[i][j].f[k]=i*10+j*2.5+k;
+ } /* end for */
+
+ /* Create file */
+ fid1 = H5Fcreate(FILE29, H5F_ACC_TRUNC, H5P_DEFAULT, H5P_DEFAULT);
+
+ /* Create dataspace for datasets */
+ sid1 = H5Screate_simple(SPACE1_RANK, sdims1, NULL);
+
+ /* Create a compound datatype to refer to */
+ tid2 = H5Tcreate(H5T_COMPOUND, sizeof(s1_t));
+
+ /* Insert integer field */
+ ret = H5Tinsert (tid2, "i", HOFFSET(s1_t,i), H5T_NATIVE_INT);
+
+ /* Create an array of floats datatype */
+ tid3 = H5Tarray_create (H5T_NATIVE_FLOAT,ARRAY1_RANK,tdims1,NULL);
+
+ /* Insert float array field */
+ ret = H5Tinsert (tid2, "f", HOFFSET(s1_t,f), tid3);
+
+ /* Close array of floats field datatype */
+ ret=H5Tclose(tid3);
+
+ /* Create an array datatype to refer to */
+ tid1 = H5Tarray_create (tid2,ARRAY1_RANK,tdims1,NULL);
+
+ /* Close compound datatype */
+ ret=H5Tclose(tid2);
+
+ /* Create a dataset */
+ dataset=H5Dcreate(fid1,"Dataset1",tid1,sid1,H5P_DEFAULT);
+
+ /* Write dataset to disk */
+ ret=H5Dwrite(dataset,tid1,H5S_ALL,H5S_ALL,H5P_DEFAULT,wdata);
+
+ /* Close Dataset */
+ ret = H5Dclose(dataset);
+ ret = H5Tclose(tid1);
+ ret = H5Sclose(sid1);
+ ret = H5Fclose(fid1);
+}
+
+static void test_array6(void)
+{
+ hvl_t wdata[SPACE1_DIM1][ARRAY1_DIM1]; /* Information to write */
+ hid_t fid1; /* HDF5 File IDs */
+ hid_t dataset; /* Dataset ID */
+ hid_t sid1; /* Dataspace ID */
+ hid_t tid1; /* Array Datatype ID */
+ hid_t tid2; /* VL Datatype ID */
+ hsize_t sdims1[] = {SPACE1_DIM1};
+ hsize_t tdims1[] = {ARRAY1_DIM1};
+ intn i,j,k; /* counting variables */
+ herr_t ret; /* Generic return value */
+
+ /* Initialize array data to write */
+ for(i=0; i<SPACE1_DIM1; i++)
+ for(j=0; j<ARRAY1_DIM1; j++) {
+ wdata[i][j].p=malloc((i+j+1)*sizeof(unsigned int));
+ wdata[i][j].len=i+j+1;
+ for(k=0; k<(i+j+1); k++)
+ ((unsigned int *)wdata[i][j].p)[k]=i*100+j*10+k;
+ } /* end for */
+
+ /* Create file */
+ fid1 = H5Fcreate(FILE30, H5F_ACC_TRUNC, H5P_DEFAULT, H5P_DEFAULT);
+
+ /* Create dataspace for datasets */
+ sid1 = H5Screate_simple(SPACE1_RANK, sdims1, NULL);
+
+ /* Create a compound datatype to refer to */
+ tid2 = H5Tvlen_create(H5T_NATIVE_UINT);
+
+ /* Create an array datatype to refer to */
+ tid1 = H5Tarray_create (tid2,ARRAY1_RANK,tdims1,NULL);
+
+ /* Close VL datatype */
+ ret=H5Tclose(tid2);
+
+ /* Create a dataset */
+ dataset=H5Dcreate(fid1,"Dataset1",tid1,sid1,H5P_DEFAULT);
+
+ /* Write dataset to disk */
+ ret=H5Dwrite(dataset,tid1,H5S_ALL,H5S_ALL,H5P_DEFAULT,wdata);
+
+ /* Reclaim the write VL data */
+ ret=H5Dvlen_reclaim(tid1,sid1,H5P_DEFAULT,wdata);
+
+ /* Close Dataset */
+ ret = H5Dclose(dataset);
+ ret = H5Tclose(tid1);
+ ret = H5Sclose(sid1);
+ ret = H5Fclose(fid1);
+}
+
+static void test_array7(void)
+{
+ hvl_t wdata[SPACE1_DIM1][ARRAY1_DIM1]; /* Information to write */
+ hid_t fid1; /* HDF5 File IDs */
+ hid_t dataset; /* Dataset ID */
+ hid_t sid1; /* Dataspace ID */
+ hid_t tid1; /* Array Datatype ID */
+ hid_t tid2; /* VL Datatype ID */
+ hid_t tid3; /* Nested Array Datatype ID */
+ hsize_t sdims1[] = {SPACE1_DIM1};
+ hsize_t tdims1[] = {ARRAY1_DIM1};
+ intn i,j,k,l; /* Index variables */
+ herr_t ret; /* Generic return value */
+
+ /* Initialize array data to write */
+ for(i=0; i<SPACE1_DIM1; i++)
+ for(j=0; j<ARRAY1_DIM1; j++) {
+ wdata[i][j].p=malloc((i+j+1)*(sizeof(unsigned int)*ARRAY1_DIM1));
+ wdata[i][j].len=i+j+1;
+ for(k=0; k<(i+j+1); k++)
+ for(l=0; l<ARRAY1_DIM1; l++)
+ ((unsigned int *)wdata[i][j].p)[k*ARRAY1_DIM1+l]=i*1000+j*100+k*10+l;
+ } /* end for */
+
+ /* Create file */
+ fid1 = H5Fcreate(FILE31, H5F_ACC_TRUNC, H5P_DEFAULT, H5P_DEFAULT);
+
+ /* Create dataspace for datasets */
+ sid1 = H5Screate_simple(SPACE1_RANK, sdims1, NULL);
+
+ /* Create the nested array datatype to refer to */
+ tid3 = H5Tarray_create(H5T_NATIVE_UINT,ARRAY1_RANK,tdims1,NULL);
+
+ /* Create a VL datatype of 1-D arrays to refer to */
+ tid2 = H5Tvlen_create(tid3);
+
+ /* Close nested array datatype */
+ ret=H5Tclose(tid3);
+
+ /* Create an array datatype to refer to */
+ tid1 = H5Tarray_create (tid2,ARRAY1_RANK,tdims1,NULL);
+
+ /* Close VL datatype */
+ ret=H5Tclose(tid2);
+
+ /* Create a dataset */
+ dataset=H5Dcreate(fid1,"Dataset1",tid1,sid1,H5P_DEFAULT);
+
+ /* Write dataset to disk */
+ ret=H5Dwrite(dataset,tid1,H5S_ALL,H5S_ALL,H5P_DEFAULT,wdata);
+
+ /* Reclaim the write VL data */
+ ret=H5Dvlen_reclaim(tid1,sid1,H5P_DEFAULT,wdata);
+
+ /* Close Dataset */
+ ret = H5Dclose(dataset);
+ ret = H5Tclose(tid1);
+ ret = H5Sclose(sid1);
+ ret = H5Fclose(fid1);
+}
+
+static void test_empty(void)
+{
+ typedef struct {
+ int a;
+ float b;
+ char c;
+ } empty_struct;
+ hid_t file, dset, space, type;
+ hsize_t dims[] = { SPACE1_DIM1 };
+ herr_t ret=0;
+
+ ret = ret; /* so that compiler won't complain "is set but never used" */
+ file = H5Fcreate(FILE32, H5F_ACC_TRUNC, H5P_DEFAULT, H5P_DEFAULT);
+
+ space = H5Screate_simple(SPACE1_RANK, dims, NULL);
+
+ /* write out an empty vlen dataset */
+ type = H5Tvlen_create(H5T_NATIVE_INT);
+ dset = H5Dcreate(file, "Dataset1.0", type, space, H5P_DEFAULT);
+ /* Don't write any data */
+ ret = H5Dclose(dset);
+ ret = H5Tclose(type);
+
+ /* write out an empty native integer dataset dataset */
+ dset = H5Dcreate(file, "Dataset2.0", H5T_NATIVE_INT, space, H5P_DEFAULT);
+ /* Don't write any data */
+ ret = H5Dclose(dset);
+
+ /* write out an empty native floating-point dataset dataset */
+ dset = H5Dcreate(file, "Dataset3.0", H5T_NATIVE_FLOAT, space, H5P_DEFAULT);
+ /* Don't write any data */
+ ret = H5Dclose(dset);
+
+ /* write out an empty array dataset */
+ type = H5Tarray_create(H5T_NATIVE_INT,SPACE1_RANK,dims,NULL);
+ dset = H5Dcreate(file, "Dataset4.0", type, space, H5P_DEFAULT);
+ /* Don't write any data */
+ ret = H5Dclose(dset);
+ ret = H5Tclose(type);
+
+ /* write out an empty compound dataset */
+ type = H5Tcreate(H5T_COMPOUND,sizeof(empty_struct));
+ H5Tinsert(type, "a", HOFFSET(empty_struct, a),H5T_NATIVE_INT);
+ H5Tinsert(type, "b", HOFFSET(empty_struct, b),H5T_NATIVE_FLOAT);
+ H5Tinsert(type, "c", HOFFSET(empty_struct, c),H5T_NATIVE_CHAR);
+ dset = H5Dcreate(file, "Dataset5.0", type, space, H5P_DEFAULT);
+ /* Don't write any data */
+ ret = H5Dclose(dset);
+ ret = H5Tclose(type);
+
+ ret = H5Sclose(space);
+
+ ret = H5Fclose(file);
+}
+
+int main(void)
+{
+ test_group();
+ test_attribute();
+ test_softlink();
+ test_dataset();
+ test_hardlink();
+ test_compound_dt();
+ test_all();
+ test_loop();
+
+ test_dataset2();
+ test_compound_dt2();
+ test_loop2();
+ test_many();
+
+ test_str();
+ test_str2();
+
+ test_enum();
+
+ test_objref();
+ test_datareg();
+
+ test_nestcomp();
+
+ test_opaque();
+
+ test_bitfields();
+
+ test_vldatatypes();
+ test_vldatatypes2();
+ test_vldatatypes3();
+ test_vldatatypes4();
+
+ test_array1();
+ test_array2();
+ test_array3();
+ test_array4();
+ test_array5();
+ test_array6();
+ test_array7();
+
+ test_empty();
+
+ return 0;
+}
diff --git a/tools/h5dump/testh5dump.sh b/tools/h5dump/testh5dump.sh
new file mode 100755
index 0000000..05dfb09
--- /dev/null
+++ b/tools/h5dump/testh5dump.sh
@@ -0,0 +1,197 @@
+#! /bin/sh
+#
+# Copyright (C) 1998-2001 National Center for Supercomputing Applications
+# All rights reserved.
+#
+# Tests for the h5dump tool
+
+DUMPER=h5dump # The tool name
+DUMPER_BIN=`pwd`/$DUMPER # The path of the tool binary
+
+CMP='cmp -s'
+DIFF='diff -c'
+
+nerrors=0
+verbose=yes
+
+# The build (current) directory might be different than the source directory.
+if test -z "$srcdir"; then
+ srcdir=.
+fi
+
+test -d ../testfiles || mkdir ../testfiles
+
+# Print a line-line message left justified in a field of 70 characters
+# beginning with the word "Testing".
+#
+TESTING() {
+ SPACES=" "
+ echo "Testing $* $SPACES" | cut -c1-70 | tr -d '\012'
+}
+
+# Run a test and print PASS or *FAIL*. If a test fails then increment
+# the `nerrors' global variable and (if $verbose is set) display the
+# difference between the actual output and the expected output. The
+# expected output is given as the first argument to this function and
+# the actual output file is calculated by replacing the `.ddl' with
+# `.out'. The actual output is not removed if $HDF5_NOCLEANUP has a
+# non-zero value.
+#
+TOOLTEST() {
+ expect="$srcdir/../testfiles/$1"
+ actual="../testfiles/`basename $1 .ddl`.out"
+ shift
+
+ # Run test.
+ TESTING $DUMPER $@
+
+ (
+ echo "#############################"
+ echo "Expected output for '$DUMPER $@'"
+ echo "#############################"
+ cd $srcdir/../testfiles
+ $RUNSERIAL $DUMPER_BIN "$@"
+ ) >$actual 2>&1
+
+ if $CMP $expect $actual; then
+ echo " PASSED"
+ else
+ echo "*FAILED*"
+ echo " Expected result (*.ddl) differs from actual result (*.out)"
+ nerrors="`expr $nerrors + 1`"
+ test yes = "$verbose" && $DIFF $expect $actual |sed 's/^/ /'
+ fi
+
+ # Clean up output file
+ if test -z "$HDF5_NOCLEANUP"; then
+ rm -f $actual
+ fi
+}
+
+##############################################################################
+##############################################################################
+### T H E T E S T S ###
+##############################################################################
+##############################################################################
+
+# test for displaying groups
+TOOLTEST tgroup-1.ddl tgroup.h5
+# test for displaying the selected groups
+TOOLTEST tgroup-2.ddl --group=/g2 --group / -g /y tgroup.h5
+
+# test for displaying simple space datasets
+TOOLTEST tdset-1.ddl tdset.h5
+# test for displaying selected datasets
+TOOLTEST tdset-2.ddl -H -d dset1 -d /dset2 --dataset=dset3 tdset.h5
+
+# test for displaying attributes
+TOOLTEST tattr-1.ddl tattr.h5
+# test for displaying the selected attributes of string type and scalar space
+TOOLTEST tattr-2.ddl -a /attr1 --attribute /attr4 --attribute=/attr5 tattr.h5
+# test for header and error messages
+TOOLTEST tattr-3.ddl --header -a /attr2 --attribute=/attr tattr.h5
+
+# test for displaying soft links
+TOOLTEST tslink-1.ddl tslink.h5
+# test for displaying the selected link
+TOOLTEST tslink-2.ddl -l slink2 tslink.h5
+
+# tests for hard links
+TOOLTEST thlink-1.ddl thlink.h5
+TOOLTEST thlink-2.ddl -d /g1/dset2 --dataset /dset1 --dataset=/g1/g1.1/dset3 thlink.h5
+TOOLTEST thlink-3.ddl -d /g1/g1.1/dset3 --dataset /g1/dset2 --dataset=/dset1 thlink.h5
+TOOLTEST thlink-4.ddl -g /g1 thlink.h5
+TOOLTEST thlink-5.ddl -d /dset1 -g /g2 -d /g1/dset2 thlink.h5
+
+# tests for compound data types
+TOOLTEST tcomp-1.ddl tcompound.h5
+# test for named data types
+TOOLTEST tcomp-2.ddl -t /type1 --datatype /type2 --datatype=/group1/type3 tcompound.h5
+# test for unamed type
+TOOLTEST tcomp-3.ddl -t /#5992:0 -g /group2 tcompound.h5
+
+#test for the nested compound type
+TOOLTEST tnestcomp-1.ddl tnestedcomp.h5
+
+# test for options
+TOOLTEST tall-1.ddl tall.h5
+TOOLTEST tall-2.ddl --header -g /g1/g1.1 -a attr2 tall.h5
+TOOLTEST tall-3.ddl -d /g2/dset2.1 -l /g1/g1.2/g1.2.1/slink tall.h5
+
+# test for loop detection
+TOOLTEST tloop-1.ddl tloop.h5
+
+# test for string
+TOOLTEST tstr-1.ddl tstr.h5
+TOOLTEST tstr-2.ddl tstr2.h5
+
+# test for file created by Lib SAF team
+TOOLTEST tsaf.ddl tsaf.h5
+
+# test for file with variable length data
+TOOLTEST tvldtypes1.ddl tvldtypes1.h5
+TOOLTEST tvldtypes2.ddl tvldtypes2.h5
+TOOLTEST tvldtypes3.ddl tvldtypes3.h5
+TOOLTEST tvldtypes4.ddl tvldtypes4.h5
+
+# test for files with array data
+TOOLTEST tarray1.ddl tarray1.h5
+TOOLTEST tarray2.ddl tarray2.h5
+TOOLTEST tarray3.ddl tarray3.h5
+TOOLTEST tarray4.ddl tarray4.h5
+TOOLTEST tarray5.ddl tarray5.h5
+TOOLTEST tarray6.ddl tarray6.h5
+TOOLTEST tarray7.ddl tarray7.h5
+
+# test for files with empty data
+TOOLTEST tempty.ddl tempty.h5
+
+# test XML
+TOOLTEST tall.h5.xml --xml tall.h5
+TOOLTEST tattr.h5.xml --xml tattr.h5
+TOOLTEST tbitfields.h5.xml --xml tbitfields.h5
+TOOLTEST tcompound.h5.xml --xml tcompound.h5
+TOOLTEST tcompound2.h5.xml --xml tcompound2.h5
+TOOLTEST tdatareg.h5.xml --xml tdatareg.h5
+TOOLTEST tdset.h5.xml --xml tdset.h5
+TOOLTEST tdset2.h5.xml --xml tdset2.h5
+TOOLTEST tenum.h5.xml --xml tenum.h5
+TOOLTEST tgroup.h5.xml --xml tgroup.h5
+TOOLTEST thlink.h5.xml --xml thlink.h5
+TOOLTEST tloop.h5.xml --xml tloop.h5
+TOOLTEST tloop2.h5.xml --xml tloop2.h5
+TOOLTEST tmany.h5.xml --xml tmany.h5
+TOOLTEST tnestedcomp.h5.xml --xml tnestedcomp.h5
+TOOLTEST tobjref.h5.xml --xml tobjref.h5
+TOOLTEST topaque.h5.xml --xml topaque.h5
+TOOLTEST tslink.h5.xml --xml tslink.h5
+TOOLTEST tstr.h5.xml --xml tstr.h5
+TOOLTEST tstr2.h5.xml --xml tstr2.h5
+TOOLTEST tref.h5.xml --xml tref.h5
+TOOLTEST tname-amp.h5.xml --xml tname-amp.h5
+TOOLTEST tname-apos.h5.xml --xml tname-apos.h5
+TOOLTEST tname-gt.h5.xml --xml tname-gt.h5
+TOOLTEST tname-lt.h5.xml --xml tname-lt.h5
+TOOLTEST tname-quot.h5.xml --xml tname-quot.h5
+TOOLTEST tname-sp.h5.xml --xml tname-sp.h5
+TOOLTEST tstring.h5.xml --xml tstring.h5
+TOOLTEST tstring-at.h5.xml --xml tstring-at.h5
+TOOLTEST tref-escapes.h5.xml --xml tref-escapes.h5
+TOOLTEST tref-escapes-at.h5.xml --xml tref-escapes-at.h5
+TOOLTEST tnodata.h5.xml --xml tnodata.h5
+TOOLTEST tarray1.h5.xml --xml tarray1.h5
+TOOLTEST tarray2.h5.xml --xml tarray2.h5
+TOOLTEST tarray3.h5.xml --xml tarray3.h5
+TOOLTEST tarray6.h5.xml --xml tarray6.h5
+TOOLTEST tarray7.h5.xml --xml tarray7.h5
+TOOLTEST tvldtypes1.h5.xml --xml tvldtypes1.h5
+TOOLTEST tvldtypes2.h5.xml --xml tvldtypes2.h5
+TOOLTEST tvldtypes3.h5.xml --xml tvldtypes3.h5
+TOOLTEST tsaf.h5.xml --xml tsaf.h5
+TOOLTEST tempty.h5.xml --xml tempty.h5
+
+if test $nerrors -eq 0 ; then
+ echo "All $DUMPER tests passed."
+fi
+
+exit $nerrors
generated by cgit v0.12 at 2024-11-06 21:30:04 (GMT)