[svn-r605] Added in h5dump tools created by Ruey-Hsia.

Renamed what was called h5dump.c to h5tools.c.
Changed Makefile.in to reflect all the changes.
(Make dependence is to be processed later.)

Tested in Solaris 2.5

1 files changed, 660 insertions, 0 deletions

diff --git a/tools/h5dump.c b/tools/h5dump.c
new file mode 100644
index 0000000..a8a0a81
--- /dev/null
+++ b/tools/h5dump.c
@@ -0,0 +1,660 @@
+#include <h5dump.h>
+
+static int indent = 0;
+
+/*-------------------------------------------------------------------------
+ * Function:    usage
+ *
+ * Purpose:     Print the usage message about dumper
+ *
+ * Return:      void
+ *
+ * Programmer:  Ruey-Hsia Li
+ *
+ * Modifications:
+ *
+ *-----------------------------------------------------------------------*/
+static void
+usage()
+{
+
+printf("Usage: dumper <filename>\n");
+
+/*
+    printf(" Usage: h5dumper [OPTIONS] <file>\n");
+    printf(" OPTIONS\n");
+    printf("  -H         Print a usage message \n");
+    printf("  -nobb      No boot block\n");
+    printf("  -nodata    No data\n");
+    printf("  -g <name>  Dump everything in the group with name <name>\n");
+    printf("  -d <name>  Dump everything in the dataset with name <name>\n");
+    printf("  -l <name>  Dump the target of the link with name <link>\n");
+*/
+}
+
+
+/*-------------------------------------------------------------------------
+ * Function:    indentation
+ *
+ * Purpose:     Print spaces for indentation
+ *
+ * Return:      void
+ *
+ * Programmer:  Ruey-Hsia Li
+ *
+ * Modifications:
+ *
+ *-----------------------------------------------------------------------*/
+static void indentation(int x) {
+
+  while (x>0) {
+         printf(" "); 
+         x--;
+  }
+
+}
+
+
+/*-------------------------------------------------------------------------
+ * Function:    datatype_name
+ *
+ * Purpose:     Returns the name of data type. 
+ *
+ * Return:      Returns a pointer to a string. 
+ *
+ * Programmer:  Ruey-Hsia Li
+ *
+ * Modifications:
+ *
+ *-----------------------------------------------------------------------*/
+static char*
+datatype_name(hid_t type) {
+
+    switch (H5Tget_class(type)) {
+
+    case H5T_INTEGER:
+
+        if (H5Tequal(type, H5T_NATIVE_CHAR)) 
+            return "H5T_NATIVE_CHAR";
+        else if (H5Tequal(type, H5T_NATIVE_UCHAR))
+            return "H5T_NATIVE_UCHAR";
+        else if (H5Tequal(type, H5T_NATIVE_SHORT))
+            return "H5T_NATIVE_SHORT";
+        else if (H5Tequal(type, H5T_NATIVE_USHORT))
+            return "H5T_NATIVE_USHORT";
+        else if (H5Tequal(type, H5T_NATIVE_INT))
+            return "H5T_NATIVE_INT";
+        else if (H5Tequal(type, H5T_NATIVE_UINT))
+            return "H5T_NATIVE_UINT";
+        else if (H5Tequal(type, H5T_NATIVE_LONG))
+            return "H5T_NATIVE_LONG";
+        else if (H5Tequal(type, H5T_NATIVE_ULONG))
+            return "H5T_NATIVE_ULONG";
+        else if (H5Tequal(type, H5T_NATIVE_LLONG))
+            return "H5T_NATIVE_LLONG";
+        else if (H5Tequal(type, H5T_NATIVE_ULLONG))
+            return "H5T_NATIVE_ULLONG";
+        else if (H5Tequal(type, H5T_STD_I8BE))
+            return "H5T_STD_I8BE";
+        else if (H5Tequal(type, H5T_STD_I8LE))
+            return "H5T_STD_I8LE";
+        else if (H5Tequal(type, H5T_STD_I16BE))
+            return "H5T_STD_I16BE";
+        else if (H5Tequal(type, H5T_STD_I16LE))
+            return "H5T_STD_I16LE";
+        else if (H5Tequal(type, H5T_STD_I32BE))
+            return "H5T_STD_I32BE";
+        else if (H5Tequal(type, H5T_STD_I32LE))
+            return "H5T_STD_I32LE";
+        else if (H5Tequal(type, H5T_STD_I64BE))
+            return "H5T_STD_I64BE";
+        else if (H5Tequal(type, H5T_STD_I64LE))
+            return "H5T_STD_I64LE";
+        else if (H5Tequal(type, H5T_STD_U8BE))
+            return "H5T_STD_U8BE";
+        else if (H5Tequal(type, H5T_STD_U8LE))
+            return "H5T_STD_U8LE";
+        else if (H5Tequal(type, H5T_STD_U16BE))
+            return "H5T_STD_U16BE";
+        else if (H5Tequal(type, H5T_STD_U16LE))
+            return "H5T_STD_U16LE";
+        else if (H5Tequal(type, H5T_STD_U32BE))
+            return "H5T_STD_U32BE";
+        else if (H5Tequal(type, H5T_STD_U32LE))
+            return "H5T_STD_U32LE";
+        else if (H5Tequal(type, H5T_STD_U64BE))
+            return "H5T_STD_U64BE";
+        else if (H5Tequal(type, H5T_STD_U64LE))
+            return "H5T_STD_U64LE";
+        else return "unknown integer";
+
+    case H5T_FLOAT: 
+
+        if (H5Tequal(type, H5T_NATIVE_FLOAT))
+            return "H5T_NATIVE_FLOAT";
+        else if (H5Tequal(type, H5T_NATIVE_DOUBLE))
+            return "H5T_NATIVE_DOUBLE";
+        else if (H5Tequal(type, H5T_NATIVE_LDOUBLE))
+            return "H5T_NATIVE_LDOUBLE";
+        else if (H5Tequal(type, H5T_IEEE_F32BE))
+            return "H5T_IEEE_F32BE";
+        else if (H5Tequal(type, H5T_IEEE_F32LE))
+            return "H5T_IEEE_F32LE";
+        else if (H5Tequal(type, H5T_IEEE_F64BE))
+            return "H5T_IEEE_F64BE";
+        else if (H5Tequal(type, H5T_IEEE_F64LE))
+            return "H5T_IEEE_F64LE";
+        else return "unknown float";
+
+    case H5T_TIME: return "time: not yet implemented";
+
+    case H5T_STRING: 
+
+        if (H5Tequal(type,H5T_C_S1))
+            return "H5T_C_S1";
+        else if (H5Tequal(type,H5T_FORTRAN_S1))
+            return "H5T_FORTRAN_S1";
+        else return "unknown string";
+
+    case H5T_BITFIELD: 
+
+        if (H5Tequal(type, H5T_STD_B8BE))
+            return "H5T_STD_B8BE";
+        else if (H5Tequal(type, H5T_STD_B8LE))
+            return "H5T_STD_B8LE";
+        else if (H5Tequal(type, H5T_STD_B16BE))
+            return "H5T_STD_B16BE";
+        else if (H5Tequal(type, H5T_STD_B16LE))
+            return "H5T_STD_B16LE";
+        else if (H5Tequal(type, H5T_STD_B32BE))
+            return "H5T_STD_B32BE";
+        else if (H5Tequal(type, H5T_STD_B32LE))
+            return "H5T_STD_B32LE";
+        else if (H5Tequal(type, H5T_STD_B64BE))
+            return "H5T_STD_B64BE";
+        else if (H5Tequal(type, H5T_STD_B64LE))
+            return "H5T_STD_B64LE";
+        else return "unknown bitfield";
+
+    case H5T_OPAQUE: return "opaque: not yet implemented";
+
+    case H5T_COMPOUND: 
+
+         return "compound: not yet implemented";
+
+    default:
+            return "unknown data type";
+    }
+
+}
+
+
+/*-------------------------------------------------------------------------
+ * Function:    dump_bb
+ *
+ * Purpose:     Dump the boot block
+ *
+ * Return:      void
+ *
+ * Programmer:  Ruey-Hsia Li
+ *
+ * Modifications:
+ *
+ *-----------------------------------------------------------------------*/
+static void
+dump_bb() {
+
+    printf ("%s %s %s\n", BOOT_BLOCK, BEGIN, END);
+
+}
+
+
+/*-------------------------------------------------------------------------
+ * Function:    dump_datatype
+ *
+ * Purpose:     Dump the data type. Data type can be HDF5 predefined
+ *              atomic data type, named data type or compound data type. 
+ *
+ * Return:      void 
+ *
+ * Programmer:  Ruey-Hsia Li
+ *
+ * Modifications:
+ *
+ *-----------------------------------------------------------------------*/
+static void
+dump_datatype (hid_t type) {
+char *pt;
+char *fname ;
+hid_t nmembers, mtype;
+int i, ndims, perm[512]; 
+size_t dims[512];
+
+    indent += col;
+    indentation (indent);
+    pt = datatype_name(type);
+    printf ("%s %s \"%s\" %s\n", DATATYPE, BEGIN, pt, END);
+    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 dataset_id, hid_t space) {
+hsize_t size[64];
+hsize_t maxsize[64];  /* check max dims size */
+int ndims = H5Sextent_dims(space, size, maxsize);
+int i;
+
+    indent += col;
+
+    indentation (indent);
+
+    printf("%s ", DATASPACE);
+
+    if (H5Sis_simple(space)) {
+
+        HDfprintf (stdout, "%s %s ( %Hu",BEGIN, ARRAY, size[0]);
+        for (i = 1; i < ndims; i++) 
+             HDfprintf (stdout, ", %Hu", size[i]);
+        printf(" ) ");
+           
+        if (maxsize[0]==H5S_UNLIMITED)
+            HDfprintf (stdout, "( %s", "H5S_UNLIMITED");
+        else
+            HDfprintf (stdout, "( %Hu", 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\n", END);
+
+    } else
+
+        printf("%s not yet implemented %s\n", BEGIN, END);
+
+    indent -= col;
+
+}
+
+
+/*-------------------------------------------------------------------------
+ * 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;
+
+    indentation(indent);
+    begin_obj (ATTRIBUTE, attr_name); 
+
+    if ((attr_id = H5Aopen_name (attr, attr_name))>= 0) {
+
+        type = H5Aget_type(attr_id);
+        space = H5Aget_space(attr_id);
+        dump_datatype(type);
+        dump_dataspace(attr_id, space);
+        dump_data(attr_id, ATTRIBUTE_DATA);
+        H5Tclose(type);
+        H5Sclose(space);
+	H5Aclose (attr_id);
+
+    } else {
+        indent += col;
+        indentation (indent);
+        printf("Unable to open attribute.\n", attr_name);
+        indent -= col;
+        return FAIL;
+    }
+
+    indentation (indent);
+    end_obj();
+
+    return SUCCEED;
+
+}
+
+
+/*-------------------------------------------------------------------------
+ * Function:    dump all
+ *
+ * Purpose:     Dump everything in the specified object
+ *
+ * Return:      Success:        SUCCEED
+ *
+ *              Failure:        FAIL
+ *
+ * Programmer:  Ruey-Hsia Li
+ *
+ * Modifications:
+ *
+ *-----------------------------------------------------------------------*/
+static herr_t
+dump_all (hid_t group, const char *name, void __unused__ *op_data)
+{
+hid_t obj;
+hid_t (*func)(void*);
+void *edata;
+char buf[512]; /* Is 512 large enough? */
+
+    /* Disable error reporting */
+    H5Eget_auto (&func, &edata);
+    H5Eset_auto (NULL, NULL);
+
+
+    if (H5Gget_linkval (group, name, sizeof(buf), buf)>=0) {  
+
+        indentation (indent);
+        begin_obj(SOFTLINK, name);
+        indent += col;
+        indentation (indent);
+        printf ("linktarget \"%s\"\n", buf);
+        indent -= col;
+        indentation (indent);
+        end_obj();
+
+    } else if ((obj=H5Dopen (group, name))>=0) {              
+
+        dump_dataset (obj, name);
+        H5Dclose (obj);
+
+    } else if ((obj=H5Gopen (group, name))>=0) {
+
+           dump_group (obj, name);
+           H5Gclose (obj);
+
+    } else if ((obj=H5Topen(group, name))>=0) {
+    
+           dump_named_datatype (obj, name);
+           H5Tclose(obj);
+
+    } else {
+
+        printf ("Unknown Object %s\n", name);
+        H5Eset_auto (func, edata);
+        return FAIL;
+
+    }
+
+    /* Restore error reporting */
+    H5Eset_auto (func, edata);
+
+    return SUCCEED;
+
+}
+
+
+/*-------------------------------------------------------------------------
+ * Function:    dump_named_datatype
+ *
+ * Purpose:     Dump named data type
+ *
+ * Return:      void
+ *
+ * Programmer:  Ruey-Hsia Li
+ *
+ * Modifications:
+ *
+ *-----------------------------------------------------------------------*/
+static void
+dump_named_datatype (hid_t type_id, const char *name) {
+char *fname ;
+hid_t nmembers, mtype;
+int i, ndims, perm[512]; /* dimensionality */
+size_t dims[512];
+
+    indentation (indent);
+    begin_obj(DATATYPE, name);
+
+    indent += col;
+    indentation(indent);
+    printf("named data type: not yet implemented.\n");
+    indent -= col;
+
+    indentation (indent);
+    end_obj();
+
+}
+
+
+/*-------------------------------------------------------------------------
+ * Function:    dump_group
+ *
+ * Purpose:     Dump everything within the specified group
+ *
+ * Return:      void
+ *
+ * Programmer:  Ruey-Hsia Li
+ *
+ * Modifications:
+ *
+ *-----------------------------------------------------------------------*/
+static void
+dump_group (hid_t gid, const char *name) {
+
+    indentation (indent);
+    begin_obj(GROUP, name);
+    indent += col;
+    H5Aiterate (gid, NULL, dump_attr, NULL);
+    H5Giterate (gid, ".", NULL, dump_all, NULL);
+    indent -= col;
+    indentation (indent);
+    end_obj();
+
+}
+
+
+/*-------------------------------------------------------------------------
+ * 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(DATASET, name);
+    indent += col;
+    H5Aiterate (did, NULL, dump_attr, NULL);
+    indent -= col;
+    type = H5Dget_type (did);
+    space = H5Dget_space (did);
+    dump_datatype(type);
+    dump_dataspace(did, space);
+
+    switch (H5Tget_class(type)) {
+    case H5T_INTEGER:
+         dump_data(did, DATASET_DATA);
+         break;
+    case H5T_FLOAT:
+         dump_data(did, DATASET_DATA);
+         break;
+    case H5T_TIME:
+         indent += col;
+         indentation (indent);
+         indent -= col;
+         printf("DATA{ not yet implemented.}\n");
+         break;
+    case H5T_STRING:
+         indent += col;
+         indentation (indent);
+         indent -= col;
+         printf("DATA{ not yet implemented.}\n");
+         break;
+    case H5T_BITFIELD:
+         indent += col;
+         indentation (indent);
+         indent -= col;
+         printf("DATA{ not yet implemented.}\n");
+         break;
+    case H5T_OPAQUE:
+         indent += col;
+         indentation (indent);
+         indent -= col;
+         printf("DATA{ not yet implemented.}\n");
+         break;
+    case H5T_COMPOUND:
+         indent += col;
+         indentation (indent);
+         indent -= col;
+         printf("DATA{ not yet implemented.}\n");
+         break;
+    default: break;
+    }
+
+    H5Tclose(type);
+    H5Sclose(space);
+    indentation (indent);
+    end_obj();
+    
+}
+
+
+/*-------------------------------------------------------------------------
+ * 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) {
+
+    hid_t               f_type ;
+    size_t              size ;
+    h5dump_t            info;
+
+    indent += col;
+    indentation (indent);
+    printf("%s %s", DATA, BEGIN);
+
+    if (obj_data == DATASET_DATA)
+        f_type = H5Dget_type(obj_id);
+    else
+        f_type = H5Aget_type(obj_id);
+
+    size = H5Tget_size(f_type);
+
+    /* Set to all default values and then override */
+    memset(&info, 0, sizeof info);
+    info.idx_fmt = "        (%s) ";
+    info.line_ncols = 80;
+
+    /*
+     * If the dataset is a 1-byte integer type then format it as an ASCI
+     * character string instead of integers.
+     */
+    if (1==size && H5T_INTEGER==H5Tget_class(f_type)) {
+        info.elmt_suf1 = "";
+        info.elmt_suf2 = "";
+        info.idx_fmt = "        (%s) \"";
+        info.line_suf = "\"";
+        printf("\"");
+    }
+
+   
+    /*
+     * Print all the values.
+     */
+
+    if (h5dump1(stdout, &info, obj_id, -1, obj_data)<0) {
+        printf("Unable to print data.");
+    }
+
+    if (1==size && H5T_INTEGER==H5Tget_class(f_type)) 
+        printf("\"");
+
+    printf("%s\n", END);
+    indent -= col;
+
+    H5Tclose(f_type);
+
+}
+
+
+/*-------------------------------------------------------------------------
+ * Function:    main
+ *
+ * Purpose:     HDF5 dumper
+ *
+ * Return:      Success:	0
+ *              Failure:	1
+ *
+ * Programmer:  Ruey-Hsia Li
+ *
+ * Modifications:
+ *
+ *-----------------------------------------------------------------------*/
+int
+main(int argc, char *argv[]) {
+hid_t fid, gid;
+hid_t plist=H5P_DEFAULT;
+const char *fname = NULL;
+
+    if (argc > 2 || argc <= 1) {
+        usage();
+        exit(1);
+    }
+
+    /* arguments */
+    fname = argv[1];
+
+    /* open file */
+    if ((fid = H5Fopen (fname, H5F_ACC_RDONLY, plist))<0) exit(1);
+   
+    begin_obj("HDF5", fname);
+
+    gid = H5Gopen (fid, "/");
+
+    dump_group(gid, "/");
+
+    end_obj();
+    
+    if (H5Gclose (gid) < 0) exit(1);
+
+    if (H5Fclose (fid) < 0) exit(1);
+    
+
+    return 0;
+
+}