mirror of
https://github.com/HDFGroup/hdf5.git
synced 2024-12-09 07:32:32 +08:00
1c61b6fe13
Bug 1707 is that H5Eset_auto causes a seg fault when an application uses -DH5_USE_16_API with the 1.8 library to compile. I created a branch off the trunk called set_auto to continue working on the problem. Tested on jam - backing out, simple.
7123 lines
236 KiB
C
7123 lines
236 KiB
C
/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
|
||
* Copyright by The HDF Group. *
|
||
* Copyright by the Board of Trustees of the University of Illinois. *
|
||
* All rights reserved. *
|
||
* *
|
||
* This file is part of HDF5. The full HDF5 copyright notice, including *
|
||
* terms governing use, modification, and redistribution, is contained in *
|
||
* the files COPYING and Copyright.html. COPYING can be found at the root *
|
||
* of the source code distribution tree; Copyright.html can be found at the *
|
||
* root level of an installed copy of the electronic HDF5 document set and *
|
||
* is linked from the top-level documents page. It can also be found at *
|
||
* http://hdfgroup.org/HDF5/doc/Copyright.html. If you do not have *
|
||
* access to either file, you may request a copy from help@hdfgroup.org. *
|
||
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
|
||
#include <stdio.h>
|
||
#include <stdlib.h>
|
||
|
||
#include "h5dump.h"
|
||
#include "H5private.h"
|
||
#include "h5tools.h"
|
||
#include "h5tools_utils.h"
|
||
#include "h5tools_ref.h"
|
||
#include "h5trav.h"
|
||
|
||
/* Name of tool */
|
||
#define PROGRAMNAME "h5dump"
|
||
|
||
/* Macros for displaying objects */
|
||
#define begin_obj(obj,name,begin) \
|
||
do { \
|
||
if (name) \
|
||
printf("%s \"%s\" %s\n", (obj), (name), (begin)); \
|
||
else \
|
||
printf("%s %s\n", (obj), (begin)); \
|
||
} while(0);
|
||
|
||
#define end_obj(obj,end) \
|
||
do { \
|
||
if(HDstrlen(end)) { \
|
||
printf("%s", end); \
|
||
if(HDstrlen(obj)) \
|
||
printf(" "); \
|
||
} \
|
||
if(HDstrlen(obj)) \
|
||
printf("%s", obj); \
|
||
printf("\n"); \
|
||
} while(0);
|
||
|
||
/* 3 private values: can't be set, but can be read.
|
||
Note: these are defined in H5Zprivate, they are
|
||
duplicated here.
|
||
*/
|
||
#define H5_SZIP_LSB_OPTION_MASK 8
|
||
#define H5_SZIP_MSB_OPTION_MASK 16
|
||
#define H5_SZIP_RAW_OPTION_MASK 128
|
||
|
||
/* List of table structures. There is one table structure for each file */
|
||
typedef struct h5dump_table_list_t {
|
||
size_t nalloc;
|
||
size_t nused;
|
||
struct {
|
||
unsigned long fileno; /* File number that these tables refer to */
|
||
hid_t oid; /* ID of an object in this file, held open so fileno is consistent */
|
||
table_t *group_table; /* Table of groups */
|
||
table_t *dset_table; /* Table of datasets */
|
||
table_t *type_table; /* Table of datatypes */
|
||
} *tables;
|
||
} h5dump_table_list_t;
|
||
|
||
static int unamedtype = 0; /* shared datatype with no name */
|
||
static h5dump_table_list_t table_list = {0, 0, NULL};
|
||
static table_t *group_table = NULL, *dset_table = NULL, *type_table = NULL;
|
||
static hbool_t hit_elink = FALSE; /* whether we have traversed an external link */
|
||
static size_t prefix_len = 1024;
|
||
static char *prefix;
|
||
static const char *driver = NULL; /* The driver to open the file with. */
|
||
static const h5dump_header_t *dump_header_format;
|
||
static const char *fp_format = NULL;
|
||
const char *outfname=NULL;
|
||
|
||
|
||
/* things to display or which are set via command line parameters */
|
||
static int display_all = TRUE;
|
||
static int display_oid = FALSE;
|
||
static int display_data = TRUE;
|
||
static int display_attr_data = TRUE;
|
||
static int display_char = FALSE; /*print 1-byte numbers as ASCII */
|
||
static int usingdasho = FALSE;
|
||
static int display_bb = FALSE; /*superblock */
|
||
static int display_dcpl = FALSE; /*dcpl */
|
||
static int display_fi = FALSE; /*file index */
|
||
static int display_ai = TRUE; /*array index */
|
||
static int display_escape = FALSE; /*escape non printable characters */
|
||
static int display_region = FALSE; /*print region reference data */
|
||
|
||
/* sort parameters */
|
||
static H5_index_t sort_by = H5_INDEX_NAME; /*sort_by [creation_order | name] */
|
||
static H5_iter_order_t sort_order = H5_ITER_INC; /*sort_order [ascending | descending] */
|
||
|
||
/**
|
||
** Added for XML **
|
||
**/
|
||
|
||
/* module-scoped variables for XML option */
|
||
#define DEFAULT_XSD "http://www.hdfgroup.org/DTDs/HDF5-File.xsd"
|
||
#define DEFAULT_DTD "http://www.hdfgroup.org/DTDs/HDF5-File.dtd"
|
||
|
||
static int doxml = 0;
|
||
static int useschema = 1;
|
||
static const char *xml_dtd_uri = NULL;
|
||
static const char *xmlnsprefix="hdf5:";
|
||
static int indent; /*how far in to indent the line */
|
||
|
||
/** end XML **/
|
||
|
||
/* internal functions */
|
||
static hid_t h5_fileaccess(void);
|
||
static void dump_oid(hid_t oid);
|
||
static void print_enum(hid_t type);
|
||
static int xml_name_to_XID(const char *, char *, int , int );
|
||
static void init_prefix(char **prfx, size_t prfx_len);
|
||
static void add_prefix(char **prfx, size_t *prfx_len, const char *name);
|
||
/* callback function used by H5Literate() */
|
||
static herr_t dump_all_cb(hid_t group, const char *name, const H5L_info_t *linfo, void *op_data);
|
||
static int dump_extlink(hid_t group, const char *linkname, const char *objname);
|
||
|
||
|
||
|
||
static h5tool_format_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 */
|
||
" "H5_PRINTF_HADDR_FMT, /*obj_format */
|
||
|
||
1, /*dset_hidefileno */
|
||
"DATASET %s ", /*dset_format */
|
||
"%s", /*dset_blockformat_pre */
|
||
"%s", /*dset_ptformat_pre */
|
||
"%s", /*dset_ptformat */
|
||
1, /*array indices */
|
||
1 /*escape non printable characters */
|
||
};
|
||
|
||
/**
|
||
** 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 h5tool_format_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 */
|
||
" "H5_PRINTF_HADDR_FMT, /*obj_format */
|
||
|
||
1, /*dset_hidefileno */
|
||
"DATASET %s ", /*dset_format */
|
||
"%s", /*dset_blockformat_pre */
|
||
"%s", /*dset_ptformat_pre */
|
||
"%s", /*dset_ptformat */
|
||
0, /*array indices */
|
||
0 /*escape non printable characters */
|
||
};
|
||
|
||
/** XML **/
|
||
|
||
static const h5dump_header_t standardformat = {
|
||
"standardformat", /*name */
|
||
"HDF5", /*fileebgin */
|
||
"", /*fileend */
|
||
SUPER_BLOCK, /*bootblockbegin */
|
||
"", /*bootblockend */
|
||
H5_TOOLS_GROUP, /*groupbegin */
|
||
"", /*groupend */
|
||
H5_TOOLS_DATASET, /*datasetbegin */
|
||
"", /*datasetend */
|
||
ATTRIBUTE, /*attributebegin */
|
||
"", /*attributeend */
|
||
H5_TOOLS_DATATYPE, /*datatypebegin */
|
||
"", /*datatypeend */
|
||
DATASPACE, /*dataspacebegin */
|
||
"", /*dataspaceend */
|
||
DATA, /*databegin */
|
||
"", /*dataend */
|
||
SOFTLINK, /*softlinkbegin */
|
||
"", /*softlinkend */
|
||
EXTLINK, /*extlinkbegin */
|
||
"", /*extlinkend */
|
||
UDLINK, /*udlinkbegin */
|
||
"", /*udlinkend */
|
||
SUBSET, /*subsettingbegin */
|
||
"", /*subsettingend */
|
||
START, /*startbegin */
|
||
"", /*startend */
|
||
STRIDE, /*stridebegin */
|
||
"", /*strideend */
|
||
COUNT, /*countbegin */
|
||
"", /*countend */
|
||
BLOCK, /*blockbegin */
|
||
"", /*blockend */
|
||
|
||
"{", /*fileblockbegin */
|
||
"}", /*fileblockend */
|
||
"{", /*bootblockblockbegin */
|
||
"}", /*bootblockblockend */
|
||
"{", /*groupblockbegin */
|
||
"}", /*groupblockend */
|
||
"{", /*datasetblockbegin */
|
||
"}", /*datasetblockend */
|
||
"{", /*attributeblockbegin */
|
||
"}", /*attributeblockend */
|
||
"", /*datatypeblockbegin */
|
||
"", /*datatypeblockend */
|
||
"", /*dataspaceblockbegin */
|
||
"", /*dataspaceblockend */
|
||
"{", /*datablockbegin */
|
||
"}", /*datablockend */
|
||
"{", /*softlinkblockbegin */
|
||
"}", /*softlinkblockend */
|
||
"{", /*extlinkblockbegin */
|
||
"}", /*extlinkblockend */
|
||
"{", /*udlinkblockbegin */
|
||
"}", /*udlinkblockend */
|
||
"{", /*strblockbegin */
|
||
"}", /*strblockend */
|
||
"{", /*enumblockbegin */
|
||
"}", /*enumblockend */
|
||
"{", /*structblockbegin */
|
||
"}", /*structblockend */
|
||
"{", /*vlenblockbegin */
|
||
"}", /*vlenblockend */
|
||
"{", /*subsettingblockbegin */
|
||
"}", /*subsettingblockend */
|
||
"(", /*startblockbegin */
|
||
");", /*startblockend */
|
||
"(", /*strideblockbegin */
|
||
");", /*strideblockend */
|
||
"(", /*countblockbegin */
|
||
");", /*countblockend */
|
||
"(", /*blockblockbegin */
|
||
");", /*blockblockend */
|
||
|
||
"", /*dataspacedescriptionbegin */
|
||
"", /*dataspacedescriptionend */
|
||
"(", /*dataspacedimbegin */
|
||
")", /*dataspacedimend */
|
||
};
|
||
|
||
/**
|
||
** Added for XML **
|
||
**/
|
||
/* internal functions used by XML option */
|
||
static void xml_print_datatype(hid_t, unsigned);
|
||
static void xml_print_enum(hid_t);
|
||
static int xml_print_refs(hid_t, int);
|
||
static int xml_print_strs(hid_t, int);
|
||
static char *xml_escape_the_string(const char *, int);
|
||
static char *xml_escape_the_name(const char *);
|
||
|
||
/* a structure for handling the order command-line parameters come in */
|
||
struct handler_t {
|
||
void (*func)(hid_t, const char *, void *, int, const char *);
|
||
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.
|
||
*/
|
||
static const char *s_opts = "hnpeyBHirVa:c:d:f:g:k:l:t:w:xD:uX:o:b*F:s:S:Aq:z:m:R";
|
||
static struct long_options l_opts[] = {
|
||
{ "help", no_arg, 'h' },
|
||
{ "hel", no_arg, 'h' },
|
||
{ "contents", no_arg, 'n' },
|
||
{ "properties", no_arg, 'p' },
|
||
{ "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' },
|
||
{ "filedriver", require_arg, 'f' },
|
||
{ "filedrive", require_arg, 'f' },
|
||
{ "filedriv", require_arg, 'f' },
|
||
{ "filedri", require_arg, 'f' },
|
||
{ "filedr", require_arg, 'f' },
|
||
{ "filed", require_arg, 'f' },
|
||
{ "file", require_arg, 'f' },
|
||
{ "fil", require_arg, 'f' },
|
||
{ "fi", require_arg, 'f' },
|
||
{ "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' },
|
||
{ "start", require_arg, 's' },
|
||
{ "star", require_arg, 's' },
|
||
{ "sta", require_arg, 's' },
|
||
{ "stride", require_arg, 'S' },
|
||
{ "strid", require_arg, 'S' },
|
||
{ "string", no_arg, 'r' },
|
||
{ "strin", no_arg, 'r' },
|
||
{ "use-dtd", no_arg, 'u' },
|
||
{ "use-dt", no_arg, 'u' },
|
||
{ "use-d", no_arg, 'u' },
|
||
{ "use-", no_arg, 'u' },
|
||
{ "use", no_arg, 'u' },
|
||
{ "us", no_arg, 'u' },
|
||
{ "u", no_arg, 'u' },
|
||
{ "width", require_arg, 'w' },
|
||
{ "widt", require_arg, 'w' },
|
||
{ "wid", require_arg, 'w' },
|
||
{ "wi", require_arg, 'w' },
|
||
{ "xml-dtd", require_arg, 'D' },
|
||
{ "xml-dt", require_arg, 'D' },
|
||
{ "xml-d", require_arg, 'D' },
|
||
{ "xml-ns", require_arg, 'X' },
|
||
{ "xml-n", require_arg, 'X' },
|
||
{ "xml", no_arg, 'x' },
|
||
{ "xm", no_arg, 'x' },
|
||
{ "onlyattr", no_arg, 'A' },
|
||
{ "escape", no_arg, 'e' },
|
||
{ "noindex", no_arg, 'y' },
|
||
{ "binary", optional_arg, 'b' },
|
||
{ "form", require_arg, 'F' },
|
||
{ "sort_by", require_arg, 'q' },
|
||
{ "sort_order", require_arg, 'z' },
|
||
{ "format", require_arg, 'm' },
|
||
{ "region", no_arg, 'R' },
|
||
{ NULL, 0, '\0' }
|
||
};
|
||
|
||
|
||
/**
|
||
** 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_named_datatype(hid_t, const char *);
|
||
static void dump_dataset(hid_t, const char *, struct subset_t *);
|
||
static void dump_dataspace(hid_t space);
|
||
static void dump_datatype(hid_t type);
|
||
static void dump_data(hid_t, int, struct subset_t *, int);
|
||
static void dump_dcpl(hid_t dcpl, hid_t type_id, hid_t obj_id);
|
||
static void dump_comment(hid_t obj_id);
|
||
static void dump_fcpl(hid_t fid);
|
||
static void dump_fcontents(hid_t fid);
|
||
/* callback function used by H5Aiterate2() */
|
||
static herr_t dump_attr_cb(hid_t loc_id, const char *attr_name, const H5A_info_t *info, void *_op_data);
|
||
|
||
|
||
/* XML format: same interface, alternative output */
|
||
|
||
static void xml_dump_group(hid_t, const char *);
|
||
static void xml_dump_named_datatype(hid_t, const char *);
|
||
static void xml_dump_dataset(hid_t, const char *, struct subset_t *);
|
||
static void xml_dump_dataspace(hid_t space);
|
||
static void xml_dump_datatype(hid_t type);
|
||
static herr_t xml_dump_attr(hid_t, const char *, const H5A_info_t *, void *);
|
||
static void xml_dump_data(hid_t, int, struct subset_t *, int);
|
||
|
||
/**
|
||
** 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 *, struct subset_t *);
|
||
void (*dump_dataspace_function) (hid_t);
|
||
void (*dump_datatype_function) (hid_t);
|
||
herr_t (*dump_attribute_function) (hid_t, const char *, const H5A_info_t *, void *);
|
||
void (*dump_data_function) (hid_t, int, struct subset_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_cb,
|
||
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;
|
||
|
||
|
||
/*-------------------------------------------------------------------------
|
||
* Function: leave
|
||
*
|
||
* Purpose: Shutdown MPI & HDF5 and call exit()
|
||
*
|
||
* Return: Does not return
|
||
*
|
||
* Programmer: Quincey Koziol
|
||
* Saturday, 31. January 2004
|
||
*
|
||
* Modifications:
|
||
*
|
||
*-------------------------------------------------------------------------
|
||
*/
|
||
static void
|
||
leave(int ret)
|
||
{
|
||
h5tools_close();
|
||
|
||
exit(ret);
|
||
}
|
||
|
||
|
||
/*-------------------------------------------------------------------------
|
||
* Function: usage
|
||
*
|
||
* Purpose: Print the usage message about dumper
|
||
*
|
||
* Return: void
|
||
*
|
||
* Programmer: Ruey-Hsia Li
|
||
*
|
||
* Modifications:
|
||
* Pedro Vicente, October 5, 2007. Add -q and -z flags
|
||
*-------------------------------------------------------------------------
|
||
*/
|
||
static void
|
||
usage(const char *prog)
|
||
{
|
||
fflush(stdout);
|
||
fprintf(stdout, "usage: %s [OPTIONS] file\n", prog);
|
||
fprintf(stdout, " OPTIONS\n");
|
||
fprintf(stdout, " -h, --help Print a usage message and exit\n");
|
||
fprintf(stdout, " -n, --contents Print a list of the file contents and exit\n");
|
||
fprintf(stdout, " -B, --superblock Print the content of the super block\n");
|
||
fprintf(stdout, " -H, --header Print the header only; no data is displayed\n");
|
||
fprintf(stdout, " -A, --onlyattr Print the header and value of attributes\n");
|
||
fprintf(stdout, " -i, --object-ids Print the object ids\n");
|
||
fprintf(stdout, " -r, --string Print 1-byte integer datasets as ASCII\n");
|
||
fprintf(stdout, " -e, --escape Escape non printing characters\n");
|
||
fprintf(stdout, " -V, --version Print version number and exit\n");
|
||
fprintf(stdout, " -a P, --attribute=P Print the specified attribute\n");
|
||
fprintf(stdout, " -d P, --dataset=P Print the specified dataset\n");
|
||
fprintf(stdout, " -y, --noindex Do not print array indices with the data\n");
|
||
fprintf(stdout, " -p, --properties Print dataset filters, storage layout and fill value\n");
|
||
fprintf(stdout, " -f D, --filedriver=D Specify which driver to open the file with\n");
|
||
fprintf(stdout, " -g P, --group=P Print the specified group and all members\n");
|
||
fprintf(stdout, " -l P, --soft-link=P Print the value(s) of the specified soft link\n");
|
||
fprintf(stdout, " -o F, --output=F Output raw data into file F\n");
|
||
fprintf(stdout, " -b B, --binary=B Binary file output, of form B\n");
|
||
fprintf(stdout, " -t P, --datatype=P Print the specified named datatype\n");
|
||
fprintf(stdout, " -w N, --width=N Set the number of columns of output. A value of 0 (zero)\n");
|
||
fprintf(stdout, " sets the number of columns to the maximum (65535).\n");
|
||
fprintf(stdout, " Default width is 80 columns.\n");
|
||
fprintf(stdout, " -m T, --format=T Set the floating point output format\n");
|
||
fprintf(stdout, " -q Q, --sort_by=Q Sort groups and attributes by index Q\n");
|
||
fprintf(stdout, " -z Z, --sort_order=Z Sort groups and attributes by order Z\n");
|
||
fprintf(stdout, " -R, --region Print dataset pointed by region references\n");
|
||
fprintf(stdout, " -x, --xml Output in XML using Schema\n");
|
||
fprintf(stdout, " -u, --use-dtd Output in XML using DTD\n");
|
||
fprintf(stdout, " -D U, --xml-dtd=U Use the DTD or schema at U\n");
|
||
fprintf(stdout, " -X S, --xml-ns=S (XML Schema) Use qualified names n the XML\n");
|
||
fprintf(stdout, " \":\": no namespace, default: \"hdf5:\"\n");
|
||
fprintf(stdout, " E.g., to dump a file called `-f', use h5dump -- -f\n");
|
||
fprintf(stdout, "\n");
|
||
fprintf(stdout, " Subsetting is available by using the following options with a dataset\n");
|
||
fprintf(stdout, " attribute. Subsetting is done by selecting a hyperslab from the data.\n");
|
||
fprintf(stdout, " Thus, the options mirror those for performing a hyperslab selection.\n");
|
||
fprintf(stdout, " One of the START, COUNT, STRIDE, or BLOCK parameters are mandatory if you do subsetting.\n");
|
||
fprintf(stdout, " The STRIDE, COUNT, and BLOCK parameters are optional and will default to 1 in\n");
|
||
fprintf(stdout, " each dimension. START is optional and will default to 0 in each dimension.\n");
|
||
fprintf(stdout, "\n");
|
||
fprintf(stdout, " -s START, --start=START Offset of start of subsetting selection\n");
|
||
fprintf(stdout, " -S STRIDE, --stride=STRIDE Hyperslab stride\n");
|
||
fprintf(stdout, " -c COUNT, --count=COUNT Number of blocks to include in selection\n");
|
||
fprintf(stdout, " -k BLOCK, --block=BLOCK Size of block in hyperslab\n");
|
||
fprintf(stdout, " START, COUNT, STRIDE, and BLOCK - is a list of integers the number of which are equal to the\n");
|
||
fprintf(stdout, " number of dimensions in the dataspace being queried\n");
|
||
fprintf(stdout, "\n");
|
||
fprintf(stdout, " D - is the file driver to use in opening the file. Acceptable values\n");
|
||
fprintf(stdout, " are \"sec2\", \"family\", \"split\", \"multi\", \"direct\", and \"stream\". Without\n");
|
||
fprintf(stdout, " the file driver flag, the file will be opened with each driver in\n");
|
||
fprintf(stdout, " turn and in the order specified above until one driver succeeds\n");
|
||
fprintf(stdout, " in opening the file.\n");
|
||
fprintf(stdout, " F - is a filename.\n");
|
||
fprintf(stdout, " P - is the full path from the root group to the object.\n");
|
||
fprintf(stdout, " N - is an integer greater than 1.\n");
|
||
fprintf(stdout, " T - is a string containing the floating point format, e.g '%%.3f'\n");
|
||
fprintf(stdout, " U - is a URI reference (as defined in [IETF RFC 2396],\n");
|
||
fprintf(stdout, " updated by [IETF RFC 2732])\n");
|
||
fprintf(stdout, " B - is the form of binary output: NATIVE for a memory type, FILE for the\n");
|
||
fprintf(stdout, " file type, LE or BE for pre-existing little or big endian types.\n");
|
||
fprintf(stdout, " Must be used with -o (output file) and it is recommended that\n");
|
||
fprintf(stdout, " -d (dataset) is used. B is an optional argument, defaults to NATIVE\n");
|
||
fprintf(stdout, " Q - is the sort index type. It can be \"creation_order\" or \"name\" (default)\n");
|
||
fprintf(stdout, " Z - is the sort order type. It can be \"descending\" or \"ascending\" (default)\n");
|
||
fprintf(stdout, "\n");
|
||
fprintf(stdout, " Examples:\n");
|
||
fprintf(stdout, "\n");
|
||
fprintf(stdout, " 1) Attribute foo of the group /bar_none in file quux.h5\n");
|
||
fprintf(stdout, "\n");
|
||
fprintf(stdout, " h5dump -a /bar_none/foo quux.h5\n");
|
||
fprintf(stdout, "\n");
|
||
fprintf(stdout, " 2) Selecting a subset from dataset /foo in file quux.h5\n");
|
||
fprintf(stdout, "\n");
|
||
fprintf(stdout, " h5dump -d /foo -s \"0,1\" -S \"1,1\" -c \"2,3\" -k \"2,2\" quux.h5\n");
|
||
fprintf(stdout, "\n");
|
||
fprintf(stdout, " 3) Saving dataset 'dset' in file quux.h5 to binary file 'out.bin'\n");
|
||
fprintf(stdout, " using a little-endian type\n");
|
||
fprintf(stdout, "\n");
|
||
fprintf(stdout, " h5dump -d /dset -b LE -o out.bin quux.h5\n");
|
||
fprintf(stdout, "\n");
|
||
}
|
||
|
||
|
||
/*-------------------------------------------------------------------------
|
||
* Function: table_list_add
|
||
*
|
||
* Purpose: Add a new set of tables
|
||
*
|
||
* Return: index of added table on success, -1 on failure
|
||
*
|
||
* Programmer: Neil Fortner, nfortne2@hdfgroup.org
|
||
* Adapted from trav_addr_add in h5trav.c by Quincey Koziol
|
||
*
|
||
* Date: October 13, 2008
|
||
*
|
||
*-------------------------------------------------------------------------
|
||
*/
|
||
static ssize_t
|
||
table_list_add(hid_t oid, unsigned long file_no)
|
||
{
|
||
size_t idx; /* Index of table to use */
|
||
find_objs_t info;
|
||
|
||
/* Allocate space if necessary */
|
||
if(table_list.nused == table_list.nalloc) {
|
||
void *tmp_ptr;
|
||
|
||
table_list.nalloc = MAX(1, table_list.nalloc * 2);
|
||
if(NULL == (tmp_ptr = HDrealloc(table_list.tables, table_list.nalloc * sizeof(table_list.tables[0]))))
|
||
return -1;
|
||
table_list.tables = tmp_ptr;
|
||
} /* end if */
|
||
|
||
/* Append it */
|
||
idx = table_list.nused++;
|
||
table_list.tables[idx].fileno = file_no;
|
||
table_list.tables[idx].oid = oid;
|
||
if(H5Iinc_ref(oid) < 0) {
|
||
table_list.nused--;
|
||
return -1;
|
||
}
|
||
if(init_objs(oid, &info, &table_list.tables[idx].group_table,
|
||
&table_list.tables[idx].dset_table, &table_list.tables[idx].type_table) < 0) {
|
||
H5Idec_ref(oid);
|
||
table_list.nused--;
|
||
return -1;
|
||
}
|
||
|
||
#ifdef H5DUMP_DEBUG
|
||
dump_tables(&info);
|
||
#endif /* H5DUMP_DEBUG */
|
||
|
||
return((ssize_t) idx);
|
||
} /* end table_list_add() */
|
||
|
||
|
||
/*-------------------------------------------------------------------------
|
||
* Function: table_list_visited
|
||
*
|
||
* Purpose: Check if a table already exists for the specified fileno
|
||
*
|
||
* Return: The index of the matching table, or -1 if no matches found
|
||
*
|
||
* Programmer: Neil Fortner, nfortne2@hdfgroup.org
|
||
* Adapted from trav_addr_visited in h5trav.c by Quincey Koziol
|
||
*
|
||
* Date: October 13, 2008
|
||
*
|
||
*-------------------------------------------------------------------------
|
||
*/
|
||
static ssize_t
|
||
table_list_visited(unsigned long file_no)
|
||
{
|
||
size_t u; /* Local index variable */
|
||
|
||
/* Look for table */
|
||
for(u = 0; u < table_list.nused; u++)
|
||
/* Check for fileno value already in array */
|
||
if(table_list.tables[u].fileno == file_no)
|
||
return((ssize_t) u);
|
||
|
||
/* Didn't find table */
|
||
return(-1);
|
||
} /* end table_list_visited() */
|
||
|
||
|
||
/*-------------------------------------------------------------------------
|
||
* Function: table_list_free
|
||
*
|
||
* Purpose: Frees the table list
|
||
*
|
||
* Return: void
|
||
*
|
||
* Programmer: Neil Fortner, nfortne2@hdfgroup.org
|
||
*
|
||
* Date: October 13, 2008
|
||
*
|
||
*-------------------------------------------------------------------------
|
||
*/
|
||
static void
|
||
table_list_free(void)
|
||
{
|
||
size_t u; /* Local index variable */
|
||
|
||
/* Iterate over tables */
|
||
for(u = 0; u < table_list.nused; u++) {
|
||
/* Release object id */
|
||
if(H5Idec_ref(table_list.tables[u].oid) < 0)
|
||
h5tools_setstatus(EXIT_FAILURE);
|
||
|
||
/* Free each table */
|
||
free_table(table_list.tables[u].group_table);
|
||
free_table(table_list.tables[u].dset_table);
|
||
free_table(table_list.tables[u].type_table);
|
||
}
|
||
|
||
/* Free the table list */
|
||
HDfree(table_list.tables);
|
||
table_list.tables = NULL;
|
||
table_list.nalloc = table_list.nused = 0;
|
||
} /* end table_list_free() */
|
||
|
||
|
||
/*-------------------------------------------------------------------------
|
||
* Function: print_datatype
|
||
*
|
||
* Purpose: print the datatype.
|
||
*
|
||
* Return: void
|
||
*
|
||
* Programmer: Ruey-Hsia Li
|
||
*
|
||
* Modifications: pvn, March 28, 2006
|
||
* print information about type when a native match is not possible
|
||
*
|
||
*-------------------------------------------------------------------------
|
||
*/
|
||
static void
|
||
print_datatype(hid_t type,unsigned in_group)
|
||
{
|
||
char *mname;
|
||
hid_t mtype, str_type;
|
||
unsigned nmembers;
|
||
unsigned ndims;
|
||
unsigned i;
|
||
size_t size=0;
|
||
hsize_t dims[H5DUMP_MAX_RANK];
|
||
H5T_str_t str_pad;
|
||
H5T_cset_t cset;
|
||
H5T_order_t order;
|
||
hid_t super;
|
||
hid_t tmp_type;
|
||
htri_t is_vlstr=FALSE;
|
||
const char *order_s=NULL; /* byte order string */
|
||
H5T_sign_t sign; /* sign scheme value */
|
||
const char *sign_s=NULL; /* sign scheme string */
|
||
|
||
if (!in_group && H5Tcommitted(type) > 0) {
|
||
H5O_info_t oinfo;
|
||
obj_t *obj; /* Found object */
|
||
|
||
H5Oget_info(type, &oinfo);
|
||
obj = search_obj(type_table, oinfo.addr);
|
||
|
||
if(obj) {
|
||
if(!obj->recorded)
|
||
HDfprintf(stdout,"\"/#%a\"", obj->objno);
|
||
else
|
||
printf("\"%s\"", obj->objname);
|
||
} else {
|
||
error_msg("unknown committed type.\n");
|
||
h5tools_setstatus(EXIT_FAILURE);
|
||
}
|
||
} else {
|
||
switch(H5Tget_class(type)) {
|
||
case H5T_INTEGER:
|
||
if(H5Tequal(type, H5T_STD_I8BE) == TRUE) {
|
||
printf("H5T_STD_I8BE");
|
||
} else if(H5Tequal(type, H5T_STD_I8LE) == TRUE) {
|
||
printf("H5T_STD_I8LE");
|
||
} else if(H5Tequal(type, H5T_STD_I16BE) == TRUE) {
|
||
printf("H5T_STD_I16BE");
|
||
} else if(H5Tequal(type, H5T_STD_I16LE) == TRUE) {
|
||
printf("H5T_STD_I16LE");
|
||
} else if(H5Tequal(type, H5T_STD_I32BE) == TRUE) {
|
||
printf("H5T_STD_I32BE");
|
||
} else if(H5Tequal(type, H5T_STD_I32LE) == TRUE) {
|
||
printf("H5T_STD_I32LE");
|
||
} else if(H5Tequal(type, H5T_STD_I64BE) == TRUE) {
|
||
printf("H5T_STD_I64BE");
|
||
} else if(H5Tequal(type, H5T_STD_I64LE) == TRUE) {
|
||
printf("H5T_STD_I64LE");
|
||
} else if(H5Tequal(type, H5T_STD_U8BE) == TRUE) {
|
||
printf("H5T_STD_U8BE");
|
||
} else if(H5Tequal(type, H5T_STD_U8LE) == TRUE) {
|
||
printf("H5T_STD_U8LE");
|
||
} else if(H5Tequal(type, H5T_STD_U16BE) == TRUE) {
|
||
printf("H5T_STD_U16BE");
|
||
} else if(H5Tequal(type, H5T_STD_U16LE) == TRUE) {
|
||
printf("H5T_STD_U16LE");
|
||
} else if(H5Tequal(type, H5T_STD_U32BE) == TRUE) {
|
||
printf("H5T_STD_U32BE");
|
||
} else if(H5Tequal(type, H5T_STD_U32LE) == TRUE) {
|
||
printf("H5T_STD_U32LE");
|
||
} else if(H5Tequal(type, H5T_STD_U64BE) == TRUE) {
|
||
printf("H5T_STD_U64BE");
|
||
} else if(H5Tequal(type, H5T_STD_U64LE) == TRUE) {
|
||
printf("H5T_STD_U64LE");
|
||
} else if(H5Tequal(type, H5T_NATIVE_SCHAR) == TRUE) {
|
||
printf("H5T_NATIVE_SCHAR");
|
||
} else if(H5Tequal(type, H5T_NATIVE_UCHAR) == TRUE) {
|
||
printf("H5T_NATIVE_UCHAR");
|
||
} else if(H5Tequal(type, H5T_NATIVE_SHORT) == TRUE) {
|
||
printf("H5T_NATIVE_SHORT");
|
||
} else if(H5Tequal(type, H5T_NATIVE_USHORT) == TRUE) {
|
||
printf("H5T_NATIVE_USHORT");
|
||
} else if(H5Tequal(type, H5T_NATIVE_INT) == TRUE) {
|
||
printf("H5T_NATIVE_INT");
|
||
} else if(H5Tequal(type, H5T_NATIVE_UINT) == TRUE) {
|
||
printf("H5T_NATIVE_UINT");
|
||
} else if(H5Tequal(type, H5T_NATIVE_LONG) == TRUE) {
|
||
printf("H5T_NATIVE_LONG");
|
||
} else if(H5Tequal(type, H5T_NATIVE_ULONG) == TRUE) {
|
||
printf("H5T_NATIVE_ULONG");
|
||
} else if(H5Tequal(type, H5T_NATIVE_LLONG) == TRUE) {
|
||
printf("H5T_NATIVE_LLONG");
|
||
} else if(H5Tequal(type, H5T_NATIVE_ULLONG) == TRUE) {
|
||
printf("H5T_NATIVE_ULLONG");
|
||
} else {
|
||
|
||
/* byte order */
|
||
if(H5Tget_size(type)>1) {
|
||
order = H5Tget_order(type);
|
||
if (H5T_ORDER_LE == order) {
|
||
order_s = " little-endian";
|
||
} else if (H5T_ORDER_BE == order) {
|
||
order_s = " big-endian";
|
||
} else if (H5T_ORDER_VAX == order) {
|
||
order_s = " mixed-endian";
|
||
} else {
|
||
order_s = " unknown-byte-order";
|
||
}
|
||
} else {
|
||
order_s = "";
|
||
}
|
||
|
||
/* sign */
|
||
if ((sign=H5Tget_sign(type))>=0)
|
||
{
|
||
if (H5T_SGN_NONE == sign) {
|
||
sign_s = " unsigned";
|
||
} else if (H5T_SGN_2 == sign) {
|
||
sign_s = "";
|
||
} else {
|
||
sign_s = " unknown-sign";
|
||
}
|
||
} else {
|
||
sign_s = " unknown-sign";
|
||
}
|
||
|
||
/* print size, order, and sign */
|
||
printf("%lu-bit%s%s integer",
|
||
(unsigned long)(8*H5Tget_size(type)), order_s, sign_s);
|
||
}
|
||
break;
|
||
|
||
case H5T_FLOAT:
|
||
if(H5Tequal(type, H5T_IEEE_F32BE) == TRUE) {
|
||
printf("H5T_IEEE_F32BE");
|
||
} else if(H5Tequal(type, H5T_IEEE_F32LE) == TRUE) {
|
||
printf("H5T_IEEE_F32LE");
|
||
} else if(H5Tequal(type, H5T_IEEE_F64BE) == TRUE) {
|
||
printf("H5T_IEEE_F64BE");
|
||
} else if(H5Tequal(type, H5T_IEEE_F64LE) == TRUE) {
|
||
printf("H5T_IEEE_F64LE");
|
||
} else if(H5Tequal(type, H5T_VAX_F32) == TRUE) {
|
||
printf("H5T_VAX_F32");
|
||
} else if(H5Tequal(type, H5T_VAX_F64) == TRUE) {
|
||
printf("H5T_VAX_F64");
|
||
} else if(H5Tequal(type, H5T_NATIVE_FLOAT) == TRUE) {
|
||
printf("H5T_NATIVE_FLOAT");
|
||
} else if(H5Tequal(type, H5T_NATIVE_DOUBLE) == TRUE) {
|
||
printf("H5T_NATIVE_DOUBLE");
|
||
#if H5_SIZEOF_LONG_DOUBLE !=0
|
||
} else if(H5Tequal(type, H5T_NATIVE_LDOUBLE) == TRUE) {
|
||
printf("H5T_NATIVE_LDOUBLE");
|
||
#endif
|
||
} else {
|
||
|
||
/* byte order */
|
||
if(H5Tget_size(type)>1) {
|
||
order = H5Tget_order(type);
|
||
if (H5T_ORDER_LE == order) {
|
||
order_s = " little-endian";
|
||
} else if (H5T_ORDER_BE == order) {
|
||
order_s = " big-endian";
|
||
} else if (H5T_ORDER_VAX == order) {
|
||
order_s = " mixed-endian";
|
||
} else {
|
||
order_s = " unknown-byte-order";
|
||
}
|
||
} else {
|
||
order_s = "";
|
||
}
|
||
|
||
/* print size and byte order */
|
||
printf("%lu-bit%s floating-point",
|
||
(unsigned long)(8*H5Tget_size(type)), order_s);
|
||
|
||
}
|
||
break;
|
||
|
||
case H5T_TIME:
|
||
printf("H5T_TIME: not yet implemented");
|
||
break;
|
||
|
||
case H5T_STRING:
|
||
/* Make a copy of type in memory in case when TYPE is on disk, the size
|
||
* will be bigger than in memory. This makes it easier to compare
|
||
* types in memory. */
|
||
tmp_type = H5Tcopy(type);
|
||
size = H5Tget_size(tmp_type);
|
||
str_pad = H5Tget_strpad(tmp_type);
|
||
cset = H5Tget_cset(tmp_type);
|
||
is_vlstr = H5Tis_variable_str(tmp_type);
|
||
|
||
printf("H5T_STRING %s\n", dump_header_format->strblockbegin);
|
||
indent += COL;
|
||
|
||
indentation(indent + COL);
|
||
if(is_vlstr)
|
||
printf("%s H5T_VARIABLE;\n", STRSIZE);
|
||
else
|
||
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);
|
||
if(is_vlstr)
|
||
H5Tset_size(str_type, H5T_VARIABLE);
|
||
else
|
||
H5Tset_size(str_type, size);
|
||
H5Tset_cset(str_type, cset);
|
||
H5Tset_strpad(str_type, str_pad);
|
||
|
||
indentation(indent + COL);
|
||
printf("%s ", CTYPE);
|
||
|
||
/* Check C variable-length string first. Are the two types equal? */
|
||
if (H5Tequal(tmp_type, str_type)) {
|
||
printf("H5T_C_S1;\n");
|
||
goto done;
|
||
}
|
||
|
||
/* Change the endianness and see if they're equal. */
|
||
order = H5Tget_order(tmp_type);
|
||
if(order==H5T_ORDER_LE)
|
||
H5Tset_order(str_type, H5T_ORDER_LE);
|
||
else if(order==H5T_ORDER_BE)
|
||
H5Tset_order(str_type, H5T_ORDER_BE);
|
||
|
||
if (H5Tequal(tmp_type, str_type)) {
|
||
printf("H5T_C_S1;\n");
|
||
goto done;
|
||
}
|
||
|
||
/* If not equal to C variable-length string, check Fortran type. */
|
||
H5Tclose(str_type);
|
||
str_type = H5Tcopy(H5T_FORTRAN_S1);
|
||
H5Tset_cset(str_type, cset);
|
||
H5Tset_size(str_type, size);
|
||
H5Tset_strpad(str_type, str_pad);
|
||
|
||
/* Are the two types equal? */
|
||
if (H5Tequal(tmp_type, str_type)) {
|
||
printf("H5T_FORTRAN_S1;\n");
|
||
goto done;
|
||
}
|
||
|
||
/* Change the endianness and see if they're equal. */
|
||
order = H5Tget_order(tmp_type);
|
||
if(order==H5T_ORDER_LE)
|
||
H5Tset_order(str_type, H5T_ORDER_LE);
|
||
else if(order==H5T_ORDER_BE)
|
||
H5Tset_order(str_type, H5T_ORDER_BE);
|
||
|
||
if (H5Tequal(tmp_type, str_type)) {
|
||
printf("H5T_FORTRAN_S1;\n");
|
||
goto done;
|
||
}
|
||
|
||
/* Type doesn't match any of above. */
|
||
printf("unknown_one_character_type;\n ");
|
||
h5tools_setstatus(EXIT_FAILURE);
|
||
|
||
done:
|
||
H5Tclose(str_type);
|
||
H5Tclose(tmp_type);
|
||
|
||
indent -= COL;
|
||
indentation(indent + COL);
|
||
printf("%s", dump_header_format->strblockend);
|
||
break;
|
||
|
||
case H5T_BITFIELD:
|
||
if (H5Tequal(type, H5T_STD_B8BE)==TRUE) {
|
||
printf("H5T_STD_B8BE");
|
||
} else if (H5Tequal(type, H5T_STD_B8LE)==TRUE) {
|
||
printf("H5T_STD_B8LE");
|
||
} else if (H5Tequal(type, H5T_STD_B16BE)==TRUE) {
|
||
printf("H5T_STD_B16BE");
|
||
} else if (H5Tequal(type, H5T_STD_B16LE)==TRUE) {
|
||
printf("H5T_STD_B16LE");
|
||
} else if (H5Tequal(type, H5T_STD_B32BE)==TRUE) {
|
||
printf("H5T_STD_B32BE");
|
||
} else if (H5Tequal(type, H5T_STD_B32LE)==TRUE) {
|
||
printf("H5T_STD_B32LE");
|
||
} else if (H5Tequal(type, H5T_STD_B64BE)==TRUE) {
|
||
printf("H5T_STD_B64BE");
|
||
} else if (H5Tequal(type, H5T_STD_B64LE)==TRUE) {
|
||
printf("H5T_STD_B64LE");
|
||
} else {
|
||
printf("undefined bitfield");
|
||
h5tools_setstatus(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:
|
||
nmembers = H5Tget_nmembers(type);
|
||
printf("H5T_COMPOUND %s\n", dump_header_format->structblockbegin);
|
||
|
||
for (i = 0; i < nmembers; i++) {
|
||
mname = 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,0);
|
||
|
||
if (H5Tget_class(mtype) == H5T_COMPOUND)
|
||
indent -= COL;
|
||
|
||
printf(" \"%s\";\n", mname);
|
||
free(mname);
|
||
}
|
||
|
||
indentation(indent);
|
||
printf("%s", dump_header_format->structblockend);
|
||
break;
|
||
|
||
case H5T_REFERENCE:
|
||
printf("H5T_REFERENCE");
|
||
/* The BNF document states that the type of reference should be
|
||
* displayed after "H5T_REFERENCE". Therefore add the missing
|
||
* reference type if the region command line option is used. This
|
||
* reference type will not be displayed if the region option is not used. */
|
||
if(display_region) {
|
||
if (H5Tequal(type, H5T_STD_REF_DSETREG)==TRUE) {
|
||
printf(" { H5T_STD_REF_DSETREG }");
|
||
}
|
||
else {
|
||
printf(" { H5T_STD_REF_OBJECT }");
|
||
}
|
||
}
|
||
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,0);
|
||
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,0);
|
||
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_dims2(type, dims);
|
||
|
||
/* Print array dimensions */
|
||
for (i = 0; i < ndims; i++)
|
||
printf("[%d]", (int) dims[i]);
|
||
|
||
printf(" ");
|
||
|
||
/* Print base type */
|
||
print_datatype(super,0);
|
||
|
||
/* Close array base type */
|
||
H5Tclose(super);
|
||
|
||
/* Print closing */
|
||
printf(" }");
|
||
|
||
break;
|
||
|
||
default:
|
||
printf("unknown datatype");
|
||
h5tools_setstatus(EXIT_FAILURE);
|
||
break;
|
||
}
|
||
} /* end else */
|
||
}
|
||
|
||
|
||
/*-------------------------------------------------------------------------
|
||
* Function: dump_datatype
|
||
*
|
||
* Purpose: Dump the datatype. Datatype can be HDF5 predefined
|
||
* atomic datatype or committed/transient datatype.
|
||
*
|
||
* 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,0);
|
||
|
||
end_obj(dump_header_format->datatypeend,
|
||
dump_header_format->datatypeblockend);
|
||
indent -= COL;
|
||
}
|
||
|
||
/*-------------------------------------------------------------------------
|
||
* Function: dump_dataspace
|
||
*
|
||
* Purpose: Dump the dataspace. Dataspace can be named dataspace,
|
||
* 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);
|
||
H5S_class_t space_type = H5Sget_simple_extent_type(space);
|
||
int i;
|
||
|
||
indentation(indent + COL);
|
||
printf("%s ", dump_header_format->dataspacebegin);
|
||
|
||
switch(space_type) {
|
||
case H5S_SCALAR:
|
||
/* scalar dataspace */
|
||
HDfprintf(stdout, "%s %s",
|
||
dump_header_format->dataspacedescriptionbegin, S_SCALAR);
|
||
break;
|
||
|
||
case H5S_SIMPLE:
|
||
/* simple dataspace */
|
||
HDfprintf(stdout, "%s %s { %s %Hu",
|
||
dump_header_format->dataspacedescriptionbegin, S_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);
|
||
break;
|
||
|
||
case H5S_NULL:
|
||
/* null dataspace */
|
||
HDfprintf(stdout, "%s %s",
|
||
dump_header_format->dataspacedescriptionbegin, S_NULL);
|
||
break;
|
||
|
||
case H5S_NO_CLASS:
|
||
default:
|
||
printf("%s unknown dataspace %s\n", BEGIN, END);
|
||
break;
|
||
} /* end switch */
|
||
|
||
end_obj(dump_header_format->dataspaceend,
|
||
dump_header_format->dataspaceblockend);
|
||
}
|
||
|
||
|
||
/*-------------------------------------------------------------------------
|
||
* Function: dump_attr_cb
|
||
*
|
||
* Purpose: attribute function callback called by H5Aiterate2, displays the attribute
|
||
*
|
||
* Return: Success: SUCCEED
|
||
*
|
||
* Failure: FAIL
|
||
*
|
||
* Programmer: Ruey-Hsia Li
|
||
*
|
||
* Modifications: Pedro Vicente, October 4, 2007
|
||
* Added H5A_info_t parameter to conform with H5Aiterate2
|
||
*
|
||
*-------------------------------------------------------------------------
|
||
*/
|
||
static herr_t
|
||
dump_attr_cb(hid_t oid, const char *attr_name, const H5A_info_t UNUSED *info, void UNUSED *_op_data)
|
||
{
|
||
hid_t attr_id;
|
||
herr_t ret = SUCCEED;
|
||
|
||
indentation(indent);
|
||
begin_obj(dump_header_format->attributebegin, attr_name,
|
||
dump_header_format->attributeblockbegin);
|
||
|
||
if((attr_id = H5Aopen(oid, attr_name, H5P_DEFAULT)) < 0) {
|
||
indentation(indent + COL);
|
||
error_msg("unable to open attribute \"%s\"\n", attr_name);
|
||
indentation(indent);
|
||
end_obj(dump_header_format->attributeend,
|
||
dump_header_format->attributeblockend);
|
||
h5tools_setstatus(EXIT_FAILURE);
|
||
ret = FAIL;
|
||
} else {
|
||
hid_t type, space;
|
||
|
||
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 || display_attr_data)
|
||
dump_data(attr_id, ATTRIBUTE_DATA, NULL, display_ai);
|
||
|
||
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)
|
||
{
|
||
hid_t oid, attr_id;
|
||
char *obj_name;
|
||
const char *attr_name;
|
||
int j;
|
||
|
||
j = (int)HDstrlen(name) - 1;
|
||
obj_name = (char *)HDmalloc((size_t)j + 2);
|
||
|
||
/* find the last / */
|
||
while(name[j] != '/' && j >= 0)
|
||
j--;
|
||
|
||
/* object name */
|
||
if(j == -1)
|
||
HDstrcpy(obj_name, "/");
|
||
else {
|
||
HDstrncpy(obj_name, name, (size_t)j + 1);
|
||
obj_name[j + 1] = '\0';
|
||
} /* end else */
|
||
|
||
attr_name = name + j + 1;
|
||
begin_obj(dump_header_format->attributebegin, name,
|
||
dump_header_format->attributeblockbegin);
|
||
|
||
/* Open the object with the attribute */
|
||
if((oid = H5Oopen(loc_id, obj_name, H5P_DEFAULT)) < 0) {
|
||
indentation(COL);
|
||
error_msg("unable to open object \"%s\"\n", obj_name);
|
||
end_obj(dump_header_format->attributeend, dump_header_format->attributeblockend);
|
||
h5tools_setstatus(EXIT_FAILURE);
|
||
return FAIL;
|
||
} /* end if */
|
||
|
||
if((attr_id = H5Aopen(oid, attr_name, H5P_DEFAULT)) >= 0) {
|
||
hid_t type, space;
|
||
|
||
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 || display_attr_data)
|
||
dump_data(attr_id, ATTRIBUTE_DATA, NULL, display_ai);
|
||
|
||
H5Tclose(type);
|
||
H5Sclose(space);
|
||
H5Aclose(attr_id);
|
||
end_obj(dump_header_format->attributeend,
|
||
dump_header_format->attributeblockend);
|
||
} else {
|
||
indentation(COL);
|
||
error_msg("unable to open attribute \"%s\"\n", obj_name);
|
||
end_obj(dump_header_format->attributeend, dump_header_format->attributeblockend);
|
||
h5tools_setstatus(EXIT_FAILURE);
|
||
}
|
||
|
||
/* Close object */
|
||
if(H5Oclose(oid) < 0) {
|
||
h5tools_setstatus(EXIT_FAILURE);
|
||
return FAIL;
|
||
} /* end if */
|
||
|
||
HDfree(obj_name);
|
||
return SUCCEED;
|
||
}
|
||
|
||
/*-------------------------------------------------------------------------
|
||
* Function: dump_all_cb
|
||
*
|
||
* Purpose: function callback called by H5Literate,
|
||
* displays 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
|
||
*
|
||
* PVN, May 2008
|
||
* Dump external links
|
||
*
|
||
*-------------------------------------------------------------------------
|
||
*/
|
||
static herr_t
|
||
dump_all_cb(hid_t group, const char *name, const H5L_info_t *linfo, void UNUSED *op_data)
|
||
{
|
||
hid_t obj;
|
||
char *obj_path = NULL; /* Full path of object */
|
||
herr_t ret = SUCCEED;
|
||
|
||
/* Build the object's path name */
|
||
obj_path = (char *)HDmalloc(HDstrlen(prefix) + HDstrlen(name) + 2);
|
||
HDassert(obj_path);
|
||
HDstrcpy(obj_path, prefix);
|
||
HDstrcat(obj_path, "/");
|
||
HDstrcat(obj_path, name);
|
||
|
||
if(linfo->type == H5L_TYPE_HARD) {
|
||
H5O_info_t oinfo;
|
||
|
||
/* Stat the object */
|
||
if(H5Oget_info_by_name(group, name, &oinfo, H5P_DEFAULT) < 0) {
|
||
error_msg("unable to get object information for \"%s\"\n", name);
|
||
h5tools_setstatus(EXIT_FAILURE);
|
||
ret = FAIL;
|
||
goto done;
|
||
} /* end if */
|
||
|
||
switch(oinfo.type)
|
||
{
|
||
case H5O_TYPE_GROUP:
|
||
if((obj = H5Gopen2(group, name, H5P_DEFAULT)) < 0)
|
||
{
|
||
error_msg("unable to dump group \"%s\"\n", name);
|
||
h5tools_setstatus(EXIT_FAILURE);
|
||
ret = FAIL;
|
||
}
|
||
else
|
||
{
|
||
char *old_prefix; /* Pointer to previous prefix */
|
||
|
||
/* Keep copy of prefix before iterating into group */
|
||
old_prefix = HDstrdup(prefix);
|
||
HDassert(old_prefix);
|
||
|
||
/* Append group name to prefix */
|
||
add_prefix(&prefix, &prefix_len, name);
|
||
|
||
/* Iterate into group */
|
||
dump_function_table->dump_group_function(obj, name);
|
||
|
||
/* Restore old prefix name */
|
||
HDstrcpy(prefix, old_prefix);
|
||
HDfree(old_prefix);
|
||
|
||
/* Close group */
|
||
H5Gclose(obj);
|
||
}
|
||
break;
|
||
|
||
case H5O_TYPE_DATASET:
|
||
if((obj = H5Dopen2(group, name, H5P_DEFAULT)) >= 0) {
|
||
if(oinfo.rc > 1 || hit_elink) {
|
||
obj_t *found_obj; /* Found object */
|
||
|
||
found_obj = search_obj(dset_table, oinfo.addr);
|
||
|
||
if(found_obj == NULL) {
|
||
indentation(indent);
|
||
begin_obj(dump_header_format->datasetbegin, name,
|
||
dump_header_format->datasetblockbegin);
|
||
indentation(indent + COL);
|
||
error_msg("internal error (file %s:line %d)\n",
|
||
__FILE__, __LINE__);
|
||
indentation(indent);
|
||
end_obj(dump_header_format->datasetend,
|
||
dump_header_format->datasetblockend);
|
||
h5tools_setstatus(EXIT_FAILURE);
|
||
ret = FAIL;
|
||
H5Dclose(obj);
|
||
goto done;
|
||
} else if(found_obj->displayed) {
|
||
indentation(indent);
|
||
|
||
if(!doxml) {
|
||
begin_obj(dump_header_format->datasetbegin, name,
|
||
dump_header_format->datasetblockbegin);
|
||
indentation(indent + COL);
|
||
printf("%s \"%s\"\n", HARDLINK, found_obj->objname);
|
||
indentation(indent);
|
||
end_obj(dump_header_format->datasetend,
|
||
dump_header_format->datasetblockend);
|
||
} else {
|
||
/* the XML version */
|
||
char *t_obj_path = xml_escape_the_name(obj_path);
|
||
char *t_prefix = xml_escape_the_name(HDstrcmp(prefix,"") ? prefix : "/");
|
||
char *t_name = xml_escape_the_name(name);
|
||
char *t_objname = xml_escape_the_name(found_obj->objname);
|
||
char dsetxid[100];
|
||
char parentxid[100];
|
||
char pointerxid[100];
|
||
|
||
/* Create OBJ-XIDs for the parent and object */
|
||
xml_name_to_XID(obj_path, dsetxid, sizeof(dsetxid), 1);
|
||
xml_name_to_XID(prefix, parentxid, sizeof(parentxid), 1);
|
||
|
||
printf("<%sDataset Name=\"%s\" OBJ-XID=\"%s-%d\" "
|
||
"H5Path=\"%s\" Parents=\"%s\" "
|
||
"H5ParentPaths=\"%s\">\n",
|
||
xmlnsprefix,
|
||
t_name, /* Dataset Name */
|
||
dsetxid, get_next_xid(), /* OBJ-XID */
|
||
t_obj_path, /* H5Path */
|
||
parentxid, /* Parents */
|
||
t_prefix); /* H5ParentPaths */
|
||
|
||
indentation(indent + COL);
|
||
xml_name_to_XID(found_obj->objname, pointerxid, sizeof(pointerxid), 1);
|
||
printf("<%sDatasetPtr OBJ-XID=\"%s\" H5Path=\"%s\"/>\n",
|
||
xmlnsprefix,
|
||
pointerxid,t_objname);
|
||
indentation(indent);
|
||
printf("</%sDataset>\n", xmlnsprefix);
|
||
|
||
HDfree(t_name);
|
||
HDfree(t_obj_path);
|
||
HDfree(t_prefix);
|
||
HDfree(t_objname);
|
||
}
|
||
|
||
H5Dclose(obj);
|
||
goto done;
|
||
} else {
|
||
found_obj->displayed = TRUE;
|
||
}
|
||
} /* end if */
|
||
|
||
dump_function_table->dump_dataset_function(obj, name, NULL);
|
||
H5Dclose(obj);
|
||
} else {
|
||
error_msg("unable to dump dataset \"%s\"\n", name);
|
||
h5tools_setstatus(EXIT_FAILURE);
|
||
ret = FAIL;
|
||
}
|
||
break;
|
||
|
||
case H5O_TYPE_NAMED_DATATYPE:
|
||
if((obj = H5Topen2(group, name, H5P_DEFAULT)) < 0) {
|
||
error_msg("unable to dump datatype \"%s\"\n", name);
|
||
h5tools_setstatus(EXIT_FAILURE);
|
||
ret = FAIL;
|
||
} else {
|
||
dump_function_table->dump_named_datatype_function(obj, name);
|
||
H5Tclose(obj);
|
||
}
|
||
break;
|
||
|
||
default:
|
||
error_msg("unknown object \"%s\"\n", name);
|
||
h5tools_setstatus(EXIT_FAILURE);
|
||
ret = FAIL;
|
||
}
|
||
} /* end if */
|
||
else {
|
||
char *targbuf;
|
||
|
||
switch(linfo->type) {
|
||
case H5L_TYPE_SOFT:
|
||
indentation(indent);
|
||
targbuf = (char *)HDmalloc(linfo->u.val_size);
|
||
HDassert(targbuf);
|
||
|
||
if(!doxml) {
|
||
begin_obj(dump_header_format->softlinkbegin, name,
|
||
dump_header_format->softlinkblockbegin);
|
||
indentation(indent + COL);
|
||
}
|
||
|
||
if(H5Lget_val(group, name, targbuf, linfo->u.val_size, H5P_DEFAULT) < 0) {
|
||
error_msg("unable to get link value\n");
|
||
h5tools_setstatus(EXIT_FAILURE);
|
||
ret = FAIL;
|
||
} else {
|
||
/* print the value of a soft link */
|
||
if (!doxml) {
|
||
/* Standard DDL: no modification */
|
||
printf("LINKTARGET \"%s\"\n", targbuf);
|
||
} else {
|
||
/* XML */
|
||
char linkxid[100];
|
||
char parentxid[100];
|
||
char targetxid[100];
|
||
char *t_prefix = xml_escape_the_name(HDstrcmp(prefix,"") ? prefix : "/");
|
||
char *t_name = xml_escape_the_name(name);
|
||
char *t_targbuf = xml_escape_the_name(targbuf);
|
||
char *t_obj_path = xml_escape_the_name(obj_path);
|
||
char *t_link_path;
|
||
int res;
|
||
|
||
t_link_path = (char *)HDmalloc(HDstrlen(prefix) + linfo->u.val_size + 1);
|
||
if(targbuf[0] == '/')
|
||
HDstrcpy(t_link_path, targbuf);
|
||
else {
|
||
HDstrcpy(t_link_path, prefix);
|
||
HDstrcat(HDstrcat(t_link_path, "/"), targbuf);
|
||
} /* end else */
|
||
|
||
/* Create OBJ-XIDs for the parent and object */
|
||
xml_name_to_XID(t_obj_path, linkxid, sizeof(linkxid), 1);
|
||
xml_name_to_XID(prefix, parentxid, sizeof(parentxid), 1);
|
||
|
||
/* Try to create an OBJ-XID for the object pointed to */
|
||
res = xml_name_to_XID(t_link_path, targetxid, sizeof(targetxid), 0);
|
||
if (res == 0) {
|
||
/* target obj found */
|
||
printf("<%sSoftLink LinkName=\"%s\" "
|
||
"OBJ-XID=\"%s\" "
|
||
"H5SourcePath=\"%s\" "
|
||
"TargetPath=\"%s\" TargetObj=\"%s\" "
|
||
"Parents=\"%s\" H5ParentPaths=\"%s\" />\n",
|
||
xmlnsprefix,
|
||
t_name, /* LinkName */
|
||
linkxid, /* OBJ-XID */
|
||
t_obj_path, /* H5SourcePath */
|
||
t_targbuf, /* TargetPath */
|
||
targetxid, /* TargetObj */
|
||
parentxid, /* Parents */
|
||
t_prefix); /* H5ParentPaths */
|
||
} else {
|
||
/* dangling link -- omit from xml attributes */
|
||
printf("<%sSoftLink LinkName=\"%s\" "
|
||
"OBJ-XID=\"%s\" "
|
||
"H5SourcePath=\"%s\" "
|
||
"TargetPath=\"%s\" "
|
||
"Parents=\"%s\" H5ParentPaths=\"%s\" />\n",
|
||
xmlnsprefix,
|
||
t_name, /* LinkName */
|
||
linkxid, /* OBJ-XID */
|
||
t_obj_path, /* H5SourcePath */
|
||
t_targbuf, /* TargetPath */
|
||
parentxid, /* Parents */
|
||
t_prefix); /* H5ParentPaths */
|
||
}
|
||
|
||
HDfree(t_prefix);
|
||
HDfree(t_name);
|
||
HDfree(t_targbuf);
|
||
HDfree(t_obj_path);
|
||
HDfree(t_link_path);
|
||
}
|
||
}
|
||
|
||
if (!doxml) {
|
||
indentation(indent);
|
||
end_obj(dump_header_format->softlinkend,
|
||
dump_header_format->softlinkblockend);
|
||
}
|
||
|
||
HDfree(targbuf);
|
||
break;
|
||
|
||
case H5L_TYPE_EXTERNAL:
|
||
targbuf = (char *)HDmalloc(linfo->u.val_size);
|
||
HDassert(targbuf);
|
||
|
||
indentation(indent);
|
||
if(!doxml)
|
||
begin_obj(dump_header_format->extlinkbegin, name, dump_header_format->extlinkblockbegin);
|
||
|
||
if(H5Lget_val(group, name, targbuf, linfo->u.val_size, H5P_DEFAULT) < 0) {
|
||
error_msg("unable to get external link value\n");
|
||
h5tools_setstatus(EXIT_FAILURE);
|
||
ret = FAIL;
|
||
} /* end if */
|
||
else {
|
||
const char *filename;
|
||
const char *targname;
|
||
|
||
if(H5Lunpack_elink_val(targbuf, linfo->u.val_size, NULL, &filename, &targname) < 0) {
|
||
error_msg("unable to unpack external link value\n");
|
||
h5tools_setstatus(EXIT_FAILURE);
|
||
ret = FAIL;
|
||
} /* end if */
|
||
else {
|
||
if(!doxml) {
|
||
indentation(indent + COL);
|
||
printf("TARGETFILE \"%s\"\n", filename);
|
||
indentation(indent + COL);
|
||
printf("TARGETPATH \"%s\"\n", targname);
|
||
|
||
/* dump the external link */
|
||
dump_extlink(group, name, targname);
|
||
|
||
|
||
} /* end if */
|
||
/* XML */
|
||
else {
|
||
char linkxid[100];
|
||
char parentxid[100];
|
||
char *t_name = xml_escape_the_name(name);
|
||
char *t_prefix = xml_escape_the_name(HDstrcmp(prefix,"") ? prefix : "/");
|
||
char *t_obj_path = xml_escape_the_name(obj_path);
|
||
char *t_filename = xml_escape_the_name(filename);
|
||
char *t_targname = xml_escape_the_name(targname);
|
||
|
||
/* Create OBJ-XIDs for the parent and object */
|
||
xml_name_to_XID(t_obj_path, linkxid, sizeof(linkxid), 1);
|
||
xml_name_to_XID(prefix, parentxid, sizeof(parentxid), 1);
|
||
|
||
printf("<%sExternalLink LinkName=\"%s\" "
|
||
"OBJ-XID=\"%s\" "
|
||
"H5SourcePath=\"%s\" "
|
||
"TargetFilename=\"%s\" "
|
||
"TargetPath=\"%s\" "
|
||
"Parents=\"%s\" H5ParentPaths=\"%s\" />\n",
|
||
xmlnsprefix,
|
||
t_name, /* LinkName */
|
||
linkxid, /* OBJ-XID */
|
||
t_obj_path, /* H5SourcePath */
|
||
filename, /* TargetFilename */
|
||
targname, /* TargetPath*/
|
||
parentxid, /* Parents */
|
||
t_prefix); /* H5ParentPaths */
|
||
HDfree(t_prefix);
|
||
HDfree(t_name);
|
||
HDfree(t_filename);
|
||
HDfree(t_targname);
|
||
HDfree(t_obj_path);
|
||
} /* end else */
|
||
} /* end else */
|
||
} /* end else */
|
||
if(!doxml) {
|
||
indentation(indent);
|
||
end_obj(dump_header_format->extlinkend, dump_header_format->extlinkblockend);
|
||
} /* end if */
|
||
HDfree(targbuf);
|
||
break;
|
||
|
||
default:
|
||
indentation(indent);
|
||
if(!doxml) {
|
||
begin_obj(dump_header_format->udlinkbegin, name, dump_header_format->udlinkblockbegin);
|
||
indentation(indent + COL);
|
||
printf("LINKCLASS %d\n", linfo->type);
|
||
indentation(indent);
|
||
end_obj(dump_header_format->udlinkend, dump_header_format->udlinkblockend);
|
||
} /* end if */
|
||
/* XML */
|
||
else {
|
||
char linkxid[100];
|
||
char parentxid[100];
|
||
char *t_name = xml_escape_the_name(name);
|
||
char *t_prefix = xml_escape_the_name(HDstrcmp(prefix,"") ? prefix : "/");
|
||
char *t_obj_path = xml_escape_the_name(obj_path);
|
||
|
||
/* Create OBJ-XIDs for the parent and object */
|
||
xml_name_to_XID(t_obj_path, linkxid, sizeof(linkxid), 1);
|
||
xml_name_to_XID(prefix, parentxid, sizeof(parentxid), 1);
|
||
|
||
printf("<%sUserDefined LinkName=\"%s\" "
|
||
"OBJ-XID=\"%s\" "
|
||
"H5SourcePath=\"%s\" "
|
||
"LinkClass=\"%d\" "
|
||
"Parents=\"%s\" H5ParentPaths=\"%s\" />\n",
|
||
xmlnsprefix,
|
||
t_name, /* LinkName */
|
||
linkxid, /* OBJ-XID */
|
||
t_obj_path, /* H5SourcePath */
|
||
linfo->type, /* LinkClass */
|
||
parentxid, /* Parents */
|
||
t_prefix); /* H5ParentPaths */
|
||
HDfree(t_prefix);
|
||
HDfree(t_name);
|
||
HDfree(t_obj_path);
|
||
} /* end else */
|
||
break;
|
||
} /* end switch */
|
||
} /* end else */
|
||
|
||
done:
|
||
if(obj_path)
|
||
HDfree(obj_path);
|
||
return ret;
|
||
}
|
||
|
||
/*-------------------------------------------------------------------------
|
||
* Function: dump_named_datatype
|
||
*
|
||
* Purpose: Dump named datatype
|
||
*
|
||
* Return: void
|
||
*
|
||
* Programmer: Ruey-Hsia Li
|
||
*
|
||
* Modifications:
|
||
* Pedro Vicente, March 27, 2006
|
||
* added display of attributes
|
||
* Pedro Vicente, October 4, 2007, added parameters to H5Aiterate2() to allow for
|
||
* other iteration orders
|
||
*
|
||
*-------------------------------------------------------------------------
|
||
*/
|
||
static void
|
||
dump_named_datatype(hid_t tid, const char *name)
|
||
{
|
||
H5O_info_t oinfo;
|
||
unsigned attr_crt_order_flags;
|
||
hid_t tcpl_id; /* datatype creation property list ID */
|
||
|
||
|
||
if ((tcpl_id = H5Tget_create_plist(tid)) < 0)
|
||
{
|
||
error_msg("error in getting creation property list ID\n");
|
||
h5tools_setstatus(EXIT_FAILURE);
|
||
}
|
||
|
||
/* query the creation properties for attributes */
|
||
if (H5Pget_attr_creation_order(tcpl_id, &attr_crt_order_flags) < 0)
|
||
{
|
||
error_msg("error in getting creation properties\n");
|
||
h5tools_setstatus(EXIT_FAILURE);
|
||
}
|
||
|
||
if(H5Pclose(tcpl_id) < 0) {
|
||
error_msg("error in closing creation property list ID\n");
|
||
h5tools_setstatus(EXIT_FAILURE);
|
||
}
|
||
|
||
|
||
indentation(indent);
|
||
printf("%s \"%s\" %s", dump_header_format->datatypebegin, name,
|
||
dump_header_format->datatypeblockbegin);
|
||
|
||
H5Oget_info(tid, &oinfo);
|
||
|
||
/* Must check for uniqueness of all objects if we've traversed an elink,
|
||
* otherwise only check if the reference count > 1.
|
||
*/
|
||
if(oinfo.rc > 1 || hit_elink) {
|
||
obj_t *found_obj; /* Found object */
|
||
|
||
found_obj = search_obj(type_table, oinfo.addr);
|
||
|
||
if (found_obj == NULL) {
|
||
error_msg("internal error (file %s:line %d)\n",
|
||
__FILE__, __LINE__);
|
||
h5tools_setstatus(EXIT_FAILURE);
|
||
goto done;
|
||
}
|
||
else if (found_obj->displayed) {
|
||
printf("%s \"%s\"\n", HARDLINK, found_obj->objname);
|
||
goto done;
|
||
}
|
||
else
|
||
found_obj->displayed = TRUE;
|
||
} /* end if */
|
||
|
||
print_datatype(tid, 1);
|
||
if(H5Tget_class(tid) != H5T_COMPOUND)
|
||
printf(";\n");
|
||
|
||
/* print attributes */
|
||
indent += COL;
|
||
|
||
/* attribute iteration: if there is a request to do H5_INDEX_CRT_ORDER and tracking order is set
|
||
in the datatype's create property list for attributes, then, sort by creation order, otherwise by name */
|
||
|
||
if( (sort_by == H5_INDEX_CRT_ORDER) && (attr_crt_order_flags & H5P_CRT_ORDER_TRACKED)) {
|
||
if(H5Aiterate2(tid, sort_by, sort_order, NULL, dump_attr_cb, NULL) < 0) {
|
||
error_msg("error getting attribute information\n");
|
||
h5tools_setstatus(EXIT_FAILURE);
|
||
} /* end if */
|
||
} /* end if */
|
||
else {
|
||
if(H5Aiterate2(tid, H5_INDEX_NAME, sort_order, NULL, dump_attr_cb, NULL) < 0) {
|
||
error_msg("error getting attribute information\n");
|
||
h5tools_setstatus(EXIT_FAILURE);
|
||
} /* end if */
|
||
} /* end else */
|
||
|
||
indent -= COL;
|
||
|
||
done:
|
||
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_cb -- add parameter to select everything.
|
||
*
|
||
* Pedro Vicente, October 1, 2007
|
||
* handle several iteration orders for attributes and groups
|
||
*
|
||
*-------------------------------------------------------------------------
|
||
*/
|
||
static void
|
||
dump_group(hid_t gid, const char *name)
|
||
{
|
||
H5O_info_t oinfo;
|
||
hid_t dset, type;
|
||
char type_name[1024], *tmp;
|
||
unsigned crt_order_flags;
|
||
unsigned attr_crt_order_flags;
|
||
hid_t gcpl_id;
|
||
|
||
|
||
if ((gcpl_id = H5Gget_create_plist(gid)) < 0)
|
||
{
|
||
error_msg("error in getting group creation property list ID\n");
|
||
h5tools_setstatus(EXIT_FAILURE);
|
||
}
|
||
|
||
/* query the group creation properties for attributes */
|
||
if (H5Pget_attr_creation_order(gcpl_id, &attr_crt_order_flags) < 0)
|
||
{
|
||
error_msg("error in getting group creation properties\n");
|
||
h5tools_setstatus(EXIT_FAILURE);
|
||
}
|
||
|
||
/* query the group creation properties */
|
||
if(H5Pget_link_creation_order(gcpl_id, &crt_order_flags) < 0)
|
||
{
|
||
error_msg("error in getting group creation properties\n");
|
||
h5tools_setstatus(EXIT_FAILURE);
|
||
}
|
||
|
||
if(H5Pclose(gcpl_id) < 0) {
|
||
error_msg("error in closing group creation property list ID\n");
|
||
h5tools_setstatus(EXIT_FAILURE);
|
||
}
|
||
|
||
|
||
tmp = (char *)HDmalloc(HDstrlen(prefix) + HDstrlen(name) + 2);
|
||
HDstrcpy(tmp, prefix);
|
||
indentation(indent);
|
||
begin_obj(dump_header_format->groupbegin, name, dump_header_format->groupblockbegin);
|
||
indent += COL;
|
||
|
||
if(display_oid)
|
||
dump_oid(gid);
|
||
|
||
dump_comment(gid);
|
||
|
||
if(!HDstrcmp(name, "/") && unamedtype) {
|
||
unsigned u; /* Local index variable */
|
||
|
||
/* dump unamed type in root group */
|
||
for(u = 0; u < type_table->nobjs; u++)
|
||
if(!type_table->objs[u].recorded) {
|
||
dset = H5Dopen2(gid, type_table->objs[u].objname, H5P_DEFAULT);
|
||
type = H5Dget_type(dset);
|
||
sprintf(type_name, "#"H5_PRINTF_HADDR_FMT, type_table->objs[u].objno);
|
||
dump_function_table->dump_named_datatype_function(type, type_name);
|
||
H5Tclose(type);
|
||
H5Dclose(dset);
|
||
}
|
||
} /* end if */
|
||
|
||
H5Oget_info(gid, &oinfo);
|
||
|
||
/* Must check for uniqueness of all objects if we've traversed an elink,
|
||
* otherwise only check if the reference count > 1.
|
||
*/
|
||
if(oinfo.rc > 1 || hit_elink) {
|
||
obj_t *found_obj; /* Found object */
|
||
|
||
found_obj = search_obj(group_table, oinfo.addr);
|
||
|
||
if (found_obj == NULL) {
|
||
indentation(indent);
|
||
error_msg("internal error (file %s:line %d)\n", __FILE__, __LINE__);
|
||
h5tools_setstatus(EXIT_FAILURE);
|
||
}
|
||
else if (found_obj->displayed) {
|
||
indentation(indent);
|
||
printf("%s \"%s\"\n", HARDLINK, found_obj->objname);
|
||
}
|
||
else {
|
||
found_obj->displayed = TRUE;
|
||
/* attribute iteration: if there is a request to do H5_INDEX_CRT_ORDER and tracking order is set
|
||
in the group for attributes, then, sort by creation order, otherwise by name */
|
||
|
||
if((sort_by == H5_INDEX_CRT_ORDER) && (attr_crt_order_flags & H5P_CRT_ORDER_TRACKED)) {
|
||
if(H5Aiterate2(gid, sort_by, sort_order, NULL, dump_attr_cb, NULL) < 0) {
|
||
error_msg("error getting attribute information\n");
|
||
h5tools_setstatus(EXIT_FAILURE);
|
||
} /* end if */
|
||
} /* end if */
|
||
else {
|
||
if(H5Aiterate2(gid, H5_INDEX_NAME, sort_order, NULL, dump_attr_cb, NULL) < 0) {
|
||
error_msg("error getting attribute information\n");
|
||
h5tools_setstatus(EXIT_FAILURE);
|
||
} /* end if */
|
||
} /* end else */
|
||
|
||
/* if there is a request to do H5_INDEX_CRT_ORDER and tracking order is set
|
||
in the group, then, sort by creation order, otherwise by name */
|
||
|
||
if((sort_by == H5_INDEX_CRT_ORDER) && (crt_order_flags & H5P_CRT_ORDER_TRACKED))
|
||
H5Literate(gid, sort_by, sort_order, NULL, dump_all_cb, NULL);
|
||
else
|
||
H5Literate(gid, H5_INDEX_NAME, sort_order, NULL, dump_all_cb, NULL);
|
||
|
||
}
|
||
}
|
||
|
||
|
||
else
|
||
{
|
||
|
||
/* attribute iteration: if there is a request to do H5_INDEX_CRT_ORDER and tracking order is set
|
||
in the group for attributes, then, sort by creation order, otherwise by name */
|
||
|
||
if((sort_by == H5_INDEX_CRT_ORDER) && (attr_crt_order_flags & H5P_CRT_ORDER_TRACKED)) {
|
||
if(H5Aiterate2(gid, sort_by, sort_order, NULL, dump_attr_cb, NULL) < 0) {
|
||
error_msg("error getting attribute information\n");
|
||
h5tools_setstatus(EXIT_FAILURE);
|
||
} /* end if */
|
||
} /* end if */
|
||
else {
|
||
if(H5Aiterate2(gid, H5_INDEX_NAME, sort_order, NULL, dump_attr_cb, NULL) < 0) {
|
||
error_msg("error getting attribute information\n");
|
||
h5tools_setstatus(EXIT_FAILURE);
|
||
} /* end if */
|
||
} /* end else */
|
||
|
||
/* if there is a request to do H5_INDEX_CRT_ORDER and tracking order is set
|
||
in the group, then, sort by creation order, otherwise by name */
|
||
|
||
if((sort_by == H5_INDEX_CRT_ORDER) && (crt_order_flags & H5P_CRT_ORDER_TRACKED))
|
||
H5Literate(gid, sort_by, sort_order, NULL, dump_all_cb, NULL);
|
||
else
|
||
H5Literate(gid, H5_INDEX_NAME, sort_order, NULL, dump_all_cb, NULL);
|
||
|
||
|
||
}
|
||
|
||
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:
|
||
* Pedro Vicente, 2004, added dataset creation property list display
|
||
* Pedro Vicente, October 4, 2007, added parameters to H5Aiterate2() to allow for
|
||
* other iteration orders
|
||
*
|
||
*-------------------------------------------------------------------------
|
||
*/
|
||
static void
|
||
dump_dataset(hid_t did, const char *name, struct subset_t *sset)
|
||
{
|
||
hid_t type, space;
|
||
unsigned attr_crt_order_flags;
|
||
hid_t dcpl_id; /* dataset creation property list ID */
|
||
|
||
|
||
if ((dcpl_id = H5Dget_create_plist(did)) < 0)
|
||
{
|
||
error_msg("error in getting creation property list ID\n");
|
||
h5tools_setstatus(EXIT_FAILURE);
|
||
}
|
||
|
||
/* query the creation properties for attributes */
|
||
if (H5Pget_attr_creation_order(dcpl_id, &attr_crt_order_flags) < 0)
|
||
{
|
||
error_msg("error in getting creation properties\n");
|
||
h5tools_setstatus(EXIT_FAILURE);
|
||
}
|
||
|
||
indentation(indent);
|
||
begin_obj(dump_header_format->datasetbegin, name,
|
||
dump_header_format->datasetblockbegin);
|
||
|
||
type = H5Dget_type(did);
|
||
space = H5Dget_space(did);
|
||
|
||
dump_comment(did);
|
||
dump_datatype(type);
|
||
dump_dataspace(space);
|
||
|
||
if(display_oid)
|
||
dump_oid(did);
|
||
|
||
if(display_dcpl)
|
||
dump_dcpl(dcpl_id, type, 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, sset, display_ai);
|
||
break;
|
||
|
||
default:
|
||
break;
|
||
} /* end switch */
|
||
|
||
indent += COL;
|
||
|
||
if ( !bin_output )
|
||
{
|
||
|
||
/* attribute iteration: if there is a request to do H5_INDEX_CRT_ORDER and tracking order is set
|
||
in the group for attributes, then, sort by creation order, otherwise by name */
|
||
|
||
if( (sort_by == H5_INDEX_CRT_ORDER) && (attr_crt_order_flags & H5P_CRT_ORDER_TRACKED)) {
|
||
if(H5Aiterate2(did, sort_by, sort_order, NULL, dump_attr_cb, NULL) < 0) {
|
||
error_msg("error getting attribute information\n");
|
||
h5tools_setstatus(EXIT_FAILURE);
|
||
} /* end if */
|
||
} /* end if */
|
||
else {
|
||
if(H5Aiterate2(did, H5_INDEX_NAME, sort_order, NULL, dump_attr_cb, NULL) < 0) {
|
||
error_msg("error getting attribute information\n");
|
||
h5tools_setstatus(EXIT_FAILURE);
|
||
} /* end if */
|
||
} /* end else */
|
||
|
||
}
|
||
|
||
indent -= COL;
|
||
|
||
H5Tclose(type);
|
||
H5Sclose(space);
|
||
H5Pclose(dcpl_id);
|
||
|
||
|
||
indentation(indent);
|
||
end_obj(dump_header_format->datasetend,dump_header_format->datasetblockend);
|
||
}
|
||
|
||
/*-------------------------------------------------------------------------
|
||
* Function: dump_dims
|
||
*
|
||
* Purpose: Dump the dimensions handed to it in a comma separated list
|
||
*
|
||
* Return: void
|
||
*
|
||
* Programmer: Bill Wendling
|
||
* Tuesday, 27. February 2001
|
||
*
|
||
* Modifications:
|
||
*
|
||
*-------------------------------------------------------------------------
|
||
*/
|
||
static void
|
||
dump_dims(hsize_t *s, int dims)
|
||
{
|
||
int i;
|
||
|
||
for (i = 0; i < dims; i++) {
|
||
printf(HSIZE_T_FORMAT, s[i]);
|
||
|
||
if (i + 1 != dims)
|
||
printf(", ");
|
||
}
|
||
}
|
||
|
||
/*-------------------------------------------------------------------------
|
||
* Function: dump_subsetting_header
|
||
*
|
||
* Purpose: Dump the subsetting header like specified in the DDL.
|
||
*
|
||
* Return: void
|
||
*
|
||
* Programmer: Bill Wendling
|
||
* Tuesday, 27. February 2001
|
||
*
|
||
* Modifications:
|
||
*
|
||
*-------------------------------------------------------------------------
|
||
*/
|
||
static void
|
||
dump_subsetting_header(struct subset_t *sset, int dims)
|
||
{
|
||
indentation(indent);
|
||
printf("%s %s\n", dump_header_format->subsettingbegin,
|
||
dump_header_format->subsettingblockbegin);
|
||
|
||
indent += COL;
|
||
indentation(indent);
|
||
printf("%s %s ", dump_header_format->startbegin,
|
||
dump_header_format->startblockbegin);
|
||
dump_dims(sset->start.data, dims);
|
||
printf("%s %s\n", dump_header_format->startend,
|
||
dump_header_format->startblockend);
|
||
|
||
indentation(indent);
|
||
printf("%s %s ", dump_header_format->stridebegin,
|
||
dump_header_format->strideblockbegin);
|
||
dump_dims(sset->stride.data, dims);
|
||
printf("%s %s\n", dump_header_format->strideend,
|
||
dump_header_format->strideblockend);
|
||
|
||
indentation(indent);
|
||
printf("%s %s ", dump_header_format->countbegin,
|
||
dump_header_format->countblockbegin);
|
||
|
||
if(sset->count.data)
|
||
dump_dims(sset->count.data, dims);
|
||
else
|
||
printf("DEFAULT");
|
||
|
||
printf("%s %s\n", dump_header_format->countend,
|
||
dump_header_format->countblockend);
|
||
|
||
indentation(indent);
|
||
printf("%s %s ", dump_header_format->blockbegin,
|
||
dump_header_format->blockblockbegin);
|
||
|
||
if(sset->block.data)
|
||
dump_dims(sset->block.data, dims);
|
||
else
|
||
printf("DEFAULT");
|
||
|
||
printf("%s %s\n", dump_header_format->blockend,
|
||
dump_header_format->blockblockend);
|
||
}
|
||
|
||
/*-------------------------------------------------------------------------
|
||
* Function: dump_data
|
||
*
|
||
* Purpose: Dump attribute or dataset data
|
||
*
|
||
* Return: void
|
||
*
|
||
* Programmer: Ruey-Hsia Li
|
||
*
|
||
* Modifications: pvn, print the matrix indices
|
||
* Albert Cheng, 2004/11/18
|
||
* Add --string printing for attributes too.
|
||
*
|
||
*-------------------------------------------------------------------------
|
||
*/
|
||
static void
|
||
dump_data(hid_t obj_id, int obj_data, struct subset_t *sset, int display_index)
|
||
{
|
||
h5tool_format_t *outputformat = &dataformat;
|
||
int status = -1;
|
||
void *buf;
|
||
hid_t space, type, p_type;
|
||
H5S_class_t space_type;
|
||
int ndims, i;
|
||
hsize_t size[64], nelmts = 1, alloc_size;
|
||
int depth;
|
||
int stdindent = COL; /* should be 3 */
|
||
|
||
if (fp_format)
|
||
{
|
||
outputformat->fmt_double = fp_format;
|
||
outputformat->fmt_float = fp_format;
|
||
}
|
||
|
||
if (nCols==0) {
|
||
outputformat->line_ncols = 65535;
|
||
outputformat->line_per_line = 1;
|
||
}
|
||
else
|
||
outputformat->line_ncols = nCols;
|
||
outputformat->do_escape=display_escape;
|
||
/* print the matrix indices */
|
||
outputformat->pindex=display_index;
|
||
|
||
/* do not print indices for regions */
|
||
if(obj_data == DATASET_DATA) {
|
||
hid_t f_type = H5Dget_type(obj_id);
|
||
|
||
if (H5Tequal(f_type, H5T_STD_REF_DSETREG)) {
|
||
/* For the region option, correct the display of indices */
|
||
if (display_region) {
|
||
if (display_index) {
|
||
outputformat->pindex = 1;
|
||
outputformat->idx_fmt = "(%s): ";
|
||
outputformat->idx_n_fmt = HSIZE_T_FORMAT;
|
||
outputformat->idx_sep = ",";
|
||
outputformat->line_pre = "%s";
|
||
}
|
||
else {
|
||
outputformat->pindex = 0;
|
||
outputformat->idx_fmt = "";
|
||
outputformat->idx_n_fmt = "";
|
||
outputformat->idx_sep = "";
|
||
outputformat->line_pre = "";
|
||
}
|
||
}
|
||
else
|
||
outputformat->pindex = 0;
|
||
}
|
||
H5Tclose(f_type);
|
||
}
|
||
|
||
if (outputformat->pindex) {
|
||
outputformat->idx_fmt = "(%s): ";
|
||
outputformat->idx_n_fmt = HSIZE_T_FORMAT;
|
||
outputformat->idx_sep = ",";
|
||
outputformat->line_pre = "%s";
|
||
}
|
||
|
||
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;
|
||
|
||
if (sset && obj_data == DATASET_DATA) {
|
||
hid_t f_space = H5Dget_space(obj_id);
|
||
|
||
dump_subsetting_header(sset, H5Sget_simple_extent_ndims(f_space));
|
||
H5Sclose(f_space);
|
||
|
||
/* recalculate the depth of the data */
|
||
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) {
|
||
hid_t f_type = H5Dget_type(obj_id);
|
||
char string_prefix[64];
|
||
h5tool_format_t string_dataformat;
|
||
|
||
if(display_char && H5Tget_size(f_type) == 1 && H5Tget_class(f_type) == H5T_INTEGER) {
|
||
/*
|
||
* Print 1-byte integer data as an ASCII character string
|
||
* instead of integers if the `-r' or `--string' command-line
|
||
* option was given.
|
||
*
|
||
* We don't want to modify the global dataformat, so make a
|
||
* copy of it instead.
|
||
*/
|
||
string_dataformat = *outputformat;
|
||
string_dataformat.idx_fmt = " ";
|
||
string_dataformat.line_multi_new = 1;
|
||
string_dataformat.line_1st = " %s\"";
|
||
string_dataformat.line_pre = " %s";
|
||
string_dataformat.line_cont = " %s";
|
||
string_dataformat.str_repeat = 8;
|
||
string_dataformat.ascii = TRUE;
|
||
string_dataformat.elmt_suf1 = "";
|
||
string_dataformat.elmt_suf2 = "";
|
||
string_dataformat.line_indent = "";
|
||
strcpy(string_prefix, string_dataformat.line_pre);
|
||
strcat(string_prefix, "\"");
|
||
string_dataformat.line_pre = string_prefix;
|
||
string_dataformat.line_suf = "\"";
|
||
outputformat = &string_dataformat;
|
||
}
|
||
|
||
|
||
status = h5tools_dump_dset(stdout, outputformat, obj_id, -1, sset, depth);
|
||
|
||
H5Tclose(f_type);
|
||
}
|
||
else {
|
||
/* need to call h5tools_dump_mem for the attribute data */
|
||
space = H5Aget_space(obj_id);
|
||
space_type = H5Sget_simple_extent_type(space);
|
||
if(space_type == H5S_NULL || space_type == H5S_NO_CLASS) {
|
||
status = SUCCEED;
|
||
}
|
||
else {
|
||
char string_prefix[64];
|
||
h5tool_format_t string_dataformat;
|
||
|
||
type = H5Aget_type(obj_id);
|
||
p_type = h5tools_get_native_type(type);
|
||
|
||
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)
|
||
if (display_char && H5Tget_size(type) == 1 && H5Tget_class(type) == H5T_INTEGER) {
|
||
/*
|
||
* Print 1-byte integer data as an ASCII character string
|
||
* instead of integers if the `-r' or `--string' command-line
|
||
* option was given.
|
||
*
|
||
* We don't want to modify the global dataformat, so make a
|
||
* copy of it instead.
|
||
*/
|
||
string_dataformat = *outputformat;
|
||
string_dataformat.idx_fmt = " ";
|
||
string_dataformat.line_multi_new = 1;
|
||
string_dataformat.line_1st = " %s\"";
|
||
string_dataformat.line_pre = " %s";
|
||
string_dataformat.line_cont = " %s";
|
||
string_dataformat.str_repeat = 8;
|
||
string_dataformat.ascii = TRUE;
|
||
string_dataformat.elmt_suf1 = "";
|
||
string_dataformat.elmt_suf2 = "";
|
||
string_dataformat.line_indent = "";
|
||
strcpy(string_prefix, string_dataformat.line_pre);
|
||
strcat(string_prefix, "\"");
|
||
string_dataformat.line_pre = string_prefix;
|
||
string_dataformat.line_suf = "\"";
|
||
outputformat = &string_dataformat;
|
||
}
|
||
|
||
status = h5tools_dump_mem(stdout, outputformat, obj_id, p_type,
|
||
space, buf, depth);
|
||
|
||
free(buf);
|
||
H5Tclose(p_type);
|
||
H5Tclose(type);
|
||
}
|
||
H5Sclose(space);
|
||
}
|
||
|
||
if (status == FAIL) {
|
||
indentation(indent + COL);
|
||
error_msg("unable to print data\n");
|
||
h5tools_setstatus(EXIT_FAILURE);
|
||
}
|
||
|
||
indentation(indent);
|
||
end_obj(dump_header_format->dataend, dump_header_format->datablockend);
|
||
indent -= COL;
|
||
|
||
if (sset && obj_data == DATASET_DATA) {
|
||
indentation(indent);
|
||
end_obj(dump_header_format->subsettingend,
|
||
dump_header_format->subsettingblockend);
|
||
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: dump_comment
|
||
*
|
||
* Purpose: prints the comment for the the object name
|
||
*
|
||
* Return: void
|
||
*
|
||
* Programmer: pvn
|
||
*
|
||
* Modifications:
|
||
*
|
||
*-------------------------------------------------------------------------
|
||
*/
|
||
static void
|
||
dump_comment(hid_t obj_id)
|
||
{
|
||
char comment[50];
|
||
|
||
comment[0] = '\0';
|
||
H5Oget_comment(obj_id, comment, sizeof(comment));
|
||
|
||
if(comment[0]) {
|
||
indentation(indent);
|
||
printf("COMMENT \"%s\"\n", comment);
|
||
} /* end if */
|
||
} /* end dump_comment() */
|
||
|
||
|
||
/*-------------------------------------------------------------------------
|
||
* Function: dump_fill_value
|
||
*
|
||
* Purpose: prints the fill value
|
||
*
|
||
* Return: void
|
||
*
|
||
* Programmer: pvn
|
||
*
|
||
* Modifications:
|
||
*
|
||
*-------------------------------------------------------------------------
|
||
*/
|
||
|
||
static void dump_fill_value(hid_t dcpl,hid_t type_id, hid_t obj_id)
|
||
{
|
||
h5tools_context_t ctx; /*print context */
|
||
size_t size;
|
||
void *buf=NULL;
|
||
hsize_t nelmts=1;
|
||
h5tool_format_t *outputformat = &dataformat;
|
||
hid_t n_type;
|
||
|
||
memset(&ctx, 0, sizeof(ctx));
|
||
ctx.indent_level=2;
|
||
|
||
n_type = h5tools_get_native_type(type_id);
|
||
|
||
size = H5Tget_size(n_type);
|
||
buf = malloc(size);
|
||
|
||
H5Pget_fill_value(dcpl, n_type, buf);
|
||
|
||
h5tools_dump_simple_data(stdout, outputformat, obj_id, &ctx, START_OF_DATA | END_OF_DATA, nelmts, n_type, buf);
|
||
|
||
H5Tclose(n_type);
|
||
|
||
if (buf)
|
||
free (buf);
|
||
}
|
||
|
||
|
||
/*-------------------------------------------------------------------------
|
||
* Function: dump_dcpl
|
||
*
|
||
* Purpose: prints several dataset create property list properties
|
||
*
|
||
* Return: void
|
||
*
|
||
* Programmer: pvn
|
||
*
|
||
* Modifications: pvn, March 28, 2008
|
||
* Add a COMPRESSION ratio information for cases when filters are present
|
||
*
|
||
*-------------------------------------------------------------------------
|
||
*/
|
||
static void
|
||
dump_dcpl(hid_t dcpl_id,hid_t type_id, hid_t obj_id)
|
||
{
|
||
int nfilters; /* number of filters */
|
||
unsigned filt_flags; /* filter flags */
|
||
H5Z_filter_t filtn; /* filter identification number */
|
||
unsigned cd_values[20]; /* filter client data values */
|
||
size_t cd_nelmts; /* filter client number of values */
|
||
char f_name[256]; /* filter name */
|
||
unsigned szip_options_mask;
|
||
unsigned szip_pixels_per_block;
|
||
hsize_t chsize[64]; /* chunk size in elements */
|
||
int rank; /* rank */
|
||
char name[256]; /* external file name */
|
||
off_t offset; /* offset of external file */
|
||
hsize_t size; /* size of external file */
|
||
H5D_fill_value_t fvstatus;
|
||
H5D_alloc_time_t at;
|
||
H5D_fill_time_t ft;
|
||
hsize_t storage_size;
|
||
haddr_t ioffset;
|
||
int i;
|
||
unsigned j;
|
||
|
||
storage_size = H5Dget_storage_size(obj_id);
|
||
nfilters = H5Pget_nfilters(dcpl_id);
|
||
ioffset = H5Dget_offset(obj_id);
|
||
HDstrcpy(f_name,"\0");
|
||
|
||
/*-------------------------------------------------------------------------
|
||
* STORAGE_LAYOUT
|
||
*-------------------------------------------------------------------------
|
||
*/
|
||
indentation(indent + COL);
|
||
printf("%s %s\n", STORAGE_LAYOUT, BEGIN);
|
||
|
||
if (H5D_CHUNKED == H5Pget_layout(dcpl_id)) {
|
||
/*start indent */
|
||
indent += COL;
|
||
indentation(indent + COL);
|
||
printf("%s ", CHUNKED);
|
||
|
||
rank = H5Pget_chunk(dcpl_id,NELMTS(chsize),chsize);
|
||
HDfprintf(stdout,"%s %Hu", dump_header_format->dataspacedimbegin, chsize[0]);
|
||
for ( i=1; i<rank; i++)
|
||
HDfprintf(stdout, ", %Hu", chsize[i]);
|
||
printf(" %s\n", dump_header_format->dataspacedimend);
|
||
indentation(indent + COL);
|
||
|
||
|
||
/* if there are filters, print a compression ratio */
|
||
if ( nfilters )
|
||
{
|
||
|
||
hid_t sid = H5Dget_space( obj_id );
|
||
hid_t tid = H5Dget_type( obj_id );
|
||
size_t datum_size = H5Tget_size( tid );
|
||
hsize_t dims[H5S_MAX_RANK];
|
||
int ndims = H5Sget_simple_extent_dims( sid, dims, NULL);
|
||
hsize_t nelmts = 1;
|
||
double ratio = 0;
|
||
int ok = 0;
|
||
|
||
/* only print the compression ratio for these filters */
|
||
for ( i = 0; i < nfilters; i++)
|
||
{
|
||
cd_nelmts = NELMTS(cd_values);
|
||
filtn = H5Pget_filter2(dcpl_id, (unsigned)i, &filt_flags, &cd_nelmts,
|
||
cd_values, sizeof(f_name), f_name, NULL);
|
||
|
||
switch (filtn)
|
||
{
|
||
case H5Z_FILTER_DEFLATE:
|
||
case H5Z_FILTER_SZIP:
|
||
case H5Z_FILTER_NBIT:
|
||
case H5Z_FILTER_SCALEOFFSET:
|
||
ok = 1;
|
||
break;
|
||
}
|
||
}
|
||
|
||
if (ndims && ok )
|
||
{
|
||
hsize_t uncomp_size;
|
||
|
||
for (i = 0; i < ndims; i++)
|
||
{
|
||
nelmts *= dims[i];
|
||
}
|
||
uncomp_size = nelmts * datum_size;
|
||
|
||
/* compression ratio = uncompressed size / compressed size */
|
||
|
||
if (storage_size != 0)
|
||
ratio = (double) uncomp_size / (double) storage_size;
|
||
|
||
HDfprintf(stdout, "SIZE %Hu (%.3f:1 COMPRESSION)\n ", storage_size, ratio);
|
||
|
||
}
|
||
else
|
||
HDfprintf(stdout, "SIZE %Hu\n ", storage_size);
|
||
|
||
|
||
H5Sclose(sid);
|
||
H5Tclose(tid);
|
||
|
||
}
|
||
else
|
||
{
|
||
HDfprintf(stdout, "SIZE %Hu\n ", storage_size);
|
||
}
|
||
|
||
/*end indent */
|
||
indent -= COL;
|
||
indentation(indent + COL);
|
||
printf("%s\n",END);
|
||
}
|
||
else if (H5D_COMPACT == H5Pget_layout(dcpl_id)) {
|
||
/*start indent */
|
||
indent += COL;
|
||
indentation(indent + COL);
|
||
printf("%s\n", COMPACT);
|
||
|
||
indentation(indent + COL);
|
||
HDfprintf(stdout, "SIZE %Hu\n", storage_size);
|
||
|
||
/*end indent */
|
||
indent -= COL;
|
||
indentation(indent + COL);
|
||
printf("%s\n",END);
|
||
}
|
||
else if (H5D_CONTIGUOUS == H5Pget_layout(dcpl_id)) {
|
||
int next;
|
||
|
||
next = H5Pget_external_count(dcpl_id);
|
||
|
||
/*-------------------------------------------------------------------------
|
||
* EXTERNAL_FILE
|
||
*-------------------------------------------------------------------------
|
||
*/
|
||
if (next) {
|
||
/*start indent */
|
||
indent += COL;
|
||
indentation(indent + COL);
|
||
printf("%s\n", CONTIGUOUS);
|
||
|
||
indentation(indent + COL);
|
||
printf("%s %s\n", EXTERNAL, BEGIN);
|
||
|
||
/*start indent */
|
||
indent += COL;
|
||
for ( j=0; j<(unsigned)next; j++) {
|
||
H5Pget_external(dcpl_id,j,sizeof(name),name,&offset,&size);
|
||
indentation(indent + COL);
|
||
HDfprintf(stdout,"FILENAME %s SIZE %Hu OFFSET %ld\n",name,size,offset);
|
||
}
|
||
/*end indent */
|
||
indent -= COL;
|
||
indentation(indent + COL);
|
||
printf("%s\n",END);
|
||
|
||
/*end indent */
|
||
indent -= COL;
|
||
indentation(indent + COL);
|
||
printf("%s\n",END);
|
||
}
|
||
else {
|
||
/*start indent */
|
||
indent += COL;
|
||
indentation(indent + COL);
|
||
printf("%s\n", CONTIGUOUS);
|
||
|
||
indentation(indent + COL);
|
||
HDfprintf(stdout,"SIZE %Hu\n", storage_size);
|
||
indentation(indent + COL);
|
||
HDfprintf(stdout,"OFFSET %Hu\n", ioffset);
|
||
|
||
/*end indent */
|
||
indent -= COL;
|
||
indentation(indent + COL);
|
||
printf("%s\n",END);
|
||
}
|
||
}
|
||
/*-------------------------------------------------------------------------
|
||
* FILTERS
|
||
*-------------------------------------------------------------------------
|
||
*/
|
||
|
||
|
||
indentation(indent + COL);
|
||
printf("%s %s\n", FILTERS, BEGIN);
|
||
indent += COL;
|
||
|
||
if (nfilters) {
|
||
for (i=0; i<nfilters; i++) {
|
||
cd_nelmts = NELMTS(cd_values);
|
||
filtn = H5Pget_filter2(dcpl_id, (unsigned)i, &filt_flags, &cd_nelmts,
|
||
cd_values, sizeof(f_name), f_name, NULL);
|
||
|
||
switch (filtn) {
|
||
case H5Z_FILTER_DEFLATE:
|
||
indentation(indent + COL);
|
||
printf("%s %s %s %d %s\n", DEFLATE, BEGIN, DEFLATE_LEVEL, cd_values[0], END);
|
||
break;
|
||
case H5Z_FILTER_SHUFFLE:
|
||
indentation(indent + COL);
|
||
printf("%s\n", SHUFFLE);
|
||
break;
|
||
case H5Z_FILTER_FLETCHER32:
|
||
indentation(indent + COL);
|
||
printf("%s\n", FLETCHER32);
|
||
break;
|
||
case H5Z_FILTER_SZIP:
|
||
{
|
||
szip_options_mask=cd_values[0];;
|
||
szip_pixels_per_block=cd_values[1];
|
||
|
||
indentation(indent + COL);
|
||
printf("%s %s\n",SZIP, BEGIN);
|
||
|
||
/*start indent */
|
||
indent += COL;
|
||
indentation(indent + COL);
|
||
printf("PIXELS_PER_BLOCK %d\n", szip_pixels_per_block);
|
||
|
||
indentation(indent + COL);
|
||
if (szip_options_mask & H5_SZIP_CHIP_OPTION_MASK)
|
||
printf("MODE %s\n", "HARDWARE");
|
||
else if (szip_options_mask & H5_SZIP_ALLOW_K13_OPTION_MASK)
|
||
printf("MODE %s\n", "K13");
|
||
|
||
indentation(indent + COL);
|
||
if (szip_options_mask & H5_SZIP_EC_OPTION_MASK)
|
||
printf("CODING %s\n", "ENTROPY");
|
||
else if (szip_options_mask & H5_SZIP_NN_OPTION_MASK)
|
||
printf("CODING %s\n", "NEAREST NEIGHBOUR");
|
||
|
||
indentation(indent + COL);
|
||
if (szip_options_mask & H5_SZIP_LSB_OPTION_MASK)
|
||
printf("BYTE_ORDER %s\n", "LSB");
|
||
else if (szip_options_mask & H5_SZIP_MSB_OPTION_MASK)
|
||
printf("BYTE_ORDER %s\n", "MSB");
|
||
|
||
indentation(indent + COL);
|
||
if (szip_options_mask & H5_SZIP_RAW_OPTION_MASK)
|
||
printf("HEADER %s\n", "RAW");
|
||
|
||
/*end indent */
|
||
indent -= COL;
|
||
indentation(indent + COL);
|
||
printf("%s\n",END);
|
||
}
|
||
break;
|
||
case H5Z_FILTER_NBIT:
|
||
indentation(indent + COL);
|
||
printf("%s\n", NBIT);
|
||
break;
|
||
case H5Z_FILTER_SCALEOFFSET:
|
||
indentation(indent + COL);
|
||
printf("%s %s %s %d %s\n", SCALEOFFSET, BEGIN, SCALEOFFSET_MINBIT, cd_values[0], END);
|
||
break;
|
||
default:
|
||
indentation(indent + COL);
|
||
if (H5Zfilter_avail(filtn))
|
||
printf("%s %s\n", "USER_REGISTERED_FILTER", BEGIN);
|
||
else
|
||
printf("%s %s\n", "UNKNOWN_FILTER", BEGIN);
|
||
/*start indent */
|
||
indent += COL;
|
||
indentation(indent + COL);
|
||
printf("FILTER_ID %d\n", filtn);
|
||
if (f_name[0]!='\0') {
|
||
indentation(indent + COL);
|
||
printf("COMMENT %s\n", f_name);
|
||
}
|
||
if (cd_nelmts) {
|
||
indentation(indent + COL);
|
||
printf("%s %s ","PARAMS", BEGIN);
|
||
for (j=0; j<cd_nelmts; j++)
|
||
printf("%d ", cd_values[j]);
|
||
printf("%s\n", END);
|
||
}
|
||
break;
|
||
}/*switch*/
|
||
} /*i*/
|
||
}/*nfilters*/
|
||
else {
|
||
indentation(indent + COL);
|
||
printf("NONE\n");
|
||
}
|
||
indent -= COL;
|
||
indentation(indent + COL);
|
||
printf("%s\n",END);
|
||
|
||
/*-------------------------------------------------------------------------
|
||
* FILLVALUE
|
||
*-------------------------------------------------------------------------
|
||
*/
|
||
indentation(indent + COL);
|
||
printf("%s %s\n", FILLVALUE, BEGIN);
|
||
/*start indent */
|
||
indent += COL;
|
||
indentation(indent + COL);
|
||
printf("FILL_TIME ");
|
||
H5Pget_fill_time(dcpl_id, &ft);
|
||
switch ( ft ) {
|
||
case H5D_FILL_TIME_ALLOC:
|
||
printf("%s", "H5D_FILL_TIME_ALLOC\n");
|
||
break;
|
||
case H5D_FILL_TIME_NEVER:
|
||
printf("%s", "H5D_FILL_TIME_NEVER\n");
|
||
break;
|
||
case H5D_FILL_TIME_IFSET:
|
||
printf("%s", "H5D_FILL_TIME_IFSET\n");
|
||
break;
|
||
default:
|
||
assert(0);
|
||
break;
|
||
}
|
||
indentation(indent + COL);
|
||
printf("%s ", "VALUE ");
|
||
H5Pfill_value_defined(dcpl_id, &fvstatus);
|
||
if (fvstatus == H5D_FILL_VALUE_UNDEFINED)
|
||
printf("%s\n", "H5D_FILL_VALUE_UNDEFINED");
|
||
else
|
||
dump_fill_value(dcpl_id,type_id,obj_id);
|
||
/* end indent */
|
||
indent -= COL;
|
||
indentation(indent + COL);
|
||
printf("\n");
|
||
indentation(indent + COL);
|
||
printf("%s\n",END);
|
||
|
||
/*-------------------------------------------------------------------------
|
||
* ALLOCATION_TIME
|
||
*-------------------------------------------------------------------------
|
||
*/
|
||
indentation(indent + COL);
|
||
printf("ALLOCATION_TIME %s\n",BEGIN);
|
||
/*start indent */
|
||
indent += COL;
|
||
indentation(indent + COL);
|
||
H5Pget_alloc_time(dcpl_id, &at);
|
||
switch (at) {
|
||
case H5D_ALLOC_TIME_EARLY:
|
||
printf("%s", "H5D_ALLOC_TIME_EARLY\n");
|
||
break;
|
||
case H5D_ALLOC_TIME_INCR:
|
||
printf("%s", "H5D_ALLOC_TIME_INCR\n");
|
||
break;
|
||
case H5D_ALLOC_TIME_LATE:
|
||
printf("%s", "H5D_ALLOC_TIME_LATE\n");
|
||
break;
|
||
default:
|
||
assert(0);
|
||
break;
|
||
}
|
||
/* end indent */
|
||
indent -= COL;
|
||
indentation(indent + COL);
|
||
printf("%s\n",END);
|
||
}
|
||
|
||
/*-------------------------------------------------------------------------
|
||
* Function: dump_fcpl
|
||
*
|
||
* Purpose: prints file creation property list information
|
||
*
|
||
* Return: void
|
||
*
|
||
* Programmer: pvn
|
||
*
|
||
* Modifications:
|
||
*
|
||
*-------------------------------------------------------------------------
|
||
*/
|
||
static void
|
||
dump_fcpl(hid_t fid)
|
||
{
|
||
hid_t fcpl; /* file creation property list ID */
|
||
hid_t fapl; /* file access property list ID */
|
||
hsize_t userblock; /* userblock size retrieved from FCPL */
|
||
size_t off_size; /* size of offsets in the file */
|
||
size_t len_size; /* size of lengths in the file */
|
||
hid_t fdriver; /* file driver */
|
||
char dname[32]; /* buffer to store driver name */
|
||
unsigned sym_lk; /* symbol table B-tree leaf 'K' value */
|
||
unsigned sym_ik; /* symbol table B-tree internal 'K' value */
|
||
unsigned istore_ik; /* indexed storage B-tree internal 'K' value */
|
||
H5F_file_space_type_t fs_strategy; /* file space strategy */
|
||
hsize_t fs_threshold; /* free-space section threshold */
|
||
H5F_info2_t finfo; /* file information */
|
||
|
||
fcpl=H5Fget_create_plist(fid);
|
||
H5Fget_info2(fid, &finfo);
|
||
H5Pget_userblock(fcpl,&userblock);
|
||
H5Pget_sizes(fcpl,&off_size,&len_size);
|
||
H5Pget_sym_k(fcpl,&sym_ik,&sym_lk);
|
||
H5Pget_istore_k(fcpl,&istore_ik);
|
||
H5Pget_file_space(fcpl, &fs_strategy, &fs_threshold);
|
||
H5Pclose(fcpl);
|
||
fapl=h5_fileaccess();
|
||
fdriver=H5Pget_driver(fapl);
|
||
H5Pclose(fapl);
|
||
|
||
/*-------------------------------------------------------------------------
|
||
* SUPER_BLOCK
|
||
*-------------------------------------------------------------------------
|
||
*/
|
||
printf("%s %s\n",SUPER_BLOCK, BEGIN);
|
||
indentation(indent + COL);
|
||
printf("%s %u\n","SUPERBLOCK_VERSION", finfo.super.version);
|
||
indentation(indent + COL);
|
||
printf("%s %u\n","FREELIST_VERSION", finfo.free.version);
|
||
indentation(indent + COL);
|
||
printf("%s %u\n","SYMBOLTABLE_VERSION", 0); /* Retain this for backward compatibility, for now (QAK) */
|
||
indentation(indent + COL);
|
||
printf("%s %u\n","OBJECTHEADER_VERSION", finfo.sohm.version);
|
||
indentation(indent + COL);
|
||
HDfprintf(stdout,"%s %Hd\n","OFFSET_SIZE", (long long)off_size);
|
||
indentation(indent + COL);
|
||
HDfprintf(stdout,"%s %Hd\n","LENGTH_SIZE", (long long)len_size);
|
||
indentation(indent + COL);
|
||
printf("%s %u\n","BTREE_RANK", sym_ik);
|
||
indentation(indent + COL);
|
||
printf("%s %d\n","BTREE_LEAF", sym_lk);
|
||
|
||
if (H5FD_CORE==fdriver)
|
||
HDstrcpy(dname,"H5FD_CORE");
|
||
#ifdef H5_HAVE_DIRECT
|
||
else if (H5FD_DIRECT==fdriver)
|
||
HDstrcpy(dname,"H5FD_DIRECT");
|
||
#endif
|
||
else if (H5FD_FAMILY==fdriver)
|
||
HDstrcpy(dname,"H5FD_FAMILY");
|
||
else if (H5FD_LOG==fdriver)
|
||
HDstrcpy(dname,"H5FD_LOG");
|
||
else if (H5FD_MPIO==fdriver)
|
||
HDstrcpy(dname,"H5FD_MPIO");
|
||
else if (H5FD_MULTI==fdriver)
|
||
HDstrcpy(dname,"H5FD_MULTI");
|
||
else if (H5FD_SEC2==fdriver)
|
||
HDstrcpy(dname,"H5FD_SEC2");
|
||
else if (H5FD_STDIO==fdriver)
|
||
HDstrcpy(dname,"H5FD_STDIO");
|
||
#ifdef H5_HAVE_STREAM
|
||
else if (H5FD_STREAM==fdriver)
|
||
HDstrcpy(dname,"H5FD_STREAM");
|
||
#endif
|
||
else
|
||
HDstrcpy(dname,"Unknown driver");
|
||
|
||
/* Take out this because the driver used can be different from the
|
||
* standard output. */
|
||
/*indentation(indent + COL);
|
||
printf("%s %s\n","FILE_DRIVER", dname);*/
|
||
indentation(indent + COL);
|
||
printf("%s %u\n","ISTORE_K", istore_ik);
|
||
|
||
indentation(indent + COL);
|
||
if(fs_strategy == H5F_FILE_SPACE_ALL_PERSIST)
|
||
printf("%s %s\n", "FILE_SPACE_STRATEGY", "H5F_FILE_SPACE_ALL_PERSIST");
|
||
else if(fs_strategy == H5F_FILE_SPACE_ALL)
|
||
printf("%s %s\n", "FILE_SPACE_STRATEGY", "H5F_FILE_SPACE_ALL");
|
||
else if(fs_strategy == H5F_FILE_SPACE_AGGR_VFD)
|
||
printf("%s %s\n", "FILE_SPACE_STRATEGY", "H5F_FILE_SPACE_AGGR_VFD");
|
||
else if(fs_strategy == H5F_FILE_SPACE_VFD)
|
||
printf("%s %s\n", "FILE_SPACE_STRATEGY", "H5F_FILE_SPACE_VFD");
|
||
else
|
||
printf("%s %s\n", "FILE_SPACE_STRATEGY", "Unknown strategy");
|
||
indentation(indent + COL);
|
||
HDfprintf(stdout, "%s %Hu\n","FREE_SPACE_THRESHOLD", fs_threshold);
|
||
|
||
printf("%s\n",END);
|
||
|
||
/*-------------------------------------------------------------------------
|
||
* USER_BLOCK
|
||
*-------------------------------------------------------------------------
|
||
*/
|
||
printf("USER_BLOCK %s\n",BEGIN);
|
||
indentation(indent + COL);
|
||
HDfprintf(stdout,"%s %Hu\n","USERBLOCK_SIZE", userblock);
|
||
printf("%s\n",END);
|
||
}
|
||
|
||
/*-------------------------------------------------------------------------
|
||
* Function: dump_fcontents
|
||
*
|
||
* Purpose: prints all objects
|
||
*
|
||
* Return: void
|
||
*
|
||
* Programmer: pvn
|
||
*
|
||
* Modifications:
|
||
*
|
||
*-------------------------------------------------------------------------
|
||
*/
|
||
|
||
static void dump_fcontents(hid_t fid)
|
||
{
|
||
|
||
printf("%s %s\n",FILE_CONTENTS, BEGIN);
|
||
|
||
/* special case of unamed types in root group */
|
||
if (unamedtype) {
|
||
unsigned u;
|
||
|
||
for (u = 0; u < type_table->nobjs; u++) {
|
||
if (!type_table->objs[u].recorded)
|
||
printf(" %-10s /#"H5_PRINTF_HADDR_FMT"\n", "datatype", type_table->objs[u].objno);
|
||
}
|
||
}
|
||
|
||
/* print objects in the files */
|
||
h5trav_print(fid);
|
||
|
||
printf(" %s\n",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:
|
||
* pvn June, 1, 2006. Add a switch for binary output
|
||
*
|
||
*-------------------------------------------------------------------------
|
||
*/
|
||
static int
|
||
set_output_file(const char *fname, int is_bin)
|
||
{
|
||
FILE *f; /* temporary holding place for the stream pointer
|
||
* so that rawdatastream is changed only when succeeded */
|
||
|
||
if (rawdatastream && rawdatastream != stdout) {
|
||
if (fclose(rawdatastream))
|
||
perror("closing rawdatastream");
|
||
else
|
||
rawdatastream = NULL;
|
||
}
|
||
|
||
/* binary output */
|
||
if (is_bin)
|
||
{
|
||
if ((f = fopen(fname, "wb")) != NULL) {
|
||
rawdatastream = f;
|
||
return 0;
|
||
}
|
||
}
|
||
else
|
||
{
|
||
if ((f = fopen(fname, "w")) != NULL) {
|
||
rawdatastream = f;
|
||
return 0;
|
||
}
|
||
}
|
||
|
||
return -1;
|
||
}
|
||
|
||
|
||
|
||
/*-------------------------------------------------------------------------
|
||
* Function: set_binary_form
|
||
*
|
||
* Purpose: set the binary form of output by translating from a string input
|
||
* parameter to a integer return value
|
||
*
|
||
* Return: integer form of binary output or -1 if none found
|
||
*
|
||
* Programmer: Pedro Vicente Nunes
|
||
* June 28, 2006
|
||
*
|
||
* Modifications:
|
||
*
|
||
*-------------------------------------------------------------------------
|
||
*/
|
||
static int
|
||
set_binary_form(const char *form)
|
||
{
|
||
int bform=-1;
|
||
|
||
if (strcmp(form,"NATIVE")==0 ||
|
||
strcmp(form,"MEMORY")==0)
|
||
{/* native form */
|
||
bform = 0;
|
||
}
|
||
else if (strcmp(form,"FILE")==0) /* file type form */
|
||
bform = 1;
|
||
else if (strcmp(form,"LE")==0) /* convert to little endian */
|
||
bform = 2;
|
||
else if (strcmp(form,"BE")==0) /* convert to big endian */
|
||
bform = 3;
|
||
|
||
return bform;
|
||
}
|
||
|
||
/*-------------------------------------------------------------------------
|
||
* Function: set_sort_by
|
||
*
|
||
* Purpose: set the "by" form of sorting by translating from a string input
|
||
* parameter to a H5_index_t return value
|
||
* current sort values are [creation_order | name]
|
||
*
|
||
* Return: H5_index_t form of sort or H5_INDEX_UNKNOWN if none found
|
||
*
|
||
* Programmer: Pedro Vicente Nunes
|
||
* October 1, 2007
|
||
*
|
||
* Modifications:
|
||
*
|
||
*-------------------------------------------------------------------------
|
||
*/
|
||
static H5_index_t
|
||
set_sort_by(const char *form)
|
||
{
|
||
H5_index_t idx_type = H5_INDEX_UNKNOWN;
|
||
|
||
if (strcmp(form,"name")==0) /* H5_INDEX_NAME */
|
||
idx_type = H5_INDEX_NAME;
|
||
else if (strcmp(form,"creation_order")==0) /* H5_INDEX_CRT_ORDER */
|
||
idx_type = H5_INDEX_CRT_ORDER;
|
||
|
||
return idx_type;
|
||
}
|
||
|
||
|
||
|
||
/*-------------------------------------------------------------------------
|
||
* Function: set_sort_order
|
||
*
|
||
* Purpose: set the order of sorting by translating from a string input
|
||
* parameter to a H5_iter_order_t return value
|
||
* current order values are [ascending | descending ]
|
||
*
|
||
* Return: H5_iter_order_t form of order or H5_ITER_UNKNOWN if none found
|
||
*
|
||
* Programmer: Pedro Vicente Nunes
|
||
* October 1, 2007
|
||
*
|
||
* Modifications:
|
||
*
|
||
*-------------------------------------------------------------------------
|
||
*/
|
||
static H5_iter_order_t
|
||
set_sort_order(const char *form)
|
||
{
|
||
H5_iter_order_t iter_order = H5_ITER_UNKNOWN;
|
||
|
||
if (strcmp(form,"ascending")==0) /* H5_ITER_INC */
|
||
iter_order = H5_ITER_INC;
|
||
else if (strcmp(form,"descending")==0) /* H5_ITER_DEC */
|
||
iter_order = H5_ITER_DEC;
|
||
|
||
return iter_order;
|
||
}
|
||
|
||
|
||
/*-------------------------------------------------------------------------
|
||
* Function: handle_attributes
|
||
*
|
||
* Purpose: Handle the attributes from the command.
|
||
*
|
||
* Return: void
|
||
*
|
||
* Programmer: Bill Wendling
|
||
* Tuesday, 9. January 2001
|
||
*
|
||
* Modifications:
|
||
*
|
||
* PVN, May 2008
|
||
* add an extra parameter PE, to allow printing/not printing of error messages
|
||
*
|
||
*-------------------------------------------------------------------------
|
||
*/
|
||
static void
|
||
handle_attributes(hid_t fid, const char *attr, void UNUSED * data, int UNUSED pe, const char UNUSED *display_name)
|
||
{
|
||
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: <none>
|
||
*
|
||
* Programmer: Bill Wendling
|
||
* Tuesday, 6. February 2001
|
||
*
|
||
*-------------------------------------------------------------------------
|
||
*/
|
||
static void
|
||
parse_hsize_list(const char *h_list, subset_d *d)
|
||
{
|
||
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;
|
||
|
||
/* 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;
|
||
|
||
/* allocate an array for the integers in the list */
|
||
p_list = (hsize_t *)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)atof(ptr);
|
||
|
||
while (isdigit(*ptr))
|
||
/* scroll to end of integer */
|
||
ptr++;
|
||
}
|
||
d->data = p_list;
|
||
d->len = size_count;
|
||
|
||
return;
|
||
}
|
||
|
||
/*-------------------------------------------------------------------------
|
||
* 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 = (struct subset_t *)calloc(1, sizeof(struct subset_t));
|
||
parse_hsize_list(brace, &s->start);
|
||
|
||
while (*brace && *brace != ';')
|
||
brace++;
|
||
|
||
if (*brace)
|
||
brace++;
|
||
|
||
parse_hsize_list(brace, &s->stride);
|
||
|
||
while (*brace && *brace != ';')
|
||
brace++;
|
||
|
||
if (*brace)
|
||
brace++;
|
||
|
||
parse_hsize_list(brace, &s->count);
|
||
|
||
while (*brace && *brace != ';')
|
||
brace++;
|
||
|
||
if (*brace)
|
||
brace++;
|
||
|
||
parse_hsize_list(brace, &s->block);
|
||
}
|
||
}
|
||
|
||
return s;
|
||
}
|
||
|
||
/*-------------------------------------------------------------------------
|
||
* Function: handle_datasets
|
||
*
|
||
* Purpose: Handle the datasets from the command.
|
||
*
|
||
* Return: void
|
||
*
|
||
* Programmer: Bill Wendling
|
||
* Tuesday, 9. January 2001
|
||
*
|
||
* Modifications:
|
||
* Pedro Vicente, Tuesday, January 15, 2008
|
||
* check for block overlap\
|
||
*
|
||
* Pedro Vicente, May 8, 2008
|
||
* added a flag PE that prints/not prints error messages
|
||
* added for cases of external links not found, to avoid printing of
|
||
* objects not found, since external links are dumped on a trial error basis
|
||
*
|
||
*-------------------------------------------------------------------------
|
||
*/
|
||
static void
|
||
handle_datasets(hid_t fid, const char *dset, void *data, int pe, const char *display_name)
|
||
{
|
||
H5O_info_t oinfo;
|
||
hid_t dsetid;
|
||
struct subset_t *sset = (struct subset_t *)data;
|
||
const char *real_name = display_name ? display_name : dset;
|
||
|
||
if((dsetid = H5Dopen2(fid, dset, H5P_DEFAULT)) < 0)
|
||
{
|
||
if (pe)
|
||
{
|
||
begin_obj(dump_header_format->datasetbegin, real_name,
|
||
dump_header_format->datasetblockbegin);
|
||
indentation(COL);
|
||
error_msg("unable to open dataset \"%s\"\n", real_name);
|
||
end_obj(dump_header_format->datasetend,
|
||
dump_header_format->datasetblockend);
|
||
h5tools_setstatus(EXIT_FAILURE);
|
||
}
|
||
return;
|
||
} /* end if */
|
||
|
||
if(sset) {
|
||
unsigned int i;
|
||
hid_t sid = H5Dget_space(dsetid);
|
||
unsigned int ndims = H5Sget_simple_extent_ndims(sid);
|
||
|
||
H5Sclose(sid);
|
||
|
||
if(!sset->start.data || !sset->stride.data || !sset->count.data || !sset->block.data) {
|
||
/* they didn't specify a ``stride'' or ``block''. default to 1 in all
|
||
* dimensions */
|
||
if(!sset->start.data) {
|
||
/* default to (0, 0, ...) for the start coord */
|
||
sset->start.data = (hsize_t *)calloc(ndims, sizeof(hsize_t));
|
||
sset->start.len = ndims;
|
||
}
|
||
|
||
if(!sset->stride.data) {
|
||
sset->stride.data = (hsize_t *)calloc(ndims, sizeof(hsize_t));
|
||
sset->stride.len = ndims;
|
||
for (i = 0; i < ndims; i++)
|
||
sset->stride.data[i] = 1;
|
||
}
|
||
|
||
if(!sset->count.data) {
|
||
sset->count.data = (hsize_t *)calloc(ndims, sizeof(hsize_t));
|
||
sset->count.len = ndims;
|
||
for (i = 0; i < ndims; i++)
|
||
sset->count.data[i] = 1;
|
||
}
|
||
|
||
if(!sset->block.data) {
|
||
sset->block.data = (hsize_t *)calloc(ndims, sizeof(hsize_t));
|
||
sset->block.len = ndims;
|
||
for (i = 0; i < ndims; i++)
|
||
sset->block.data[i] = 1;
|
||
}
|
||
}
|
||
|
||
/*-------------------------------------------------------------------------
|
||
* check for dimension overflow
|
||
*-------------------------------------------------------------------------
|
||
*/
|
||
if(sset->start.len > ndims) {
|
||
error_msg("number of start dims (%u) exceed dataset dims (%u)\n", sset->start.len, ndims);
|
||
h5tools_setstatus(EXIT_FAILURE);
|
||
return;
|
||
}
|
||
if(sset->stride.len > ndims) {
|
||
error_msg("number of stride dims (%u) exceed dataset dims (%u)\n", sset->stride.len, ndims);
|
||
h5tools_setstatus(EXIT_FAILURE);
|
||
return;
|
||
}
|
||
if(sset->count.len > ndims) {
|
||
error_msg("number of count dims (%u) exceed dataset dims (%u)\n", sset->count.len, ndims);
|
||
h5tools_setstatus(EXIT_FAILURE);
|
||
return;
|
||
}
|
||
if(sset->block.len > ndims) {
|
||
error_msg("number of block dims (%u) exceed dataset dims (%u)\n", sset->block.len, ndims);
|
||
h5tools_setstatus(EXIT_FAILURE);
|
||
return;
|
||
}
|
||
|
||
/*-------------------------------------------------------------------------
|
||
* check for block overlap
|
||
*-------------------------------------------------------------------------
|
||
*/
|
||
for(i = 0; i < ndims; i++) {
|
||
if(sset->count.data[i] > 1) {
|
||
if(sset->stride.data[i] < sset->block.data[i]) {
|
||
error_msg("wrong subset selection; blocks overlap\n");
|
||
h5tools_setstatus(EXIT_FAILURE);
|
||
return;
|
||
} /* end if */
|
||
} /* end if */
|
||
} /* end for */
|
||
} /* end if */
|
||
|
||
|
||
H5Oget_info(dsetid, &oinfo);
|
||
if(oinfo.rc > 1 || hit_elink) {
|
||
obj_t *found_obj; /* Found object */
|
||
|
||
found_obj = search_obj(dset_table, oinfo.addr);
|
||
|
||
if(found_obj) {
|
||
if (found_obj->displayed) {
|
||
indentation(indent);
|
||
begin_obj(dump_header_format->datasetbegin, real_name,
|
||
dump_header_format->datasetblockbegin);
|
||
indentation(indent + COL);
|
||
printf("%s \"%s\"\n", HARDLINK, found_obj->objname);
|
||
indentation(indent);
|
||
end_obj(dump_header_format->datasetend,
|
||
dump_header_format->datasetblockend);
|
||
} else {
|
||
found_obj->displayed = TRUE;
|
||
dump_dataset(dsetid, real_name, sset);
|
||
}
|
||
}
|
||
else
|
||
h5tools_setstatus(EXIT_FAILURE);
|
||
}
|
||
else
|
||
dump_dataset(dsetid, real_name, sset);
|
||
|
||
if(H5Dclose(dsetid) < 0)
|
||
h5tools_setstatus(EXIT_FAILURE);
|
||
}
|
||
|
||
/*-------------------------------------------------------------------------
|
||
* Function: handle_groups
|
||
*
|
||
* Purpose: Handle the groups from the command.
|
||
*
|
||
* Return: void
|
||
*
|
||
* Programmer: Bill Wendling
|
||
* Tuesday, 9. January 2001
|
||
*
|
||
* Modifications: Pedro Vicente, September 26, 2007
|
||
* handle creation order
|
||
*
|
||
* Pedro Vicente, May 8, 2008
|
||
* added a flag PE that prints/not prints error messages
|
||
* added for cases of external links not found, to avoid printing of
|
||
* objects not found, since external links are dumped on a trial error basis
|
||
*
|
||
*-------------------------------------------------------------------------
|
||
*/
|
||
static void
|
||
handle_groups(hid_t fid, const char *group, void UNUSED * data, int pe, const char * display_name)
|
||
{
|
||
hid_t gid;
|
||
const char *real_name = display_name ? display_name : group;
|
||
|
||
|
||
if((gid = H5Gopen2(fid, group, H5P_DEFAULT)) < 0)
|
||
{
|
||
if ( pe )
|
||
{
|
||
begin_obj(dump_header_format->groupbegin, real_name, dump_header_format->groupblockbegin);
|
||
indentation(COL);
|
||
error_msg("unable to open group \"%s\"\n", real_name);
|
||
end_obj(dump_header_format->groupend, dump_header_format->groupblockend);
|
||
h5tools_setstatus(EXIT_FAILURE);
|
||
}
|
||
}
|
||
else
|
||
{
|
||
size_t new_len = HDstrlen(group) + 1;
|
||
|
||
if(prefix_len <= new_len)
|
||
{
|
||
prefix_len = new_len;
|
||
prefix = (char *)HDrealloc(prefix, prefix_len);
|
||
} /* end if */
|
||
|
||
HDstrcpy(prefix, group);
|
||
|
||
dump_group(gid, real_name);
|
||
|
||
if(H5Gclose(gid) < 0)
|
||
h5tools_setstatus(EXIT_FAILURE);
|
||
} /* end else */
|
||
} /* end handle_groups() */
|
||
|
||
/*-------------------------------------------------------------------------
|
||
* Function: handle_links
|
||
*
|
||
* Purpose: Handle soft or UD links from the command.
|
||
*
|
||
* Return: void
|
||
*
|
||
* Programmer: Bill Wendling
|
||
* Tuesday, 9. January 2001
|
||
*
|
||
* Modifications:
|
||
*
|
||
*-------------------------------------------------------------------------
|
||
*/
|
||
static void
|
||
handle_links(hid_t fid, const char *links, void UNUSED * data, int UNUSED pe, const char UNUSED *display_name)
|
||
{
|
||
H5L_info_t linfo;
|
||
|
||
if(H5Lget_info(fid, links, &linfo, H5P_DEFAULT) < 0) {
|
||
error_msg("unable to get link info from \"%s\"\n", links);
|
||
h5tools_setstatus(EXIT_FAILURE);
|
||
} else if(linfo.type == H5L_TYPE_HARD) {
|
||
error_msg("\"%s\" is a hard link\n", links);
|
||
h5tools_setstatus(EXIT_FAILURE);
|
||
} else {
|
||
char *buf = (char *)HDmalloc(linfo.u.val_size);
|
||
|
||
switch(linfo.type) {
|
||
case H5L_TYPE_SOFT: /* Soft link */
|
||
begin_obj(dump_header_format->softlinkbegin, links,
|
||
dump_header_format->softlinkblockbegin);
|
||
indentation(COL);
|
||
if(H5Lget_val(fid, links, buf, linfo.u.val_size, H5P_DEFAULT) >= 0)
|
||
printf("LINKTARGET \"%s\"\n", buf);
|
||
else {
|
||
error_msg("h5dump error: unable to get link value for \"%s\"\n",
|
||
links);
|
||
h5tools_setstatus(EXIT_FAILURE);
|
||
}
|
||
end_obj(dump_header_format->softlinkend,
|
||
dump_header_format->softlinkblockend);
|
||
break;
|
||
|
||
case H5L_TYPE_EXTERNAL:
|
||
begin_obj(dump_header_format->udlinkbegin, links,
|
||
dump_header_format->udlinkblockbegin);
|
||
indentation(COL);
|
||
begin_obj(dump_header_format->extlinkbegin, links,
|
||
dump_header_format->extlinkblockbegin);
|
||
if(H5Lget_val(fid, links, buf, linfo.u.val_size, H5P_DEFAULT) >= 0) {
|
||
const char *elink_file;
|
||
const char *elink_path;
|
||
|
||
if(H5Lunpack_elink_val(buf, linfo.u.val_size, NULL, &elink_file, &elink_path)>=0) {
|
||
indentation(COL);
|
||
printf("LINKCLASS %d\n", linfo.type);
|
||
indentation(COL);
|
||
printf("TARGETFILE \"%s\"\n", elink_file);
|
||
indentation(COL);
|
||
printf("TARGETPATH \"%s\"\n", elink_path);
|
||
} else {
|
||
error_msg("h5dump error: unable to unpack external link value for \"%s\"\n", links);
|
||
h5tools_setstatus(EXIT_FAILURE);
|
||
}
|
||
} else {
|
||
error_msg("h5dump error: unable to get external link value for \"%s\"\n", links);
|
||
h5tools_setstatus(EXIT_FAILURE);
|
||
}
|
||
end_obj(dump_header_format->extlinkend,
|
||
dump_header_format->extlinkblockend);
|
||
break;
|
||
|
||
default:
|
||
begin_obj(dump_header_format->udlinkbegin, links,
|
||
dump_header_format->udlinkblockbegin);
|
||
indentation(COL);
|
||
begin_obj(dump_header_format->udlinkbegin, links,
|
||
dump_header_format->udlinkblockbegin);
|
||
indentation(COL);
|
||
printf("LINKCLASS %d\n", linfo.type);
|
||
end_obj(dump_header_format->udlinkend,
|
||
dump_header_format->udlinkblockend);
|
||
break;
|
||
} /* end switch */
|
||
HDfree(buf);
|
||
} /* end else */
|
||
}
|
||
|
||
/*-------------------------------------------------------------------------
|
||
* Function: handle_datatypes
|
||
*
|
||
* Purpose: Handle the datatypes from the command.
|
||
*
|
||
* Return: void
|
||
*
|
||
* Programmer: Bill Wendling
|
||
* Tuesday, 9. January 2001
|
||
*
|
||
* Modifications:
|
||
*
|
||
* Pedro Vicente, May 8, 2008
|
||
* added a flag PE that prints/not prints error messages
|
||
* added for cases of external links not found, to avoid printing of
|
||
* objects not found, since external links are dumped on a trial error basis
|
||
*
|
||
*-------------------------------------------------------------------------
|
||
*/
|
||
static void
|
||
handle_datatypes(hid_t fid, const char *type, void UNUSED * data, int pe, const char *display_name)
|
||
{
|
||
hid_t type_id;
|
||
const char *real_name = display_name ? display_name : type;
|
||
|
||
if((type_id = H5Topen2(fid, type, H5P_DEFAULT)) < 0)
|
||
{
|
||
/* check if type is unamed datatype */
|
||
unsigned idx = 0;
|
||
|
||
while(idx < type_table->nobjs )
|
||
{
|
||
char name[128];
|
||
|
||
if(!type_table->objs[idx].recorded)
|
||
{
|
||
/* unamed datatype */
|
||
sprintf(name, "/#"H5_PRINTF_HADDR_FMT, type_table->objs[idx].objno);
|
||
|
||
if(!HDstrcmp(name, real_name))
|
||
break;
|
||
} /* end if */
|
||
|
||
idx++;
|
||
} /* end while */
|
||
|
||
if(idx == type_table->nobjs)
|
||
{
|
||
if ( pe )
|
||
{
|
||
/* unknown type */
|
||
begin_obj(dump_header_format->datatypebegin, real_name,
|
||
dump_header_format->datatypeblockbegin);
|
||
indentation(COL);
|
||
error_msg("unable to open datatype \"%s\"\n", real_name);
|
||
end_obj(dump_header_format->datatypeend,
|
||
dump_header_format->datatypeblockend);
|
||
h5tools_setstatus(EXIT_FAILURE);
|
||
}
|
||
}
|
||
else
|
||
{
|
||
hid_t dsetid = H5Dopen2(fid, type_table->objs[idx].objname, H5P_DEFAULT);
|
||
type_id = H5Dget_type(dsetid);
|
||
dump_named_datatype(type_id, real_name);
|
||
H5Tclose(type_id);
|
||
H5Dclose(dsetid);
|
||
}
|
||
}
|
||
else
|
||
{
|
||
dump_named_datatype(type_id, real_name);
|
||
|
||
if(H5Tclose(type_id) < 0)
|
||
h5tools_setstatus(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:
|
||
* pvn June, 1, 2006. Add a switch for binary output
|
||
*
|
||
*-------------------------------------------------------------------------
|
||
*/
|
||
static struct handler_t *
|
||
parse_command_line(int argc, const char *argv[])
|
||
{
|
||
struct handler_t *hand, *last_dset = NULL;
|
||
int i, opt, last_was_dset = FALSE;
|
||
|
||
/* no arguments */
|
||
if (argc == 1) {
|
||
usage(h5tools_getprogname());
|
||
leave(EXIT_FAILURE);
|
||
}
|
||
|
||
/* this will be plenty big enough to hold the info */
|
||
hand = (struct handler_t *)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 'R':
|
||
display_region = TRUE;
|
||
region_output = TRUE;
|
||
break;
|
||
case 'B':
|
||
display_bb = TRUE;
|
||
last_was_dset = FALSE;
|
||
break;
|
||
case 'n':
|
||
display_fi = TRUE;
|
||
last_was_dset = FALSE;
|
||
break;
|
||
case 'p':
|
||
display_dcpl = TRUE;
|
||
break;
|
||
case 'y':
|
||
display_ai = FALSE;
|
||
break;
|
||
case 'e':
|
||
display_escape = TRUE;
|
||
break;
|
||
case 'H':
|
||
display_data = FALSE;
|
||
display_attr_data = FALSE;
|
||
last_was_dset = FALSE;
|
||
break;
|
||
case 'A':
|
||
display_data = FALSE;
|
||
display_attr_data = TRUE;
|
||
last_was_dset = FALSE;
|
||
break;
|
||
case 'i':
|
||
display_oid = TRUE;
|
||
last_was_dset = FALSE;
|
||
break;
|
||
case 'r':
|
||
display_char = TRUE;
|
||
break;
|
||
case 'V':
|
||
print_version(h5tools_getprogname());
|
||
leave(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 = HDstrdup(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 = HDstrdup(opt_arg);
|
||
hand[i].subset_info = parse_subset_params(hand[i].obj);
|
||
last_dset = &hand[i];
|
||
break;
|
||
}
|
||
|
||
last_was_dset = TRUE;
|
||
break;
|
||
case 'f':
|
||
driver = opt_arg;
|
||
break;
|
||
case 'g':
|
||
display_all = 0;
|
||
|
||
for (i = 0; i < argc; i++)
|
||
if (!hand[i].func) {
|
||
hand[i].func = handle_groups;
|
||
hand[i].obj = HDstrdup(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 = HDstrdup(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 = HDstrdup(opt_arg);
|
||
break;
|
||
}
|
||
|
||
last_was_dset = FALSE;
|
||
break;
|
||
|
||
case 'o':
|
||
if ( bin_output ) {
|
||
if (set_output_file(opt_arg, 1) < 0) {
|
||
usage(h5tools_getprogname());
|
||
leave(EXIT_FAILURE);
|
||
}
|
||
}
|
||
else {
|
||
if (set_output_file(opt_arg, 0) < 0) {
|
||
usage(h5tools_getprogname());
|
||
leave(EXIT_FAILURE);
|
||
}
|
||
}
|
||
|
||
usingdasho = TRUE;
|
||
last_was_dset = FALSE;
|
||
outfname = opt_arg;
|
||
break;
|
||
|
||
case 'b':
|
||
if ( opt_arg != NULL) {
|
||
if ( ( bin_form = set_binary_form(opt_arg)) < 0) {
|
||
/* failed to set binary form */
|
||
usage(h5tools_getprogname());
|
||
leave(EXIT_FAILURE);
|
||
}
|
||
}
|
||
bin_output = TRUE;
|
||
if (outfname!=NULL) {
|
||
if (set_output_file(outfname, 1) < 0) {
|
||
/* failed to set output file */
|
||
usage(h5tools_getprogname());
|
||
leave(EXIT_FAILURE);
|
||
}
|
||
|
||
last_was_dset = FALSE;
|
||
}
|
||
break;
|
||
|
||
case 'q':
|
||
if ( ( sort_by = set_sort_by(opt_arg)) < 0) {
|
||
/* failed to set "sort by" form */
|
||
usage(h5tools_getprogname());
|
||
leave(EXIT_FAILURE);
|
||
}
|
||
break;
|
||
|
||
case 'z':
|
||
if ( ( sort_order = set_sort_order(opt_arg)) < 0) {
|
||
/* failed to set "sort order" form */
|
||
usage(h5tools_getprogname());
|
||
leave(EXIT_FAILURE);
|
||
}
|
||
break;
|
||
|
||
/** begin XML parameters **/
|
||
case 'x':
|
||
/* select XML output */
|
||
doxml = TRUE;
|
||
useschema = TRUE;
|
||
dump_header_format = NULL;
|
||
dump_function_table = &xml_function_table;
|
||
break;
|
||
case 'u':
|
||
doxml = TRUE;
|
||
useschema = FALSE;
|
||
xmlnsprefix = "";
|
||
dump_header_format = NULL;
|
||
dump_function_table = &xml_function_table;
|
||
break;
|
||
case 'D':
|
||
/* specify alternative XML DTD or schema */
|
||
/* To Do: check format of this value? */
|
||
xml_dtd_uri = opt_arg;
|
||
break;
|
||
|
||
case 'm':
|
||
/* specify alternative floating point printing format */
|
||
fp_format = opt_arg;
|
||
break;
|
||
|
||
|
||
|
||
|
||
case 'X':
|
||
/* specify XML namespace (default="hdf5:"), or none */
|
||
/* To Do: check format of this value? */
|
||
if (!useschema) {
|
||
usage(h5tools_getprogname());
|
||
leave(EXIT_FAILURE);
|
||
}
|
||
if (strcmp(opt_arg,":") == 0) {
|
||
xmlnsprefix = "";
|
||
} else {
|
||
xmlnsprefix = opt_arg;
|
||
}
|
||
break;
|
||
/** end XML parameters **/
|
||
|
||
/** begin subsetting parameters **/
|
||
case 's':
|
||
case 'S':
|
||
case 'c':
|
||
case 'k': {
|
||
struct subset_t *s;
|
||
|
||
if (!last_was_dset) {
|
||
error_msg("option `-%c' can only be used after --dataset option\n",
|
||
opt);
|
||
leave(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 = (struct subset_t *)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, S,
|
||
* 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.data); parse_hsize_list(opt_arg, &s->start); break;
|
||
case 'S': free(s->stride.data); parse_hsize_list(opt_arg, &s->stride); break;
|
||
case 'c': free(s->count.data); parse_hsize_list(opt_arg, &s->count); break;
|
||
case 'k': free(s->block.data); parse_hsize_list(opt_arg, &s->block); 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(h5tools_getprogname());
|
||
leave(EXIT_SUCCESS);
|
||
case '?':
|
||
default:
|
||
usage(h5tools_getprogname());
|
||
leave(EXIT_FAILURE);
|
||
}
|
||
}
|
||
|
||
parse_end:
|
||
/* check for file name to be processed */
|
||
if (argc <= opt_ind) {
|
||
error_msg("missing file name\n");
|
||
usage(h5tools_getprogname());
|
||
leave(EXIT_FAILURE);
|
||
}
|
||
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.data);
|
||
free(hand[i].subset_info->stride.data);
|
||
free(hand[i].subset_info->count.data);
|
||
free(hand[i].subset_info->block.data);
|
||
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.
|
||
*
|
||
* REMcG
|
||
* August 2003
|
||
* Major upgrade to XML support.
|
||
*
|
||
* Pedro Vicente
|
||
* September 2007
|
||
* list objects in requested order (creation order or alphabetically)
|
||
*
|
||
*-------------------------------------------------------------------------
|
||
*/
|
||
int
|
||
main(int argc, const char *argv[])
|
||
{
|
||
hid_t fid, gid;
|
||
char *fname = NULL;
|
||
void *edata;
|
||
H5E_auto2_t func;
|
||
H5O_info_t oi;
|
||
struct handler_t *hand;
|
||
int i;
|
||
unsigned u;
|
||
|
||
h5tools_setprogname(PROGRAMNAME);
|
||
h5tools_setstatus(EXIT_SUCCESS);
|
||
dump_header_format = &standardformat;
|
||
dump_function_table = &ddl_function_table;
|
||
|
||
/* Disable error reporting */
|
||
H5Eget_auto2(H5E_DEFAULT, &func, &edata);
|
||
H5Eset_auto2(H5E_DEFAULT, NULL, NULL);
|
||
|
||
/* Initialize h5tools lib */
|
||
h5tools_init();
|
||
hand = parse_command_line(argc, argv);
|
||
|
||
if ( bin_output && outfname == NULL )
|
||
{
|
||
error_msg("binary output requires a file name, use -o <filename>\n");
|
||
leave(EXIT_FAILURE);
|
||
}
|
||
|
||
/* Check for conflicting options */
|
||
if (doxml) {
|
||
if (!display_all) {
|
||
error_msg("option \"%s\" not available for XML\n",
|
||
"to display selected objects");
|
||
leave(EXIT_FAILURE);
|
||
} else if (display_bb) {
|
||
error_msg("option \"%s\" not available for XML\n",
|
||
"--boot-block");
|
||
leave(EXIT_FAILURE);
|
||
} else if (display_oid == 1) {
|
||
error_msg("option \"%s\" not available for XML\n",
|
||
"--object-ids");
|
||
leave(EXIT_FAILURE);
|
||
} else if (display_char == TRUE) {
|
||
error_msg("option \"%s\" not available for XML\n",
|
||
"--string");
|
||
leave(EXIT_FAILURE);
|
||
} else if (usingdasho) {
|
||
error_msg("option \"%s\" not available for XML\n",
|
||
"--output");
|
||
leave(EXIT_FAILURE);
|
||
}
|
||
} else {
|
||
if (xml_dtd_uri) {
|
||
warn_msg("option \"%s\" only applies with XML: %s\n",
|
||
"--xml-dtd", xml_dtd_uri);
|
||
}
|
||
}
|
||
|
||
if (argc <= opt_ind) {
|
||
error_msg("missing file name\n");
|
||
usage(h5tools_getprogname());
|
||
leave(EXIT_FAILURE);
|
||
}
|
||
fname = HDstrdup(argv[opt_ind]);
|
||
|
||
fid = h5tools_fopen(fname, H5F_ACC_RDONLY, H5P_DEFAULT, driver, NULL, 0);
|
||
|
||
if (fid < 0) {
|
||
error_msg("unable to open file \"%s\"\n", fname);
|
||
leave(EXIT_FAILURE);
|
||
}
|
||
|
||
/* allocate and initialize internal data structure */
|
||
init_prefix(&prefix, prefix_len);
|
||
|
||
/* Prepare to find objects that might be targets of a reference */
|
||
fill_ref_path_table(fid);
|
||
|
||
if(doxml) {
|
||
/* initialize XML */
|
||
|
||
/* reset prefix! */
|
||
HDstrcpy(prefix, "");
|
||
|
||
/* make sure the URI is initialized to something */
|
||
if (xml_dtd_uri == NULL) {
|
||
if (useschema) {
|
||
xml_dtd_uri = DEFAULT_XSD;
|
||
} else {
|
||
xml_dtd_uri = DEFAULT_DTD;
|
||
xmlnsprefix = "";
|
||
}
|
||
} else {
|
||
if (useschema && strcmp(xmlnsprefix,"")) {
|
||
error_msg("Cannot set Schema URL for a qualified namespace--use -X or -U option with -D \n");
|
||
leave(EXIT_FAILURE);
|
||
}
|
||
}
|
||
}
|
||
|
||
|
||
/* Get object info for root group */
|
||
if(H5Oget_info_by_name(fid, "/", &oi, H5P_DEFAULT) < 0) {
|
||
error_msg("internal error (file %s:line %d)\n", __FILE__, __LINE__);
|
||
h5tools_setstatus(EXIT_FAILURE);
|
||
goto done;
|
||
}
|
||
|
||
/* Initialize object tables */
|
||
if(table_list_add(fid, oi.fileno) < 0) {
|
||
error_msg("internal error (file %s:line %d)\n", __FILE__, __LINE__);
|
||
h5tools_setstatus(EXIT_FAILURE);
|
||
goto done;
|
||
}
|
||
group_table = table_list.tables[0].group_table;
|
||
dset_table = table_list.tables[0].dset_table;
|
||
type_table = table_list.tables[0].type_table;
|
||
|
||
/* does there exist unamed committed datatype */
|
||
for (u = 0; u < type_table->nobjs; u++)
|
||
if (!type_table->objs[u].recorded) {
|
||
unamedtype = 1;
|
||
break;
|
||
} /* end if */
|
||
|
||
/* start to dump - display file header information */
|
||
if (!doxml) {
|
||
begin_obj(dump_header_format->filebegin, fname,
|
||
dump_header_format->fileblockbegin);
|
||
} else {
|
||
printf("<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n");
|
||
|
||
/* alternative first element, depending on schema or DTD. */
|
||
if (useschema) {
|
||
if (strcmp(xmlnsprefix,"") == 0) {
|
||
printf("<HDF5-File xmlns:xsi=\"http://www.w3.org/2001/XMLSchema-instance\" xsi:noNamespaceSchemaLocation=\"%s\">\n",
|
||
xml_dtd_uri);
|
||
} else {
|
||
/* TO DO: make -url option work in this case (may need new option) */
|
||
char * ns;
|
||
char *indx;
|
||
|
||
ns = HDstrdup(xmlnsprefix);
|
||
indx = strrchr(ns,(int)':');
|
||
if (indx) *indx = '\0';
|
||
|
||
printf("<%sHDF5-File xmlns:%s=\"http://hdfgroup.org/DTDs/HDF5-File\" "
|
||
"xmlns:xsi=\"http://www.w3.org/2001/XMLSchema-instance\" "
|
||
"xsi:schemaLocation=\"http://hdfgroup.org/DTDs/HDF5-File "
|
||
"http://www.hdfgroup.org/DTDs/HDF5-File.xsd\">\n",xmlnsprefix,ns);
|
||
}
|
||
} else {
|
||
printf("<!DOCTYPE HDF5-File PUBLIC \"HDF5-File.dtd\" \"%s\">\n",
|
||
xml_dtd_uri);
|
||
printf("<HDF5-File>\n");
|
||
}
|
||
}
|
||
|
||
if (!doxml) {
|
||
if (display_fi) {
|
||
dump_fcontents(fid);
|
||
end_obj(dump_header_format->fileend,dump_header_format->fileblockend);
|
||
goto done;
|
||
}
|
||
|
||
if (display_bb)
|
||
dump_fcpl(fid);
|
||
}
|
||
|
||
if(display_all)
|
||
{
|
||
if((gid = H5Gopen2(fid, "/", H5P_DEFAULT)) < 0)
|
||
{
|
||
error_msg("unable to open root group\n");
|
||
h5tools_setstatus(EXIT_FAILURE);
|
||
}
|
||
else
|
||
{
|
||
|
||
dump_function_table->dump_group_function(gid, "/" );
|
||
|
||
}
|
||
|
||
if(H5Gclose(gid) < 0)
|
||
{
|
||
error_msg("unable to close root group\n");
|
||
h5tools_setstatus(EXIT_FAILURE);
|
||
}
|
||
|
||
|
||
}
|
||
else
|
||
{
|
||
/* Note: this option is not supported for XML */
|
||
if(doxml) {
|
||
error_msg("internal error (file %s:line %d)\n", __FILE__, __LINE__);
|
||
h5tools_setstatus(EXIT_FAILURE);
|
||
goto done;
|
||
} /* end if */
|
||
|
||
for(i = 0; i < argc; i++)
|
||
if(hand[i].func)
|
||
hand[i].func(fid, hand[i].obj, hand[i].subset_info, 1, NULL);
|
||
}
|
||
|
||
if (!doxml) {
|
||
end_obj(dump_header_format->fileend, dump_header_format->fileblockend);
|
||
} else {
|
||
printf("</%sHDF5-File>\n", xmlnsprefix);
|
||
}
|
||
|
||
done:
|
||
/* Free tables for objects */
|
||
table_list_free();
|
||
|
||
if (H5Fclose(fid) < 0)
|
||
h5tools_setstatus(EXIT_FAILURE);
|
||
|
||
free_handler(hand, argc);
|
||
|
||
HDfree(prefix);
|
||
HDfree(fname);
|
||
|
||
/* To Do: clean up XML table */
|
||
|
||
H5Eset_auto2(H5E_DEFAULT, func, edata);
|
||
|
||
leave(h5tools_getstatus());
|
||
}
|
||
|
||
/*-------------------------------------------------------------------------
|
||
* 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 */
|
||
unsigned char *copy = NULL; /*a pointer to value array */
|
||
unsigned nmembs; /*number of members */
|
||
int nchars; /*number of output characters */
|
||
hid_t super; /*enum base integer type */
|
||
hid_t native = -1; /*native integer datatype */
|
||
size_t dst_size; /*destination value type size */
|
||
unsigned i;
|
||
|
||
nmembs = (unsigned)H5Tget_nmembers(type);
|
||
super = H5Tget_super(type);
|
||
|
||
/*
|
||
* Determine what datatype to use for the native values. To simplify
|
||
* things we entertain three possibilities:
|
||
* 1. long long -- the largest native signed integer
|
||
* 2. unsigned long long -- the largest native unsigned integer
|
||
* 3. raw format
|
||
*/
|
||
if(H5Tget_size(type) <= sizeof(long long)) {
|
||
dst_size = sizeof(long long);
|
||
|
||
if(H5T_SGN_NONE == H5Tget_sign(type))
|
||
native = H5T_NATIVE_ULLONG;
|
||
else
|
||
native = H5T_NATIVE_LLONG;
|
||
} /* end if */
|
||
else
|
||
dst_size = H5Tget_size(type);
|
||
|
||
/* Get the names and raw values of all members */
|
||
name = (char **)calloc(nmembs, sizeof(char *));
|
||
value = (unsigned char *)calloc(nmembs, MAX(H5Tget_size(type), dst_size));
|
||
|
||
for (i = 0; i < nmembs; i++) {
|
||
name[i] = H5Tget_member_name(type, i);
|
||
H5Tget_member_value(type, i, value + i * H5Tget_size(type));
|
||
}
|
||
|
||
/* Convert values to native datatype */
|
||
if (native > 0)
|
||
H5Tconvert(super, native, nmembs, value, NULL, H5P_DEFAULT);
|
||
|
||
/*
|
||
* Sort members by increasing value
|
||
* ***not implemented yet***
|
||
*/
|
||
|
||
/* Print members */
|
||
for (i = 0; i < nmembs; i++) {
|
||
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)) {
|
||
/*On SGI Altix(cobalt), wrong values were printed out with "value+i*dst_size"
|
||
*strangely, unless use another pointer "copy".*/
|
||
copy = value+i*dst_size;
|
||
HDfprintf(stdout,"%" H5_PRINTF_LL_WIDTH "u", *((unsigned long long *)
|
||
((void *)copy)));
|
||
} else {
|
||
/*On SGI Altix(cobalt), wrong values were printed out with "value+i*dst_size"
|
||
*strangely, unless use another pointer "copy".*/
|
||
copy = value+i*dst_size;
|
||
HDfprintf(stdout,"%" H5_PRINTF_LL_WIDTH "d",
|
||
*((long long *) ((void *)copy)));
|
||
}
|
||
|
||
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, "");
|
||
}
|
||
|
||
|
||
/*
|
||
* create a string suitable for and XML NCNAME. Uses the
|
||
* object reference to create the string.
|
||
*
|
||
* 'gen'; 0 - return null if not found
|
||
* 1 - generate a fake entry and return fake id.
|
||
*/
|
||
|
||
int
|
||
xml_name_to_XID(const char *str , char *outstr, int outlen, int gen)
|
||
{
|
||
haddr_t objno; /* Object ID for object at path */
|
||
|
||
if (outlen < 22) return 1;
|
||
|
||
objno = ref_path_table_lookup(str);
|
||
if (objno == HADDR_UNDEF) {
|
||
if (HDstrlen(str) == 0) {
|
||
objno = ref_path_table_lookup("/");
|
||
if (objno == HADDR_UNDEF) {
|
||
if (gen) {
|
||
objno = ref_path_table_gen_fake(str);
|
||
sprintf(outstr, "xid_"H5_PRINTF_HADDR_FMT, objno);
|
||
return 0;
|
||
} else {
|
||
return 1;
|
||
}
|
||
}
|
||
} else {
|
||
if (gen) {
|
||
objno = ref_path_table_gen_fake(str);
|
||
sprintf(outstr, "xid_"H5_PRINTF_HADDR_FMT, objno);
|
||
return 0;
|
||
} else {
|
||
return 1;
|
||
}
|
||
}
|
||
}
|
||
|
||
sprintf(outstr, "xid_"H5_PRINTF_HADDR_FMT, objno);
|
||
|
||
return(0);
|
||
}
|
||
|
||
static const char *quote = """;
|
||
static const char *amp = "&";
|
||
static const char *lt = "<";
|
||
static const char *gt = ">";
|
||
static const char *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)
|
||
{
|
||
size_t extra;
|
||
size_t len;
|
||
size_t 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 HDstrdup(str);
|
||
|
||
cp = str;
|
||
rcp = ncp = (char *)HDmalloc(len + extra + 1);
|
||
|
||
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)
|
||
{
|
||
size_t extra;
|
||
size_t len;
|
||
size_t 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 = (char *)calloc((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, unsigned in_group)
|
||
{
|
||
char *mname;
|
||
hid_t mtype;
|
||
unsigned nmembers;
|
||
unsigned ndims;
|
||
unsigned i;
|
||
size_t size;
|
||
hsize_t dims[H5DUMP_MAX_RANK];
|
||
H5T_str_t str_pad;
|
||
H5T_cset_t cset;
|
||
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;
|
||
htri_t is_vlstr=FALSE;
|
||
|
||
if(!in_group && H5Tcommitted(type) > 0) {
|
||
H5O_info_t oinfo;
|
||
obj_t *found_obj; /* Found object */
|
||
|
||
/* detect a shared datatype, output only once */
|
||
H5Oget_info(type, &oinfo);
|
||
found_obj = search_obj(type_table, oinfo.addr);
|
||
|
||
if(found_obj) {
|
||
/* This should be defined somewhere else */
|
||
/* These 2 cases are handled the same right now, but
|
||
probably will have something different eventually */
|
||
char * dtxid = (char *)malloc(100);
|
||
|
||
xml_name_to_XID(found_obj->objname, dtxid, 100, 1);
|
||
if (!found_obj->recorded) {
|
||
/* 'anonymous' NDT. Use it's object num.
|
||
as it's name. */
|
||
printf("<%sNamedDataTypePtr OBJ-XID=\"/%s\"/>\n",
|
||
xmlnsprefix, dtxid);
|
||
} else {
|
||
/* point to the NDT by name */
|
||
char *t_objname = xml_escape_the_name(found_obj->objname);
|
||
|
||
printf("<%sNamedDataTypePtr OBJ-XID=\"%s\" H5Path=\"%s\"/>\n",
|
||
xmlnsprefix, dtxid, t_objname);
|
||
free(t_objname);
|
||
}
|
||
free(dtxid);
|
||
} else {
|
||
printf("<!-- h5dump error: unknown committed type. -->\n");
|
||
h5tools_setstatus(EXIT_FAILURE);
|
||
}
|
||
} else {
|
||
|
||
switch (H5Tget_class(type)) {
|
||
case H5T_INTEGER:
|
||
indentation(indent);
|
||
printf("<%sAtomicType>\n",xmlnsprefix);
|
||
indent += COL;
|
||
/* <hdf5:IntegerType ByteOrder="bo" Sign="torf" Size="bytes"/> */
|
||
ord = H5Tget_order(type);
|
||
sgn = H5Tget_sign(type);
|
||
indentation(indent);
|
||
printf("<%sIntegerType ByteOrder=\"",xmlnsprefix);
|
||
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("%lu", (unsigned long)sz);
|
||
printf("\" />\n");
|
||
indent -= COL;
|
||
indentation(indent);
|
||
printf("</%sAtomicType>\n",xmlnsprefix);
|
||
break;
|
||
|
||
case H5T_FLOAT:
|
||
/* <hdf5:FloatType ByteOrder="bo" Size="bytes"
|
||
SignBitLocation="bytes"
|
||
ExponentBits="eb" ExponentLocation="el"
|
||
MantissaBits="mb" MantissaLocation="ml" /> */
|
||
ord = H5Tget_order(type);
|
||
indentation(indent);
|
||
printf("<%sAtomicType>\n",xmlnsprefix);
|
||
indent += COL;
|
||
indentation(indent);
|
||
printf("<%sFloatType ByteOrder=\"",xmlnsprefix);
|
||
switch (ord) {
|
||
case H5T_ORDER_LE:
|
||
printf("LE");
|
||
break;
|
||
case H5T_ORDER_BE:
|
||
printf("BE");
|
||
break;
|
||
case H5T_ORDER_VAX:
|
||
printf("VAX");
|
||
break;
|
||
default:
|
||
printf("ERROR_UNKNOWN");
|
||
}
|
||
printf("\" Size=\"");
|
||
sz = H5Tget_size(type);
|
||
printf("%lu", (unsigned long)sz);
|
||
H5Tget_fields(type, &spos, &epos, &esize, &mpos, &msize);
|
||
printf("\" SignBitLocation=\"%lu\" ", (unsigned long)spos);
|
||
printf("ExponentBits=\"%lu\" ExponentLocation=\"%lu\" ", (unsigned long)esize, (unsigned long)epos);
|
||
printf("MantissaBits=\"%lu\" MantissaLocation=\"%lu\" />\n",
|
||
(unsigned long)msize, (unsigned long)mpos);
|
||
indent -= COL;
|
||
indentation(indent);
|
||
printf("</%sAtomicType>\n",xmlnsprefix);
|
||
break;
|
||
|
||
case H5T_TIME:
|
||
indentation(indent);
|
||
printf("<%sAtomicType>\n",xmlnsprefix);
|
||
indent += COL;
|
||
indentation(indent);
|
||
printf("<%sTimeType />\n",xmlnsprefix);
|
||
printf("<!-- H5T_TIME: not yet implemented -->");
|
||
indent -= COL;
|
||
indentation(indent);
|
||
printf("</%sAtomicType>\n",xmlnsprefix);
|
||
break;
|
||
|
||
case H5T_STRING:
|
||
/* <hdf5:StringType Cset="cs" StrSize="chars" StrPad="pad" /> */
|
||
size = H5Tget_size(type);
|
||
str_pad = H5Tget_strpad(type);
|
||
cset = H5Tget_cset(type);
|
||
is_vlstr = H5Tis_variable_str(type);
|
||
|
||
indentation(indent);
|
||
printf("<%sAtomicType>\n",xmlnsprefix);
|
||
indent += COL;
|
||
indentation(indent);
|
||
printf("<%sStringType Cset=\"",xmlnsprefix);
|
||
if (cset == H5T_CSET_ASCII) {
|
||
printf("H5T_CSET_ASCII\" ");
|
||
} else {
|
||
printf("unknown_cset\" ");
|
||
}
|
||
if(is_vlstr)
|
||
printf("StrSize=\"H5T_VARIABLE\" StrPad=\"");
|
||
else
|
||
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("</%sAtomicType>\n",xmlnsprefix);
|
||
break;
|
||
|
||
case H5T_BITFIELD:
|
||
/* <hdf5:BitfieldType ByteOrder="bo" Size="bytes"/> */
|
||
ord = H5Tget_order(type);
|
||
indentation(indent);
|
||
printf("<%sAtomicType>\n",xmlnsprefix);
|
||
indent += COL;
|
||
indentation(indent);
|
||
printf("<%sBitfieldType ByteOrder=\"",xmlnsprefix);
|
||
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=\"%lu\"/>\n", (unsigned long)size);
|
||
indent -= COL;
|
||
indentation(indent);
|
||
printf("</%sAtomicType>\n",xmlnsprefix);
|
||
break;
|
||
|
||
case H5T_OPAQUE:
|
||
/* <hdf5:OpaqueType Tag="tag" Size="bytes" /> */
|
||
indentation(indent);
|
||
printf("<%sAtomicType>\n",xmlnsprefix);
|
||
indent += COL;
|
||
indentation(indent);
|
||
printf("<%sOpaqueType Tag=\"%s\" ",xmlnsprefix, H5Tget_tag(type));
|
||
size = H5Tget_size(type);
|
||
printf("Size=\"%lu\"/>\n", (unsigned long)size);
|
||
indent -= COL;
|
||
indentation(indent);
|
||
printf("</%sAtomicType>\n",xmlnsprefix);
|
||
break;
|
||
|
||
case H5T_COMPOUND:
|
||
/* recursively describe the components of a compound datatype */
|
||
|
||
/* type of a dataset */
|
||
nmembers = H5Tget_nmembers(type);
|
||
|
||
indentation(indent);
|
||
printf("<%sCompoundType>\n",xmlnsprefix);
|
||
|
||
/* List each member Field of the type */
|
||
/* <hdf5:Field FieldName="name" > */
|
||
/* <hdf5:DataType > */
|
||
indent += COL;
|
||
for (i = 0; i < nmembers; i++) {
|
||
char *t_fname;
|
||
|
||
mname = H5Tget_member_name(type, i);
|
||
mtype = H5Tget_member_type(type, i);
|
||
indentation(indent);
|
||
t_fname = xml_escape_the_name(mname);
|
||
printf("<%sField FieldName=\"%s\">\n",xmlnsprefix, t_fname);
|
||
|
||
free(mname);
|
||
free(t_fname);
|
||
indent += COL;
|
||
indentation(indent);
|
||
printf("<%sDataType>\n",xmlnsprefix);
|
||
indent += COL;
|
||
xml_print_datatype(mtype,0);
|
||
indent -= COL;
|
||
indentation(indent);
|
||
printf("</%sDataType>\n",xmlnsprefix);
|
||
indent -= COL;
|
||
|
||
indentation(indent);
|
||
printf("</%sField>\n",xmlnsprefix);
|
||
}
|
||
indent -= COL;
|
||
indentation(indent);
|
||
printf("</%sCompoundType>\n",xmlnsprefix);
|
||
break;
|
||
|
||
case H5T_REFERENCE:
|
||
indentation(indent);
|
||
printf("<%sAtomicType>\n",xmlnsprefix);
|
||
indent += COL;
|
||
indentation(indent);
|
||
/* Only Object references supported at this time */
|
||
printf("<%sReferenceType>\n",xmlnsprefix);
|
||
indentation(indent + COL);
|
||
printf("<%sObjectReferenceType />\n",xmlnsprefix);
|
||
indentation(indent);
|
||
printf("</%sReferenceType>\n",xmlnsprefix);
|
||
indent -= COL;
|
||
indentation(indent);
|
||
printf("</%sAtomicType>\n",xmlnsprefix);
|
||
break;
|
||
|
||
case H5T_ENUM:
|
||
/* <hdf5:EnumType Nelems="ne" >
|
||
list Name, values of enum
|
||
*/
|
||
nmembs = H5Tget_nmembers(type);
|
||
indentation(indent);
|
||
printf("<%sAtomicType>\n",xmlnsprefix);
|
||
indent += COL;
|
||
indentation(indent);
|
||
printf("<%sEnumType Nelems=\"%d\">\n",xmlnsprefix, nmembs);
|
||
xml_print_enum(type);
|
||
indentation(indent);
|
||
printf("</%sEnumType>\n",xmlnsprefix);
|
||
indent -= COL;
|
||
indentation(indent);
|
||
printf("</%sAtomicType>\n",xmlnsprefix);
|
||
break;
|
||
|
||
case H5T_VLEN:
|
||
indentation(indent);
|
||
printf("<%sVLType>\n",xmlnsprefix);
|
||
super = H5Tget_super(type);
|
||
indent += COL;
|
||
indentation(indent);
|
||
printf("<%sDataType>\n",xmlnsprefix);
|
||
indent += COL;
|
||
xml_print_datatype(super,0);
|
||
indent -= COL;
|
||
indentation(indent);
|
||
printf("</%sDataType>\n",xmlnsprefix);
|
||
indent -= COL;
|
||
indentation(indent);
|
||
printf("</%sVLType>\n",xmlnsprefix);
|
||
H5Tclose(super);
|
||
|
||
break;
|
||
|
||
case H5T_ARRAY:
|
||
/* Get array base type */
|
||
super = H5Tget_super(type);
|
||
|
||
/* Print lead-in */
|
||
indentation(indent);
|
||
printf("<%sArrayType Ndims=\"",xmlnsprefix);
|
||
ndims = H5Tget_array_ndims(type);
|
||
printf("%u\">\n", ndims);
|
||
|
||
/* Get array information */
|
||
H5Tget_array_dims2(type, dims);
|
||
|
||
/* list of dimensions */
|
||
indent += COL;
|
||
for (i = 0; i < ndims; i++) {
|
||
indentation(indent);
|
||
printf("<%sArrayDimension DimSize=\"%u\"/>\n",
|
||
xmlnsprefix,
|
||
(int) dims[i]);
|
||
}
|
||
indent -= COL;
|
||
|
||
indent += COL;
|
||
indentation(indent);
|
||
printf("<%sDataType>\n",xmlnsprefix);
|
||
indent += COL;
|
||
xml_print_datatype(super,0);
|
||
indent -= COL;
|
||
indentation(indent);
|
||
printf("</%sDataType>\n",xmlnsprefix);
|
||
indent -= COL;
|
||
indentation(indent);
|
||
printf("</%sArrayType>\n",xmlnsprefix);
|
||
/* Close array base type */
|
||
H5Tclose(super);
|
||
break;
|
||
|
||
default:
|
||
printf("<!-- unknown datatype -->");
|
||
h5tools_setstatus(EXIT_FAILURE);
|
||
break;
|
||
}
|
||
} /* end else */
|
||
}
|
||
|
||
/*-------------------------------------------------------------------------
|
||
* 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)
|
||
{
|
||
|
||
indent += COL;
|
||
indentation(indent);
|
||
|
||
if(H5Tcommitted(type) > 0) {
|
||
H5O_info_t oinfo;
|
||
obj_t *found_obj; /* Found object */
|
||
|
||
/* Datatype is a shared or named datatype */
|
||
H5Oget_info(type, &oinfo);
|
||
found_obj = search_obj(type_table, oinfo.addr);
|
||
|
||
if(found_obj) {
|
||
/* Shared datatype, must be entered as an object */
|
||
/* These 2 cases are the same now, but may change */
|
||
char * dtxid = (char *)malloc(100);
|
||
|
||
xml_name_to_XID(found_obj->objname, dtxid, 100, 1);
|
||
if (!found_obj->recorded) {
|
||
/* anonymous stored datatype:
|
||
following the dumper's current
|
||
practice:
|
||
use it's object ref as its name
|
||
*/
|
||
printf("<%sNamedDataTypePtr OBJ-XID=\"%s\"/>\n",
|
||
xmlnsprefix, dtxid);
|
||
} else {
|
||
/* pointer to a named datatype already in XML */
|
||
char *t_objname = xml_escape_the_name(found_obj->objname);
|
||
|
||
printf("<%sNamedDataTypePtr OBJ-XID=\"%s\" H5Path=\"%s\" />\n",
|
||
xmlnsprefix, dtxid, t_objname);
|
||
free(t_objname);
|
||
}
|
||
free(dtxid);
|
||
} else {
|
||
printf("<!-- h5dump error: unknown committed type. -->\n");
|
||
}
|
||
indent -= COL;
|
||
}
|
||
else {
|
||
printf("<%sDataType>\n", xmlnsprefix);
|
||
indent += COL;
|
||
xml_print_datatype(type, 0);
|
||
indent -= COL;
|
||
indentation(indent);
|
||
printf("</%sDataType>\n", xmlnsprefix);
|
||
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);
|
||
H5S_class_t space_type = H5Sget_simple_extent_type(space);
|
||
int i;
|
||
|
||
indentation(indent + COL);
|
||
printf("<%sDataspace>\n", xmlnsprefix);
|
||
indentation(indent + COL + COL);
|
||
|
||
switch (space_type) {
|
||
case H5S_SCALAR:
|
||
/* scalar dataspace (just a tag, no XML attrs. defined */
|
||
printf("<%sScalarDataspace />\n",xmlnsprefix);
|
||
break;
|
||
|
||
case H5S_SIMPLE:
|
||
/* simple dataspace */
|
||
/* <hdf5:SimpleDataspace Ndims="nd"> */
|
||
printf("<%sSimpleDataspace Ndims=\"%d\">\n",xmlnsprefix, ndims);
|
||
|
||
/* print the <hdf5:Dimension> elements */
|
||
for (i = 0; i < ndims; i++) {
|
||
indentation(indent + COL + COL + COL);
|
||
if (maxsize[i] == H5S_UNLIMITED) {
|
||
HDfprintf(stdout,
|
||
"<%sDimension DimSize=\"%Hu\" MaxDimSize=\"UNLIMITED\"/>\n",
|
||
xmlnsprefix,size[i]);
|
||
} else if (maxsize[i] == (hsize_t) 0) {
|
||
HDfprintf(stdout,
|
||
"<%sDimension DimSize=\"%Hu\" MaxDimSize=\"%Hu\"/>\n",
|
||
xmlnsprefix,size[i], size[i]);
|
||
} else {
|
||
HDfprintf(stdout,
|
||
"<%sDimension DimSize=\"%Hu\" MaxDimSize=\"%Hu\"/>\n",
|
||
xmlnsprefix, size[i], maxsize[i]);
|
||
}
|
||
}
|
||
indentation(indent + COL + COL);
|
||
printf("</%sSimpleDataspace>\n", xmlnsprefix );
|
||
break;
|
||
|
||
#ifdef TMP
|
||
/* Commented out: wait until the schema is updated first */
|
||
case H5S_NULL:
|
||
/* null dataspace (just a tag, no XML attrs. defined */
|
||
printf("<%sNullDataspace />\n",xmlnsprefix);
|
||
break;
|
||
#endif /* TMP */
|
||
|
||
case H5S_NO_CLASS:
|
||
default:
|
||
printf("<!-- unknown dataspace -->\n");
|
||
}
|
||
|
||
indentation(indent + COL);
|
||
printf("</%sDataspace>\n", xmlnsprefix);
|
||
}
|
||
|
||
/*-------------------------------------------------------------------------
|
||
* 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, struct subset_t UNUSED * sset, int UNUSED pindex)
|
||
{
|
||
h5tool_format_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 */
|
||
|
||
if (fp_format)
|
||
{
|
||
outputformat->fmt_double = fp_format;
|
||
outputformat->fmt_float = fp_format;
|
||
}
|
||
|
||
if (nCols==0) {
|
||
outputformat->line_ncols = 65535;
|
||
outputformat->line_per_line = 1;
|
||
}
|
||
else
|
||
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("<%sData>\n", xmlnsprefix);
|
||
indentation(indent + COL);
|
||
printf("<%sDataFromFile>\n",xmlnsprefix);
|
||
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 = h5tools_dump_dset(stdout, outputformat, obj_id, -1, NULL, 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 = h5tools_get_native_type(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 = h5tools_dump_mem(stdout, outputformat, obj_id,
|
||
p_type, space, buf, depth);
|
||
|
||
free(buf);
|
||
H5Tclose(p_type);
|
||
H5Sclose(space);
|
||
H5Tclose(type);
|
||
}
|
||
}
|
||
|
||
if (status == FAIL) {
|
||
indentation(indent + COL);
|
||
printf("Unable to print data.\n");
|
||
status = 1;
|
||
}
|
||
|
||
indentation(indent + COL);
|
||
printf("</%sDataFromFile>\n",xmlnsprefix);
|
||
indentation(indent);
|
||
printf("</%sData>\n", xmlnsprefix);
|
||
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, const H5A_info_t UNUSED *info,
|
||
void UNUSED * op_data)
|
||
{
|
||
hid_t attr_id, type, space;
|
||
H5S_class_t space_type;
|
||
char *t_aname = xml_escape_the_name(attr_name);
|
||
|
||
indentation(indent);
|
||
printf("<%sAttribute Name=\"%s\">\n",xmlnsprefix, t_aname);
|
||
free(t_aname);
|
||
|
||
if ((attr_id = H5Aopen(attr, attr_name, H5P_DEFAULT)) >= 0) {
|
||
type = H5Aget_type(attr_id);
|
||
space = H5Aget_space(attr_id);
|
||
space_type = H5Sget_simple_extent_type(space);
|
||
|
||
dump_function_table->dump_dataspace_function(space);
|
||
dump_function_table->dump_datatype_function(type);
|
||
|
||
if (display_attr_data && space_type!=H5S_NULL) {
|
||
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, NULL, 0);
|
||
break;
|
||
|
||
case H5T_TIME:
|
||
indent += COL;
|
||
indentation(indent);
|
||
printf("<%sData>\n",xmlnsprefix);
|
||
indentation(indent);
|
||
printf("<!-- Time data not yet implemented. -->\n");
|
||
indentation(indent);
|
||
printf("<%sNoData/>\n",xmlnsprefix);
|
||
indentation(indent);
|
||
printf("<hdf5:Data>\n");
|
||
printf("</%sData>\n",xmlnsprefix);
|
||
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, NULL, 0);
|
||
break;
|
||
|
||
case H5T_REFERENCE:
|
||
indentation(indent);
|
||
printf("<%sData>\n",xmlnsprefix);
|
||
indentation(indent);
|
||
if (!H5Tequal(type, H5T_STD_REF_OBJ)) {
|
||
printf("<!-- Note: Region references not supported -->\n");
|
||
indentation(indent);
|
||
printf("<%sNoData />\n",xmlnsprefix);
|
||
} else {
|
||
printf("<%sDataFromFile>\n",xmlnsprefix);
|
||
xml_print_refs(attr_id, ATTRIBUTE_DATA);
|
||
indentation(indent);
|
||
printf("</%sDataFromFile>\n",xmlnsprefix);
|
||
}
|
||
indentation(indent);
|
||
printf("</%sData>\n",xmlnsprefix);
|
||
break;
|
||
|
||
case H5T_VLEN:
|
||
printf("<!-- Note: format of VL data not specified -->\n");
|
||
dump_function_table->dump_data_function(attr_id, ATTRIBUTE_DATA, NULL, 0);
|
||
break;
|
||
default:
|
||
indentation(indent);
|
||
printf("<%sData>\n",xmlnsprefix);
|
||
indentation(indent);
|
||
printf("<!-- Unknown datatype: %d -->\n", H5Tget_class(type));
|
||
indentation(indent);
|
||
printf("<%sNoData/>\n",xmlnsprefix);
|
||
indentation(indent);
|
||
printf("</%sData>\n",xmlnsprefix);
|
||
break;
|
||
}
|
||
} else {
|
||
/* The case of an attribute never yet written ??
|
||
* Or dataspace is H5S_NULL. */
|
||
indentation(indent + COL);
|
||
printf("<%sData>\n",xmlnsprefix);
|
||
indentation(indent + COL + COL);
|
||
printf("<%sNoData/>\n",xmlnsprefix);
|
||
indentation(indent + COL);
|
||
printf("</%sData>\n",xmlnsprefix);
|
||
}
|
||
|
||
H5Tclose(type);
|
||
H5Sclose(space);
|
||
H5Aclose(attr_id);
|
||
indentation(indent);
|
||
printf("</%sAttribute>\n", xmlnsprefix );
|
||
return SUCCEED;
|
||
|
||
} else {
|
||
/* ?? failed */
|
||
indentation(indent + COL);
|
||
printf("<!-- h5dump error: unable to open attribute. -->\n");
|
||
indentation(indent);
|
||
printf("</%sAttribute>\n", xmlnsprefix );
|
||
h5tools_setstatus(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)
|
||
{
|
||
char *tmp;
|
||
char * dtxid;
|
||
char * parentxid;
|
||
char *t_tmp;
|
||
char *t_prefix;
|
||
char *t_name;
|
||
|
||
tmp = (char *)HDmalloc(HDstrlen(prefix) + HDstrlen(name) + 2);
|
||
HDstrcpy(tmp, prefix);
|
||
HDstrcat(tmp, "/");
|
||
HDstrcat(tmp, name);
|
||
|
||
indentation(indent);
|
||
dtxid = (char *)HDmalloc(100);
|
||
parentxid = (char *)HDmalloc(100);
|
||
t_tmp = xml_escape_the_name(tmp);
|
||
t_prefix = xml_escape_the_name(prefix);
|
||
t_name = xml_escape_the_name(name);
|
||
|
||
xml_name_to_XID(tmp, dtxid, 100, 1);
|
||
xml_name_to_XID(prefix, parentxid, 100, 1);
|
||
if(HDstrncmp(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.
|
||
*/
|
||
printf("<%sNamedDataType Name=\"%s\" OBJ-XID=\"%s\" "
|
||
"Parents=\"%s\" H5ParentPaths=\"%s\">\n",
|
||
xmlnsprefix,
|
||
name, dtxid,
|
||
parentxid, HDstrcmp(prefix,"") ? t_prefix : "/");
|
||
} else {
|
||
H5O_info_t oinfo; /* Object info */
|
||
|
||
printf("<%sNamedDataType Name=\"%s\" OBJ-XID=\"%s\" "
|
||
"H5Path=\"%s\" Parents=\"%s\" H5ParentPaths=\"%s\">\n",
|
||
xmlnsprefix,
|
||
t_name, dtxid,
|
||
t_tmp, parentxid, (HDstrcmp(prefix, "") ? t_prefix : "/"));
|
||
|
||
/* Check uniqueness of named datatype */
|
||
H5Oget_info(type, &oinfo);
|
||
if(oinfo.rc > 1) {
|
||
obj_t *found_obj; /* Found object */
|
||
|
||
/* Group with more than one link to it... */
|
||
found_obj = search_obj(type_table, oinfo.addr);
|
||
|
||
if (found_obj == NULL) {
|
||
indentation(indent);
|
||
error_msg("internal error (file %s:line %d)\n",
|
||
__FILE__, __LINE__);
|
||
h5tools_setstatus(EXIT_FAILURE);
|
||
goto done;
|
||
} else if(found_obj->displayed) {
|
||
/* We have already printed this named datatype, print it as a
|
||
* NamedDatatypePtr
|
||
*/
|
||
char pointerxid[100];
|
||
char *t_objname = xml_escape_the_name(found_obj->objname);
|
||
|
||
indentation(indent + COL);
|
||
xml_name_to_XID(found_obj->objname, pointerxid, sizeof(pointerxid), 1);
|
||
printf("<%sNamedDatatypePtr OBJ-XID=\"%s\" H5Path=\"%s\"/>\n",
|
||
xmlnsprefix, pointerxid, t_objname);
|
||
indentation(indent);
|
||
printf("</%sNamedDataType>\n", xmlnsprefix);
|
||
HDfree(t_objname);
|
||
goto done;
|
||
} else
|
||
found_obj->displayed = TRUE;
|
||
}
|
||
}
|
||
|
||
indent += COL;
|
||
indentation(indent);
|
||
printf("<%sDataType>\n",xmlnsprefix);
|
||
|
||
indent += COL;
|
||
xml_print_datatype(type,1);
|
||
|
||
indent -= COL;
|
||
indentation(indent);
|
||
printf("</%sDataType>\n",xmlnsprefix);
|
||
|
||
indent -= COL;
|
||
indentation(indent);
|
||
printf("</%sNamedDataType>\n",xmlnsprefix);
|
||
|
||
done:
|
||
HDfree(dtxid);
|
||
HDfree(parentxid);
|
||
HDfree(t_tmp);
|
||
HDfree(t_prefix);
|
||
HDfree(t_name);
|
||
HDfree(tmp);
|
||
}
|
||
|
||
/*-------------------------------------------------------------------------
|
||
* Function: xml_dump_group
|
||
*
|
||
* Purpose: Dump a description of an HDF5 Group (and its members) in XML.
|
||
*
|
||
* Return: void
|
||
*
|
||
* Programmer: REMcG
|
||
*
|
||
* Modifications:
|
||
* Pedro Vicente, October 9, 2007
|
||
* added parameters to H5A(L)iterate to allow for other iteration orders
|
||
*
|
||
*-------------------------------------------------------------------------
|
||
*/
|
||
static void
|
||
xml_dump_group(hid_t gid, const char *name)
|
||
{
|
||
H5O_info_t oinfo;
|
||
char *cp;
|
||
hid_t dset, type;
|
||
char type_name[1024], *tmp = NULL;
|
||
char *par = NULL;
|
||
int isRoot = 0;
|
||
char *t_objname;
|
||
char *par_name;
|
||
unsigned crt_order_flags;
|
||
unsigned attr_crt_order_flags;
|
||
hid_t gcpl_id;
|
||
|
||
|
||
if ((gcpl_id = H5Gget_create_plist(gid)) < 0)
|
||
{
|
||
error_msg("error in getting group creation property list ID\n");
|
||
h5tools_setstatus(EXIT_FAILURE);
|
||
}
|
||
|
||
/* query the group creation properties for attributes */
|
||
if (H5Pget_attr_creation_order(gcpl_id, &attr_crt_order_flags) < 0)
|
||
{
|
||
error_msg("error in getting group creation properties\n");
|
||
h5tools_setstatus(EXIT_FAILURE);
|
||
}
|
||
|
||
/* query the group creation properties */
|
||
if(H5Pget_link_creation_order(gcpl_id, &crt_order_flags) < 0)
|
||
{
|
||
error_msg("error in getting group creation properties\n");
|
||
h5tools_setstatus(EXIT_FAILURE);
|
||
}
|
||
|
||
if(H5Pclose(gcpl_id) < 0) {
|
||
error_msg("error in closing group creation property list ID\n");
|
||
h5tools_setstatus(EXIT_FAILURE);
|
||
}
|
||
|
||
if(HDstrcmp(name, "/") == 0) {
|
||
isRoot = 1;
|
||
tmp = HDstrdup("/");
|
||
} else {
|
||
tmp = (char *)HDmalloc(HDstrlen(prefix) + HDstrlen(name) + 2);
|
||
HDstrcpy(tmp, prefix);
|
||
par = HDstrdup(tmp);
|
||
cp = HDstrrchr(par, '/');
|
||
if(cp) {
|
||
if((cp == par) && HDstrlen(par) > 1)
|
||
*(cp + 1) = '\0';
|
||
else
|
||
*cp = '\0';
|
||
}
|
||
}
|
||
|
||
indentation(indent);
|
||
indent += COL;
|
||
|
||
H5Oget_info(gid, &oinfo);
|
||
|
||
if(oinfo.rc > 1) {
|
||
obj_t *found_obj; /* Found object */
|
||
|
||
/* Group with more than one link to it... */
|
||
found_obj = search_obj(group_table, oinfo.addr);
|
||
|
||
if (found_obj == NULL) {
|
||
indentation(indent);
|
||
error_msg("internal error (file %s:line %d)\n",
|
||
__FILE__, __LINE__);
|
||
h5tools_setstatus(EXIT_FAILURE);
|
||
} else {
|
||
char *t_name = xml_escape_the_name(name);
|
||
char *grpxid = (char *)malloc(100);
|
||
char *parentxid = (char *)malloc(100);
|
||
|
||
if(found_obj->displayed) {
|
||
char *ptrstr = (char *)malloc(100);
|
||
|
||
/* already seen: enter a groupptr */
|
||
if(isRoot) {
|
||
/* probably can't happen! */
|
||
xml_name_to_XID("/", grpxid, 100, 1);
|
||
printf("<%sRootGroup OBJ-XID=\"%s\" H5Path=\"%s\">\n",
|
||
xmlnsprefix, grpxid, "/");
|
||
} else {
|
||
t_objname = xml_escape_the_name(found_obj->objname);
|
||
par_name = xml_escape_the_name(par);
|
||
xml_name_to_XID(tmp, grpxid, 100, 1);
|
||
xml_name_to_XID(par, parentxid, 100, 1);
|
||
printf("<%sGroup Name=\"%s\" OBJ-XID=\"%s-%d\" H5Path=\"%s\" "
|
||
"Parents=\"%s\" H5ParentPaths=\"%s\">\n",
|
||
xmlnsprefix,t_name, grpxid, get_next_xid(),
|
||
t_objname, parentxid, par_name);
|
||
free(t_objname);
|
||
free(par_name);
|
||
|
||
indentation(indent + COL);
|
||
t_objname = xml_escape_the_name(found_obj->objname);/* point to the NDT by name */
|
||
par_name = xml_escape_the_name(par);
|
||
xml_name_to_XID(found_obj->objname, ptrstr, 100, 1);
|
||
xml_name_to_XID(par, parentxid, 100, 1);
|
||
printf("<%sGroupPtr OBJ-XID=\"%s\" H5Path=\"%s\" "
|
||
"Parents=\"%s\" H5ParentPaths=\"%s\" />\n",
|
||
xmlnsprefix,
|
||
ptrstr, t_objname, parentxid, par_name);
|
||
free(t_objname);
|
||
free(par_name);
|
||
}
|
||
free(ptrstr);
|
||
} else {
|
||
|
||
/* first time this group has been seen -- describe it */
|
||
if(isRoot) {
|
||
xml_name_to_XID("/", grpxid, 100, 1);
|
||
printf("<%sRootGroup OBJ-XID=\"%s\" H5Path=\"%s\">\n",
|
||
xmlnsprefix, grpxid, "/");
|
||
} else {
|
||
char *t_tmp = xml_escape_the_name(tmp);
|
||
|
||
par_name = xml_escape_the_name(par);
|
||
xml_name_to_XID(tmp, grpxid, 100, 1);
|
||
xml_name_to_XID(par, parentxid, 100, 1);
|
||
printf("<%sGroup Name=\"%s\" OBJ-XID=\"%s\" H5Path=\"%s\" "
|
||
"Parents=\"%s\" H5ParentPaths=\"%s\" >\n",
|
||
xmlnsprefix,t_name, grpxid, t_tmp, parentxid, par_name);
|
||
free(t_tmp);
|
||
free(par_name);
|
||
}
|
||
found_obj->displayed = TRUE;
|
||
|
||
/* 1. do all the attributes of the group */
|
||
|
||
if((sort_by == H5_INDEX_CRT_ORDER) && (attr_crt_order_flags & H5P_CRT_ORDER_TRACKED)) {
|
||
if(H5Aiterate2(gid, sort_by, sort_order, NULL, dump_function_table->dump_attribute_function, NULL) < 0) {
|
||
error_msg("error getting attribute information\n");
|
||
h5tools_setstatus(EXIT_FAILURE);
|
||
} /* end if */
|
||
} /* end if */
|
||
else {
|
||
if(H5Aiterate2(gid, H5_INDEX_NAME, sort_order, NULL, dump_function_table->dump_attribute_function, NULL) < 0) {
|
||
error_msg("error getting attribute information\n");
|
||
h5tools_setstatus(EXIT_FAILURE);
|
||
} /* end if */
|
||
} /* end else */
|
||
|
||
if(isRoot && unamedtype) {
|
||
unsigned u;
|
||
|
||
/* Very special case: dump unamed type in root group */
|
||
for(u = 0; u < type_table->nobjs; u++) {
|
||
if(!type_table->objs[u].recorded) {
|
||
dset = H5Dopen2(gid, type_table->objs[u].objname, H5P_DEFAULT);
|
||
type = H5Dget_type(dset);
|
||
sprintf(type_name, "#"H5_PRINTF_HADDR_FMT, type_table->objs[u].objno);
|
||
dump_function_table->dump_named_datatype_function(type, type_name);
|
||
H5Tclose(type);
|
||
H5Dclose(dset);
|
||
}
|
||
}
|
||
}
|
||
|
||
/* iterate through all the links */
|
||
|
||
if( (sort_by == H5_INDEX_CRT_ORDER) && (crt_order_flags & H5P_CRT_ORDER_TRACKED))
|
||
H5Literate(gid, sort_by, sort_order, NULL, dump_all_cb, NULL);
|
||
else
|
||
H5Literate(gid, H5_INDEX_NAME, sort_order, NULL, dump_all_cb, NULL);
|
||
|
||
|
||
}
|
||
free(t_name);
|
||
free(grpxid);
|
||
free(parentxid);
|
||
}
|
||
} else {
|
||
|
||
/* only link -- must be first time! */
|
||
char *t_name = xml_escape_the_name(name);
|
||
char *grpxid = (char *)malloc(100);
|
||
char *parentxid = (char *)malloc(100);
|
||
|
||
if(isRoot) {
|
||
xml_name_to_XID("/", grpxid, 100, 1);
|
||
printf("<%sRootGroup OBJ-XID=\"%s\" H5Path=\"%s\">\n",
|
||
xmlnsprefix, grpxid, "/");
|
||
} else {
|
||
char *t_tmp = xml_escape_the_name(tmp);
|
||
|
||
par_name = xml_escape_the_name(par);
|
||
xml_name_to_XID(tmp, grpxid, 100, 1);
|
||
xml_name_to_XID(par, parentxid, 100, 1);
|
||
printf("<%sGroup Name=\"%s\" OBJ-XID=\"%s\" H5Path=\"%s\" "
|
||
"Parents=\"%s\" H5ParentPaths=\"%s\" >\n",
|
||
xmlnsprefix, t_name, grpxid, t_tmp,
|
||
parentxid, par_name);
|
||
free(t_tmp);
|
||
free(par_name);
|
||
}
|
||
free(t_name);
|
||
free(grpxid);
|
||
free(parentxid);
|
||
|
||
/* 1. do all the attributes of the group */
|
||
|
||
if((sort_by == H5_INDEX_CRT_ORDER) && (attr_crt_order_flags & H5P_CRT_ORDER_TRACKED)) {
|
||
if(H5Aiterate2(gid, sort_by, sort_order, NULL, dump_function_table->dump_attribute_function, NULL) < 0) {
|
||
error_msg("error getting attribute information\n");
|
||
h5tools_setstatus(EXIT_FAILURE);
|
||
} /* end if */
|
||
} /* end if */
|
||
else {
|
||
if(H5Aiterate2(gid, H5_INDEX_NAME, sort_order, NULL, dump_function_table->dump_attribute_function, NULL) < 0) {
|
||
error_msg("error getting attribute information\n");
|
||
h5tools_setstatus(EXIT_FAILURE);
|
||
} /* end if */
|
||
} /* end else */
|
||
|
||
|
||
if(isRoot && unamedtype) {
|
||
unsigned u;
|
||
|
||
/* Very special case: dump unamed type in root group */
|
||
for(u = 0; u < type_table->nobjs; u++) {
|
||
if(!type_table->objs[u].recorded) {
|
||
dset = H5Dopen2(gid, type_table->objs[u].objname, H5P_DEFAULT);
|
||
type = H5Dget_type(dset);
|
||
sprintf(type_name, "#"H5_PRINTF_HADDR_FMT, type_table->objs[u].objno);
|
||
dump_function_table->dump_named_datatype_function(type, type_name);
|
||
H5Tclose(type);
|
||
H5Dclose(dset);
|
||
}
|
||
}
|
||
}
|
||
|
||
/* iterate through all the links */
|
||
|
||
if( (sort_by == H5_INDEX_CRT_ORDER) && (crt_order_flags & H5P_CRT_ORDER_TRACKED))
|
||
H5Literate(gid, sort_by, sort_order, NULL, dump_all_cb, NULL);
|
||
else
|
||
H5Literate(gid, H5_INDEX_NAME, sort_order, NULL, dump_all_cb, NULL);
|
||
}
|
||
|
||
indent -= COL;
|
||
indentation(indent);
|
||
if(isRoot)
|
||
printf("</%sRootGroup>\n", xmlnsprefix);
|
||
else
|
||
printf("</%sGroup>\n" , xmlnsprefix);
|
||
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;
|
||
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 = (char *)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 = (char *)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 */
|
||
if(e < 0) {
|
||
free(buf);
|
||
return FAIL;
|
||
}
|
||
} else {
|
||
/* error */
|
||
return FAIL;
|
||
}
|
||
|
||
refbuf = (hobj_ref_t *) buf;
|
||
ssiz = H5Sget_simple_extent_npoints(space);
|
||
|
||
for (i = 0; i < ssiz; i++) {
|
||
const char *path;
|
||
|
||
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++;
|
||
}
|
||
|
||
free(buf);
|
||
|
||
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;
|
||
void *buf;
|
||
char *bp;
|
||
char *onestring=NULL;
|
||
hsize_t ssiz;
|
||
size_t tsiz, str_size=0;
|
||
size_t i;
|
||
htri_t is_vlstr;
|
||
|
||
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;
|
||
}
|
||
is_vlstr = H5Tis_variable_str(type);
|
||
|
||
if (source == DATASET_DATA) {
|
||
space = H5Dget_space(did);
|
||
ssiz = H5Sget_simple_extent_npoints(space);
|
||
ssiz *= H5Tget_size(type);
|
||
|
||
buf = malloc((size_t)ssiz);
|
||
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 = malloc((size_t)ssiz);
|
||
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);
|
||
bp = (char*)buf;
|
||
if(!is_vlstr)
|
||
onestring = (char *)calloc(tsiz, sizeof(char));
|
||
|
||
for (i = 0; i < ssiz; i++) {
|
||
if(is_vlstr) {
|
||
onestring = *(char **)bp;
|
||
if(onestring)
|
||
str_size = (size_t)HDstrlen(onestring);
|
||
} else {
|
||
HDstrncpy(onestring, bp, tsiz);
|
||
str_size = tsiz;
|
||
}
|
||
indentation(indent + COL);
|
||
|
||
if (!onestring) {
|
||
printf("NULL\n");
|
||
} else {
|
||
char *t_onestring = xml_escape_the_string(onestring, (int)str_size);
|
||
|
||
printf("\"%s\"\n", t_onestring);
|
||
free(t_onestring);
|
||
}
|
||
|
||
bp += tsiz;
|
||
}
|
||
|
||
return SUCCEED;
|
||
}
|
||
|
||
/*-------------------------------------------------------------------------
|
||
* Function: check_filters
|
||
*
|
||
* Purpose: private function to check for the filters and
|
||
* put tags in the XML.
|
||
*
|
||
* Return: void
|
||
*
|
||
* Programmer: REMcG
|
||
*
|
||
* Modifications:
|
||
*
|
||
*-------------------------------------------------------------------------
|
||
*/
|
||
static void
|
||
check_filters(hid_t dcpl)
|
||
{
|
||
int nfilt;
|
||
int i;
|
||
H5Z_filter_t filter;
|
||
char namebuf[120];
|
||
size_t cd_nelmts = 20;
|
||
unsigned int cd_values[20];
|
||
unsigned int flags;
|
||
|
||
nfilt = H5Pget_nfilters(dcpl);
|
||
if (nfilt <= 0)
|
||
return;
|
||
for (i = 0; i < nfilt; i++) {
|
||
filter = H5Pget_filter2(dcpl, (unsigned)i, &flags,
|
||
(size_t *) &cd_nelmts,
|
||
cd_values, 120, namebuf, NULL);
|
||
if (filter == H5Z_FILTER_DEFLATE) {
|
||
indentation(indent + COL);
|
||
printf("<%sDeflate Level=\"",xmlnsprefix);
|
||
if (cd_nelmts < 1) {
|
||
/* not sure what this means? */
|
||
printf("6");
|
||
} else {
|
||
printf("%d",cd_values[0]);
|
||
}
|
||
printf("\"/>\n");
|
||
} else if (filter == H5Z_FILTER_FLETCHER32) {
|
||
indentation(indent + COL);
|
||
printf("<%sFletcher32 />",xmlnsprefix);
|
||
} else if (filter == H5Z_FILTER_SHUFFLE) {
|
||
indentation(indent + COL);
|
||
printf("<%sShuffle />",xmlnsprefix);
|
||
} else if (filter == H5Z_FILTER_SZIP) {
|
||
|
||
indentation(indent + COL);
|
||
printf("<%sSZIP ",xmlnsprefix);
|
||
if (cd_nelmts < 2) {
|
||
/* no pixels ? */
|
||
printf("Pixels_per_block=\"-1\" ");
|
||
} else {
|
||
printf("Pixels_per_block=\"%d\" ",cd_values[1]);
|
||
}
|
||
/* analyse the options mask */
|
||
if (cd_values[0] & H5_SZIP_CHIP_OPTION_MASK) {
|
||
printf("Mode =\"Hardware\" ");
|
||
} else if (cd_values[0] & H5_SZIP_ALLOW_K13_OPTION_MASK) {
|
||
printf("Mode =\"K13\" ");
|
||
}
|
||
printf("Coding=\"");
|
||
if (cd_values[0] & H5_SZIP_EC_OPTION_MASK) {
|
||
printf("Entropy");
|
||
} else if (cd_values[0] & H5_SZIP_NN_OPTION_MASK) {
|
||
printf("NN");
|
||
}
|
||
printf("\" ");
|
||
|
||
printf("ByteOrder=\"");
|
||
if (cd_values[0] & H5_SZIP_LSB_OPTION_MASK) {
|
||
printf("LSB");
|
||
} else if (cd_values[0] & H5_SZIP_MSB_OPTION_MASK) {
|
||
printf("MSB");
|
||
}
|
||
printf("\" ");
|
||
|
||
if (cd_values[0] & H5_SZIP_RAW_OPTION_MASK) {
|
||
printf("Header=\"Raw\"");
|
||
}
|
||
printf("/>\n");
|
||
} else {
|
||
/* unknown option */
|
||
}
|
||
}
|
||
}
|
||
|
||
static void
|
||
xml_dump_fill_value(hid_t dcpl, hid_t type)
|
||
{
|
||
size_t sz;
|
||
size_t i;
|
||
hsize_t space;
|
||
void * buf;
|
||
char * name;
|
||
|
||
indent += COL;
|
||
indentation(indent);
|
||
printf("<%sData>\n",xmlnsprefix);
|
||
indent += COL;
|
||
|
||
space = H5Tget_size(type);
|
||
buf = malloc((size_t)space);
|
||
|
||
H5Pget_fill_value(dcpl, type, buf);
|
||
|
||
if (H5Tget_class(type) == H5T_REFERENCE) {
|
||
const char * path;
|
||
|
||
path = lookup_ref_path(*(hobj_ref_t *)buf);
|
||
|
||
indentation(indent);
|
||
printf("<%sDataFromFile>\n",xmlnsprefix);
|
||
if (!path) {
|
||
printf("\"%s\"\n", "NULL");
|
||
} else {
|
||
char *t_path = xml_escape_the_string(path, -1);
|
||
|
||
printf("\"%s\"\n", t_path);
|
||
free(t_path);
|
||
}
|
||
indentation(indent);
|
||
printf("</%sDataFromFile>\n",xmlnsprefix);
|
||
} else if (H5Tget_class(type) == H5T_STRING) {
|
||
/* ????? */
|
||
indentation(indent);
|
||
printf("<!-- String fill values not yet implemented. -->\n");
|
||
indentation(indent);
|
||
printf("<%sNoData />\n",xmlnsprefix);
|
||
} else {
|
||
/* all other data */
|
||
switch (H5Tget_class(type)) {
|
||
case H5T_INTEGER:
|
||
indentation(indent);
|
||
printf("<%sDataFromFile>\n",xmlnsprefix);
|
||
indentation(indent);
|
||
printf("\"%d\"\n",*(int *)buf);
|
||
indentation(indent);
|
||
printf("</%sDataFromFile>\n",xmlnsprefix);
|
||
break;
|
||
case H5T_FLOAT:
|
||
indentation(indent);
|
||
printf("<%sDataFromFile>\n",xmlnsprefix);
|
||
indentation(indent);
|
||
printf("\"%f\"\n",*(float *)buf);
|
||
indentation(indent);
|
||
printf("</%sDataFromFile>\n",xmlnsprefix);
|
||
break;
|
||
case H5T_BITFIELD:
|
||
case H5T_OPAQUE:
|
||
indentation(indent);
|
||
printf("<%sDataFromFile>\n",xmlnsprefix);
|
||
sz = H5Tget_size(type);
|
||
indentation(indent);
|
||
printf("\"");
|
||
for (i = 0; i < sz; i++) {
|
||
printf("%x ",*(unsigned int *)buf);
|
||
buf = (char *)buf + sizeof(unsigned int);
|
||
}
|
||
printf("\"\n");
|
||
indentation(indent);
|
||
printf("</%sDataFromFile>\n",xmlnsprefix);
|
||
break;
|
||
case H5T_ENUM:
|
||
indentation(indent);
|
||
printf("<%sDataFromFile>\n",xmlnsprefix);
|
||
name = H5Tget_member_name(type, *(unsigned *)buf);
|
||
indentation(indent);
|
||
printf("\"%s\"\n",name);
|
||
indentation(indent);
|
||
printf("</%sDataFromFile>\n",xmlnsprefix);
|
||
break;
|
||
case H5T_ARRAY:
|
||
indentation(indent);
|
||
printf("<!-- Array fill values not yet implemented. -->\n");
|
||
indentation(indent);
|
||
printf("<%sNoData />\n",xmlnsprefix);
|
||
break;
|
||
case H5T_TIME:
|
||
indentation(indent);
|
||
printf("<!-- Time fill not yet implemented. -->\n");
|
||
indentation(indent);
|
||
printf("<%sNoData />\n",xmlnsprefix);
|
||
break;
|
||
case H5T_COMPOUND:
|
||
indentation(indent);
|
||
printf("<!-- Compound fill not yet implemented. -->\n");
|
||
indentation(indent);
|
||
printf("<%sNoData />\n",xmlnsprefix);
|
||
break;
|
||
case H5T_VLEN:
|
||
indentation(indent);
|
||
printf("<!-- VL fill not yet implemented. -->\n");
|
||
indentation(indent);
|
||
printf("<%sNoData />\n",xmlnsprefix);
|
||
break;
|
||
default:
|
||
indentation(indent);
|
||
printf("<!-- Unknown fill datatype: %d -->\n", H5Tget_class(type));
|
||
indentation(indent);
|
||
printf("<%sNoData/>\n",xmlnsprefix);
|
||
break;
|
||
}
|
||
}
|
||
free(buf);
|
||
indent -= COL;
|
||
indentation(indent);
|
||
printf("</%sData>\n",xmlnsprefix);
|
||
indent -= COL;
|
||
}
|
||
|
||
/*-------------------------------------------------------------------------
|
||
* Function: xml_dump_dataset
|
||
*
|
||
* Purpose: Dump a description of an HDF5 dataset in XML.
|
||
*
|
||
* Return: void
|
||
*
|
||
* Programmer: REMcG
|
||
*
|
||
* Modifications:
|
||
* Pedro Vicente, October 9, 2007
|
||
* added parameters to H5Aiterate2 to allow for other iteration orders
|
||
*
|
||
*-------------------------------------------------------------------------
|
||
*/
|
||
static void
|
||
xml_dump_dataset(hid_t did, const char *name, struct subset_t UNUSED * sset)
|
||
{
|
||
hid_t type, space;
|
||
hid_t dcpl;
|
||
H5D_fill_value_t fvstatus;
|
||
int maxdims;
|
||
hsize_t *chsize;
|
||
int ndims;
|
||
int i;
|
||
H5D_alloc_time_t at;
|
||
H5D_fill_time_t ft;
|
||
hsize_t tempi;
|
||
char *tmp;
|
||
char *t_name, *t_tmp, *t_prefix;
|
||
unsigned attr_crt_order_flags;
|
||
char *rstr = (char *)HDmalloc(100);
|
||
char *pstr = (char *)HDmalloc(100);
|
||
|
||
tmp = (char *)HDmalloc(HDstrlen(prefix) + HDstrlen(name) + 2);
|
||
HDstrcpy(tmp, prefix);
|
||
HDstrcat(tmp, "/");
|
||
HDstrcat(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);
|
||
|
||
xml_name_to_XID(tmp, rstr, 100, 1);
|
||
xml_name_to_XID(prefix, pstr, 100, 1);
|
||
printf("<%sDataset Name=\"%s\" OBJ-XID=\"%s\" H5Path= \"%s\" Parents=\"%s\" H5ParentPaths=\"%s\">\n",xmlnsprefix,
|
||
t_name, rstr, t_tmp, pstr, strcmp(prefix, "") ? t_prefix : "/");
|
||
|
||
HDfree(t_name);
|
||
HDfree(t_tmp);
|
||
HDfree(t_prefix);
|
||
HDfree(rstr);
|
||
HDfree(pstr);
|
||
HDfree(tmp);
|
||
|
||
dcpl = H5Dget_create_plist(did);
|
||
type = H5Dget_type(did);
|
||
space = H5Dget_space(did);
|
||
|
||
/* query the creation properties for attributes */
|
||
H5Pget_attr_creation_order(dcpl, &attr_crt_order_flags);
|
||
|
||
/* Print information about storage layout */
|
||
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("<%sStorageLayout>\n",xmlnsprefix);
|
||
indent += COL;
|
||
indentation(indent);
|
||
printf("<%sChunkedLayout ",xmlnsprefix);
|
||
ndims = H5Pget_chunk(dcpl, maxdims, chsize);
|
||
printf("Ndims=\"%d\">\n", ndims);
|
||
|
||
indent += COL;
|
||
|
||
for (i = 0; i < ndims; i++) {
|
||
indentation(indent);
|
||
HDfprintf(stdout, "<%sChunkDimension DimSize=\"%Hu\" />\n",
|
||
xmlnsprefix, chsize[i]);
|
||
}
|
||
|
||
indentation(indent);
|
||
printf("<%sRequiredFilter>\n",xmlnsprefix);
|
||
indent += COL;
|
||
check_filters(dcpl);
|
||
indent -= COL;
|
||
indentation(indent);
|
||
printf("</%sRequiredFilter>\n",xmlnsprefix);
|
||
|
||
indent -= COL;
|
||
|
||
indentation(indent);
|
||
printf("</%sChunkedLayout>\n",xmlnsprefix);
|
||
indent -= COL;
|
||
indentation(indent);
|
||
printf("</%sStorageLayout>\n",xmlnsprefix);
|
||
indent -= COL;
|
||
free(chsize);
|
||
} else if (H5D_CONTIGUOUS == H5Pget_layout(dcpl)) {
|
||
indent += COL;
|
||
indentation(indent);
|
||
printf("<%sStorageLayout>\n",xmlnsprefix);
|
||
indent += COL;
|
||
indentation(indent);
|
||
printf("<%sContiguousLayout/>\n",xmlnsprefix);
|
||
indent -= COL;
|
||
indentation(indent);
|
||
printf("</%sStorageLayout>\n",xmlnsprefix);
|
||
indent -= COL;
|
||
indentation(indent);
|
||
} else if (H5D_COMPACT == H5Pget_layout(dcpl)) {
|
||
indent += COL;
|
||
indentation(indent);
|
||
printf("<%sStorageLayout>\n",xmlnsprefix);
|
||
indent += COL;
|
||
indentation(indent);
|
||
printf("<%sCompactLayout/>\n",xmlnsprefix);
|
||
indent -= COL;
|
||
indentation(indent);
|
||
printf("</%sStorageLayout>\n",xmlnsprefix);
|
||
indent -= COL;
|
||
indentation(indent);
|
||
}
|
||
/* and check for external.... ?? */
|
||
|
||
/* fill value */
|
||
|
||
indent += COL;
|
||
indentation(indent);
|
||
printf("<%sFillValueInfo ",xmlnsprefix);
|
||
H5Pget_fill_time(dcpl, &ft);
|
||
printf("FillTime=\"");
|
||
switch ( ft ) {
|
||
case H5D_FILL_TIME_ALLOC:
|
||
printf("FillOnAlloc");
|
||
break;
|
||
case H5D_FILL_TIME_NEVER:
|
||
printf("FillNever");
|
||
break;
|
||
case H5D_FILL_TIME_IFSET:
|
||
printf("FillIfSet");
|
||
break;
|
||
default:
|
||
printf("?");
|
||
break;
|
||
}
|
||
printf("\" ");
|
||
H5Pget_alloc_time(dcpl, &at);
|
||
printf("AllocationTime=\"");
|
||
switch ( at ) {
|
||
case H5D_ALLOC_TIME_EARLY:
|
||
printf("Early");
|
||
break;
|
||
case H5D_ALLOC_TIME_INCR:
|
||
printf("Incremental");
|
||
break;
|
||
case H5D_ALLOC_TIME_LATE:
|
||
printf("Late");
|
||
break;
|
||
case H5D_ALLOC_TIME_DEFAULT:
|
||
default:
|
||
printf("?");
|
||
break;
|
||
}
|
||
printf("\"");
|
||
printf(">\n");
|
||
|
||
indent += COL;
|
||
indentation(indent);
|
||
printf("<%sFillValue>\n",xmlnsprefix);
|
||
indent += COL;
|
||
H5Pfill_value_defined(dcpl, &fvstatus);
|
||
if (fvstatus == H5D_FILL_VALUE_UNDEFINED ||
|
||
(fvstatus==H5D_FILL_VALUE_DEFAULT && ft==H5D_FILL_TIME_IFSET)) {
|
||
indentation(indent + COL);
|
||
printf("<%sNoFill/>\n",xmlnsprefix);
|
||
} else {
|
||
xml_dump_fill_value(dcpl,type);
|
||
}
|
||
|
||
indent -= COL;
|
||
indentation(indent);
|
||
printf("</%sFillValue>\n",xmlnsprefix);
|
||
|
||
indent -= COL;
|
||
indentation(indent);
|
||
printf("</%sFillValueInfo>\n",xmlnsprefix);
|
||
indent -= COL;
|
||
|
||
dump_function_table->dump_dataspace_function(space);
|
||
dump_function_table->dump_datatype_function(type);
|
||
|
||
indent += COL;
|
||
|
||
if((sort_by == H5_INDEX_CRT_ORDER) && (attr_crt_order_flags & H5P_CRT_ORDER_TRACKED)) {
|
||
if(H5Aiterate2(did, sort_by, sort_order, NULL, dump_function_table->dump_attribute_function, NULL) < 0) {
|
||
error_msg("error getting attribute information\n");
|
||
h5tools_setstatus(EXIT_FAILURE);
|
||
} /* end if */
|
||
} /* end if */
|
||
else {
|
||
if(H5Aiterate2(did, H5_INDEX_NAME, sort_order, NULL, dump_function_table->dump_attribute_function, NULL) < 0) {
|
||
error_msg("error getting attribute information\n");
|
||
h5tools_setstatus(EXIT_FAILURE);
|
||
} /* end if */
|
||
} /* end else */
|
||
|
||
indent -= COL;
|
||
tempi = H5Dget_storage_size(did);
|
||
|
||
if (display_data && (tempi > 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, NULL, 0);
|
||
break;
|
||
|
||
case H5T_TIME:
|
||
indent += COL;
|
||
indentation(indent);
|
||
printf("<%sData>\n",xmlnsprefix);
|
||
indentation(indent);
|
||
printf("<!-- Time data not yet implemented. -->\n");
|
||
indentation(indent);
|
||
printf("<%sNoData />\n",xmlnsprefix);
|
||
indentation(indent);
|
||
printf("<%sData>\n",xmlnsprefix);
|
||
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, NULL, 0);
|
||
break;
|
||
|
||
case H5T_REFERENCE:
|
||
indentation(indent);
|
||
printf("<%sData>\n",xmlnsprefix);
|
||
indentation(indent);
|
||
if (!H5Tequal(type, H5T_STD_REF_OBJ)) {
|
||
printf("<!-- Note: Region references not supported -->\n");
|
||
indentation(indent);
|
||
printf("<%sNoData />\n",xmlnsprefix);
|
||
} else {
|
||
printf("<%sDataFromFile>\n",xmlnsprefix);
|
||
xml_print_refs(did, DATASET_DATA);
|
||
indentation(indent);
|
||
printf("</%sDataFromFile>\n",xmlnsprefix);
|
||
}
|
||
indentation(indent);
|
||
printf("</%sData>\n",xmlnsprefix);
|
||
break;
|
||
|
||
case H5T_VLEN:
|
||
printf("<!-- Note: format of VL data not specified -->\n");
|
||
dump_function_table->dump_data_function(did, DATASET_DATA, NULL, 0);
|
||
break;
|
||
default:
|
||
indentation(indent);
|
||
printf("<%sData>\n",xmlnsprefix);
|
||
indentation(indent);
|
||
printf("<!-- Unknown datatype: %d -->\n", H5Tget_class(type));
|
||
indentation(indent);
|
||
printf("<%sNoData/>\n",xmlnsprefix);
|
||
indentation(indent);
|
||
printf("</%sData>\n",xmlnsprefix);
|
||
break;
|
||
}
|
||
} else {
|
||
/* no data written */
|
||
indentation(indent + COL);
|
||
printf("<%sData>\n",xmlnsprefix);
|
||
indentation(indent + COL + COL);
|
||
printf("<%sNoData/>\n",xmlnsprefix);
|
||
indentation(indent + COL);
|
||
printf("</%sData>\n",xmlnsprefix);
|
||
}
|
||
|
||
H5Tclose(type);
|
||
H5Sclose(space);
|
||
H5Pclose(dcpl);
|
||
indentation(indent);
|
||
printf("</%sDataset>\n", xmlnsprefix);
|
||
}
|
||
|
||
/*-------------------------------------------------------------------------
|
||
* 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 */
|
||
unsigned nmembs; /*number of members */
|
||
hid_t super; /*enum base integer type */
|
||
hid_t native = -1; /*native integer datatype */
|
||
size_t dst_size; /*destination value type size */
|
||
unsigned i; /*miscellaneous counters */
|
||
size_t j;
|
||
|
||
nmembs = (unsigned)H5Tget_nmembers(type);
|
||
super = H5Tget_super(type);
|
||
|
||
indentation(indent);
|
||
printf("<%sDataType>\n",xmlnsprefix);
|
||
xml_print_datatype(super,0);
|
||
indentation(indent);
|
||
printf("</%sDataType>\n",xmlnsprefix);
|
||
|
||
/*
|
||
* Determine what datatype to use for the native values. To simplify
|
||
* things we entertain three possibilities:
|
||
* 1. long long -- the largest native signed integer
|
||
* 2. unsigned long long -- the largest native unsigned integer
|
||
* 3. raw format
|
||
*/
|
||
if (H5Tget_size(type) <= sizeof(long long)) {
|
||
dst_size = sizeof(long long);
|
||
|
||
if (H5T_SGN_NONE == H5Tget_sign(type)) {
|
||
native = H5T_NATIVE_ULLONG;
|
||
} else {
|
||
native = H5T_NATIVE_LLONG;
|
||
}
|
||
} else {
|
||
dst_size = H5Tget_size(type);
|
||
}
|
||
|
||
/* Get the names and raw values of all members */
|
||
name = (char **)calloc(nmembs, sizeof(char *));
|
||
value = (unsigned char *)calloc(nmembs, MAX(H5Tget_size(type), dst_size));
|
||
|
||
for (i = 0; i < nmembs; i++) {
|
||
name[i] = H5Tget_member_name(type, i);
|
||
H5Tget_member_value(type, i, value + i * H5Tget_size(type));
|
||
}
|
||
|
||
/* Convert values to native datatype */
|
||
if (native > 0)
|
||
H5Tconvert(super, native, nmembs, value, NULL, H5P_DEFAULT);
|
||
|
||
/* Sort members by increasing value */
|
||
/*not implemented yet */
|
||
|
||
/* Print members */
|
||
indent += COL;
|
||
for (i = 0; i < nmembs; i++) {
|
||
char *t_name = xml_escape_the_name(name[i]);
|
||
|
||
indentation(indent);
|
||
printf("<%sEnumElement>\n",xmlnsprefix);
|
||
indentation(indent + COL);
|
||
printf("%s\n", t_name);
|
||
free(t_name);
|
||
indentation(indent);
|
||
printf("</%sEnumElement>\n",xmlnsprefix);
|
||
indentation(indent);
|
||
printf("<%sEnumValue>\n",xmlnsprefix);
|
||
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)) {
|
||
HDfprintf(stdout,"%" H5_PRINTF_LL_WIDTH "u", *((unsigned long long *)
|
||
((void *) (value + i * dst_size))));
|
||
} else {
|
||
HDfprintf(stdout,"%" H5_PRINTF_LL_WIDTH "d",
|
||
*((long long *) ((void *) (value + i * dst_size))));
|
||
}
|
||
printf("\n");
|
||
indentation(indent);
|
||
printf("</%sEnumValue>\n",xmlnsprefix);
|
||
|
||
}
|
||
indent -= COL;
|
||
|
||
/* Release resources */
|
||
for (i = 0; i < nmembs; i++)
|
||
free(name[i]);
|
||
|
||
free(name);
|
||
free(value);
|
||
H5Tclose(super);
|
||
}
|
||
|
||
|
||
/*-------------------------------------------------------------------------
|
||
* Function: h5_fileaccess
|
||
*
|
||
* Purpose: Returns a file access template which is the default template
|
||
* but with a file driver set according to the constant or
|
||
* environment variable HDF5_DRIVER
|
||
*
|
||
* Return: Success: A file access property list
|
||
*
|
||
* Failure: -1
|
||
*
|
||
* Programmer: Robb Matzke
|
||
* Thursday, November 19, 1998
|
||
*
|
||
* Modifications:
|
||
*
|
||
*-------------------------------------------------------------------------
|
||
*/
|
||
static hid_t
|
||
h5_fileaccess(void)
|
||
{
|
||
static const char *multi_letters = "msbrglo";
|
||
const char *val = NULL;
|
||
const char *name;
|
||
char s[1024];
|
||
hid_t fapl = -1;
|
||
|
||
/* First use the environment variable, then the constant */
|
||
val = HDgetenv("HDF5_DRIVER");
|
||
#ifdef HDF5_DRIVER
|
||
if (!val) val = HDF5_DRIVER;
|
||
#endif
|
||
|
||
if ((fapl=H5Pcreate(H5P_FILE_ACCESS))<0) return -1;
|
||
if (!val || !*val) return fapl; /*use default*/
|
||
|
||
HDstrncpy(s, val, sizeof s);
|
||
s[sizeof(s)-1] = '\0';
|
||
if (NULL==(name=HDstrtok(s, " \t\n\r"))) return fapl;
|
||
|
||
if (!HDstrcmp(name, "sec2")) {
|
||
/* Unix read() and write() system calls */
|
||
if (H5Pset_fapl_sec2(fapl)<0) return -1;
|
||
} else if (!HDstrcmp(name, "stdio")) {
|
||
/* Standard C fread() and fwrite() system calls */
|
||
if (H5Pset_fapl_stdio(fapl)<0) return -1;
|
||
} else if (!HDstrcmp(name, "core")) {
|
||
/* In-core temporary file with 1MB increment */
|
||
if (H5Pset_fapl_core(fapl, 1024*1024, FALSE)<0) return -1;
|
||
} else if (!HDstrcmp(name, "split")) {
|
||
/* Split meta data and raw data each using default driver */
|
||
if (H5Pset_fapl_split(fapl,
|
||
"-m.h5", H5P_DEFAULT,
|
||
"-r.h5", H5P_DEFAULT)<0)
|
||
return -1;
|
||
} else if (!HDstrcmp(name, "multi")) {
|
||
/* Multi-file driver, general case of the split driver */
|
||
H5FD_mem_t memb_map[H5FD_MEM_NTYPES];
|
||
hid_t memb_fapl[H5FD_MEM_NTYPES];
|
||
const char *memb_name[H5FD_MEM_NTYPES];
|
||
char sv[H5FD_MEM_NTYPES][1024];
|
||
haddr_t memb_addr[H5FD_MEM_NTYPES];
|
||
H5FD_mem_t mt;
|
||
|
||
HDmemset(memb_map, 0, sizeof memb_map);
|
||
HDmemset(memb_fapl, 0, sizeof memb_fapl);
|
||
HDmemset(memb_name, 0, sizeof memb_name);
|
||
HDmemset(memb_addr, 0, sizeof memb_addr);
|
||
|
||
assert(HDstrlen(multi_letters)==H5FD_MEM_NTYPES);
|
||
for (mt=H5FD_MEM_DEFAULT; mt<H5FD_MEM_NTYPES; H5_INC_ENUM(H5FD_mem_t,mt)) {
|
||
memb_fapl[mt] = H5P_DEFAULT;
|
||
memb_map[mt] = mt;
|
||
sprintf(sv[mt], "%%s-%c.h5", multi_letters[mt]);
|
||
memb_name[mt] = sv[mt];
|
||
memb_addr[mt] = MAX(mt-1,0)*(HADDR_MAX/10);
|
||
}
|
||
|
||
if (H5Pset_fapl_multi(fapl, memb_map, memb_fapl, memb_name,
|
||
memb_addr, FALSE) < 0)
|
||
return -1;
|
||
} else if (!HDstrcmp(name, "family")) {
|
||
hsize_t fam_size = 100*1024*1024; /*100 MB*/
|
||
|
||
/* Family of files, each 1MB and using the default driver */
|
||
if ((val=HDstrtok(NULL, " \t\n\r")))
|
||
fam_size = (hsize_t)(HDstrtod(val, NULL) * 1024*1024);
|
||
if (H5Pset_fapl_family(fapl, fam_size, H5P_DEFAULT)<0)
|
||
return -1;
|
||
} else if (!HDstrcmp(name, "log")) {
|
||
long log_flags = H5FD_LOG_LOC_IO;
|
||
|
||
/* Log file access */
|
||
if ((val = HDstrtok(NULL, " \t\n\r")))
|
||
log_flags = HDstrtol(val, NULL, 0);
|
||
|
||
if (H5Pset_fapl_log(fapl, NULL, (unsigned)log_flags, 0) < 0)
|
||
return -1;
|
||
} else if (!HDstrcmp(name, "direct")) {
|
||
/* Substitute Direct I/O driver with sec2 driver temporarily because
|
||
* some output has sec2 driver as the standard. */
|
||
if (H5Pset_fapl_sec2(fapl)<0) return -1;
|
||
} else {
|
||
/* Unknown driver */
|
||
return -1;
|
||
}
|
||
|
||
return fapl;
|
||
}
|
||
|
||
|
||
/*-------------------------------------------------------------------------
|
||
* Function: init_prefix
|
||
*
|
||
* Purpose: allocate and initialize prefix
|
||
*
|
||
* Return: void
|
||
*
|
||
* Modifications:
|
||
*
|
||
*-------------------------------------------------------------------------
|
||
*/
|
||
static void
|
||
init_prefix(char **prfx, size_t prfx_len)
|
||
{
|
||
HDassert(prfx_len > 0);
|
||
*prfx = (char *)HDcalloc(prfx_len, 1);
|
||
}
|
||
|
||
|
||
/*-------------------------------------------------------------------------
|
||
* Function: add_prefix
|
||
*
|
||
* Purpose: Add object to prefix
|
||
*
|
||
* Return: void
|
||
*
|
||
*-------------------------------------------------------------------------
|
||
*/
|
||
static void
|
||
add_prefix(char **prfx, size_t *prfx_len, const char *name)
|
||
{
|
||
size_t new_len = HDstrlen(*prfx) + HDstrlen(name) + 2;
|
||
|
||
/* Check if we need more space */
|
||
if(*prfx_len <= new_len) {
|
||
*prfx_len = new_len + 1;
|
||
*prfx = (char *)HDrealloc(*prfx, *prfx_len);
|
||
}
|
||
|
||
/* Append object name to prefix */
|
||
HDstrcat(HDstrcat(*prfx, "/"), name);
|
||
} /* end add_prefix */
|
||
|
||
|
||
/*-------------------------------------------------------------------------
|
||
* Function: dump_extlink
|
||
*
|
||
* made by: PVN
|
||
*
|
||
* Purpose: Dump an external link
|
||
* Since external links are soft links, they are dumped on a trial error
|
||
* basis, attempting to dump as a dataset, as a group and as a named datatype
|
||
* Error messages are supressed
|
||
*
|
||
* Modifications:
|
||
* Neil Fortner
|
||
* 13 October 2008
|
||
* Function basically rewritten. No longer directly opens the target file,
|
||
* now initializes a new set of tables for the external file. No longer
|
||
* dumps on a trial and error basis, but errors are still suppressed.
|
||
*
|
||
*-------------------------------------------------------------------------
|
||
*/
|
||
|
||
static int dump_extlink(hid_t group, const char *linkname, const char *objname)
|
||
{
|
||
hid_t oid;
|
||
H5O_info_t oi;
|
||
table_t *old_group_table = group_table;
|
||
table_t *old_dset_table = dset_table;
|
||
table_t *old_type_table = type_table;
|
||
hbool_t old_hit_elink;
|
||
ssize_t idx;
|
||
|
||
|
||
/* Open target object */
|
||
if ((oid = H5Oopen(group, linkname, H5P_DEFAULT)) < 0)
|
||
goto fail;
|
||
|
||
/* Get object info */
|
||
if (H5Oget_info(oid, &oi) < 0) {
|
||
H5Oclose(oid);
|
||
goto fail;
|
||
}
|
||
|
||
/* Check if we have visited this file already */
|
||
if ((idx = table_list_visited(oi.fileno)) < 0) {
|
||
/* We have not visited this file, build object tables */
|
||
if ((idx = table_list_add(oid, oi.fileno)) < 0) {
|
||
H5Oclose(oid);
|
||
goto fail;
|
||
}
|
||
}
|
||
|
||
/* Do not recurse through an external link into the original file (idx=0) */
|
||
if (idx) {
|
||
/* Update table pointers */
|
||
group_table = table_list.tables[idx].group_table;
|
||
dset_table = table_list.tables[idx].dset_table;
|
||
type_table = table_list.tables[idx].type_table;
|
||
|
||
/* We will now traverse the external link, set this global to indicate this */
|
||
old_hit_elink = hit_elink;
|
||
hit_elink = TRUE;
|
||
|
||
/* add some indentation to distinguish that these objects are external */
|
||
indent += 2*COL;
|
||
|
||
/* Recurse into the external file */
|
||
switch (oi.type) {
|
||
case H5O_TYPE_GROUP:
|
||
handle_groups(group, linkname, NULL, 0, objname);
|
||
break;
|
||
case H5O_TYPE_DATASET:
|
||
handle_datasets(group, linkname, NULL, 0, objname);
|
||
break;
|
||
case H5O_TYPE_NAMED_DATATYPE:
|
||
handle_datatypes(group, linkname, NULL, 0, objname);
|
||
break;
|
||
default:
|
||
h5tools_setstatus(EXIT_FAILURE);
|
||
}
|
||
|
||
indent -= 2*COL;
|
||
|
||
/* Reset table pointers */
|
||
group_table = old_group_table;
|
||
dset_table = old_dset_table;
|
||
type_table = old_type_table;
|
||
|
||
/* Reset hit_elink */
|
||
hit_elink = old_hit_elink;
|
||
} /* end if */
|
||
|
||
if (H5Idec_ref(oid) < 0)
|
||
h5tools_setstatus(EXIT_FAILURE);
|
||
|
||
|
||
return SUCCEED;
|
||
|
||
fail:
|
||
|
||
return FAIL;
|
||
|
||
}
|
||
|