/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
* Copyright by The HDF Group. *
* 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 COPYING file, which can be found at the root of the source code *
* distribution tree, or in https://www.hdfgroup.org/licenses. *
* If you do not have access to either file, you may request a copy from *
* help@hdfgroup.org. *
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
/*
* Programmer: Robb Matzke
* Monday, March 23, 1998
*/
/*
* We include the private header file so we can get to the uniform
* programming environment it declares. Other than that, h5ls only calls
* HDF5 API functions (except for H5G_basename())
*/
#include "H5private.h"
#include "h5tools.h"
#include "h5tools_utils.h"
#include "h5tools_dump.h"
#include "h5trav.h"
/* Name of tool */
#define PROGRAMNAME "h5ls"
#define NAME_BUF_SIZE 2048
/*
* Alternative formatting for data dumped by H5LS
*
* This table only affects H5LS output.
*/
static h5tool_format_t ls_dataformat = {
0, /*raw */
"", /*fmt_raw */
"%d", /*fmt_int */
"%u", /*fmt_uint */
"%hhd", /*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 */
NULL, /* cmpd_listv */
",", /*vlen_sep */
"(", /*vlen_pre */
")", /*vlen_suf */
"", /*vlen_end */
"%s", /*elmt_fmt */
",", /*elmt_suf1 */
" ", /*elmt_suf2 */
HSIZE_T_FORMAT, /*idx_n_fmt */
",", /*idx_sep */
"(%s)", /*idx_fmt */
65535,
/*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 */
0, /*skip_first */
0, /*obj_hidefileno */
"-%lu:%" PRIuHADDR, /*obj_format */
0, /*dset_hidefileno */
"DSET-%s ", /*dset_format */
"%sBlk%lu: ", /*dset_blockformat_pre */
"%sPt%lu: ", /*dset_ptformat_pre */
"%s", /*dset_ptformat */
1, /*array indices */
1 /*escape non printable characters */
};
/* Struct to pass through to visitors */
typedef struct {
const char *fname; /* Filename */
hid_t fid; /* File ID */
hid_t gid; /* Group ID */
hbool_t symlink_target; /* Whether this is the target of an symbolic link */
symlink_trav_t *symlink_list; /* List of visited symbolic links */
size_t base_len; /* Length of base path name, if not root */
size_t name_start; /* # of leading characters to strip off path names on output */
} iter_t;
/* Command-line switches */
static int verbose_g = 0; /* lots of extra output */
static int width_g = 80; /* output width in characters */
static hbool_t address_g = FALSE; /* print raw data addresses */
static hbool_t data_g = FALSE; /* display dataset values? */
static hbool_t label_g = FALSE; /* label compound values? */
static hbool_t string_g = FALSE; /* print 1-byte numbers as ASCII? */
static hbool_t fullname_g = FALSE; /* print full path names */
static hbool_t recursive_g = FALSE; /* recursive descent listing */
static hbool_t follow_symlink_g = FALSE; /* follow symbolic links */
static hbool_t no_dangling_link_g = FALSE; /* treat dangling link is error */
static hbool_t follow_elink_g = FALSE; /* follow external links */
static hbool_t grp_literal_g = FALSE; /* list group, not contents */
static hbool_t hexdump_g = FALSE; /* show data as raw hexadecimal */
static hbool_t simple_output_g = FALSE; /* make output more machine-readable */
static hbool_t show_file_name_g = FALSE; /* show file name for full names */
static hbool_t no_line_wrap_g = FALSE; /* show data content without line wrap */
static hbool_t display_root_g = FALSE; /* show root group in output? */
/* Information about how to display each type of object */
static struct dispatch_t {
const char *name;
hid_t (*open)(hid_t loc, const char *name, hid_t apl_id);
herr_t (*close)(hid_t obj);
herr_t (*list1)(hid_t obj);
herr_t (*list2)(hid_t obj, const char *name);
} dispatch_g[H5O_TYPE_NTYPES];
#define DISPATCH(TYPE, NAME, LIST1, LIST2) \
{ \
dispatch_g[TYPE].name = (NAME); \
dispatch_g[TYPE].list1 = (LIST1); \
dispatch_g[TYPE].list2 = (LIST2); \
}
static void print_type(h5tools_str_t *buffer, hid_t type, int ind);
static hbool_t print_int_type(h5tools_str_t *buffer, hid_t type, int ind);
static hbool_t print_float_type(h5tools_str_t *buffer, hid_t type, int ind);
static herr_t visit_obj(hid_t file, const char *oname, iter_t *iter);
/*-------------------------------------------------------------------------
* Function: usage
*
* Purpose: Prints a usage message on stderr and then returns.
*
* Return: void
*-------------------------------------------------------------------------
*/
static void
usage(void)
{
FLUSHSTREAM(rawoutstream);
PRINTVALSTREAM(rawoutstream, "usage: h5ls [OPTIONS] file[/OBJECT] [file[/[OBJECT]...]\n");
PRINTVALSTREAM(rawoutstream, " OPTIONS\n");
PRINTVALSTREAM(rawoutstream, " -h, -?, --help Print a usage message and exit\n");
PRINTVALSTREAM(rawoutstream,
" -a, --address Print raw data address. If dataset is contiguous, address\n");
PRINTVALSTREAM(rawoutstream,
" is offset in file of beginning of raw data. If chunked,\n");
PRINTVALSTREAM(rawoutstream,
" returned list of addresses indicates offset of each chunk.\n");
PRINTVALSTREAM(rawoutstream, " Must be used with -v, --verbose option.\n");
PRINTVALSTREAM(rawoutstream, " Provides no information for non-dataset objects.\n");
PRINTVALSTREAM(rawoutstream, " -d, --data Print the values of datasets\n");
PRINTVALSTREAM(rawoutstream, " --enable-error-stack\n");
PRINTVALSTREAM(rawoutstream,
" Prints messages from the HDF5 error stack as they occur.\n");
PRINTVALSTREAM(rawoutstream, " --follow-symlinks\n");
PRINTVALSTREAM(rawoutstream,
" Follow symbolic links (soft links and external links)\n");
PRINTVALSTREAM(rawoutstream, " to display target object information.\n");
PRINTVALSTREAM(rawoutstream, " Without this option, h5ls identifies a symbolic link\n");
PRINTVALSTREAM(rawoutstream, " as a soft link or external link and prints the value\n");
PRINTVALSTREAM(rawoutstream,
" assigned to the symbolic link; it does not provide any\n");
PRINTVALSTREAM(rawoutstream, " information regarding the target object or determine\n");
PRINTVALSTREAM(rawoutstream, " whether the link is a dangling link.\n");
PRINTVALSTREAM(rawoutstream, " --no-dangling-links\n");
PRINTVALSTREAM(rawoutstream, " Must be used with --follow-symlinks option;\n");
PRINTVALSTREAM(rawoutstream,
" otherwise, h5ls shows error message and returns an exit\n");
PRINTVALSTREAM(rawoutstream, " code of 1.\n");
PRINTVALSTREAM(rawoutstream,
" Check for any symbolic links (soft links or external links)\n");
PRINTVALSTREAM(rawoutstream,
" that do not resolve to an existing object (dataset, group,\n");
PRINTVALSTREAM(rawoutstream, " or named datatype).\n");
PRINTVALSTREAM(rawoutstream,
" If any dangling link is found, this situation is treated\n");
PRINTVALSTREAM(rawoutstream, " as an error and h5ls returns an exit code of 1.\n");
PRINTVALSTREAM(rawoutstream, " -f, --full Print full path names instead of base names\n");
PRINTVALSTREAM(rawoutstream, " -g, --group Show information about a group, not its contents\n");
PRINTVALSTREAM(rawoutstream, " -l, --label Label members of compound datasets\n");
PRINTVALSTREAM(rawoutstream, " -r, --recursive List all groups recursively, avoiding cycles\n");
PRINTVALSTREAM(rawoutstream, " -s, --string Print 1-byte integer datasets as ASCII\n");
PRINTVALSTREAM(rawoutstream, " -S, --simple Use a machine-readable output format\n");
PRINTVALSTREAM(rawoutstream, " -wN, --width=N Set the number of columns of output\n");
PRINTVALSTREAM(rawoutstream, " -v, --verbose Generate more verbose output\n");
PRINTVALSTREAM(rawoutstream, " -V, --version Print version number and exit\n");
PRINTVALSTREAM(rawoutstream, " --vfd=DRIVER Use the specified virtual file driver\n");
PRINTVALSTREAM(rawoutstream, " -x, --hexdump Show raw data in hexadecimal format\n");
PRINTVALSTREAM(rawoutstream,
" --s3-cred=C Supply S3 authentication information to \"ros3\" vfd.\n");
PRINTVALSTREAM(rawoutstream,
" Accepts tuple of \"(<aws-region>,<access-id>,<access-key>)\".\n");
PRINTVALSTREAM(rawoutstream,
" If absent or C->\"(,,)\", defaults to no-authentication.\n");
PRINTVALSTREAM(rawoutstream, " Has no effect if vfd flag not set to \"ros3\".\n");
PRINTVALSTREAM(rawoutstream, " --hdfs-attrs=A Supply configuration information to Hadoop VFD.\n");
PRINTVALSTREAM(rawoutstream, " Accepts tuple of (<namenode name>,<namenode port>,\n");
PRINTVALSTREAM(rawoutstream, " ...<kerberos cache path>,<username>,<buffer size>)\n");
PRINTVALSTREAM(rawoutstream,
" If absent or A == '(,,,,)', all default values are used.\n");
PRINTVALSTREAM(rawoutstream, " Has no effect if vfd flag is not 'hdfs'.\n");
PRINTVALSTREAM(rawoutstream, "\n");
PRINTVALSTREAM(rawoutstream, " file/OBJECT\n");
PRINTVALSTREAM(rawoutstream, " Each object consists of an HDF5 file name optionally followed by a\n");
PRINTVALSTREAM(rawoutstream, " slash and an object name within the file (if no object is specified\n");
PRINTVALSTREAM(rawoutstream, " within the file then the contents of the root group are displayed).\n");
PRINTVALSTREAM(rawoutstream, " The file name may include a printf(3C) integer format such as\n");
PRINTVALSTREAM(rawoutstream, " \"%%05d\" to open a file family.\n");
PRINTVALSTREAM(rawoutstream, "\n");
PRINTVALSTREAM(rawoutstream, " Deprecated Options\n");
PRINTVALSTREAM(rawoutstream,
" The following options have been deprecated in HDF5. While they remain\n");
PRINTVALSTREAM(rawoutstream,
" available, they have been superseded as indicated and may be removed\n");
PRINTVALSTREAM(rawoutstream,
" from HDF5 in the future. Use the indicated replacement option in all\n");
PRINTVALSTREAM(rawoutstream,
" new work; where possible, existing scripts, et cetera, should also be\n");
PRINTVALSTREAM(rawoutstream, " updated to use the replacement option.\n");
PRINTVALSTREAM(rawoutstream, "\n");
PRINTVALSTREAM(rawoutstream, " -E or --external Follow external links.\n");
PRINTVALSTREAM(rawoutstream, " Replaced by --follow-symlinks.\n");
PRINTVALSTREAM(rawoutstream, " -e, --errors Show all HDF5 error reporting\n");
PRINTVALSTREAM(rawoutstream, " Replaced by --enable-error-stack.\n");
}
/*-------------------------------------------------------------------------
* Function: print_string
*
* Purpose: Print a string value by escaping unusual characters. If
* STREAM is null then we only count how large the output would be.
*
* Return: Number of characters printed.
*-------------------------------------------------------------------------
*/
static int
print_string(h5tools_str_t *buffer, const char *s, hbool_t escape_spaces)
{
int nprint = 0;
for (/*void*/; s && *s; s++) {
switch (*s) {
case '"':
if (buffer)
h5tools_str_append(buffer, "\\\"");
nprint += 2;
break;
case '\\':
if (buffer)
h5tools_str_append(buffer, "\\\\");
nprint += 2;
break;
case '\b':
if (buffer)
h5tools_str_append(buffer, "\\b");
nprint += 2;
break;
case '\f':
if (buffer)
h5tools_str_append(buffer, "\\f");
nprint += 2;
break;
case '\n':
if (buffer)
h5tools_str_append(buffer, "\\n");
nprint += 2;
break;
case '\r':
if (buffer)
h5tools_str_append(buffer, "\\r");
nprint += 2;
break;
case '\t':
if (buffer)
h5tools_str_append(buffer, "\\t");
nprint += 2;
break;
case ' ':
if (escape_spaces) {
if (buffer)
h5tools_str_append(buffer, "\\ ");
nprint += 2;
}
else {
if (buffer)
h5tools_str_append(buffer, " ");
nprint++;
}
break;
default:
if (isprint((int)*s)) {
if (buffer)
h5tools_str_append(buffer, "%c", *s);
nprint++;
}
else {
if (buffer)
h5tools_str_append(buffer, "\\%03o", *((const unsigned char *)s));
nprint += 4;
}
break;
}
}
return nprint;
}
/*-------------------------------------------------------------------------
* Function: print_obj_name
*
* Purpose: Print an object name and another string.
*
* Return: Success: TRUE
* Failure: FALSE, nothing printed
*-------------------------------------------------------------------------
*/
static int
print_obj_name(h5tools_str_t *buffer, const iter_t *iter, const char *oname, const char *s)
{
static char fullname[NAME_BUF_SIZE]; /* Buffer for file and/or object name */
const char *name = fullname; /* Pointer to buffer for printing */
int n;
if (show_file_name_g)
HDsnprintf(fullname, sizeof(fullname), "%s/%s", iter->fname, oname + iter->name_start);
else
name = oname + iter->name_start;
/* Print the object name, either full name or base name */
if (fullname_g)
n = print_string(buffer, name, TRUE);
else {
const char *last_sep; /* The location of the last group separator */
/* Find the last component of the path name */
if (NULL == (last_sep = HDstrrchr(name, '/')))
last_sep = name;
else {
last_sep++;
} /* end else */
n = print_string(buffer, last_sep, TRUE);
} /* end else */
h5tools_str_append(buffer, "%*s ", MAX(0, (24 - n)), s);
return TRUE;
}
/*-------------------------------------------------------------------------
* Function: print_native_type
*
* Purpose: Prints the name of a native C data type.
*
* Return: Success: TRUE
* Failure: FALSE, nothing printed.
*-------------------------------------------------------------------------
*/
static hbool_t
print_native_type(h5tools_str_t *buffer, hid_t type, int ind)
{
if (!simple_output_g) {
if (H5Tequal(type, H5T_NATIVE_SCHAR) == TRUE) {
h5tools_str_append(buffer, "native signed char");
}
else if (H5Tequal(type, H5T_NATIVE_UCHAR) == TRUE) {
h5tools_str_append(buffer, "native unsigned char");
}
else if (H5Tequal(type, H5T_NATIVE_INT) == TRUE) {
h5tools_str_append(buffer, "native int");
}
else if (H5Tequal(type, H5T_NATIVE_UINT) == TRUE) {
h5tools_str_append(buffer, "native unsigned int");
}
else if (H5Tequal(type, H5T_NATIVE_SHORT) == TRUE) {
h5tools_str_append(buffer, "native short");
}
else if (H5Tequal(type, H5T_NATIVE_USHORT) == TRUE) {
h5tools_str_append(buffer, "native unsigned short");
}
else if (H5Tequal(type, H5T_NATIVE_LONG) == TRUE) {
h5tools_str_append(buffer, "native long");
}
else if (H5Tequal(type, H5T_NATIVE_ULONG) == TRUE) {
h5tools_str_append(buffer, "native unsigned long");
}
else if (H5Tequal(type, H5T_NATIVE_LLONG) == TRUE) {
h5tools_str_append(buffer, "native long long");
}
else if (H5Tequal(type, H5T_NATIVE_ULLONG) == TRUE) {
h5tools_str_append(buffer, "native unsigned long long");
}
else if (H5Tequal(type, H5T_NATIVE_FLOAT) == TRUE) {
h5tools_str_append(buffer, "native float");
}
else if (H5Tequal(type, H5T_NATIVE_DOUBLE) == TRUE) {
h5tools_str_append(buffer, "native double");
}
else if (H5Tequal(type, H5T_NATIVE_INT8) == TRUE) {
h5tools_str_append(buffer, "native int8_t");
}
else if (H5Tequal(type, H5T_NATIVE_UINT8) == TRUE) {
h5tools_str_append(buffer, "native uint8_t");
}
else if (H5Tequal(type, H5T_NATIVE_INT16) == TRUE) {
h5tools_str_append(buffer, "native int16_t");
}
else if (H5Tequal(type, H5T_NATIVE_UINT16) == TRUE) {
h5tools_str_append(buffer, "native uint16_t");
}
else if (H5Tequal(type, H5T_NATIVE_INT32) == TRUE) {
h5tools_str_append(buffer, "native int32_t");
}
else if (H5Tequal(type, H5T_NATIVE_UINT32) == TRUE) {
h5tools_str_append(buffer, "native uint32_t");
}
else if (H5Tequal(type, H5T_NATIVE_INT64) == TRUE) {
h5tools_str_append(buffer, "native int64_t");
}
else if (H5Tequal(type, H5T_NATIVE_UINT64) == TRUE) {
h5tools_str_append(buffer, "native uint64_t");
}
else if (H5Tequal(type, H5T_NATIVE_INT_LEAST8) == TRUE) {
h5tools_str_append(buffer, "native int_least8_t");
}
else if (H5Tequal(type, H5T_NATIVE_UINT_LEAST8) == TRUE) {
h5tools_str_append(buffer, "native uint_least8_t");
}
else if (H5Tequal(type, H5T_NATIVE_INT_LEAST16) == TRUE) {
h5tools_str_append(buffer, "native int_least16_t");
}
else if (H5Tequal(type, H5T_NATIVE_UINT_LEAST16) == TRUE) {
h5tools_str_append(buffer, "native uint_least16_t");
}
else if (H5Tequal(type, H5T_NATIVE_INT_LEAST32) == TRUE) {
h5tools_str_append(buffer, "native int_least32_t");
}
else if (H5Tequal(type, H5T_NATIVE_UINT_LEAST32) == TRUE) {
h5tools_str_append(buffer, "native uint_least32_t");
}
else if (H5Tequal(type, H5T_NATIVE_INT_LEAST64) == TRUE) {
h5tools_str_append(buffer, "native int_least64_t");
}
else if (H5Tequal(type, H5T_NATIVE_UINT_LEAST64) == TRUE) {
h5tools_str_append(buffer, "native uint_least64_t");
}
else if (H5Tequal(type, H5T_NATIVE_INT_FAST8) == TRUE) {
h5tools_str_append(buffer, "native int_fast8_t");
}
else if (H5Tequal(type, H5T_NATIVE_UINT_FAST8) == TRUE) {
h5tools_str_append(buffer, "native uint_fast8_t");
}
else if (H5Tequal(type, H5T_NATIVE_INT_FAST16) == TRUE) {
h5tools_str_append(buffer, "native int_fast16_t");
}
else if (H5Tequal(type, H5T_NATIVE_UINT_FAST16) == TRUE) {
h5tools_str_append(buffer, "native uint_fast16_t");
}
else if (H5Tequal(type, H5T_NATIVE_INT_FAST32) == TRUE) {
h5tools_str_append(buffer, "native int_fast32_t");
}
else if (H5Tequal(type, H5T_NATIVE_UINT_FAST32) == TRUE) {
h5tools_str_append(buffer, "native uint_fast32_t");
}
else if (H5Tequal(type, H5T_NATIVE_INT_FAST64) == TRUE) {
h5tools_str_append(buffer, "native int_fast64_t");
}
else if (H5Tequal(type, H5T_NATIVE_UINT_FAST64) == TRUE) {
h5tools_str_append(buffer, "native uint_fast64_t");
}
else if (H5Tequal(type, H5T_NATIVE_B8) == TRUE) {
h5tools_str_append(buffer, "native 8-bit field");
}
else if (H5Tequal(type, H5T_NATIVE_B16) == TRUE) {
h5tools_str_append(buffer, "native 16-bit field");
}
else if (H5Tequal(type, H5T_NATIVE_B32) == TRUE) {
h5tools_str_append(buffer, "native 32-bit field");
}
else if (H5Tequal(type, H5T_NATIVE_B64) == TRUE) {
h5tools_str_append(buffer, "native 64-bit field");
}
else if (H5Tequal(type, H5T_NATIVE_HSIZE) == TRUE) {
h5tools_str_append(buffer, "native hsize_t");
}
else if (H5Tequal(type, H5T_NATIVE_HSSIZE) == TRUE) {
h5tools_str_append(buffer, "native hssize_t");
}
else if (H5Tequal(type, H5T_NATIVE_HERR) == TRUE) {
h5tools_str_append(buffer, "native herr_t");
}
else if (H5Tequal(type, H5T_NATIVE_HBOOL) == TRUE) {
h5tools_str_append(buffer, "native hbool_t");
}
else {
return print_int_type(buffer, type, ind);
}
}
else {
return print_int_type(buffer, type, ind);
}
return TRUE;
}
/*-------------------------------------------------------------------------
* Function: print_ieee_type
*
* Purpose: Print the name of an IEEE floating-point data type.
*
* Return: Success: TRUE
* Failure: FALSE, nothing printed
*-------------------------------------------------------------------------
*/
static hbool_t
print_ieee_type(h5tools_str_t *buffer, hid_t type, int ind)
{
if (H5Tequal(type, H5T_IEEE_F32BE) == TRUE) {
h5tools_str_append(buffer, "IEEE 32-bit big-endian float");
}
else if (H5Tequal(type, H5T_IEEE_F32LE) == TRUE) {
h5tools_str_append(buffer, "IEEE 32-bit little-endian float");
}
else if (H5Tequal(type, H5T_IEEE_F64BE) == TRUE) {
h5tools_str_append(buffer, "IEEE 64-bit big-endian float");
}
else if (H5Tequal(type, H5T_IEEE_F64LE) == TRUE) {
h5tools_str_append(buffer, "IEEE 64-bit little-endian float");
}
else {
return print_float_type(buffer, type, ind);
}
return TRUE;
}
/*-------------------------------------------------------------------------
* Function: print_precision
*
* Purpose: Prints information on the next line about precision and
* padding if the precision is less than the total data type
* size.
*
* Return: void
*-------------------------------------------------------------------------
*/
static void
print_precision(h5tools_str_t *buffer, hid_t type, int ind)
{
size_t prec; /* precision */
H5T_pad_t plsb, pmsb; /* lsb and msb padding */
const char *plsb_s = NULL; /* lsb padding string */
const char *pmsb_s = NULL; /* msb padding string */
size_t nbits; /* number of bits */
/* If the precision is less than the total size then show the precision
* and offset on the following line. Also display the padding
* information. */
if (8 * H5Tget_size(type) != (prec = H5Tget_precision(type))) {
h5tools_str_append(buffer, "\n%*s(%lu bit%s of precision beginning at bit %lu)", ind, "",
(unsigned long)prec, 1 == prec ? "" : "s", (unsigned long)H5Tget_offset(type));
H5Tget_pad(type, &plsb, &pmsb);
if (H5Tget_offset(type) > 0) {
switch (plsb) {
case H5T_PAD_ZERO:
plsb_s = "zero";
break;
case H5T_PAD_ONE:
plsb_s = "one";
break;
case H5T_PAD_BACKGROUND:
plsb_s = "bkg";
break;
case H5T_PAD_ERROR:
case H5T_NPAD:
plsb_s = "unknown";
break;
default:
break;
}
}
if ((unsigned)H5Tget_offset(type) + prec < 8 * H5Tget_size(type)) {
switch (pmsb) {
case H5T_PAD_ZERO:
pmsb_s = "zero";
break;
case H5T_PAD_ONE:
pmsb_s = "one";
break;
case H5T_PAD_BACKGROUND:
pmsb_s = "bkg";
break;
case H5T_PAD_ERROR:
case H5T_NPAD:
pmsb_s = "unknown";
break;
default:
break;
}
}
if (plsb_s || pmsb_s) {
h5tools_str_append(buffer, "\n%*s(", ind, "");
if (plsb_s) {
nbits = (unsigned)H5Tget_offset(type);
h5tools_str_append(buffer, "%lu %s bit%s at bit 0", (unsigned long)nbits, plsb_s,
1 == nbits ? "" : "s");
}
if (plsb_s && pmsb_s)
h5tools_str_append(buffer, ", ");
if (pmsb_s) {
nbits = (8 * H5Tget_size(type)) - ((unsigned)H5Tget_offset(type) + prec);
h5tools_str_append(buffer, "%lu %s bit%s at bit %lu", (unsigned long)nbits, pmsb_s,
1 == nbits ? "" : "s", (unsigned long)(8 * H5Tget_size(type) - nbits));
}
h5tools_str_append(buffer, ")");
}
}
}
/*-------------------------------------------------------------------------
* Function: print_int_type
*
* Purpose: Print the name of an integer data type. Common information
* like number of bits, byte order, and sign scheme appear on
* the first line. Additional information might appear in
* parentheses on the following lines.
*
* Return: Success: TRUE
* Failure: FALSE, nothing printed
*-------------------------------------------------------------------------
*/
static hbool_t
print_int_type(h5tools_str_t *buffer, hid_t type, int ind)
{
H5T_order_t order; /* byte order value */
const char *order_s = NULL; /* byte order string */
H5T_sign_t sign; /* sign scheme value */
const char *sign_s = NULL; /* sign scheme string */
if (H5T_INTEGER != H5Tget_class(type))
return FALSE;
/* 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 on first line, precision and padding
* information on the subsequent lines */
h5tools_str_append(buffer, "%lu-bit%s%s integer", (unsigned long)(8 * H5Tget_size(type)), order_s,
sign_s);
print_precision(buffer, type, ind);
return TRUE;
}
/*-------------------------------------------------------------------------
* Function: print_float_type
*
* Purpose: Print info about a floating point data type.
*
* Return: Success: TRUE
* Failure: FALSE, nothing printed
*-------------------------------------------------------------------------
*/
static hbool_t
print_float_type(h5tools_str_t *buffer, hid_t type, int ind)
{
H5T_order_t order; /* byte order value */
const char *order_s = NULL; /* byte order string */
size_t spos; /* sign bit position */
size_t esize, epos; /* exponent size and position */
size_t msize, mpos; /* significand size and position */
size_t ebias; /* exponent bias */
H5T_norm_t norm; /* significand normalization */
const char *norm_s = NULL; /* normalization string */
H5T_pad_t pad; /* internal padding value */
const char *pad_s = NULL; /* internal padding string */
if (H5T_FLOAT != H5Tget_class(type))
return FALSE;
/* 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 on first line, precision and padding on
* subsequent lines. */
h5tools_str_append(buffer, "%lu-bit%s floating-point", (unsigned long)(8 * H5Tget_size(type)), order_s);
print_precision(buffer, type, ind);
/* Print sizes, locations, and other information about each field */
H5Tget_fields(type, &spos, &epos, &esize, &mpos, &msize);
ebias = H5Tget_ebias(type);
norm = H5Tget_norm(type);
switch (norm) {
case H5T_NORM_IMPLIED:
norm_s = ", msb implied";
break;
case H5T_NORM_MSBSET:
norm_s = ", msb always set";
break;
case H5T_NORM_NONE:
norm_s = ", no normalization";
break;
case H5T_NORM_ERROR:
norm_s = ", unknown normalization";
break;
default:;
break;
}
h5tools_str_append(buffer, "\n%*s(significant for %lu bit%s at bit %lu%s)", ind, "", (unsigned long)msize,
1 == msize ? "" : "s", (unsigned long)mpos, norm_s);
h5tools_str_append(buffer, "\n%*s(exponent for %lu bit%s at bit %lu, bias is 0x%lx)", ind, "",
(unsigned long)esize, 1 == esize ? "" : "s", (unsigned long)epos,
(unsigned long)ebias);
h5tools_str_append(buffer, "\n%*s(sign bit at %lu)", ind, "", (unsigned long)spos);
/* Display internal padding */
if ((1 + esize + msize) < H5Tget_precision(type)) {
pad = H5Tget_inpad(type);
switch (pad) {
case H5T_PAD_ZERO:
pad_s = "zero";
break;
case H5T_PAD_ONE:
pad_s = "one";
break;
case H5T_PAD_BACKGROUND:
pad_s = "bkg";
break;
case H5T_PAD_ERROR:
case H5T_NPAD:
pad_s = "unknown";
break;
default:;
break;
}
h5tools_str_append(buffer, "\n%*s(internal padding bits are %s)", ind, "", pad_s);
}
return TRUE;
}
/*-------------------------------------------------------------------------
* Function: print_cmpd_type
*
* Purpose: Print info about a compound data type.
*
* Return: Success: TRUE
* Failure: FALSE, nothing printed
*-------------------------------------------------------------------------
*/
static hbool_t
print_cmpd_type(h5tools_str_t *buffer, hid_t type, int ind)
{
char *name = NULL; /* member name */
size_t size; /* total size of type in bytes */
hid_t subtype; /* member data type */
int nmembs; /* number of members */
int n; /* miscellaneous counters */
unsigned i; /* miscellaneous counters */
if (H5T_COMPOUND != H5Tget_class(type))
return FALSE;
if ((nmembs = H5Tget_nmembers(type)) < 0)
return FALSE;
h5tools_str_append(buffer, "struct {");
for (i = 0; i < (unsigned)nmembs; i++) {
/* Name and offset */
name = H5Tget_member_name(type, i);
h5tools_str_append(buffer, "\n%*s\"", ind + 4, "");
n = print_string(buffer, name, FALSE);
h5tools_str_append(buffer, "\"%*s +%-4lu ", MAX(0, 16 - n), "",
(unsigned long)H5Tget_member_offset(type, i));
H5free_memory(name);
/* Member's type */
subtype = H5Tget_member_type(type, i);
print_type(buffer, subtype, ind + 4);
H5Tclose(subtype);
}
size = H5Tget_size(type);
h5tools_str_append(buffer, "\n%*s} %lu byte%s", ind, "", (unsigned long)size, 1 == size ? "" : "s");
return TRUE;
}
/*-------------------------------------------------------------------------
* Function: print_enum_type
*
* Purpose: Print info about an enumeration data type.
*
* Return: Success: TRUE
* Failure: FALSE, nothing printed
*-------------------------------------------------------------------------
*/
static hbool_t
print_enum_type(h5tools_str_t *buffer, hid_t type, int ind)
{
int nmembs; /* number of members */
hid_t super; /* enum base integer type */
if (H5T_ENUM != H5Tget_class(type))
return FALSE;
if ((nmembs = H5Tget_nmembers(type)) < 0)
return FALSE;
super = H5Tget_super(type);
h5tools_str_append(buffer, "enum ");
print_type(buffer, super, ind + 4);
h5tools_str_append(buffer, " {");
if (nmembs > 0) {
char **name; /* member names */
unsigned char *value; /* value array */
hid_t native = H5I_INVALID_HID; /* native integer data type */
size_t dst_size; /* destination value type size */
unsigned i; /* miscellaneous counters */
/* Determine what data type to use for the native values. To simplify
* things we entertain three possibilities:
* 1. long long -- the largest native signed integer
* 2. unsigned long long -- the largest native unsigned integer
* 3. raw format */
if (H5Tget_size(type) <= sizeof(long long)) {
dst_size = sizeof(long long);
if (H5T_SGN_NONE == H5Tget_sign(type))
native = H5T_NATIVE_ULLONG;
else
native = H5T_NATIVE_LLONG;
} /* end if */
else
dst_size = H5Tget_size(type);
/* Get the names and raw values of all members */
name = (char **)HDcalloc((size_t)nmembs, sizeof(char *));
value = (unsigned char *)HDcalloc((size_t)nmembs, MAX(H5Tget_size(type), dst_size));
for (i = 0; i < (unsigned)nmembs; i++) {
name[i] = H5Tget_member_name(type, i);
H5Tget_member_value(type, i, value + i * H5Tget_size(type));
}
/* Convert values to native data type */
if (native > 0)
if (H5Tconvert(super, native, (size_t)nmembs, value, NULL, H5P_DEFAULT) < 0) {
/* Release resources */
for (i = 0; i < (unsigned)nmembs; i++)
H5free_memory(name[i]);
HDfree(name);
HDfree(value);
H5Tclose(super);
return FALSE;
}
/* Sort members by increasing value */
/*not implemented yet*/
/* Print members */
for (i = 0; i < (unsigned)nmembs; i++) {
unsigned char *copy; /* a pointer to value array */
int nchars; /* number of output characters */
h5tools_str_append(buffer, "\n%*s", ind + 4, "");
nchars = print_string(buffer, name[i], TRUE);
h5tools_str_append(buffer, "%*s = ", MAX(0, 16 - nchars), "");
if (native < 0) {
size_t j;
h5tools_str_append(buffer, "0x");
for (j = 0; j < dst_size; j++)
h5tools_str_append(buffer, "%02x", value[i * dst_size + j]);
}
else if (H5T_SGN_NONE == H5Tget_sign(native)) {
/*On SGI Altix(cobalt), wrong values were printed out with "value+i*dst_size"
*strangely, unless use another pointer "copy".*/
copy = value + i * dst_size;
h5tools_str_append(buffer, HSIZE_T_FORMAT, *((unsigned long long *)((void *)copy)));
}
else {
/*On SGI Altix(cobalt), wrong values were printed out with "value+i*dst_size"
*strangely, unless use another pointer "copy".*/
copy = value + i * dst_size;
h5tools_str_append(buffer, "%lld", *((long long *)((void *)copy)));
}
}
/* Release resources */
for (i = 0; i < (unsigned)nmembs; i++)
H5free_memory(name[i]);
HDfree(name);
HDfree(value);
}
else
h5tools_str_append(buffer, "\n%*s <empty>", ind + 4, "");
h5tools_str_append(buffer, "\n%*s}", ind, "");
H5Tclose(super);
return TRUE;
}
/*-------------------------------------------------------------------------
* Function: print_string_type
*
* Purpose: Print information about a string data type.
*
* Return: Success: TRUE
* Failure: FALSE, nothing printed
*-------------------------------------------------------------------------
*/
static hbool_t
print_string_type(h5tools_str_t *buffer, hid_t type, int H5_ATTR_UNUSED ind)
{
H5T_str_t pad;
const char *pad_s = NULL;
H5T_cset_t cset;
const char *cset_s = NULL;
if (H5T_STRING != H5Tget_class(type))
return FALSE;
/* Padding */
pad = H5Tget_strpad(type);
switch (pad) {
case H5T_STR_NULLTERM:
pad_s = "null-terminated";
break;
case H5T_STR_NULLPAD:
pad_s = "null-padded";
break;
case H5T_STR_SPACEPAD:
pad_s = "space-padded";
break;
case H5T_STR_RESERVED_3:
case H5T_STR_RESERVED_4:
case H5T_STR_RESERVED_5:
case H5T_STR_RESERVED_6:
case H5T_STR_RESERVED_7:
case H5T_STR_RESERVED_8:
case H5T_STR_RESERVED_9:
case H5T_STR_RESERVED_10:
case H5T_STR_RESERVED_11:
case H5T_STR_RESERVED_12:
case H5T_STR_RESERVED_13:
case H5T_STR_RESERVED_14:
case H5T_STR_RESERVED_15:
case H5T_STR_ERROR:
pad_s = "unknown-format";
break;
default:;
break;
}
/* Character set */
cset = H5Tget_cset(type);
switch (cset) {
case H5T_CSET_ASCII:
cset_s = "ASCII";
break;
case H5T_CSET_UTF8:
cset_s = "UTF-8";
break;
case H5T_CSET_RESERVED_2:
case H5T_CSET_RESERVED_3:
case H5T_CSET_RESERVED_4:
case H5T_CSET_RESERVED_5:
case H5T_CSET_RESERVED_6:
case H5T_CSET_RESERVED_7:
case H5T_CSET_RESERVED_8:
case H5T_CSET_RESERVED_9:
case H5T_CSET_RESERVED_10:
case H5T_CSET_RESERVED_11:
case H5T_CSET_RESERVED_12:
case H5T_CSET_RESERVED_13:
case H5T_CSET_RESERVED_14:
case H5T_CSET_RESERVED_15:
case H5T_CSET_ERROR:
cset_s = "unknown-character-set";
break;
default:;
break;
}
if (H5Tis_variable_str(type)) {
h5tools_str_append(buffer, "variable-length");
}
else {
h5tools_str_append(buffer, "%lu-byte", (unsigned long)H5Tget_size(type));
}
h5tools_str_append(buffer, " %s %s string", pad_s, cset_s);
return TRUE;
}
/*-------------------------------------------------------------------------
* Function: print_reference_type
*
* Purpose: Prints information about a reference data type.
*
* Return: Success: TRUE
* Failure: FALSE, nothing printed
*-------------------------------------------------------------------------
*/
static hbool_t
print_reference_type(h5tools_str_t *buffer, hid_t type, int H5_ATTR_UNUSED ind)
{
if (H5T_REFERENCE != H5Tget_class(type))
return FALSE;
if (H5Tequal(type, H5T_STD_REF_OBJ) == TRUE) {
h5tools_str_append(buffer, "object reference");
}
else if (H5Tequal(type, H5T_STD_REF_DSETREG) == TRUE) {
h5tools_str_append(buffer, "dataset region reference");
}
else {
h5tools_str_append(buffer, "%lu-byte unknown reference", (unsigned long)H5Tget_size(type));
}
return TRUE;
}
/*-------------------------------------------------------------------------
* Function: print_opaque_type
*
* Purpose: Prints information about an opaque data type.
*
* Return: Success: TRUE
* Failure: FALSE, nothing printed
*-------------------------------------------------------------------------
*/
static hbool_t
print_opaque_type(h5tools_str_t *buffer, hid_t type, int ind)
{
char *tag;
size_t size;
if (H5T_OPAQUE != H5Tget_class(type))
return FALSE;
size = H5Tget_size(type);
h5tools_str_append(buffer, "%lu-byte opaque type", (unsigned long)size);
if ((tag = H5Tget_tag(type))) {
h5tools_str_append(buffer, "\n%*s(tag = \"", ind, "");
print_string(buffer, tag, FALSE);
h5tools_str_append(buffer, "\")");
H5free_memory(tag);
}
return TRUE;
}
/*-------------------------------------------------------------------------
* Function: print_vlen_type
*
* Purpose: Print information about a variable-length type
*
* Return: Success: TRUE
* Failure: FALSE
*-------------------------------------------------------------------------
*/
static hbool_t
print_vlen_type(h5tools_str_t *buffer, hid_t type, int ind)
{
hid_t super;
if (H5T_VLEN != H5Tget_class(type))
return FALSE;
h5tools_str_append(buffer, "variable length of\n%*s", ind + 4, "");
super = H5Tget_super(type);
print_type(buffer, super, ind + 4);
H5Tclose(super);
return TRUE;
}
/*---------------------------------------------------------------------------
* Purpose: Print information about an array type
*
* Return: Success: TRUE
* Failure: FALSE
*---------------------------------------------------------------------------
*/
static hbool_t
print_array_type(h5tools_str_t *buffer, hid_t type, int ind)
{
hid_t super;
int ndims, i;
hsize_t *dims = NULL;
if (H5T_ARRAY != H5Tget_class(type))
return FALSE;
ndims = H5Tget_array_ndims(type);
if (ndims) {
dims = (hsize_t *)HDmalloc((unsigned)ndims * sizeof(dims[0]));
H5Tget_array_dims2(type, dims);
/* Print dimensions */
for (i = 0; i < ndims; i++)
h5tools_str_append(buffer, "%s" HSIZE_T_FORMAT, i ? "," : "[", dims[i]);
h5tools_str_append(buffer, "]");
HDfree(dims);
}
else
h5tools_str_append(buffer, " [SCALAR]\n", rawoutstream);
/* Print parent type */
h5tools_str_append(buffer, " ");
super = H5Tget_super(type);
print_type(buffer, super, ind + 4);
H5Tclose(super);
return TRUE;
}
/*-------------------------------------------------------------------------
* Function: print_bitfield_type
*
* Purpose: Print information about a bitfield type.
*
* Return: Success: TRUE
* Failure: FALSE, nothing printed
*-------------------------------------------------------------------------
*/
static hbool_t
print_bitfield_type(h5tools_str_t *buffer, hid_t type, int ind)
{
H5T_order_t order; /* byte order value */
const char *order_s = NULL; /* byte order string */
if (H5T_BITFIELD != H5Tget_class(type))
return FALSE;
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 = "";
}
h5tools_str_append(buffer, "%lu-bit%s bitfield", (unsigned long)(8 * H5Tget_size(type)), order_s);
print_precision(buffer, type, ind);
return TRUE;
}
/*-------------------------------------------------------------------------
* Function: print_type
*
* Purpose: Prints a data type definition. The definition is printed
* without any leading space or trailing line-feed (although
* there might be line-feeds inside the type definition). The
* first line is assumed to have IND characters before it on
* the same line (printed by the caller).
* Prints the OID of shared data types.
*
* Return: void
*-------------------------------------------------------------------------
*/
static void
print_type(h5tools_str_t *buffer, hid_t type, int ind)
{
H5T_class_t data_class = H5Tget_class(type);
/* Bad data type */
if (type < 0) {
h5tools_str_append(buffer, "<ERROR>");
return;
}
/* Shared? If so then print the type's OID */
if (H5Tcommitted(type)) {
H5O_info_t oi;
if (H5Oget_info2(type, &oi, H5O_INFO_BASIC) >= 0)
h5tools_str_append(buffer, "shared-%lu:" H5_PRINTF_HADDR_FMT " ", oi.fileno, oi.addr);
else
h5tools_str_append(buffer, "shared ");
} /* end if */
/* Print the type */
if (print_native_type(buffer, type, ind) || print_ieee_type(buffer, type, ind) ||
print_cmpd_type(buffer, type, ind) || print_enum_type(buffer, type, ind) ||
print_string_type(buffer, type, ind) || print_reference_type(buffer, type, ind) ||
print_vlen_type(buffer, type, ind) || print_array_type(buffer, type, ind) ||
print_opaque_type(buffer, type, ind) || print_bitfield_type(buffer, type, ind))
return;
/* Unknown type */
h5tools_str_append(buffer, "%lu-byte class-%u unknown", (unsigned long)H5Tget_size(type),
(unsigned)data_class);
}
/*-------------------------------------------------------------------------
* Function: dump_dataset_values
*
* Purpose: Prints all values of a dataset.
*
* Return: void
*-------------------------------------------------------------------------
*/
static void
dump_dataset_values(hid_t dset)
{
hid_t f_type = H5I_INVALID_HID;
hid_t space = H5I_INVALID_HID;
hsize_t total_size[H5S_MAX_RANK];
int ndims;
size_t nsize;
char string_prefix[64];
static char fmt_double[16];
static char fmt_float[16];
hsize_t curr_pos = 0; /* total data element position */
h5tools_str_t buffer; /* string into which to render */
h5tools_context_t ctx; /* print context */
h5tool_format_t outputformat;
h5tool_format_t *info = &ls_dataformat;
unsigned char *region_buf = NULL;
H5TOOLS_START_DEBUG(" ");
f_type = H5Dget_type(dset);
space = H5Dget_space(dset);
nsize = H5Tget_size(f_type);
HDmemset(&ctx, 0, sizeof(ctx));
HDmemset(&buffer, 0, sizeof(h5tools_str_t));
outputformat = *info;
outputformat.line_1st = NULL;
outputformat.idx_fmt = "";
if (simple_output_g) {
outputformat.idx_fmt = "";
outputformat.line_per_line = 1;
outputformat.line_multi_new = 0;
outputformat.line_pre = " ";
outputformat.line_cont = " ";
outputformat.arr_pre = "";
outputformat.arr_suf = "";
outputformat.arr_sep = " ";
if (!label_g) {
outputformat.cmpd_pre = "";
outputformat.cmpd_suf = "";
}
outputformat.cmpd_sep = " ";
if (label_g)
outputformat.cmpd_name = "%s=";
outputformat.elmt_suf1 = " ";
outputformat.str_locale = ESCAPE_HTML;
}
else {
if (no_line_wrap_g) {
outputformat.line_per_line = 1;
}
else {
outputformat.line_ncols = (unsigned)width_g;
}
if (label_g)
outputformat.cmpd_name = "%s=";
outputformat.line_pre = " %s ";
outputformat.line_cont = " %s ";
outputformat.str_repeat = 8;
outputformat.arr_pre = NULL;
outputformat.arr_suf = NULL;
outputformat.arr_sep = NULL;
outputformat.cmpd_pre = NULL;
outputformat.cmpd_suf = NULL;
outputformat.cmpd_sep = NULL;
outputformat.vlen_sep = NULL;
outputformat.vlen_pre = NULL;
outputformat.vlen_suf = NULL;
outputformat.vlen_end = NULL;
}
outputformat.arr_linebreak = 0;
/* Floating point types should display full precision */
HDsnprintf(fmt_float, sizeof(fmt_float), "%%1.%dg", FLT_DIG);
outputformat.fmt_float = fmt_float;
HDsnprintf(fmt_double, sizeof(fmt_double), "%%1.%dg", DBL_DIG);
outputformat.fmt_double = fmt_double;
if (hexdump_g) {
/* Print all data in hexadecimal format if the `-x' or `--hexdump'
* command line switch was given. */
outputformat.raw = TRUE;
}
else if (string_g && H5Tget_size(f_type) == 1 && (H5Tget_class(f_type) == H5T_INTEGER)) {
/* Print 1-byte integer data as an ASCI character string instead of
* integers if the `-s' or `--string' command-line option was given. */
outputformat.ascii = TRUE;
outputformat.elmt_suf1 = "";
outputformat.elmt_suf2 = "";
HDsnprintf(string_prefix, sizeof(string_prefix), "%s\"", outputformat.line_pre);
outputformat.line_pre = string_prefix;
outputformat.line_suf = "\"";
}
info = &outputformat;
ctx.indent_level = 1;
ctx.cur_column = (size_t)curr_pos;
/* Print all the values. */
h5tools_str_reset(&buffer);
h5tools_str_append(&buffer, " Data:\n");
h5tools_render_element(rawoutstream, info, &ctx, &buffer, &curr_pos, (size_t)info->line_ncols, (hsize_t)0,
(hsize_t)0);
ctx.need_prefix = TRUE;
ctx.cur_column = (size_t)curr_pos;
if (H5Tget_class(f_type) == H5T_REFERENCE) {
H5TOOLS_DEBUG("reference class type");
if (!H5Tequal(f_type, H5T_STD_REF_DSETREG) && !H5Tequal(f_type, H5T_STD_REF_OBJ)) {
H5TOOLS_GOTO_DONE_NO_RET();
}
ndims = (int)H5Sget_simple_extent_npoints(space);
H5TOOLS_DEBUG("ndims=%d - ctx.ndims=%d", ndims, ctx.ndims);
/* Assume entire data space to be printed */
H5Sget_simple_extent_dims(space, total_size, NULL);
init_acc_pos(ctx.ndims, total_size, ctx.acc, ctx.pos, ctx.p_min_idx);
ctx.need_prefix = TRUE;
if (NULL != (region_buf = (void *)HDcalloc(nsize, (size_t)ndims))) {
H5TOOLS_DEBUG("H5Dread reference read");
if (H5Dread(dset, f_type, H5S_ALL, H5S_ALL, H5P_DEFAULT, region_buf) < 0) {
HDfree(region_buf);
H5TOOLS_INFO("H5Dread reference failed");
H5TOOLS_GOTO_DONE_NO_RET();
}
h5tools_dump_reference(rawoutstream, info, &ctx, dset, f_type, region_buf, ndims);
PRINTVALSTREAM(rawoutstream, "\n");
HDfree(region_buf);
}
}
else {
if (h5tools_dump_dset(rawoutstream, info, &ctx, dset) < 0) {
h5tools_str_reset(&buffer);
h5tools_str_append(&buffer, " Unable to print data.");
h5tools_render_element(rawoutstream, info, &ctx, &buffer, &curr_pos, (size_t)info->line_ncols,
(hsize_t)0, (hsize_t)0);
}
}
done:
H5Sclose(space);
H5Tclose(f_type);
h5tools_str_close(&buffer);
PRINTVALSTREAM(rawoutstream, "\n");
H5TOOLS_ENDDEBUG(" ");
}
/*-------------------------------------------------------------------------
* Function: dump_attribute_values
*
* Purpose: Prints all values of a attribute.
*
* Return: void
*-------------------------------------------------------------------------
*/
static void
dump_attribute_values(hid_t attr)
{
hid_t f_type = H5I_INVALID_HID;
hid_t space = H5I_INVALID_HID;
hsize_t total_size[H5S_MAX_RANK];
int ndims;
size_t nsize;
char string_prefix[64];
static char fmt_double[16];
static char fmt_float[16];
hsize_t curr_pos = 0; /* total data element position */
h5tools_str_t buffer; /* string into which to render */
h5tools_context_t ctx; /* print context */
h5tool_format_t outputformat;
h5tool_format_t *info = &ls_dataformat;
unsigned char *region_buf = NULL;
H5TOOLS_START_DEBUG(" ");
f_type = H5Aget_type(attr);
space = H5Aget_space(attr);
nsize = H5Tget_size(f_type);
HDmemset(&ctx, 0, sizeof(ctx));
HDmemset(&buffer, 0, sizeof(h5tools_str_t));
outputformat = *info;
outputformat.line_1st = NULL;
outputformat.idx_fmt = "";
if (simple_output_g) {
outputformat.idx_fmt = "";
outputformat.line_per_line = 1;
outputformat.line_multi_new = 0;
outputformat.line_pre = " ";
outputformat.line_cont = " ";
outputformat.arr_pre = "";
outputformat.arr_suf = "";
outputformat.arr_sep = " ";
if (!label_g) {
outputformat.cmpd_pre = "";
outputformat.cmpd_suf = "";
}
outputformat.cmpd_sep = " ";
if (label_g)
outputformat.cmpd_name = "%s=";
outputformat.elmt_suf1 = " ";
outputformat.str_locale = ESCAPE_HTML;
}
else {
if (no_line_wrap_g) {
outputformat.line_per_line = 1;
}
else {
outputformat.line_ncols = (unsigned)width_g;
}
if (label_g)
outputformat.cmpd_name = "%s=";
outputformat.line_pre = " %s ";
outputformat.line_cont = " %s ";
outputformat.str_repeat = 8;
outputformat.arr_pre = NULL;
outputformat.arr_suf = NULL;
outputformat.arr_sep = NULL;
outputformat.cmpd_pre = NULL;
outputformat.cmpd_suf = NULL;
outputformat.cmpd_sep = NULL;
outputformat.vlen_sep = NULL;
outputformat.vlen_pre = NULL;
outputformat.vlen_suf = NULL;
outputformat.vlen_end = NULL;
}
outputformat.arr_linebreak = 0;
/* Floating point types should display full precision */
HDsnprintf(fmt_float, sizeof(fmt_float), "%%1.%dg", FLT_DIG);
outputformat.fmt_float = fmt_float;
HDsnprintf(fmt_double, sizeof(fmt_double), "%%1.%dg", DBL_DIG);
outputformat.fmt_double = fmt_double;
if (hexdump_g) {
/* Print all data in hexadecimal format if the `-x' or `--hexdump'
* command line switch was given. */
outputformat.raw = TRUE;
}
else if (string_g && H5Tget_size(f_type) == 1 && (H5Tget_class(f_type) == H5T_INTEGER)) {
/* Print 1-byte integer data as an ASCI character string instead of
* integers if the `-s' or `--string' command-line option was given. */
outputformat.ascii = TRUE;
outputformat.elmt_suf1 = "";
outputformat.elmt_suf2 = "";
HDsnprintf(string_prefix, sizeof(string_prefix), "%s\"", outputformat.line_pre);
outputformat.line_pre = string_prefix;
outputformat.line_suf = "\"";
}
info = &outputformat;
ctx.indent_level = 2;
ctx.cur_column = (size_t)curr_pos;
/* Print all the values. */
h5tools_str_reset(&buffer);
h5tools_str_append(&buffer, " Data:\n");
h5tools_render_element(rawoutstream, info, &ctx, &buffer, &curr_pos, (size_t)info->line_ncols, (hsize_t)0,
(hsize_t)0);
ctx.need_prefix = TRUE;
ctx.cur_column = (size_t)curr_pos;
if (H5Tget_class(f_type) == H5T_REFERENCE) {
H5TOOLS_DEBUG("reference class type");
if (!H5Tequal(f_type, H5T_STD_REF_DSETREG) && !H5Tequal(f_type, H5T_STD_REF_OBJ)) {
H5TOOLS_GOTO_DONE_NO_RET();
}
ndims = (int)H5Sget_simple_extent_npoints(space);
H5TOOLS_DEBUG("ndims=%d - ctx.ndims=%d", ndims, ctx.ndims);
/* Assume entire data space to be printed */
H5Sget_simple_extent_dims(space, total_size, NULL);
init_acc_pos(ctx.ndims, total_size, ctx.acc, ctx.pos, ctx.p_min_idx);
ctx.need_prefix = TRUE;
if (NULL != (region_buf = (void *)HDcalloc(nsize, (size_t)ndims))) {
H5TOOLS_DEBUG("H5Aread reference read");
if (H5Aread(attr, f_type, region_buf) < 0) {
HDfree(region_buf);
H5TOOLS_INFO("H5Aread reference failed");
H5TOOLS_GOTO_DONE_NO_RET();
}
ctx.indent_level++;
h5tools_dump_reference(rawoutstream, info, &ctx, attr, f_type, region_buf, ndims);
PRINTVALSTREAM(rawoutstream, "\n");
ctx.indent_level--;
HDfree(region_buf);
}
}
else {
H5TOOLS_DEBUG("Attribute data read");
ctx.indent_level++;
if (h5tools_dump_mem(rawoutstream, info, &ctx, attr) < 0) {
h5tools_str_reset(&buffer);
h5tools_str_append(&buffer, " Unable to print data.");
h5tools_render_element(rawoutstream, info, &ctx, &buffer, &curr_pos, (size_t)info->line_ncols,
(hsize_t)0, (hsize_t)0);
}
ctx.indent_level--;
H5TOOLS_DEBUG("Attribute data read complete");
}
done:
H5Sclose(space);
H5Tclose(f_type);
h5tools_str_close(&buffer);
PRINTVALSTREAM(rawoutstream, "\n");
H5TOOLS_ENDDEBUG(" ");
}
/*-------------------------------------------------------------------------
* Function: list_attr
*
* Purpose: Prints information about attributes.
*
* Return: Success: 0
* Failure: -1
*-------------------------------------------------------------------------
*/
static herr_t
list_attr(hid_t obj, const char *attr_name, const H5A_info_t H5_ATTR_UNUSED *ainfo,
void H5_ATTR_UNUSED *op_data)
{
hid_t attr = H5I_INVALID_HID;
hid_t space = H5I_INVALID_HID;
hid_t type = H5I_INVALID_HID;
hsize_t size[H5S_MAX_RANK];
hsize_t nelmts = 1;
int ndims;
int i;
H5S_class_t space_type;
hsize_t curr_pos = 0; /* total data element position */
h5tools_str_t buffer; /* string into which to render */
h5tools_context_t ctx; /* print context */
h5tool_format_t *info = &ls_dataformat;
H5TOOLS_START_DEBUG(" ");
HDmemset(&ctx, 0, sizeof(ctx));
HDmemset(&buffer, 0, sizeof(h5tools_str_t));
ctx.indent_level = 2;
ctx.cur_column = (size_t)curr_pos;
h5tools_str_reset(&buffer);
h5tools_str_append(&buffer, " Attribute: ");
print_string(&buffer, attr_name, TRUE);
H5TOOLS_DEBUG("Attribute name:%s", attr_name);
if ((attr = H5Aopen(obj, attr_name, H5P_DEFAULT)) >= 0) {
space = H5Aget_space(attr);
type = H5Aget_type(attr);
/* Data space */
ndims = H5Sget_simple_extent_dims(space, size, NULL);
space_type = H5Sget_simple_extent_type(space);
H5TOOLS_DEBUG("Attribute ndims:%d", ndims);
switch (space_type) {
case H5S_SCALAR:
/* scalar dataspace */
h5tools_str_append(&buffer, " scalar\n");
h5tools_render_element(rawoutstream, info, &ctx, &buffer, &curr_pos, (size_t)info->line_ncols,
(hsize_t)0, (hsize_t)0);
break;
case H5S_SIMPLE:
/* simple dataspace */
h5tools_str_append(&buffer, " {");
for (i = 0; i < ndims; i++) {
h5tools_str_append(&buffer, "%s" HSIZE_T_FORMAT, i ? ", " : "", size[i]);
nelmts *= size[i];
}
h5tools_str_append(&buffer, "}\n");
h5tools_render_element(rawoutstream, info, &ctx, &buffer, &curr_pos, (size_t)info->line_ncols,
(hsize_t)0, (hsize_t)0);
break;
case H5S_NULL:
/* null dataspace */
h5tools_str_append(&buffer, " null\n");
h5tools_render_element(rawoutstream, info, &ctx, &buffer, &curr_pos, (size_t)info->line_ncols,
(hsize_t)0, (hsize_t)0);
break;
case H5S_NO_CLASS:
default:
/* Unknown dataspace type */
h5tools_str_append(&buffer, " unknown\n");
h5tools_render_element(rawoutstream, info, &ctx, &buffer, &curr_pos, (size_t)info->line_ncols,
(hsize_t)0, (hsize_t)0);
break;
} /* end switch */
/* Data type */
h5tools_str_reset(&buffer);
h5tools_str_append(&buffer, " %-10s ", "Type:");
print_type(&buffer, type, 15);
h5tools_str_append(&buffer, "\n");
h5tools_render_element(rawoutstream, info, &ctx, &buffer, &curr_pos, (size_t)info->line_ncols,
(hsize_t)0, (hsize_t)0);
H5Sclose(space);
H5Tclose(type);
h5tools_str_close(&buffer);
if (data_g)
dump_attribute_values(attr);
H5Aclose(attr);
}
else {
H5TOOLS_DEBUG("Attribute open failed");
h5tools_str_close(&buffer);
}
H5TOOLS_ENDDEBUG(" ");
return 0;
}
/*-------------------------------------------------------------------------
* Function: dataset_list1
*
* Purpose: List information about a dataset which should appear on the
* same line as the dataset name. This information will precede
* information which is applicable to all objects which will be
* printed by the caller.
*
* Return: Success: 0
* Failure: -1
*-------------------------------------------------------------------------
*/
static herr_t
dataset_list1(hid_t dset)
{
hsize_t cur_size[H5S_MAX_RANK]; /* current dataset dimensions */
hsize_t max_size[H5S_MAX_RANK]; /* maximum dataset dimensions */
hid_t space; /* data space */
int ndims; /* dimensionality */
H5S_class_t space_type; /* type of dataspace */
int i;
hsize_t curr_pos = 0; /* total data element position */
h5tools_str_t buffer; /* string into which to render */
h5tools_context_t ctx; /* print context */
h5tool_format_t *info = &ls_dataformat;
HDmemset(&ctx, 0, sizeof(ctx));
HDmemset(&buffer, 0, sizeof(h5tools_str_t));
h5tools_str_reset(&buffer);
/* Information that goes on the same row as the name. The name has
* already been printed. */
space = H5Dget_space(dset);
space_type = H5Sget_simple_extent_type(space);
ndims = H5Sget_simple_extent_dims(space, cur_size, max_size);
h5tools_str_append(&buffer, " {");
for (i = 0; i < ndims; i++) {
h5tools_str_append(&buffer, "%s" HSIZE_T_FORMAT, i ? ", " : "", cur_size[i]);
if (max_size[i] == H5S_UNLIMITED) {
h5tools_str_append(&buffer, "/%s", "Inf");
}
else if (max_size[i] != cur_size[i] || verbose_g > 0) {
h5tools_str_append(&buffer, "/" HSIZE_T_FORMAT, max_size[i]);
}
}
if (space_type == H5S_SCALAR)
h5tools_str_append(&buffer, "SCALAR");
else if (space_type == H5S_NULL)
h5tools_str_append(&buffer, "NULL");
h5tools_str_append(&buffer, "}");
h5tools_render_element(rawoutstream, info, &ctx, &buffer, &curr_pos, (size_t)info->line_ncols, (hsize_t)0,
(hsize_t)0);
H5Sclose(space);
h5tools_str_close(&buffer);
return 0;
}
/*-------------------------------------------------------------------------
* Function: dataset_list2
*
* Purpose: List information about a dataset which should appear after
* information which is general to all objects.
*
* Return: Success: 0
* Failure: -1
*-------------------------------------------------------------------------
*/
static herr_t
dataset_list2(hid_t dset, const char H5_ATTR_UNUSED *name)
{
hid_t dcpl; /* dataset creation property list */
hid_t type; /* data type of dataset */
hid_t space; /* data space of dataset */
int nf; /* number of filters */
unsigned filt_flags; /* filter flags */
H5Z_filter_t filt_id; /* filter identification number */
unsigned cd_values[20]; /* filter client data values */
size_t cd_nelmts; /* filter client number of values */
size_t cd_num; /* filter client data counter */
char f_name[256]; /* filter/file name */
char s[64]; /* temporary string buffer */
off_t f_offset; /* offset in external file */
hsize_t f_size; /* bytes used in external file */
hsize_t total, used; /* total size or offset */
int ndims; /* dimensionality */
int n, max_len; /* max extern file name length */
double utilization; /* percent utilization of storage */
H5T_class_t tclass; /* datatype class identifier */
int i;
H5D_layout_t stl;
hsize_t curr_pos = 0; /* total data element position */
h5tools_str_t buffer; /* string into which to render */
h5tools_context_t ctx; /* print context */
h5tool_format_t *info = &ls_dataformat;
HDmemset(&ctx, 0, sizeof(ctx));
HDmemset(&buffer, 0, sizeof(h5tools_str_t));
h5tools_str_reset(&buffer);
if (verbose_g > 0) {
dcpl = H5Dget_create_plist(dset);
space = H5Dget_space(dset);
type = H5Dget_type(dset);
stl = H5Pget_layout(dcpl);
switch (stl) {
case H5D_CHUNKED: {
hsize_t chsize[64]; /* chunk size in elements */
ndims = H5Pget_chunk(dcpl, (int)NELMTS(chsize), chsize /*out*/);
h5tools_str_append(&buffer, " %-10s {", "Chunks:");
total = H5Tget_size(type);
for (i = 0; i < ndims; i++) {
h5tools_str_append(&buffer, "%s" HSIZE_T_FORMAT, i ? ", " : "", chsize[i]);
total *= chsize[i];
}
h5tools_str_append(&buffer, "} " HSIZE_T_FORMAT " bytes\n", total);
} break;
case H5D_COMPACT:
break;
case H5D_CONTIGUOUS:
/* Print information about external storage */
if ((nf = H5Pget_external_count(dcpl)) > 0) {
for (i = 0, max_len = 0; i < nf; i++) {
if (H5Pget_external(dcpl, (unsigned)i, sizeof(f_name), f_name, NULL, NULL) < 0)
continue;
n = print_string(NULL, f_name, TRUE);
max_len = MAX(max_len, n);
} /* end for */
h5tools_str_append(&buffer, " %-10s %d external file%s\n", "Extern:", nf,
1 == nf ? "" : "s");
h5tools_str_append(&buffer, " %4s %10s %10s %10s %s\n", "ID", "DSet-Addr",
"File-Addr", "Bytes", "File");
h5tools_str_append(&buffer, " %4s %10s %10s %10s ", "----", "----------",
"----------", "----------");
for (i = 0; i < max_len; i++)
h5tools_str_append(&buffer, "-");
h5tools_str_append(&buffer, "\n");
for (i = 0, total = 0; i < nf; i++) {
if (H5Pget_external(dcpl, (unsigned)i, sizeof(f_name), f_name, &f_offset, &f_size) <
0) {
h5tools_str_append(
&buffer,
" #%03d %10" H5_PRINTF_LL_WIDTH "u %10s %10s ***ERROR*** %s\n", i,
total, "", "", i + 1 < nf ? "Following addresses are incorrect" : "");
}
else if (H5S_UNLIMITED == f_size) {
h5tools_str_append(&buffer,
" #%03d %10" H5_PRINTF_LL_WIDTH
"u %10" H5_PRINTF_LL_WIDTH "u %10s ",
i, total, (hsize_t)f_offset, "INF");
print_string(&buffer, f_name, TRUE);
}
else {
h5tools_str_append(&buffer,
" #%03d %10" H5_PRINTF_LL_WIDTH
"u %10" H5_PRINTF_LL_WIDTH "u %10" H5_PRINTF_LL_WIDTH "u ",
i, total, (hsize_t)f_offset, f_size);
print_string(&buffer, f_name, TRUE);
}
h5tools_str_append(&buffer, "\n");
total += f_size;
}
h5tools_str_append(&buffer, " %4s %10s %10s %10s ", "----", "----------",
"----------", "----------");
for (i = 0; i < max_len; i++)
h5tools_str_append(&buffer, "-");
h5tools_str_append(&buffer, "\n");
} /* end if */
break;
case H5D_VIRTUAL: {
char dset_name[256]; /* Dataset name */
size_t vmaps;
H5Pget_virtual_count(dcpl, &vmaps);
if (vmaps) {
size_t next;
h5tools_str_append(&buffer, " %-10s {%ld} Source {\n", "Maps:", vmaps);
for (next = 0; next < (unsigned)vmaps; next++) {
H5Pget_virtual_filename(dcpl, next, f_name, sizeof(f_name));
H5Pget_virtual_dsetname(dcpl, next, dset_name, sizeof(dset_name));
h5tools_str_append(&buffer, " %-10s ", " ");
print_string(&buffer, f_name, TRUE);
h5tools_str_append(&buffer, " ");
print_string(&buffer, dset_name, TRUE);
h5tools_str_append(&buffer, "\n");
}
h5tools_str_append(&buffer, " %-10s}\n", " ");
}
} break;
case H5D_LAYOUT_ERROR:
case H5D_NLAYOUTS:
default:
h5tools_str_append(&buffer, "layout information not available");
break;
}
/* Print total raw storage size */
total = (hsize_t)H5Sget_simple_extent_npoints(space) * H5Tget_size(type);
used = H5Dget_storage_size(dset);
tclass = H5Tget_class(type);
h5tools_str_append(&buffer, " %-10s ", "Storage:");
switch (tclass) {
case H5T_VLEN:
h5tools_str_append(&buffer, "information not available");
break;
case H5T_REFERENCE:
if (H5Tequal(dset, H5T_STD_REF_DSETREG)) {
h5tools_str_append(&buffer, "information not available");
}
break;
case H5T_NO_CLASS:
case H5T_INTEGER:
case H5T_FLOAT:
case H5T_TIME:
case H5T_STRING:
case H5T_BITFIELD:
case H5T_OPAQUE:
case H5T_COMPOUND:
case H5T_ENUM:
case H5T_ARRAY:
case H5T_NCLASSES:
default:
h5tools_str_append(&buffer,
HSIZE_T_FORMAT " logical byte%s, " HSIZE_T_FORMAT " allocated byte%s",
total, 1 == total ? "" : "s", used, 1 == used ? "" : "s");
if (used > 0) {
utilization = ((double)total * 100.0) / (double)used;
h5tools_str_append(&buffer, ", %1.2f%% utilization", utilization);
}
}
h5tools_str_append(&buffer, "\n");
/* Print information about raw data filters */
if ((nf = H5Pget_nfilters(dcpl)) > 0) {
for (i = 0; i < nf; i++) {
cd_nelmts = NELMTS(cd_values);
filt_id = H5Pget_filter2(dcpl, (unsigned)i, &filt_flags, &cd_nelmts, cd_values,
sizeof(f_name), f_name, NULL);
f_name[sizeof(f_name) - 1] = '\0';
HDsnprintf(s, sizeof(s), "Filter-%d:", i);
h5tools_str_append(&buffer, " %-10s %s-%u %s {", s, (f_name[0] ? f_name : "method"),
(unsigned)filt_id, ((filt_flags & H5Z_FLAG_OPTIONAL) ? "OPT" : ""));
for (cd_num = 0; cd_num < cd_nelmts; cd_num++)
h5tools_str_append(&buffer, "%s%u", (cd_num ? ", " : ""), cd_values[cd_num]);
h5tools_str_append(&buffer, "}\n");
} /* end for */
} /* end if */
h5tools_render_element(rawoutstream, info, &ctx, &buffer, &curr_pos, (size_t)info->line_ncols,
(hsize_t)0, (hsize_t)0);
/* Print data type */
h5tools_str_reset(&buffer);
h5tools_str_append(&buffer, " %-10s ", "Type:");
print_type(&buffer, type, 15);
h5tools_str_append(&buffer, "\n");
h5tools_render_element(rawoutstream, info, &ctx, &buffer, &curr_pos, (size_t)info->line_ncols,
(hsize_t)0, (hsize_t)0);
/* Print address information */
if (address_g)
H5Ddebug(dset);
/* Close stuff */
H5Tclose(type);
H5Sclose(space);
H5Pclose(dcpl);
} /* end if */
h5tools_str_close(&buffer);
if (data_g)
dump_dataset_values(dset);
return 0;
} /* end dataset_list2() */
/*-------------------------------------------------------------------------
* Function: datatype_list2
*
* Purpose: List information about a datatype which should appear after
* information which is general to all objects.
*
* Return: Success: 0
* Failure: -1
*-------------------------------------------------------------------------
*/
static herr_t
datatype_list2(hid_t type, const char H5_ATTR_UNUSED *name)
{
if (verbose_g > 0) {
hsize_t curr_pos = 0; /* total data element position */
h5tools_str_t buffer; /* string into which to render */
h5tools_context_t ctx; /* print context */
h5tool_format_t *info = &ls_dataformat;
HDmemset(&ctx, 0, sizeof(ctx));
HDmemset(&buffer, 0, sizeof(h5tools_str_t));
h5tools_str_reset(&buffer);
h5tools_str_append(&buffer, " %-10s ", "Type:");
print_type(&buffer, type, 15);
h5tools_str_append(&buffer, "\n");
h5tools_render_element(rawoutstream, info, &ctx, &buffer, &curr_pos, (size_t)info->line_ncols,
(hsize_t)0, (hsize_t)0);
h5tools_str_close(&buffer);
}
return 0;
}
/*-------------------------------------------------------------------------
* Function: list_obj
*
* Purpose: Prints information about an object
*
* Return: Success: 0
* Failure: -1
*-------------------------------------------------------------------------
*/
static herr_t
list_obj(const char *name, const H5O_info_t *oinfo, const char *first_seen, void *_iter)
{
H5O_type_t obj_type = oinfo->type; /* Type of the object */
iter_t *iter = (iter_t *)_iter;
hsize_t curr_pos = 0; /* total data element position */
h5tools_str_t buffer; /* string into which to render */
h5tools_context_t ctx; /* print context */
h5tool_format_t *info = &ls_dataformat;
H5TOOLS_START_DEBUG(" ");
HDmemset(&ctx, 0, sizeof(ctx));
HDmemset(&buffer, 0, sizeof(h5tools_str_t));
h5tools_str_reset(&buffer);
H5TOOLS_DEBUG("Object name:%s", name);
/* Print the link's name, either full name or base name */
if (!iter->symlink_target)
print_obj_name(&buffer, iter, name, "");
/* Check object information */
if (oinfo->type < 0 || oinfo->type >= H5O_TYPE_NTYPES) {
h5tools_str_append(&buffer, "Unknown type(%d)", (int)oinfo->type);
obj_type = H5O_TYPE_UNKNOWN;
}
if (iter->symlink_target)
h5tools_str_append(&buffer, "{");
if (obj_type >= 0 && dispatch_g[obj_type].name)
h5tools_str_append(&buffer, "%s", dispatch_g[obj_type].name);
h5tools_render_element(rawoutstream, info, &ctx, &buffer, &curr_pos, (size_t)info->line_ncols, (hsize_t)0,
(hsize_t)0);
/* Check if we've seen this object before */
if (first_seen) {
h5tools_str_reset(&buffer);
h5tools_str_append(&buffer, ", same as ");
print_string(&buffer, first_seen, TRUE);
if (!iter->symlink_target) {
h5tools_str_append(&buffer, "\n");
}
h5tools_render_element(rawoutstream, info, &ctx, &buffer, &curr_pos, (size_t)info->line_ncols,
(hsize_t)0, (hsize_t)0);
} /* end if */
else {
hid_t obj_id = H5I_INVALID_HID; /* ID of object opened */
/* Open the object. Not all objects can be opened. If this is the case
* then return right away.
*/
H5TOOLS_DEBUG("Open object name=%s", name);
if (obj_type >= 0 && (obj_id = H5Oopen(iter->fid, name, H5P_DEFAULT)) < 0) {
h5tools_str_reset(&buffer);
h5tools_str_append(&buffer, " *ERROR*\n");
h5tools_render_element(rawoutstream, info, &ctx, &buffer, &curr_pos, (size_t)info->line_ncols,
(hsize_t)0, (hsize_t)0);
goto done;
} /* end if */
/* List the first line of information for the object. */
H5TOOLS_DEBUG("Object type:%d", obj_type);
if (obj_type >= 0 && dispatch_g[obj_type].list1)
(dispatch_g[obj_type].list1)(obj_id);
if (!iter->symlink_target || (verbose_g > 0)) {
h5tools_str_reset(&buffer);
h5tools_str_append(&buffer, "\n");
h5tools_render_element(rawoutstream, info, &ctx, &buffer, &curr_pos, (size_t)info->line_ncols,
(hsize_t)0, (hsize_t)0);
}
/* Show detailed information about the object, beginning with information
* which is common to all objects. */
if (verbose_g > 0) {
size_t buf_size = 0;
char *comment = NULL;
ssize_t cmt_bufsize = -1;
/* Display attributes */
H5TOOLS_DEBUG("Display attributes");
if (obj_type >= 0)
H5Aiterate2(obj_id, H5_INDEX_NAME, H5_ITER_INC, NULL, list_attr, NULL);
/* Object location & reference count */
h5tools_str_reset(&buffer);
h5tools_str_append(&buffer, " %-10s %lu:" H5_PRINTF_HADDR_FMT "\n", "Location:", oinfo->fileno,
oinfo->addr);
h5tools_str_append(&buffer, " %-10s %u\n", "Links:", (unsigned)oinfo->rc);
h5tools_render_element(rawoutstream, info, &ctx, &buffer, &curr_pos, (size_t)info->line_ncols,
(hsize_t)0, (hsize_t)0);
/* Modification time */
if (oinfo->mtime > 0) {
char buf[256];
struct tm *tm;
if (simple_output_g)
tm = HDgmtime(&(oinfo->mtime));
else
tm = HDlocaltime(&(oinfo->mtime));
if (tm) {
HDstrftime(buf, sizeof(buf), "%Y-%m-%d %H:%M:%S %Z", tm);
h5tools_str_reset(&buffer);
h5tools_str_append(&buffer, " %-10s %s\n", "Modified:", buf);
h5tools_render_element(rawoutstream, info, &ctx, &buffer, &curr_pos,
(size_t)info->line_ncols, (hsize_t)0, (hsize_t)0);
} /* end if */
} /* end if */
/* Object comment */
cmt_bufsize = H5Oget_comment(obj_id, comment, buf_size);
/* if the actual length of the comment is longer than cmt_bufsize, then call
* H5Oget_comment again with the correct value.
*/
if (cmt_bufsize > 0) {
comment = (char *)HDmalloc((size_t)cmt_bufsize + 1); /* new_size including null terminator */
if (comment) {
cmt_bufsize = H5Oget_comment(obj_id, comment, (size_t)cmt_bufsize);
if (cmt_bufsize > 0) {
comment[cmt_bufsize] = 0;
h5tools_str_reset(&buffer);
h5tools_str_append(&buffer, " %-10s \"", "Comment:");
print_string(&buffer, comment, FALSE);
h5tools_str_append(&buffer, "\"\n");
h5tools_render_element(rawoutstream, info, &ctx, &buffer, &curr_pos,
(size_t)info->line_ncols, (hsize_t)0, (hsize_t)0);
} /* end if */
HDfree(comment);
}
}
} /* end if */
/* Detailed list for object */
if (obj_type >= 0 && dispatch_g[obj_type].list2)
(dispatch_g[obj_type].list2)(obj_id, name);
/* Close the object. */
if (obj_type >= 0)
H5Oclose(obj_id);
} /* end else */
done:
if (iter->symlink_target) {
h5tools_str_reset(&buffer);
h5tools_str_append(&buffer, "}\n");
h5tools_render_element(rawoutstream, info, &ctx, &buffer, &curr_pos, (size_t)info->line_ncols,
(hsize_t)0, (hsize_t)0);
iter->symlink_target = FALSE;
}
h5tools_str_close(&buffer);
H5TOOLS_ENDDEBUG(" ");
return 0;
} /* end list_obj() */
/*-------------------------------------------------------------------------
* Function: list_lnk
*
* Purpose: Prints information about a link
*
* Return: Success: 0
* Failure: -1
*-------------------------------------------------------------------------
*/
static herr_t
list_lnk(const char *name, const H5L_info_t *linfo, void *_iter)
{
char *buf = NULL;
iter_t *iter = (iter_t *)_iter;
int ret;
hsize_t curr_pos = 0; /* total data element position */
h5tool_link_info_t lnk_info;
h5tools_str_t buffer; /* string into which to render */
h5tools_context_t ctx; /* print context */
h5tool_format_t *info = &ls_dataformat;
HDmemset(&ctx, 0, sizeof(ctx));
HDmemset(&buffer, 0, sizeof(h5tools_str_t));
h5tools_str_reset(&buffer);
/* init linkinfo struct */
HDmemset(&lnk_info, 0, sizeof(h5tool_link_info_t));
/* if verbose, make H5tools_get_symlink_info() display more */
if (verbose_g)
lnk_info.opt.msg_mode = 1;
/* Print the link's name, either full name or base name */
print_obj_name(&buffer, iter, name, "");
switch (linfo->type) {
case H5L_TYPE_SOFT:
ret = H5tools_get_symlink_info(iter->fid, name, &lnk_info, follow_symlink_g);
/* lnk_info.trg_path is malloced in H5tools_get_symlink_info()
* so it will be freed via buf later */
buf = (char *)lnk_info.trg_path;
/* error */
if (ret < 0)
goto done;
/* no dangling link option given and detect dangling link */
else if (no_dangling_link_g && ret == 0)
iter->symlink_list->dangle_link = TRUE;
h5tools_str_append(&buffer, "Soft Link {");
h5tools_str_append(&buffer, buf);
h5tools_str_append(&buffer, "}");
h5tools_render_element(rawoutstream, info, &ctx, &buffer, &curr_pos, (size_t)info->line_ncols,
(hsize_t)0, (hsize_t)0);
if (follow_symlink_g) {
hbool_t orig_grp_literal = grp_literal_g;
h5tools_str_reset(&buffer);
h5tools_str_append(&buffer, " ");
/* Check if we have already seen this softlink */
if (symlink_is_visited(iter->symlink_list, linfo->type, NULL, buf)) {
h5tools_str_append(&buffer, "{Already Visited}\n");
h5tools_render_element(rawoutstream, info, &ctx, &buffer, &curr_pos,
(size_t)info->line_ncols, (hsize_t)0, (hsize_t)0);
goto done;
}
h5tools_render_element(rawoutstream, info, &ctx, &buffer, &curr_pos, (size_t)info->line_ncols,
(hsize_t)0, (hsize_t)0);
/* Add this link to the list of seen softlinks */
if (symlink_visit_add(iter->symlink_list, linfo->type, NULL, buf) < 0)
goto done;
/* Adjust user data to specify that we are operating on the
* target of an soft link */
iter->symlink_target = TRUE;
/* Prevent recursive listing of soft link target if
* recursive_g is off */
if (!recursive_g)
grp_literal_g = TRUE;
/* Recurse through the soft link */
if (visit_obj(iter->fid, name, iter) < 0) {
grp_literal_g = orig_grp_literal;
goto done;
}
grp_literal_g = orig_grp_literal;
}
else {
h5tools_str_reset(&buffer);
h5tools_str_append(&buffer, "\n");
h5tools_render_element(rawoutstream, info, &ctx, &buffer, &curr_pos, (size_t)info->line_ncols,
(hsize_t)0, (hsize_t)0);
}
break;
case H5L_TYPE_EXTERNAL: {
const char *filename;
const char *path;
hbool_t follow_link = follow_symlink_g || follow_elink_g;
ret = H5tools_get_symlink_info(iter->fid, name, &lnk_info, follow_link);
/* lnk_info.trg_path is malloced in H5tools_get_symlink_info()
* so it will be freed via buf later */
buf = (char *)lnk_info.trg_path;
/* error */
if (ret < 0)
goto done;
/* no dangling link option given and detect dangling link */
else if (no_dangling_link_g && ret == 0)
iter->symlink_list->dangle_link = TRUE;
if (H5Lunpack_elink_val(buf, linfo->u.val_size, NULL, &filename, &path) < 0)
goto done;
h5tools_str_append(&buffer, "External Link {");
h5tools_str_append(&buffer, filename);
h5tools_str_append(&buffer, "/");
if (*path != '/')
h5tools_str_append(&buffer, "/");
h5tools_str_append(&buffer, path);
h5tools_str_append(&buffer, "}");
h5tools_render_element(rawoutstream, info, &ctx, &buffer, &curr_pos, (size_t)info->line_ncols,
(hsize_t)0, (hsize_t)0);
/* Recurse through the external link */
/* keep the follow_elink_g for backward compatibility with -E */
if (follow_link) {
hbool_t orig_grp_literal = grp_literal_g;
h5tools_str_reset(&buffer);
h5tools_str_append(&buffer, " ");
/* Check if we have already seen this elink */
if (symlink_is_visited(iter->symlink_list, linfo->type, filename, path)) {
h5tools_str_append(&buffer, "{Already Visited}\n");
h5tools_render_element(rawoutstream, info, &ctx, &buffer, &curr_pos,
(size_t)info->line_ncols, (hsize_t)0, (hsize_t)0);
goto done;
}
h5tools_render_element(rawoutstream, info, &ctx, &buffer, &curr_pos, (size_t)info->line_ncols,
(hsize_t)0, (hsize_t)0);
/* Add this link to the list of seen elinks */
if (symlink_visit_add(iter->symlink_list, linfo->type, filename, path) < 0) {
goto done;
}
/* Adjust user data to specify that we are operating on the
* target of an external link */
iter->symlink_target = TRUE;
/* Prevent recursive listing of external link target if
* recursive_g is off */
if (!recursive_g)
grp_literal_g = TRUE;
/* Recurse through the external link */
if (visit_obj(iter->fid, name, iter) < 0) {
grp_literal_g = orig_grp_literal;
goto done;
}
grp_literal_g = orig_grp_literal;
}
else
PRINTVALSTREAM(rawoutstream, "\n");
} break;
case H5L_TYPE_ERROR:
case H5L_TYPE_HARD:
case H5L_TYPE_MAX:
default:
h5tools_str_append(&buffer, "UD Link {cannot follow UD links}\n");
h5tools_render_element(rawoutstream, info, &ctx, &buffer, &curr_pos, (size_t)info->line_ncols,
(hsize_t)0, (hsize_t)0);
break;
} /* end switch */
done:
h5tools_str_close(&buffer);
if (buf)
HDfree(buf);
return 0;
} /* end list_lnk() */
/*-------------------------------------------------------------------------
* Function: visit_obj
*
* Purpose: Begins iteration on an object
*
* Return: Success: 0
* Failure: -1
*-------------------------------------------------------------------------
*/
static herr_t
visit_obj(hid_t file, const char *oname, iter_t *iter)
{
int retval = 0;
H5O_info_t oi; /* Information for object */
hsize_t curr_pos = 0; /* total data element position */
h5tools_str_t buffer; /* string into which to render */
h5tools_context_t ctx; /* print context */
h5tool_format_t *info = &ls_dataformat;
HDmemset(&ctx, 0, sizeof(ctx));
HDmemset(&buffer, 0, sizeof(h5tools_str_t));
h5tools_str_reset(&buffer);
/* Retrieve info for object to list */
if (H5Oget_info_by_name2(file, oname, &oi, H5O_INFO_BASIC | H5O_INFO_TIME, H5P_DEFAULT) < 0) {
if (iter->symlink_target) {
h5tools_str_append(&buffer, "{**NOT FOUND**}\n");
iter->symlink_target = FALSE;
}
else
print_obj_name(&buffer, iter, oname, "**NOT FOUND**");
h5tools_render_element(rawoutstream, info, &ctx, &buffer, &curr_pos, (size_t)info->line_ncols,
(hsize_t)0, (hsize_t)0);
retval = -1;
goto done;
} /* end if */
/* Check for group iteration */
if (H5O_TYPE_GROUP == oi.type && !grp_literal_g) {
/* Get ID for group */
if (!iter->symlink_target && (iter->gid = H5Gopen2(file, oname, H5P_DEFAULT)) < 0) {
h5tools_str_append(&buffer, "%s: unable to open '%s' as group\n", iter->fname, oname);
h5tools_render_element(rawoutstream, info, &ctx, &buffer, &curr_pos, (size_t)info->line_ncols,
(hsize_t)0, (hsize_t)0);
goto done; /* Previously "continue", when this code was in main().
* We don't "continue" here in order to close the file
* and free the file name properly. */
} /* end if */
/* Delay specifying the name start point so the original object name is
* displayed if it is a link or non-group object */
iter->name_start = iter->base_len;
/* Specified name is a group. List the complete contents of the group. */
h5trav_visit(file, oname, (hbool_t)(display_root_g || iter->symlink_target), recursive_g, list_obj,
list_lnk, iter, H5O_INFO_BASIC | H5O_INFO_TIME);
/* Close group */
if (!iter->symlink_target)
H5Gclose(iter->gid);
} /* end if */
else {
/* Use file ID for root group ID */
iter->gid = file;
/* Specified name is a non-group object -- list that object */
list_obj(oname, &oi, NULL, iter);
} /* end else */
done:
h5tools_str_close(&buffer);
return retval;
}
/*-------------------------------------------------------------------------
* Function: get_width
*
* Purpose: Figure out how wide the screen is. This is highly
* unportable, but the user can always override the width we
* detect by giving a command-line option. These code snippets
* were borrowed from the GNU less(1).
*
* Return: Success: Number of columns.
* Failure: Some default number of columns.
*-------------------------------------------------------------------------
*/
static int
get_width(void)
{
int width = 80; /*the default */
char *s;
/* Try to get it from the COLUMNS environment variable first since it's
* value is sometimes wrong. */
if ((s = HDgetenv("COLUMNS")) && *s && isdigit((int)*s))
width = (int)HDstrtol(s, NULL, 0);
#if defined(H5_HAVE_STRUCT_VIDEOCONFIG) && defined(H5_HAVE__GETVIDEOCONFIG)
{
/* Microsoft C */
struct videoconfig w;
_getvideoconfig(&w);
width = w.numtextcols;
}
#elif defined(H5_HAVE_STRUCT_TEXT_INFO) && defined(H5_HAVE_GETTEXTINFO)
{
/* Borland C or DJGPPC */
struct text_info w;
gettextinfo(&w);
width = w.screenwidth;
}
#elif defined(H5_HAVE_GETCONSOLESCREENBUFFERINFO)
{
/* Win32 C */
CONSOLE_SCREEN_BUFFER_INFO scr;
GetConsoleScreenBufferInfo(GetStdHandle(STD_OUTPUT_HANDLE), &scr);
width = scr.srWindow.Right - scr.srWindow.Left + 1;
}
#elif defined(H5_HAVE__SCRSIZE)
{
/* OS/2 */
int w[2];
_scrsize(w);
width = w[0];
}
#elif defined(H5_HAVE_TIOCGWINSZ) && defined(H5_HAVE_IOCTL)
{
/* Unix with ioctl(TIOCGWINSZ) */
struct winsize w;
if (ioctl(2, (int)TIOCGWINSZ, &w) >= 0 && w.ws_col > 0)
width = w.ws_col;
}
#elif defined(H5_HAVE_TIOCGETD) && defined(H5_HAVE_IOCTL)
{
/* Unix with ioctl(TIOCGETD) */
struct uwdata w;
if (ioctl(2, WIOCGETD, &w) >= 0 && w.uw_width > 0)
width = w.uw_width / w.uw_hs;
}
#endif
/* Set to at least 1 */
if (width < 1)
width = 1;
return width;
}
/*-------------------------------------------------------------------------
* Function: is_valid_args
*
* Purpose: check if command line arguments are valid
*
* Return: Success: TRUE (1)
* Failure: FALSE (0)
*-------------------------------------------------------------------------*/
static hbool_t
is_valid_args(void)
{
hbool_t ret = TRUE;
if (recursive_g && grp_literal_g) {
HDfprintf(rawerrorstream, "Error: 'recursive' option not compatible with 'group info' option!\n\n");
ret = FALSE;
goto out;
}
if (no_dangling_link_g && !follow_symlink_g) {
HDfprintf(rawerrorstream,
"Error: --no-dangling-links must be used along with --follow-symlinks option!\n\n");
ret = FALSE;
goto out;
}
out:
return ret;
}
/*-------------------------------------------------------------------------
* Function: leave
*
* Purpose: Close HDF5 and MPI and call exit()
*
* Return: Does not return
*-------------------------------------------------------------------------
*/
static void
leave(int ret)
{
h5tools_close();
HDexit(ret);
}
/*-------------------------------------------------------------------------
* Function: main
*
* Purpose: Opens a file and lists the specified group
*
* Return: Success: 0
* Failure: 1
*-------------------------------------------------------------------------
*/
int
main(int argc, char *argv[])
{
hid_t file_id = H5I_INVALID_HID;
char *fname = NULL, *oname = NULL, *x = NULL;
const char *s = NULL;
char *rest;
int argno;
static char root_name[] = "/";
char drivername[50];
const char *preferred_driver = NULL;
int err_exit = 0;
hid_t fapl_id = H5P_DEFAULT;
#ifdef H5_HAVE_ROS3_VFD
/* Default "anonymous" S3 configuration */
H5FD_ros3_fapl_t ros3_fa = {
1, /* Structure Version */
false, /* Authenticate? */
"", /* AWS Region */
"", /* Access Key ID */
"", /* Secret Access Key */
};
#endif /* H5_HAVE_ROS3_VFD */
#ifdef H5_HAVE_LIBHDFS
/* "Default" HDFS configuration */
H5FD_hdfs_fapl_t hdfs_fa = {
1, /* Structure Version */
"localhost", /* Namenode Name */
0, /* Namenode Port */
"", /* Kerberos ticket cache */
"", /* User name */
2048, /* Stream buffer size */
};
#endif /* H5_HAVE_LIBHDFS */
h5tools_setprogname(PROGRAMNAME);
h5tools_setstatus(EXIT_SUCCESS);
/* Initialize h5tools lib */
h5tools_init();
/* Build object display table */
DISPATCH(H5O_TYPE_GROUP, "Group", NULL, NULL);
DISPATCH(H5O_TYPE_DATASET, "Dataset", dataset_list1, dataset_list2);
DISPATCH(H5O_TYPE_NAMED_DATATYPE, "Type", NULL, datatype_list2);
/* Default output width */
width_g = get_width();
/* Switches come before non-switch arguments */
for (argno = 1; argno < argc && '-' == argv[argno][0]; argno++) {
if (!HDstrcmp(argv[argno], "--")) {
/* Last switch */
argno++;
break;
}
else if (!HDstrcmp(argv[argno], "--help")) {
usage();
leave(EXIT_SUCCESS);
}
else if (!HDstrcmp(argv[argno], "--address")) {
address_g = TRUE;
}
else if (!HDstrcmp(argv[argno], "--data")) {
data_g = TRUE;
}
else if (!HDstrcmp(argv[argno], "--enable-error-stack")) {
enable_error_stack = 1;
}
else if (!HDstrcmp(argv[argno], "--errors")) {
/* deprecated --errors */
enable_error_stack = 1;
}
else if (!HDstrcmp(argv[argno], "--follow-symlinks")) {
follow_symlink_g = TRUE;
}
else if (!HDstrcmp(argv[argno], "--no-dangling-links")) {
no_dangling_link_g = TRUE;
}
else if (!HDstrcmp(argv[argno], "--external")) {
follow_elink_g = TRUE;
}
else if (!HDstrcmp(argv[argno], "--full")) {
fullname_g = TRUE;
}
else if (!HDstrcmp(argv[argno], "--group")) {
grp_literal_g = TRUE;
}
else if (!HDstrcmp(argv[argno], "--label")) {
label_g = TRUE;
}
else if (!HDstrcmp(argv[argno], "--recursive")) {
recursive_g = TRUE;
fullname_g = TRUE;
}
else if (!HDstrcmp(argv[argno], "--simple")) {
simple_output_g = TRUE;
}
else if (!HDstrcmp(argv[argno], "--string")) {
string_g = TRUE;
}
else if (!HDstrncmp(argv[argno], "--vfd=", (size_t)6)) {
preferred_driver = argv[argno] + 6;
}
else if (!HDstrncmp(argv[argno], "--width=", (size_t)8)) {
width_g = (int)HDstrtol(argv[argno] + 8, &rest, 0);
if (0 == width_g)
no_line_wrap_g = TRUE;
else if (width_g < 0 || *rest) {
usage();
leave(EXIT_FAILURE);
}
}
else if (!HDstrcmp(argv[argno], "--width")) {
if ((argno + 1) >= argc) {
usage();
leave(EXIT_FAILURE);
}
else {
s = argv[++argno];
}
width_g = (int)HDstrtol(s, &rest, 0);
if (width_g <= 0 || *rest) {
usage();
leave(EXIT_FAILURE);
}
}
else if (!HDstrcmp(argv[argno], "--verbose")) {
verbose_g++;
}
else if (!HDstrcmp(argv[argno], "--version")) {
print_version(h5tools_getprogname());
leave(EXIT_SUCCESS);
}
else if (!HDstrcmp(argv[argno], "--hexdump")) {
hexdump_g = TRUE;
}
else if (!HDstrncmp(argv[argno], "-w", (size_t)2)) {
if (argv[argno][2]) {
s = argv[argno] + 2;
}
else if ((argno + 1) >= argc) {
usage();
leave(EXIT_FAILURE);
}
else {
s = argv[++argno];
}
width_g = (int)HDstrtol(s, &rest, 0);
if (0 == width_g) {
no_line_wrap_g = TRUE;
}
else if (width_g < 0 || *rest) {
usage();
leave(EXIT_FAILURE);
}
}
else if (!HDstrncmp(argv[argno], "--s3-cred=", (size_t)10)) {
#ifdef H5_HAVE_ROS3_VFD
char const *start = NULL;
start = strchr(argv[argno], '=');
if (start == NULL) {
HDfprintf(rawerrorstream,
"Error: Unable to parse null credentials tuple\n"
" For anonymous access, omit \"--s3-cred\" and use only \"--vfd=ros3\"\n\n");
usage();
leave(EXIT_FAILURE);
}
start++;
if (h5tools_parse_ros3_fapl_tuple(start, ',', &ros3_fa) < 0) {
HDfprintf(rawerrorstream, "Error: failed to parse S3 VFD credential info\n\n");
usage();
leave(EXIT_FAILURE);
}
#else
HDfprintf(rawerrorstream, "Error: Read-Only S3 VFD is not enabled\n\n");
usage();
leave(EXIT_FAILURE);
#endif
}
else if (!HDstrncmp(argv[argno], "--hdfs-attrs=", (size_t)13)) {
#ifdef H5_HAVE_LIBHDFS
char const *start = NULL;
start = argv[argno] + 13; /* should never segfault: worst case of */
if (*start != '(') { /* null-termintor after '='. */
usage();
leave(EXIT_FAILURE);
}
if (h5tools_parse_hdfs_fapl_tuple(start, ',', &hdfs_fa) < 0) {
HDfprintf(rawerrorstream, "Error: failed to parse HDFS VFD configuration info\n\n");
usage();
leave(EXIT_FAILURE);
}
#else
HDfprintf(rawerrorstream, "Error: The HDFS VFD is not enabled\n\n");
usage();
leave(EXIT_FAILURE);
#endif
}
else if ('-' != argv[argno][1]) {
/* Single-letter switches */
for (s = argv[argno] + 1; *s; s++) {
switch (*s) {
case '?':
case 'h': /* --help */
usage();
leave(EXIT_SUCCESS);
break;
case 'a': /* --address */
address_g = TRUE;
break;
case 'd': /* --data */
data_g = TRUE;
break;
/* deprecated -e */
case 'e': /* --errors */
enable_error_stack = 1;
break;
case 'E': /* --external */
follow_elink_g = TRUE;
break;
case 'f': /* --full */
fullname_g = TRUE;
break;
case 'g': /* --group */
grp_literal_g = TRUE;
break;
case 'l': /* --label */
label_g = TRUE;
break;
case 'r': /* --recursive */
recursive_g = TRUE;
fullname_g = TRUE;
break;
case 'S': /* --simple */
simple_output_g = TRUE;
break;
case 's': /* --string */
string_g = TRUE;
break;
case 'v': /* --verbose */
verbose_g++;
break;
case 'V': /* --version */
print_version(h5tools_getprogname());
leave(EXIT_SUCCESS);
break;
case 'x': /* --hexdump */
hexdump_g = TRUE;
break;
default:
usage();
leave(EXIT_FAILURE);
} /* end switch */
} /* end for */
}
else {
HDfprintf(stderr, "Unknown argument: %s\n", argv[argno]);
usage();
leave(EXIT_FAILURE);
}
} /* end for */
/* enable error reporting if command line option */
h5tools_error_report();
/* If no arguments remain then print a usage message (instead of doing
* absolutely nothing ;-) */
if (argno >= argc) {
usage();
leave(EXIT_FAILURE);
} /* end if */
/* Check for conflicting arguments */
if (!is_valid_args()) {
usage();
leave(EXIT_FAILURE);
}
if (preferred_driver) {
h5tools_vfd_info_t vfd_info;
vfd_info.info = NULL;
vfd_info.name = preferred_driver;
if (!HDstrcmp(preferred_driver, drivernames[ROS3_VFD_IDX])) {
#ifdef H5_HAVE_ROS3_VFD
vfd_info.info = (void *)&ros3_fa;
#else
HDfprintf(rawerrorstream, "Error: Read-Only S3 VFD is not enabled\n\n");
leave(EXIT_FAILURE);
#endif
}
else if (!HDstrcmp(preferred_driver, drivernames[HDFS_VFD_IDX])) {
#ifdef H5_HAVE_LIBHDFS
vfd_info.info = (void *)&hdfs_fa;
#else
HDfprintf(rawerrorstream, "Error: The HDFS VFD is not enabled\n\n");
leave(EXIT_FAILURE);
#endif
}
if ((fapl_id = h5tools_get_fapl(H5P_DEFAULT, &vfd_info)) < 0) {
HDfprintf(rawerrorstream, "Error: Unable to create FAPL for file access\n\n");
leave(EXIT_FAILURE);
}
}
/* Each remaining argument is an hdf5 file followed by an optional slash
* and object name.
*
* Example: ../dir1/foo/bar/baz
* \_________/\______/
* file obj
*
* The dichotomy is determined by calling H5Fopen() repeatedly until it
* succeeds. The first call uses the entire name and each subsequent call
* chops off the last component. If we reach the beginning of the name
* then there must have been something wrong with the file (perhaps it
* doesn't exist). */
show_file_name_g = (argc - argno > 1); /*show file names if more than one*/
while (argno < argc) {
H5L_info_t li;
iter_t iter;
symlink_trav_t symlink_list;
size_t u;
fname = HDstrdup(argv[argno++]);
oname = NULL;
file_id = H5I_INVALID_HID;
while (fname && *fname) {
file_id = h5tools_fopen(fname, H5F_ACC_RDONLY, fapl_id, (fapl_id == H5P_DEFAULT) ? FALSE : TRUE,
drivername, sizeof drivername);
if (file_id >= 0) {
if (verbose_g)
PRINTSTREAM(rawoutstream, "Opened \"%s\" with %s driver.\n", fname, drivername);
break; /*success*/
} /* end if */
/* Shorten the file name; lengthen the object name */
x = oname;
oname = HDstrrchr(fname, '/');
if (x)
*x = '/';
if (!oname)
break;
*oname = '\0';
} /* end while */
if (file_id < 0) {
HDfprintf(rawerrorstream, "%s: unable to open file\n", argv[argno - 1]);
HDfree(fname);
err_exit = 1;
continue;
} /* end if */
if (oname) {
/* Always use absolute paths to avoid confusion, keep track of where
* to begin path name output */
*oname = '/';
iter.base_len = HDstrlen(oname);
iter.base_len -= oname[iter.base_len - 1] == '/';
x = oname;
if (NULL == (oname = HDstrdup(oname))) {
HDfprintf(rawerrorstream, "memory allocation failed\n");
leave(EXIT_FAILURE);
}
*x = '\0';
/* Delay specifying the name start point so the original object name
* is displayed if it is a link or non-group object */
iter.name_start = 1;
}
if (!oname || !*oname) {
oname = root_name;
if (recursive_g)
display_root_g = TRUE;
iter.base_len = 0;
iter.name_start = 0;
/* Use x to remember if we have allocated space in oname */
x = NULL;
} /* end if */
/* Remember the file information for later */
iter.fname = fname;
iter.fid = file_id;
iter.gid = H5I_INVALID_HID;
iter.symlink_target = FALSE;
iter.symlink_list = &symlink_list;
iter.symlink_list->dangle_link = FALSE;
/* Initialize list of visited symbolic links */
symlink_list.nused = symlink_list.nalloc = 0;
symlink_list.objs = NULL;
/* Check for root group as object name */
if (HDstrcmp(oname, root_name) != 0) {
/* Check the type of link given */
if (H5Lget_info(file_id, oname, &li, H5P_DEFAULT) < 0) {
hsize_t curr_pos = 0; /* total data element position */
h5tools_str_t buffer; /* string into which to render */
h5tools_context_t ctx; /* print context */
h5tool_format_t *info = &ls_dataformat;
HDmemset(&ctx, 0, sizeof(ctx));
HDmemset(&buffer, 0, sizeof(h5tools_str_t));
h5tools_str_reset(&buffer);
print_obj_name(&buffer, &iter, oname, "**NOT FOUND**");
h5tools_render_element(rawoutstream, info, &ctx, &buffer, &curr_pos, (size_t)info->line_ncols,
(hsize_t)0, (hsize_t)0);
leave(EXIT_FAILURE);
} /* end if */
} /* end if */
else
li.type = H5L_TYPE_HARD;
/* Open the object and display it's information */
if (li.type == H5L_TYPE_HARD) {
if (visit_obj(file_id, oname, &iter) < 0) {
leave(EXIT_FAILURE);
}
} /* end if(li.type == H5L_TYPE_HARD) */
else {
/* Specified name is not for object -- list that link */
/* Use file_id ID for root group ID */
iter.gid = file_id;
list_lnk(oname, &li, &iter);
}
H5Fclose(file_id);
HDfree(fname);
if (x)
HDfree(oname);
for (u = 0; u < symlink_list.nused; u++) {
if (symlink_list.objs[u].type == H5L_TYPE_EXTERNAL)
HDfree(symlink_list.objs[u].file);
HDfree(symlink_list.objs[u].path);
}
HDfree(symlink_list.objs);
/* if no-dangling-links option specified and dangling link found */
if (no_dangling_link_g && iter.symlink_list->dangle_link)
err_exit = 1;
} /* end while */
if (fapl_id != H5P_DEFAULT) {
if (0 < H5Pclose(fapl_id)) {
HDfprintf(rawerrorstream, "Error: Unable to set close fapl entry\n\n");
leave(EXIT_FAILURE);
}
}
if (err_exit)
leave(EXIT_FAILURE);
else
leave(EXIT_SUCCESS);
} /* end main() */