mirror of
https://github.com/HDFGroup/hdf5.git
synced 2025-03-25 17:00:45 +08:00
[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
This commit is contained in:
Albert Cheng
parent
9945c358aa
commit
4322bfe90a
@ -10,16 +10,16 @@
|
||||
CPPFLAGS=-I../src -I. @CPPFLAGS@
|
||||
|
||||
# These are our main targets:
|
||||
PROGS=h5debug h5import h5ls h5repart
|
||||
PROGS=h5debug h5import h5ls h5repart h5dump
|
||||
LIB=libh5tools.a
|
||||
LIBS=../src/libhdf5.a libh5tools.a @LIBS@
|
||||
|
||||
# Source and object files for the library.
|
||||
LIB_SRC=h5dump.c
|
||||
LIB_SRC=h5tools.c
|
||||
LIB_OBJ=$(LIB_SRC:.c=.o)
|
||||
|
||||
# Source and object files for programs...
|
||||
PROG_SRC=h5debug.c h5import.c h5ls.c h5repart.c
|
||||
PROG_SRC=h5debug.c h5import.c h5ls.c h5repart.c h5dump.c h5dumputil.c
|
||||
PROG_OBJ=$(PROG_SRC:.c=.o)
|
||||
PRIVATE_HDR=h5tools.h
|
||||
|
||||
@ -36,4 +36,7 @@ h5ls: h5ls.o $(LIB) ../src/libhdf5.a
|
||||
h5repart: h5repart.o $(LIB) ../src/libhdf5.a
|
||||
$(CC) $(CFLAGS) -o $@ h5repart.o $(LIBS)
|
||||
|
||||
h5dump: h5dump.o h5dumputil.o $(LIB) ../src/libhdf5.a
|
||||
$(CC) $(CFLAGS) -o $@ h5dump.o h5dumputil.o $(LIBS)
|
||||
|
||||
@CONCLUDE@
|
||||
|
||||
660
tools/h5dump.c
Normal file
660
tools/h5dump.c
Normal file
@ -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;
|
||||
|
||||
}
|
||||
160
tools/h5dump.h
Normal file
160
tools/h5dump.h
Normal file
@ -0,0 +1,160 @@
|
||||
#ifndef _DUMPER_H
|
||||
#define _DUMPER_H
|
||||
|
||||
#include <hdf5.h>
|
||||
#include <H5private.h>
|
||||
#include <h5tools.h>
|
||||
|
||||
#define BOOT_BLOCK "BOOT_BLOCK"
|
||||
#define GROUP "GROUP"
|
||||
#define DATASET "DATASET"
|
||||
#define ATTRIBUTE "ATTRIBUTE"
|
||||
#define DATATYPE "DATATYPE"
|
||||
#define DATASPACE "DATASPACE"
|
||||
#define DATA "DATA"
|
||||
#define ARRAY "ARRAY"
|
||||
#define OTHER "OTHER"
|
||||
#define STORAGELAYOUT "STORAGELAYOUT"
|
||||
#define COMPRESSION "COMPRESSION"
|
||||
#define EXTERNAL "EXTERNAL"
|
||||
#define HARDLINK "HARDLINK"
|
||||
#define SOFTLINK "SOFTLINK"
|
||||
|
||||
#define BEGIN "{"
|
||||
#define END "}"
|
||||
|
||||
#define ATTRIBUTE_DATA 0
|
||||
#define DATASET_DATA 1
|
||||
|
||||
|
||||
#define begin_obj(x,y) printf("%s \"%s\" %s\n", x, y, BEGIN)
|
||||
#define end_obj() printf("%s\n", END);
|
||||
|
||||
#define col 3;
|
||||
|
||||
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 *);
|
||||
|
||||
#endif
|
||||
|
||||
|
||||
/*
|
||||
* Copyright © 1998 NCSA
|
||||
* All rights reserved.
|
||||
*
|
||||
* Programmer: Robb Matzke <matzke@llnl.gov>
|
||||
* Thursday, July 23, 1998
|
||||
*
|
||||
* Purpose: Support functions for the various tools.
|
||||
*/
|
||||
#ifndef _H5TOOLS_H
|
||||
#define _H5TOOLS_H
|
||||
|
||||
#include <stdio.h>
|
||||
|
||||
/*
|
||||
* Information about how to format output.
|
||||
*/
|
||||
typedef struct h5dump_t {
|
||||
/*
|
||||
* Fields associated with compound array members.
|
||||
*
|
||||
* pre: A string to print at the beginning of each array. The
|
||||
* default value is the left square bracket `['.
|
||||
*
|
||||
* sep: A string to print between array values. The default
|
||||
* value is a comma.
|
||||
*
|
||||
* suf: A strint to print at the end of each array. The default
|
||||
* value is a right square bracket `]'.
|
||||
*/
|
||||
const char *arr_pre;
|
||||
const char *arr_sep;
|
||||
const char *arr_suf;
|
||||
|
||||
/*
|
||||
* Fields associated with compound data types.
|
||||
*
|
||||
* name: How the name of the struct member is printed in the
|
||||
* values. By default the name is not printed, but a
|
||||
* reasonable setting might be "%s=" which prints the name
|
||||
* followed by an equal sign and then the value.
|
||||
*
|
||||
* sep: A string that separates one member from another. The
|
||||
* default is a comma.
|
||||
*
|
||||
* pre: A string to print at the beginning of a compound type.
|
||||
* The default is a left curly brace.
|
||||
*
|
||||
* suf: A string to print at the end of each compound type. The
|
||||
* default is a right curly brace.
|
||||
*/
|
||||
const char *cmpd_name;
|
||||
const char *cmpd_sep;
|
||||
const char *cmpd_pre;
|
||||
const char *cmpd_suf;
|
||||
|
||||
/*
|
||||
* Fields associated with the individual elements.
|
||||
*
|
||||
* fmt: A printf(3c) format to use to print the value string
|
||||
* after it has been rendered. The default is "%s".
|
||||
*
|
||||
* suf1: This string is appended to elements which are followed by
|
||||
* another element whether the following element is on the
|
||||
* same line or the next line. The default is a comma.
|
||||
*
|
||||
* suf2: This string is appended (after `suf1') to elements which
|
||||
* are followed on the same line by another element. The
|
||||
* default is a single space.
|
||||
*/
|
||||
const char *elmt_fmt;
|
||||
const char *elmt_suf1;
|
||||
const char *elmt_suf2;
|
||||
|
||||
/*
|
||||
* Fields associated with the index values printed at the left edge of
|
||||
* each line of output.
|
||||
*
|
||||
* n_fmt: Each index value is printed according to this printf(3c)
|
||||
* format string which should include a format for a long
|
||||
* integer. The default is "%lu".
|
||||
*
|
||||
* sep: Each integer in the index list will be separated from the
|
||||
* others by this string, which defaults to a comma.
|
||||
*
|
||||
* fmt: After the index values are formated individually and
|
||||
* separated from one another by some string, the entire
|
||||
* resulting string will be formated according to this
|
||||
* printf(3c) format which should include a format for a
|
||||
* character string. The default is "%s".
|
||||
*/
|
||||
const char *idx_n_fmt; /*index number format */
|
||||
const char *idx_sep; /*separator between numbers */
|
||||
const char *idx_fmt; /*entire index format */
|
||||
|
||||
/*
|
||||
* Fields associated with entire lines.
|
||||
*
|
||||
* ncols: Number of columns per line defaults to 80.
|
||||
*
|
||||
* suf: This character string will be appended to each line of
|
||||
* output. It should not contain line feeds. The default
|
||||
* is the empty string.
|
||||
*
|
||||
* sep: A character string to be printed after every line feed
|
||||
* defaulting to the empty string. It should end with a
|
||||
* line feed.
|
||||
*/
|
||||
int line_ncols; /*columns of output */
|
||||
const char *line_suf; /*string to append to each line */
|
||||
const char *line_sep; /*separates lines */
|
||||
|
||||
} h5dump_t;
|
||||
|
||||
|
||||
int h5dump1(FILE *stream, const h5dump_t *info, hid_t dset, hid_t p_type, int);
|
||||
|
||||
#endif
|
||||
523
tools/h5dumputil.c
Normal file
523
tools/h5dumputil.c
Normal file
@ -0,0 +1,523 @@
|
||||
/*
|
||||
* Note: this program is a modification of h5dump.c by Robb Matzke.
|
||||
*/
|
||||
#include <assert.h>
|
||||
#include <ctype.h>
|
||||
#include <h5dump.h>
|
||||
#include <hdf5.h>
|
||||
#include <stdio.h>
|
||||
#include <stdlib.h>
|
||||
#include <string.h>
|
||||
|
||||
/*
|
||||
* The output functions need a temporary buffer to hold a piece of the
|
||||
* dataset while it's being printed. This constant sets the limit on the
|
||||
* size of that temporary buffer in bytes. For efficiency's sake, choose the
|
||||
* largest value suitable for your machine (for testing use a small value).
|
||||
*/
|
||||
#define H5DUMP_BUFSIZE 1024
|
||||
|
||||
#define OPT(X,S) ((X)?(X):(S))
|
||||
#define MIN(X,Y) ((X)<(Y)?(X):(Y))
|
||||
#define NELMTS(X) (sizeof(X)/sizeof(*X))
|
||||
#define ALIGN(A,Z) ((((A)+(Z)-1)/(Z))*(Z))
|
||||
|
||||
#define DATASET_DATA 1
|
||||
|
||||
/*-------------------------------------------------------------------------
|
||||
* Function: h5dump_prefix
|
||||
*
|
||||
* Purpose: Prints the prefix to show up at the begining of the line.
|
||||
*
|
||||
* Return: void
|
||||
*
|
||||
* Programmer: Robb Matzke
|
||||
* Thursday, July 23, 1998
|
||||
*
|
||||
* Modifications:
|
||||
*
|
||||
*-------------------------------------------------------------------------
|
||||
*/
|
||||
static void
|
||||
h5dump_prefix(char *s/*out*/, const h5dump_t *info, hsize_t elmtno, int ndims,
|
||||
hsize_t min_idx[], hsize_t max_idx[])
|
||||
{
|
||||
hsize_t p_prod[8], p_idx[8];
|
||||
hsize_t n, i;
|
||||
char temp[1024];
|
||||
|
||||
/*
|
||||
* Calculate the number of elements represented by a unit change in a
|
||||
* certain index position.
|
||||
*/
|
||||
for (i=ndims-1, p_prod[ndims-1]=1; i>0; --i) {
|
||||
p_prod[i-1] = (max_idx[i]-min_idx[i]) * p_prod[i];
|
||||
}
|
||||
|
||||
/*
|
||||
* Calculate the index values from the element number.
|
||||
*/
|
||||
for (i=0, n=elmtno; i<(hsize_t)ndims; i++) {
|
||||
p_idx[i] = n / p_prod[i] + min_idx[i];
|
||||
n %= p_prod[i];
|
||||
}
|
||||
|
||||
/*
|
||||
* Print the index values.
|
||||
*/
|
||||
*temp = '\0';
|
||||
for (i=0; i<(hsize_t)ndims; i++) {
|
||||
if (i) strcat(temp, OPT(info->idx_sep, ","));
|
||||
sprintf(temp+strlen(temp), OPT(info->idx_n_fmt, "%lu"),
|
||||
(unsigned long)p_idx[i]);
|
||||
}
|
||||
|
||||
/*
|
||||
* Add prefix and suffix to the index.
|
||||
*/
|
||||
sprintf(s, OPT(info->idx_fmt, "%s: "), temp);
|
||||
}
|
||||
|
||||
|
||||
/*-------------------------------------------------------------------------
|
||||
* Function: h5dump_sprint
|
||||
*
|
||||
* Purpose: Prints the value pointed to by VP into the string S assuming
|
||||
* the data type of VP is TYPE.
|
||||
*
|
||||
* Return: void
|
||||
*
|
||||
* Programmer: Robb Matzke
|
||||
* Thursday, July 23, 1998
|
||||
*
|
||||
* Modifications:
|
||||
*
|
||||
*-------------------------------------------------------------------------
|
||||
*/
|
||||
static void
|
||||
h5dump_sprint(char *s/*out*/, const h5dump_t *info, hid_t type, void *vp)
|
||||
{
|
||||
size_t i, n, offset;
|
||||
char temp[1024], *name;
|
||||
hid_t memb;
|
||||
int nmembs, j;
|
||||
|
||||
if (H5Tequal(type, H5T_NATIVE_DOUBLE)) {
|
||||
sprintf(temp, "%g", *((double*)vp));
|
||||
} else if (H5Tequal(type, H5T_NATIVE_FLOAT)) {
|
||||
sprintf(temp, "%g", *((float*)vp));
|
||||
} else if (H5Tequal(type, H5T_NATIVE_CHAR) ||
|
||||
H5Tequal(type, H5T_NATIVE_UCHAR)) {
|
||||
switch (*((char*)vp)) {
|
||||
case '\\':
|
||||
strcpy(temp, "\\\\");
|
||||
break;
|
||||
case '\b':
|
||||
strcpy(temp, "\\b");
|
||||
break;
|
||||
case '\f':
|
||||
strcpy(temp, "\\f");
|
||||
break;
|
||||
case '\n':
|
||||
strcpy(temp, "\\n");
|
||||
break;
|
||||
case '\r':
|
||||
strcpy(temp, "\\r");
|
||||
break;
|
||||
case '\t':
|
||||
strcpy(temp, "\\t");
|
||||
break;
|
||||
default:
|
||||
if (isprint(*((char*)vp))) sprintf(temp, "%c", *((char*)vp));
|
||||
else sprintf(temp, "\\%03o", *((unsigned char*)vp));
|
||||
break;
|
||||
}
|
||||
} else if (H5Tequal(type, H5T_NATIVE_SHORT)) {
|
||||
sprintf(temp, "%d", *((short*)vp));
|
||||
} else if (H5Tequal(type, H5T_NATIVE_USHORT)) {
|
||||
sprintf(temp, "%u", *((unsigned short*)vp));
|
||||
} else if (H5Tequal(type, H5T_NATIVE_INT)) {
|
||||
sprintf(temp, "%d", *((int*)vp));
|
||||
} else if (H5Tequal(type, H5T_NATIVE_UINT)) {
|
||||
sprintf(temp, "%u", *((unsigned*)vp));
|
||||
} else if (H5Tequal(type, H5T_NATIVE_LONG)) {
|
||||
sprintf(temp, "%ld", *((long*)vp));
|
||||
} else if (H5Tequal(type, H5T_NATIVE_ULONG)) {
|
||||
sprintf(temp, "%lu", *((unsigned long*)vp));
|
||||
} else if (H5T_COMPOUND==H5Tget_class(type)) {
|
||||
nmembs = H5Tget_nmembers(type);
|
||||
strcpy(temp, OPT(info->cmpd_pre, "{"));
|
||||
for (j=0; j<nmembs; j++) {
|
||||
if (j) strcat(temp, OPT(info->cmpd_sep, ","));
|
||||
|
||||
/* The name */
|
||||
name = H5Tget_member_name(type, j);
|
||||
sprintf(temp+strlen(temp), OPT(info->cmpd_name, ""), name);
|
||||
free(name);
|
||||
|
||||
/* The value */
|
||||
offset = H5Tget_member_offset(type, j);
|
||||
memb = H5Tget_member_type(type, j);
|
||||
h5dump_sprint(temp+strlen(temp), info, memb, (char*)vp+offset);
|
||||
H5Tclose(memb);
|
||||
}
|
||||
strcat(temp, OPT(info->cmpd_suf, "}"));
|
||||
} else {
|
||||
strcpy(temp, "0x");
|
||||
n = H5Tget_size(type);
|
||||
for (i=0; i<n; i++) {
|
||||
sprintf(temp+strlen(temp), "%02x", ((unsigned char*)vp)[i]);
|
||||
}
|
||||
}
|
||||
|
||||
sprintf(s, OPT(info->elmt_fmt, "%s"), temp);
|
||||
}
|
||||
|
||||
|
||||
/*-------------------------------------------------------------------------
|
||||
* Function: h5dump_simple
|
||||
*
|
||||
* Purpose: Print some values from a dataset with a simple data space.
|
||||
* This is a special case of h5dump().
|
||||
*
|
||||
* Return: Success: 0
|
||||
*
|
||||
* Failure: -1
|
||||
*
|
||||
* Programmer: Robb Matzke
|
||||
* Thursday, July 23, 1998
|
||||
*
|
||||
* Modifications:
|
||||
*
|
||||
*-------------------------------------------------------------------------
|
||||
*/
|
||||
static int
|
||||
h5dump_simple(FILE *stream, const h5dump_t *info, hid_t dset, hid_t p_type, int obj_data)
|
||||
{
|
||||
hid_t f_space; /*file data space */
|
||||
int ndims; /*dimensionality */
|
||||
hsize_t elmtno, i; /*counters */
|
||||
int carry; /*counter carry value */
|
||||
hssize_t zero[8]; /*vector of zeros */
|
||||
int need_prefix=1; /*indices need printing */
|
||||
|
||||
/* Print info */
|
||||
hsize_t p_min_idx[8]; /*min selected index */
|
||||
hsize_t p_max_idx[8]; /*max selected index */
|
||||
size_t p_type_nbytes; /*size of memory type */
|
||||
hsize_t p_nelmts; /*total selected elmts */
|
||||
char p_buf[256]; /*output string */
|
||||
size_t p_column=0; /*output column */
|
||||
size_t p_ncolumns=80; /*default num columns */
|
||||
char p_prefix[1024]; /*line prefix string */
|
||||
|
||||
/* Stripmine info */
|
||||
hsize_t sm_size[8]; /*stripmine size */
|
||||
hsize_t sm_nbytes; /*bytes per stripmine */
|
||||
hsize_t sm_nelmts; /*elements per stripmine*/
|
||||
unsigned char *sm_buf; /*buffer for raw data */
|
||||
hid_t sm_space; /*stripmine data space */
|
||||
|
||||
/* Hyperslab info */
|
||||
hssize_t hs_offset[8]; /*starting offset */
|
||||
hsize_t hs_size[8]; /*size this pass */
|
||||
hsize_t hs_nelmts; /*elements in request */
|
||||
|
||||
/*
|
||||
* Check that everything looks okay. The dimensionality must not be too
|
||||
* great and the dimensionality of the items selected for printing must
|
||||
* match the dimensionality of the dataset.
|
||||
*/
|
||||
if (obj_data == DATASET_DATA)
|
||||
f_space = H5Dget_space(dset);
|
||||
else
|
||||
f_space = H5Aget_space(dset);
|
||||
|
||||
ndims = H5Sextent_ndims(f_space);
|
||||
if ((size_t)ndims>NELMTS(sm_size)) return -1;
|
||||
|
||||
/* Assume entire data space to be printed */
|
||||
for (i=0; i<(hsize_t)ndims; i++) p_min_idx[i] = 0;
|
||||
H5Sextent_dims(f_space, p_max_idx, NULL);
|
||||
for (i=0, p_nelmts=1; i<(hsize_t)ndims; i++) {
|
||||
p_nelmts *= p_max_idx[i]-p_min_idx[i];
|
||||
}
|
||||
|
||||
/*
|
||||
* Determine the strip mine size and allocate a buffer. The strip mine is
|
||||
* a hyperslab whose size is manageable.
|
||||
*/
|
||||
p_type_nbytes = H5Tget_size(p_type);
|
||||
for (i=ndims, sm_nbytes=p_type_nbytes; i>0; --i) {
|
||||
sm_size[i-1] = MIN (p_max_idx[i-1]-p_min_idx[i-1],
|
||||
H5DUMP_BUFSIZE/sm_nbytes);
|
||||
sm_nbytes *= sm_size[i-1];
|
||||
assert(sm_nbytes>0);
|
||||
}
|
||||
sm_buf = malloc(sm_nbytes);
|
||||
sm_nelmts = sm_nbytes/p_type_nbytes;
|
||||
sm_space = H5Screate_simple(1, &sm_nelmts, NULL);
|
||||
|
||||
/* Local things */
|
||||
if (info->line_ncols>0) p_ncolumns = info->line_ncols;
|
||||
|
||||
/* The stripmine loop */
|
||||
memset(hs_offset, 0, sizeof hs_offset);
|
||||
memset(zero, 0, sizeof zero);
|
||||
for (elmtno=0; elmtno<p_nelmts; elmtno+=hs_nelmts) {
|
||||
|
||||
/* Calculate the hyperslab size */
|
||||
for (i=0, hs_nelmts=1; i<(hsize_t)ndims; i++) {
|
||||
hs_size[i] = MIN(sm_size[i], p_max_idx[i]-hs_offset[i]);
|
||||
hs_nelmts *= hs_size[i];
|
||||
}
|
||||
|
||||
/* Read the data */
|
||||
H5Sselect_hyperslab(f_space, H5S_SELECT_SET, hs_offset, NULL,
|
||||
hs_size, NULL);
|
||||
H5Sselect_hyperslab(sm_space, H5S_SELECT_SET, zero, NULL,
|
||||
&hs_nelmts, NULL);
|
||||
|
||||
|
||||
if (obj_data == DATASET_DATA)
|
||||
H5Dread(dset, p_type, sm_space, f_space, H5P_DEFAULT, sm_buf);
|
||||
else
|
||||
H5Aread(dset, p_type, sm_buf);
|
||||
|
||||
/* Print the data */
|
||||
for (i=0; i<hs_nelmts; i++) {
|
||||
/* Render the element */
|
||||
h5dump_sprint(p_buf, info, p_type, sm_buf+i*p_type_nbytes);
|
||||
if (elmtno+i+1<p_nelmts) {
|
||||
strcat(p_buf, OPT(info->elmt_suf1, ","));
|
||||
}
|
||||
|
||||
/* Print the prefix */
|
||||
/*
|
||||
if ((p_column +
|
||||
strlen(p_buf) +
|
||||
strlen(OPT(info->elmt_suf2, " ")) +
|
||||
strlen(OPT(info->line_suf, ""))) > p_ncolumns) {
|
||||
need_prefix = 1;
|
||||
}
|
||||
|
||||
if (need_prefix) {
|
||||
h5dump_prefix(p_prefix, info, elmtno+i, ndims,
|
||||
p_min_idx, p_max_idx);
|
||||
if (p_column) {
|
||||
fputs(OPT(info->line_suf, ""), stream);
|
||||
putc('\n', stream);
|
||||
fputs(OPT(info->line_sep, ""), stream);
|
||||
}
|
||||
fputs(p_prefix, stream);
|
||||
p_column = strlen(p_prefix);
|
||||
need_prefix = 0;
|
||||
} else {
|
||||
fputs(OPT(info->elmt_suf2, " "), stream);
|
||||
p_column += strlen(OPT(info->elmt_suf2, " "));
|
||||
|
||||
}
|
||||
|
||||
*/
|
||||
|
||||
fputs(p_buf, stream);
|
||||
/*
|
||||
p_column += strlen(p_buf);
|
||||
*/
|
||||
}
|
||||
|
||||
/* Calculate the next hyperslab offset */
|
||||
for (i=ndims, carry=1; i>0 && carry; --i) {
|
||||
hs_offset[i-1] += hs_size[i-1];
|
||||
if (hs_offset[i-1]==(hssize_t)p_max_idx[i-1]) {
|
||||
hs_offset[i-1] = p_min_idx[i-1];
|
||||
} else {
|
||||
carry = 0;
|
||||
}
|
||||
}
|
||||
}
|
||||
/*
|
||||
|
||||
if (p_column) {
|
||||
fputs(OPT(info->line_suf, ""), stream);
|
||||
putc('\n', stream);
|
||||
fputs(OPT(info->line_sep, ""), stream);
|
||||
}
|
||||
*/
|
||||
H5Sclose(sm_space);
|
||||
H5Sclose(f_space);
|
||||
return 0;
|
||||
}
|
||||
|
||||
|
||||
/*-------------------------------------------------------------------------
|
||||
* Function: h5dump_fixtype
|
||||
*
|
||||
* Purpose: Given a file data type choose a memory data type which is
|
||||
* appropriate for printing the data.
|
||||
*
|
||||
* Return: Success: Memory data type
|
||||
*
|
||||
* Failure: FAIL
|
||||
*
|
||||
* Programmer: Robb Matzke
|
||||
* Thursday, July 23, 1998
|
||||
*
|
||||
* Modifications:
|
||||
*
|
||||
*-------------------------------------------------------------------------
|
||||
*/
|
||||
static hid_t
|
||||
h5dump_fixtype(hid_t f_type)
|
||||
{
|
||||
hid_t m_type=-1, f_memb;
|
||||
hid_t *memb=NULL;
|
||||
char **name=NULL;
|
||||
int nmembs, i;
|
||||
size_t size;
|
||||
|
||||
size = H5Tget_size(f_type);
|
||||
switch (H5Tget_class(f_type)) {
|
||||
|
||||
case H5T_INTEGER:
|
||||
/*
|
||||
* Use the smallest native integer type of the same sign as the file
|
||||
* such that the memory type is at least as large as the file type.
|
||||
* If there is no memory type large enough then use the largest
|
||||
* memory type available.
|
||||
*/
|
||||
if (size<=sizeof(char)) {
|
||||
m_type = H5Tcopy(H5T_NATIVE_CHAR);
|
||||
} else if (size<=sizeof(short)) {
|
||||
m_type = H5Tcopy(H5T_NATIVE_SHORT);
|
||||
} else if (size<=sizeof(int)) {
|
||||
m_type = H5Tcopy(H5T_NATIVE_INT);
|
||||
} else if (size<=sizeof(long)) {
|
||||
m_type = H5Tcopy(H5T_NATIVE_LONG);
|
||||
} else {
|
||||
m_type = H5Tcopy(H5T_NATIVE_LLONG);
|
||||
}
|
||||
H5Tset_sign(m_type, H5Tget_size(f_type));
|
||||
break;
|
||||
|
||||
case H5T_FLOAT:
|
||||
/*
|
||||
* Use the smallest native floating point type available such that
|
||||
* its size is at least as large as the file type. If there is not
|
||||
* native type large enough then use the largest native type.
|
||||
*/
|
||||
if (size<=sizeof(float)) {
|
||||
m_type = H5Tcopy(H5T_NATIVE_FLOAT);
|
||||
} else if (size<=sizeof(double)) {
|
||||
m_type = H5Tcopy(H5T_NATIVE_DOUBLE);
|
||||
} else {
|
||||
m_type = H5Tcopy(H5T_NATIVE_LDOUBLE);
|
||||
}
|
||||
break;
|
||||
|
||||
case H5T_COMPOUND:
|
||||
nmembs = H5Tget_nmembers(f_type);
|
||||
memb = calloc(nmembs, sizeof(hid_t));
|
||||
name = calloc(nmembs, sizeof(char*));
|
||||
|
||||
for (i=0, size=0; i<nmembs; i++) {
|
||||
f_memb = H5Tget_member_type(f_type, i);
|
||||
memb[i] = h5dump_fixtype(f_memb);
|
||||
size = ALIGN(size, H5Tget_size(memb[i])) + H5Tget_size(memb[i]);
|
||||
H5Tclose(f_memb);
|
||||
name[i] = H5Tget_member_name(f_type, i);
|
||||
if (memb[i]<0 || NULL==name[i]) goto done;
|
||||
}
|
||||
|
||||
m_type = H5Tcreate(H5T_COMPOUND, size);
|
||||
for (i=0, size=0; i<nmembs; i++) {
|
||||
H5Tinsert(m_type, name[i], size, memb[i]);
|
||||
size = ALIGN(size, H5Tget_size(memb[i])) + H5Tget_size(memb[i]);
|
||||
}
|
||||
break;
|
||||
|
||||
case H5T_TIME:
|
||||
case H5T_STRING:
|
||||
case H5T_BITFIELD:
|
||||
case H5T_OPAQUE:
|
||||
/*
|
||||
* These type classes are not implemented yet.
|
||||
*/
|
||||
break;
|
||||
|
||||
default:
|
||||
/* What the heck? */
|
||||
break;
|
||||
}
|
||||
|
||||
done:
|
||||
/* Clean up temp buffers */
|
||||
if (memb && name) {
|
||||
for (i=0; i<nmembs; i++) {
|
||||
if (memb[i]>=0) H5Tclose(memb[i]);
|
||||
if (name[i]) free(name[i]);
|
||||
}
|
||||
free(memb);
|
||||
free(name);
|
||||
}
|
||||
|
||||
return m_type;
|
||||
}
|
||||
|
||||
|
||||
/*-------------------------------------------------------------------------
|
||||
* Function: h5dump
|
||||
*
|
||||
* Purpose: Print some values from a dataset. The values to print are
|
||||
* determined by the P_SPACE argument and the format to use to
|
||||
* print them is determined by the P_TYPE argument.
|
||||
*
|
||||
* Return: Success: 0
|
||||
*
|
||||
* Failure: -1
|
||||
*
|
||||
* Programmer: Robb Matzke
|
||||
* Thursday, July 23, 1998
|
||||
*
|
||||
* Modifications:
|
||||
*
|
||||
*-------------------------------------------------------------------------
|
||||
*/
|
||||
int
|
||||
h5dump1(FILE *stream, const h5dump_t *info, hid_t dset, hid_t _p_type, int obj_data)
|
||||
{
|
||||
hid_t f_space;
|
||||
hid_t p_type = _p_type;
|
||||
hid_t f_type;
|
||||
int status;
|
||||
|
||||
/* Check the data space */
|
||||
if (obj_data == DATASET_DATA)
|
||||
f_space = H5Dget_space(dset);
|
||||
else
|
||||
f_space = H5Aget_space(dset);
|
||||
|
||||
if (H5Sis_simple(f_space)<=0) return -1;
|
||||
H5Sclose(f_space);
|
||||
|
||||
/*
|
||||
* Check the data type. If the caller didn't supply a data type then
|
||||
* use an appropriate native data type.
|
||||
*/
|
||||
|
||||
if (obj_data == DATASET_DATA)
|
||||
f_type = H5Dget_type(dset);
|
||||
else
|
||||
f_type = H5Aget_type(dset);
|
||||
|
||||
if (p_type<0) {
|
||||
p_type = h5dump_fixtype(f_type);
|
||||
H5Tclose(f_type);
|
||||
if (p_type<0) return -1;
|
||||
}
|
||||
|
||||
/* Print the data */
|
||||
status = h5dump_simple(stream, info, dset, p_type, obj_data);
|
||||
if (p_type!=_p_type) H5Tclose(p_type);
|
||||
return status;
|
||||
}
|
||||
Loading…
x
Reference in New Issue
Block a user