mirror/hdf5
2
0
Fork 0
mirror of https://github.com/HDFGroup/hdf5.git synced 2025-01-18 15:15:56 +08:00
Code Issues Packages Projects Releases Wiki Activity
a0f4dd17a7
hdf5/tools/h5tools.c
Bill Wendling 71090d2e9a [svn-r3412] Purpose: 
Code cleanup
Description:
    Cleaned the code up a bit getting rid of some warnings about "const"
    being lost from passing a const char * to a function, etc.

    Also force the error messages to stderr instead of simply printing
    them to stdout. The same behaviour can be achieved by running h5dump
    like:

            h5dump ... 2>&1

    however, the error reporting before this change wasn't consistent in
    its use. I also made some of the error messages clearer (giving names
    of the failed types and, when there's an "internal error", reporting
    the line number the error occurred on so that we can debug).
Solution:
    Converted to "fflush(stdout); fprintf(stderr,...);" for all error
    reportings.
Platforms tested:
    Linux
2001-02-15 14:31:55 -05:00

2689 lines
80 KiB
C
Raw Blame History

This file contains invisible Unicode characters

This file contains invisible Unicode characters that are indistinguishable to humans but may be processed differently by a computer. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.

/*
* Copyright © 1998, 2001 National Center for Supercomputing Applications
* All rights reserved.
*
* Programmer: Robb Matzke <matzke@llnl.gov>
* Thursday, July 23, 1998
*
* Purpose: A library for displaying the values of a dataset in a human
* readable format.
*/
/*
* Portions of this work are derived from _Obfuscated C and Other Mysteries_,
* by Don Libes, copyright (c) 1993 by John Wiley & Sons, Inc.
*/
#include <ctype.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include "h5tools.h"
#include "hdf5.h"
#include "H5private.h"
#include "h5dump.h"
/* taken from h5dumputil.c */
/*
* If REPEAT_VERBOSE is defined then character strings will be printed so
* that repeated character sequences like "AAAAAAAAAA" are displayed as
*
* 'A' repeates 9 times
*
* Otherwise the format is more Perl-like
*
* 'A'*10
*
*/
#define REPEAT_VERBOSE
/*
* The output functions need a temporary buffer to hold a piece of the
* dataset while it's being printed. This constant sets the limit on the
* size of that temporary buffer in bytes. For efficiency's sake, choose the
* largest value suitable for your machine (for testing use a small value).
*/
#if 1
#define H5DUMP_BUFSIZE (1024 * 1024)
#else
#define H5DUMP_BUFSIZE (1024)
#endif
#define OPT(X,S) ((X) ? (X) : (S))
#define ALIGN(A,Z) ((((A) + (Z) - 1) / (Z)) * (Z))
#define START_OF_DATA 0x0001
#define END_OF_DATA 0x0002
/* Special strings embedded in the output */
#define OPTIONAL_LINE_BREAK "\001"
/* Variable length string datatype */
#define STR_INIT_LEN 4096 /*initial length */
/* module-scoped variables */
static int h5tools_init_g; /* if h5tools lib has been initialized */
int indent;
int compound_data;
int nCols = 80;
FILE *rawdatastream; /* should initialize to stdout but gcc moans about it */
/* ``get_option'' variables */
int opt_err = 1; /*get_option prints errors if this is on */
int opt_ind = 1; /*token pointer */
const char *opt_arg; /*flag argument (or value) */
typedef struct h5dump_str_t {
char *s; /*allocate string */
size_t len; /*length of actual value */
size_t nalloc; /*allocated size of string */
} h5dump_str_t;
/* Output variables */
typedef struct h5dump_context_t {
size_t cur_column; /*current column for output */
size_t cur_elmt; /*current element/output line */
int need_prefix; /*is line prefix needed? */
int ndims; /*dimensionality */
hsize_t p_min_idx[H5S_MAX_RANK]; /*min selected index */
hsize_t p_max_idx[H5S_MAX_RANK]; /*max selected index */
int prev_multiline; /*was prev datum multiline? */
size_t prev_prefix_len;/*length of previous prefix */
int continuation; /*continuation of previous data?*/
int size_last_dim; /*the size of the last dimension,
*needed so we can break after each
*row */
int indent_level; /*the number of times we need some
*extra indentation */
int default_indent_level; /*this is used when the indent
*level gets changed */
} h5dump_context_t;
typedef herr_t (*H5G_operator_t)(hid_t, const char*, void*);
extern void free_table(table_t **table);
extern void dump_table(char *name, table_t* table);
extern int get_table_idx(table_t *table, unsigned long *);
extern int get_tableflag(table_t*, int);
extern int set_tableflag(table_t*, int);
extern char *get_objectname(table_t*, int);
/*-------------------------------------------------------------------------
* Function: get_option
*
* Purpose: Determine the command-line options a user specified. We can
* accept both short and long type command-lines.
*
* Return: Success: The short valued "name" of the command line
* parameter or EOF if there are no more
* parameters to process.
*
* Failure: A question mark.
*
* Programmer: Bill Wendling
* Friday, 5. January 2001
*
* Modifications:
*
*-------------------------------------------------------------------------
*/
int
get_option(int argc, const char **argv, const char *opts, const struct long_options *l_opts)
{
static int sp = 1; /* character index in current token */
int opt_opt = '?'; /* option character passed back to user */
if (sp == 1) {
/* check for more flag-like tokens */
if (opt_ind >= argc || argv[opt_ind][0] != '-' || argv[opt_ind][1] == '\0') {
return EOF;
} else if (strcmp(argv[opt_ind], "--") == 0) {
opt_ind++;
return EOF;
}
}
if (sp == 1 && argv[opt_ind][0] == '-' && argv[opt_ind][1] == '-') {
/* long command line option */
const char *arg = &argv[opt_ind][2];
register int i;
for (i = 0; l_opts && l_opts[i].name; i++) {
size_t len = strlen(l_opts[i].name);
if (strncmp(arg, l_opts[i].name, len) == 0) {
/* we've found a matching long command line flag */
opt_opt = l_opts[i].shortval;
if (l_opts[i].has_arg != no_arg) {
if (arg[len] == '=') {
opt_arg = &arg[len + 1];
} else if (opt_ind < (argc - 1) && argv[opt_ind + 1][0] != '-') {
opt_arg = argv[++opt_ind];
} else if (l_opts[i].has_arg == require_arg) {
if (opt_err)
fprintf(stderr,
"%s: option required for \"--%s\" flag\n",
argv[0], arg);
opt_opt = '?';
}
} else {
if (arg[len] == '=') {
if (opt_err)
fprintf(stderr,
"%s: no option required for \"%s\" flag\n",
argv[0], arg);
opt_opt = '?';
}
opt_arg = NULL;
}
break;
}
}
if (l_opts[i].name == NULL) {
/* exhausted all of the l_opts we have and still didn't match */
if (opt_err)
fprintf(stderr, "%s: unknown option \"%s\"\n", argv[0], arg);
opt_opt = '?';
}
opt_ind++;
sp = 1;
} else {
register char *cp; /* pointer into current token */
/* short command line option */
opt_opt = argv[opt_ind][sp];
if (opt_opt == ':' || (cp = strchr(opts, opt_opt)) == 0) {
if (opt_err)
fprintf(stderr, "%s: unknown option \"%c\"\n",
argv[0], opt_opt);
/* if no chars left in this token, move to next token */
if (argv[opt_ind][++sp] == '\0') {
opt_ind++;
sp = 1;
}
return '?';
}
if (*++cp == ':') {
/* if a value is expected, get it */
if (argv[opt_ind][sp + 1] != '\0') {
/* flag value is rest of current token */
opt_arg = &argv[opt_ind++][sp + 1];
} else if (++opt_ind >= argc) {
if (opt_err)
fprintf(stderr,
"%s: value expected for option \"%c\"\n",
argv[0], opt_opt);
opt_opt = '?';
} else {
/* flag value is next token */
opt_arg = argv[opt_ind++];
}
sp = 1;
} else {
/* set up to look at next char in token, next time */
if (argv[opt_ind][++sp] == '\0') {
/* no more in current token, so setup next token */
opt_ind++;
sp = 1;
}
opt_arg = NULL;
}
}
/* return the current flag character found */
return opt_opt;
}
/*-------------------------------------------------------------------------
* Function: h5tools_init
*
* Purpose: Initialize the H5 Tools library.
* This should be called before any other h5tools function is
* called. Effect of any h5tools function called before this
* has been called is undetermined.
*
* Return: None
*
* Programmer: Albert Cheng, 2000-10-31
*
* Modifications:
*-------------------------------------------------------------------------
*/
void
h5tools_init(void)
{
if (!h5tools_init_g) {
if (!rawdatastream)
rawdatastream = stdout;
h5tools_init_g++;
}
}
/*-------------------------------------------------------------------------
* Function: h5tools_close
*
* Purpose: Close the H5 Tools library by closing or releasing resources
* such as files opened by the library.
* This should be called after all other h5tools functions have
* been called. Effect of any h5tools function called after this
* has been called is undetermined.
*
* Return: None
*
* Programmer: Albert Cheng, 2000-10-31
*
* Modifications:
*-------------------------------------------------------------------------
*/
void
h5tools_close(void)
{
if (h5tools_init_g) {
if (rawdatastream && rawdatastream != stdout) {
if (fclose(rawdatastream))
perror("closing rawdatastream");
else
rawdatastream = NULL;
}
h5tools_init_g = 0;
}
}
/*-------------------------------------------------------------------------
* Function: h5dump_str_close
*
* Purpose: Closes a string by releasing it's memory and setting the size
* information to zero.
*
* Return: void
*
* Programmer: Robb Matzke
* Monday, April 26, 1999
*
* Modifications:
*
*-------------------------------------------------------------------------
*/
static void
h5dump_str_close(h5dump_str_t *str)
{
if (str && str->nalloc) {
free(str->s);
memset(str, 0, sizeof(h5dump_str_t));
}
}
/*-------------------------------------------------------------------------
* Function: h5dump_str_len
*
* Purpose: Returns the length of the string, not counting the null
* terminator.
*
* Return: Success: Length of string
*
* Failure: 0
*
* Programmer: Robb Matzke
* Monday, April 26, 1999
*
* Modifications:
*
*-------------------------------------------------------------------------
*/
static size_t
h5dump_str_len(h5dump_str_t *str)
{
return str->len;
}
/*-------------------------------------------------------------------------
* Function: h5dump_str_append
*
* Purpose: Formats variable arguments according to printf() format
* string and appends the result to variable length string STR.
*
* Return: Success: Pointer to buffer containing result.
*
* Failure: NULL
*
* Programmer: Robb Matzke
* Monday, April 26, 1999
*
* Modifications:
*
*-------------------------------------------------------------------------
*/
static char *
h5dump_str_append(h5dump_str_t *str/*in,out*/, const char *fmt, ...)
{
va_list ap;
va_start(ap, fmt);
/* Make sure we have some memory into which to print */
if (!str->s || str->nalloc <= 0) {
str->nalloc = STR_INIT_LEN;
str->s = malloc(str->nalloc);
assert(str->s);
str->s[0] = '\0';
str->len = 0;
}
while (1) {
size_t avail = str->nalloc - str->len;
size_t nchars = (size_t)HDvsnprintf(str->s+str->len, avail, fmt, ap);
if (nchars < avail) {
/* success */
str->len += nchars;
break;
}
/* Try again with twice as much space */
str->nalloc *= 2;
str->s = realloc(str->s, str->nalloc);
assert(str->s);
}
va_end(ap);
return str->s;
}
/*-------------------------------------------------------------------------
* Function: h5dump_str_reset
*
* Purpose: Reset the string to the empty value. If no memory is
* allocated yet then initialize the h5dump_str_t struct.
*
* Return: Success: Ptr to the buffer which contains a null
* character as the first element.
*
* Failure: NULL
*
* Programmer: Robb Matzke
* Monday, April 26, 1999
*
* Modifications:
*
*-------------------------------------------------------------------------
*/
static char *
h5dump_str_reset(h5dump_str_t *str/*in,out*/)
{
if (!str->s || str->nalloc <= 0) {
str->nalloc = STR_INIT_LEN;
str->s = malloc(str->nalloc);
assert(str->s);
}
str->s[0] = '\0';
str->len = 0;
return str->s;
}
/*-------------------------------------------------------------------------
* Function: h5dump_str_trunc
*
* Purpose: Truncate a string to be at most SIZE characters.
*
* Return: Success: Pointer to the string
*
* Failure: NULL
*
* Programmer: Robb Matzke
* Monday, April 26, 1999
*
* Modifications:
*
*-------------------------------------------------------------------------
*/
static char *
h5dump_str_trunc(h5dump_str_t *str/*in,out*/, size_t size)
{
if (size < str->len) {
str->len = size;
str->s[size] = '\0';
}
return str->s;
}
/*-------------------------------------------------------------------------
* Function: h5dump_str_fmt
*
* Purpose: Reformat a string contents beginning at character START
* according to printf format FMT. FMT should contain no format
* specifiers except possibly the `%s' variety. For example, if
* the input string is `hello' and the format is "<<%s>>" then
* the output value will be "<<hello>>".
*
* Return: Success: A pointer to the resulting string.
*
* Failure: NULL
*
* Programmer: Robb Matzke
* Monday, April 26, 1999
*
* Modifications:
*
*-------------------------------------------------------------------------
*/
static char *
h5dump_str_fmt(h5dump_str_t *str/*in,out*/, size_t start, const char *fmt)
{
char _temp[1024], *temp = _temp;
/* If the format string is simply "%s" then don't bother doing anything */
if (!strcmp(fmt, "%s"))
return str->s;
/*
* Save the input value if there is a `%' anywhere in FMT. Otherwise
* don't bother because we don't need a temporary copy.
*/
if (strchr(fmt, '%')) {
if (str->len - start + 1 > sizeof(_temp)) {
temp = malloc(str->len-start + 1);
assert(temp);
}
strcpy(temp, str->s + start);
}
/* Reset the output string and append a formatted version */
h5dump_str_trunc(str, start);
h5dump_str_append(str, fmt, temp);
/* Free the temp buffer if we allocated one */
if (temp != _temp)
free(temp);
return str->s;
}
/*-------------------------------------------------------------------------
* Function: h5dump_prefix
*
* Purpose: Renders the line prefix value into string STR.
*
* Return: Success: Pointer to the prefix.
*
* Failure: NULL
*
* Programmer: Robb Matzke
* Thursday, July 23, 1998
*
* Modifications:
*
*-------------------------------------------------------------------------
*/
static char *
h5dump_prefix(h5dump_str_t *str/*in,out*/, const h5dump_t *info,
hsize_t elmtno, int ndims, hsize_t min_idx[], hsize_t max_idx[])
{
hsize_t p_prod[H5S_MAX_RANK], p_idx[H5S_MAX_RANK];
hsize_t n, i = 0;
h5dump_str_reset(str);
if (ndims > 0) {
/*
* Calculate the number of elements represented by a unit change in a
* certain index position.
*/
for (i = ndims - 1, p_prod[ndims - 1] = 1; i > 0; --i) {
p_prod[i - 1] = (max_idx[i] - min_idx[i]) * p_prod[i];
}
/*
* Calculate the index values from the element number.
*/
for (i = 0, n = elmtno; i < (hsize_t)ndims; i++) {
p_idx[i] = n / p_prod[i] + min_idx[i];
n %= p_prod[i];
}
/*
* Print the index values.
*/
for (i = 0; i < (hsize_t)ndims; i++) {
if (i)
h5dump_str_append(str, "%s", OPT(info->idx_sep, ","));
h5dump_str_append(str, OPT(info->idx_n_fmt, "%lu"),
(unsigned long)p_idx[i]);
}
} else {
/* Scalar */
h5dump_str_append(str, OPT(info->idx_n_fmt, "%lu"), (unsigned long)0);
}
/*
* Add prefix and suffix to the index.
*/
return h5dump_str_fmt(str, 0, OPT(info->idx_fmt, "%s: "));
}
/*-------------------------------------------------------------------------
* Function: h5dump_escape
*
* Purpose: Changes all "funny" characters in S into standard C escape
* sequences. If ESCAPE_SPACES is non-zero then spaces are
* escaped by prepending a backslash.
*
* Return: Success: S
*
* Failure: NULL if the buffer would overflow. The
* buffer has as many left-to-right escapes as
* possible before overflow would have happened.
*
* Programmer: Robb Matzke
* Monday, April 26, 1999
*
* Modifications:
*
*-------------------------------------------------------------------------
*/
static char *
h5dump_escape(char *s/*in,out*/, size_t size, int escape_spaces)
{
size_t n = strlen(s);
size_t i;
const char *escape;
char octal[8];
for (i = 0; i < n; i++) {
switch (s[i]) {
case '"':
escape = "\\\"";
break;
case '\\':
escape = "\\\\";
break;
case '\b':
escape = "\\b";
break;
case '\f':
escape = "\\f";
break;
case '\n':
escape = "\\n";
break;
case '\r':
escape = "\\r";
break;
case '\t':
escape = "\\t";
break;
case ' ':
escape = escape_spaces ? "\\ " : NULL;
break;
default:
if (!isprint((int)*s)) {
sprintf(octal, "\\%03o", (unsigned char)s[i]);
escape = octal;
} else {
escape = NULL;
}
break;
}
if (escape) {
size_t esc_size = strlen(escape);
if (n + esc_size + 1 > size)
/*would overflow*/
return NULL;
memmove(s + i + esc_size, s + i, (n - i) + 1); /*make room*/
memcpy(s + i, escape, esc_size); /*insert*/
n += esc_size;
i += esc_size - 1;
}
}
return s;
}
/*-------------------------------------------------------------------------
* Function: h5dump_is_zero
*
* Purpose: Determines if memory is initialized to all zero bytes.
*
* Return: TRUE if all bytes are zero; FALSE otherwise
*
* Programmer: Robb Matzke
* Monday, June 7, 1999
*
* Modifications:
*
*-------------------------------------------------------------------------
*/
static hbool_t
h5dump_is_zero(const void *_mem, size_t size)
{
const unsigned char *mem = (const unsigned char *)_mem;
while (size-- > 0)
if (mem[size])
return FALSE;
return TRUE;
}
/*-------------------------------------------------------------------------
* Function: h5dump_region
*
* Purpose: Prints information about a dataspace region by appending
* the information to the specified string.
*
* Return: Success: 0
*
* Failure: NULL
*
* Programmer: Robb Matzke
* Monday, June 7, 1999
*
* Modifications:
*
*-------------------------------------------------------------------------
*/
static int
h5dump_region(hid_t region, h5dump_str_t *str/*in,out*/, const h5dump_t *info)
{
hssize_t nblocks, npoints;
hsize_t alloc_size;
hsize_t *ptdata;
int ndims = H5Sget_simple_extent_ndims(region);
/*
* These two functions fail if the region does not have blocks or points,
* respectively. They do not currently know how to translate from one to
* the other.
*/
H5E_BEGIN_TRY {
nblocks = H5Sget_select_hyper_nblocks(region);
npoints = H5Sget_select_elem_npoints(region);
} H5E_END_TRY;
h5dump_str_append(str, "{");
/* Print block information */
if (nblocks > 0) {
int i;
alloc_size=nblocks * ndims * 2 * sizeof(ptdata[0]);
assert(alloc_size==(hsize_t)((size_t)alloc_size)); /*check for overflow*/
ptdata = malloc((size_t)alloc_size);
H5_CHECK_OVERFLOW(nblocks,hssize_t,hsize_t);
H5Sget_select_hyper_blocklist(region, (hsize_t)0, (hsize_t)nblocks, ptdata);
for (i = 0; i < nblocks; i++) {
int j;
h5dump_str_append(str, info->dset_blockformat_pre,
i ? "," OPTIONAL_LINE_BREAK " " : "",
(unsigned long)i);
/* Start coordinates and opposite corner */
for (j = 0; j < ndims; j++)
h5dump_str_append(str, "%s%lu", j ? "," : "(",
(unsigned long)ptdata[i * 2 * ndims + j]);
for (j = 0; j < ndims; j++)
h5dump_str_append(str, "%s%lu", j ? "," : ")-(",
(unsigned long)ptdata[i * 2 * ndims + j + ndims]);
h5dump_str_append(str, ")");
}
free(ptdata);
}
/* Print point information */
if (npoints > 0) {
int i;
alloc_size=npoints * ndims * sizeof(ptdata[0]);
assert(alloc_size==(hsize_t)((size_t)alloc_size)); /*check for overflow*/
ptdata = malloc((size_t)alloc_size);
H5_CHECK_OVERFLOW(npoints,hssize_t,hsize_t);
H5Sget_select_elem_pointlist(region, (hsize_t)0, (hsize_t)npoints, ptdata);
for (i = 0; i < npoints; i++) {
int j;
h5dump_str_append(str, info->dset_ptformat_pre ,
i ? "," OPTIONAL_LINE_BREAK " " : "",
(unsigned long)i);
for (j = 0; j < ndims; j++)
h5dump_str_append(str, "%s%lu", j ? "," : "(",
(unsigned long)(ptdata[i * ndims + j]));
h5dump_str_append(str, ")");
}
free(ptdata);
}
h5dump_str_append(str, "}");
return 0;
}
/*-------------------------------------------------------------------------
* Function: h5dump_sprint
*
* Purpose: Renders the value pointed to by VP of type TYPE into variable
* length string STR.
*
* Return: A pointer to memory containing the result or NULL on error.
*
* Programmer: Robb Matzke
* Thursday, July 23, 1998
*
* Modifications:
* Robb Matzke, 1999-04-26
* Made this function safe from overflow problems by allowing it
* to reallocate the output string.
*
* Robb Matzke, 1999-06-04
* Added support for object references. The new `container'
* argument is the dataset where the reference came from.
*
* Robb Matzke, 1999-06-07
* Added support for printing raw data. If info->raw is non-zero
* then data is printed in hexadecimal format.
*
*-------------------------------------------------------------------------
*/
static char *
h5dump_sprint(h5dump_str_t *str/*in,out*/, const h5dump_t *info,
hid_t container, hid_t type, void *vp, h5dump_context_t *ctx)
{
size_t n, offset, size, nelmts, start;
char *name, quote='\0';
unsigned char *ucp_vp = (unsigned char *)vp;
char *cp_vp = (char *)vp;
hid_t memb, obj, region;
int nmembs, otype;
static char fmt_llong[8], fmt_ullong[8];
H5T_str_t pad;
H5G_stat_t sb;
/*some tempvars to store the value before we append it to the string
to get rid of the memory alignment problem*/
float tempfloat;
double tempdouble;
int tempint;
unsigned int tempuint;
short tempshort;
unsigned short tempushort;
long templong;
unsigned long tempulong;
unsigned long_long tempullong;
long_long templlong;
/* Build default formats for long long types */
if (!fmt_llong[0]) {
sprintf(fmt_llong, "%%%sd", PRINTF_LL_WIDTH);
sprintf(fmt_ullong, "%%%su", PRINTF_LL_WIDTH);
}
/* Append value depending on data type */
start = h5dump_str_len(str);
if (info->raw) {
unsigned int i;
h5dump_str_append(str, "0x");
n = H5Tget_size(type);
for (i = 0; i < n; i++)
h5dump_str_append(str, OPT(info->fmt_raw, "%02x"), ucp_vp[i]);
} else if (H5Tequal(type, H5T_NATIVE_FLOAT)) {
memcpy(&tempfloat, vp, sizeof(float));
h5dump_str_append(str, OPT(info->fmt_float, "%g"), tempfloat);
} else if (H5Tequal(type, H5T_NATIVE_DOUBLE)) {
memcpy(&tempdouble, vp, sizeof(double));
h5dump_str_append(str, OPT(info->fmt_double, "%g"), tempdouble);
} else if (info->ascii && (H5Tequal(type, H5T_NATIVE_SCHAR) ||
H5Tequal(type, H5T_NATIVE_UCHAR))) {
if (ESCAPE_HTML == info->str_locale) {
if (*cp_vp <= ' ' || *cp_vp > '~')
h5dump_str_append(str, "%%%02X", *ucp_vp);
else
h5dump_str_append(str, "%c", *cp_vp);
} else {
switch (*cp_vp) {
case '"':
h5dump_str_append(str, "\\\"");
break;
case '\\':
h5dump_str_append(str, "\\\\");
break;
case '\b':
h5dump_str_append(str, "\\b");
break;
case '\f':
h5dump_str_append(str, "\\f");
break;
case '\n':
h5dump_str_append(str, "\\n");
break;
case '\r':
h5dump_str_append(str, "\\r");
break;
case '\t':
h5dump_str_append(str, "\\t");
break;
default:
if (isprint(*cp_vp))
h5dump_str_append(str, "%c", *cp_vp);
else
h5dump_str_append(str, "\\%03o", *ucp_vp);
break;
}
}
} else if (H5T_STRING == H5Tget_class(type)) {
unsigned int i;
size = H5Tget_size(type);
quote = '\0';
pad = H5Tget_strpad(type);
for (i=0;
i < size && (cp_vp[i] != '\0' || pad != H5T_STR_NULLTERM);
i++) {
int j = 1;
/*
* Count how many times the next character repeats. If the
* threshold is zero then that means it can repeat any number
* of times.
*/
if (info->str_repeat > 0)
while (i + j < size && cp_vp[i] == cp_vp[i + j])
j++;
/*
* Print the opening quote. If the repeat count is high enough to
* warrant printing the number of repeats instead of enumerating
* the characters, then make sure the character to be repeated is
* in it's own quote.
*/
if (info->str_repeat > 0 && j > info->str_repeat) {
if (quote)
h5dump_str_append(str, "%c", quote);
quote = '\'';
h5dump_str_append(str, "%s%c", i ? " " : "", quote);
} else if (!quote) {
quote = '"';
h5dump_str_append(str, "%s%c", i ? " " : "", quote);
}
/* Print the character */
if (ESCAPE_HTML == info->str_locale) {
if (cp_vp[i] <= ' ' || cp_vp[i] > '~') {
h5dump_str_append(str, "%%%02X", ucp_vp[i]);
} else {
h5dump_str_append(str, "%c", cp_vp[i]);
}
} else {
switch (cp_vp[i]) {
case '"':
h5dump_str_append(str, "\\\"");
break;
case '\\':
h5dump_str_append(str, "\\\\");
break;
case '\b':
h5dump_str_append(str, "\\b");
break;
case '\f':
h5dump_str_append(str, "\\f");
break;
case '\n':
h5dump_str_append(str, "\\n");
break;
case '\r':
h5dump_str_append(str, "\\r");
break;
case '\t':
h5dump_str_append(str, "\\t");
break;
default:
if (isprint(cp_vp[i]))
h5dump_str_append(str, "%c", cp_vp[i]);
else
h5dump_str_append(str, "\\%03o", ucp_vp[i]);
break;
}
}
/* Print the repeat count */
if (info->str_repeat && j > info->str_repeat) {
#ifdef REPEAT_VERBOSE
h5dump_str_append(str, "%c repeats %d times", quote, j - 1);
#else
h5dump_str_append(str, "%c*%d", quote, j - 1);
#endif
quote = '\0';
i += j - 1;
}
}
if (quote)
h5dump_str_append(str, "%c", quote);
if (0 == i)
h5dump_str_append(str, "\"\""); /*empty string*/
} else if (H5Tequal(type, H5T_NATIVE_INT)) {
memcpy(&tempint, vp, sizeof(int));
h5dump_str_append(str, OPT(info->fmt_int, "%d"), tempint);
} else if (H5Tequal(type, H5T_NATIVE_UINT)) {
memcpy(&tempuint, vp, sizeof(unsigned int));
h5dump_str_append(str, OPT(info->fmt_uint, "%u"), tempuint);
} else if (H5Tequal(type, H5T_NATIVE_SCHAR)) {
h5dump_str_append(str, OPT(info->fmt_schar, "%d"), *((signed char*)vp));
} else if (H5Tequal(type, H5T_NATIVE_UCHAR)) {
h5dump_str_append(str, OPT(info->fmt_uchar, "%u"), *((unsigned char*)vp));
} else if (H5Tequal(type, H5T_NATIVE_SHORT)) {
memcpy(&tempshort, vp, sizeof(short));
h5dump_str_append(str, OPT(info->fmt_short, "%d"), tempshort);
} else if (H5Tequal(type, H5T_NATIVE_USHORT)) {
memcpy(&tempushort, vp, sizeof(unsigned short));
h5dump_str_append(str, OPT(info->fmt_ushort, "%u"), tempushort);
} else if (H5Tequal(type, H5T_NATIVE_LONG)) {
memcpy(&templong, vp, sizeof(long));
h5dump_str_append(str, OPT(info->fmt_long, "%ld"), templong);
} else if (H5Tequal(type, H5T_NATIVE_ULONG)) {
memcpy(&tempulong, vp, sizeof(unsigned long));
h5dump_str_append(str, OPT(info->fmt_ulong, "%lu"), tempulong);
} else if (H5Tequal(type, H5T_NATIVE_LLONG)) {
memcpy(&templlong, vp, sizeof(long_long));
h5dump_str_append(str, OPT(info->fmt_llong, fmt_llong), templlong);
} else if (H5Tequal(type, H5T_NATIVE_ULLONG)) {
memcpy(&tempullong, vp, sizeof(unsigned long_long));
h5dump_str_append(str, OPT(info->fmt_ullong, fmt_ullong), tempullong);
} else if (H5Tequal(type, H5T_NATIVE_HSSIZE)) {
if (sizeof(hssize_t) == sizeof(int)) {
memcpy(&tempint, vp, sizeof(int));
h5dump_str_append(str, OPT(info->fmt_int, "%d"), tempint);
} else if (sizeof(hssize_t) == sizeof(long)) {
memcpy(&templong, vp, sizeof(long));
h5dump_str_append(str, OPT(info->fmt_long, "%ld"), templong);
} else {
memcpy(&templlong, vp, sizeof(long_long));
h5dump_str_append(str, OPT(info->fmt_llong, fmt_llong), templlong);
}
} else if (H5Tequal(type, H5T_NATIVE_HSIZE)) {
if (sizeof(hsize_t) == sizeof(int)) {
memcpy(&tempuint, vp, sizeof(unsigned int));
h5dump_str_append(str, OPT(info->fmt_uint, "%u"), tempuint);
} else if (sizeof(hsize_t) == sizeof(long)) {
memcpy(&tempulong, vp, sizeof(long));
h5dump_str_append(str, OPT(info->fmt_ulong, "%lu"), tempulong);
} else {
memcpy(&tempullong, vp, sizeof(unsigned long_long));
h5dump_str_append(str, OPT(info->fmt_ullong, fmt_ullong), tempullong);
}
} else if (H5T_COMPOUND==H5Tget_class(type)) {
int j, x;
nmembs = H5Tget_nmembers(type);
h5dump_str_append(str, "%s", OPT(info->cmpd_pre, "{"));
for (j = 0; j < nmembs; j++) {
if (j)
h5dump_str_append(str, "%s", OPT(info->cmpd_sep, ", " OPTIONAL_LINE_BREAK));
/* RPM 2000-10-31
* If the previous character is a line-feed (which is true when
* h5dump is running) then insert some white space for
* indentation. Be warned that column number calculations will be
* incorrect and that object indices at the beginning of the line
* will be missing (h5dump doesn't display them anyway). */
if (ctx->indent_level >= 0 && str->len &&
str->s[str->len - 1] == '\n') {
h5dump_str_append(str, OPT(info->line_pre, ""), "");
for (x = 0; x < ctx->indent_level + 1; x++)
h5dump_str_append(str, "%s", OPT(info->line_indent, ""));
}
/* The name */
name = H5Tget_member_name(type, j);
h5dump_str_append(str, OPT(info->cmpd_name, ""), name);
free(name);
/* The value */
offset = H5Tget_member_offset(type, j);
memb = H5Tget_member_type(type, j);
ctx->indent_level++;
h5dump_sprint(str, info, container, memb, cp_vp + offset , ctx);
ctx->indent_level--;
H5Tclose(memb);
}
/* RPM 2000-10-31
* If the previous character is a line feed (which is true when
* h5dump is running) then insert some white space for indentation.
* Be warned that column number calculations will be incorrect and
* that object indices at the beginning of the line will be missing
* (h5dump doesn't display them anyway). */
h5dump_str_append(str, "%s", OPT(info->cmpd_end, ""));
if (ctx->indent_level >= 0 && str->len &&
str->s[str->len - 1] == '\n') {
h5dump_str_append(str, OPT(info->line_pre, ""), "");
for (x = 0; x < ctx->indent_level; x++)
h5dump_str_append(str, "%s", OPT(info->line_indent, ""));
}
h5dump_str_append(str, "%s", OPT(info->cmpd_suf, "}"));
} else if (H5T_ENUM==H5Tget_class(type)) {
char enum_name[1024];
if (H5Tenum_nameof(type, vp, enum_name, sizeof enum_name) >= 0) {
h5dump_str_append(str, h5dump_escape(enum_name, sizeof(enum_name), TRUE));
} else {
unsigned int i;
h5dump_str_append(str, "0x");
n = H5Tget_size(type);
for (i = 0; i < n; i++)
h5dump_str_append(str, "%02x", ucp_vp[i]);
}
} else if (H5Tequal(type, H5T_STD_REF_DSETREG)) {
/*
* Dataset region reference -- show the type and OID of the referenced
* object, but we are unable to show the region yet because there
* isn't enough support in the data space layer. - rpm 19990604
*/
if (h5dump_is_zero(vp, H5Tget_size(type))) {
h5dump_str_append(str, "NULL");
} else {
obj = H5Rdereference(container, H5R_DATASET_REGION, vp);
region = H5Rget_region(container, H5R_DATASET_REGION, vp);
H5Gget_objinfo(obj, ".", FALSE, &sb);
if (info->dset_hidefileno)
h5dump_str_append(str, info->dset_format, sb.objno[1], sb.objno[0]);
else
h5dump_str_append(str, info->dset_format,
sb.fileno[1], sb.fileno[0], sb.objno[1], sb.objno[0]);
h5dump_region(region, str, info);
H5Sclose(region);
H5Dclose(obj);
}
} else if (H5Tequal(type, H5T_STD_REF_OBJ)) {
/*
* Object references -- show the type and OID of the referenced
* object.
*/
if (h5dump_is_zero(vp, H5Tget_size(type))) {
h5dump_str_append(str, "NULL");
} else {
otype = H5Rget_object_type(container, vp);
obj = H5Rdereference(container, H5R_OBJECT, vp);
H5Gget_objinfo(obj, ".", FALSE, &sb);
/* Print object type and close object */
switch (otype) {
case H5G_GROUP:
h5dump_str_append(str, GROUPNAME);
H5Gclose(obj);
break;
case H5G_DATASET:
h5dump_str_append(str, DATASET);
H5Dclose(obj);
break;
case H5G_TYPE:
h5dump_str_append(str, DATATYPE);
H5Tclose(obj);
break;
default:
h5dump_str_append(str, "%u-", otype);
break;
}
/* Print OID */
if (info->obj_hidefileno) {
h5dump_str_append(str, info->obj_format, sb.objno[1], sb.objno[0]);
} else {
h5dump_str_append(str, info->obj_format,
sb.fileno[1], sb.fileno[0], sb.objno[1], sb.objno[0]);
}
}
} else if (H5T_ARRAY==H5Tget_class(type)) {
int x;
unsigned int i;
int k;
hsize_t dims[H5S_MAX_RANK];
int ndims;
/* Get the array's base datatype for each element */
memb=H5Tget_super(type);
size = H5Tget_size(memb);
ndims = H5Tget_array_ndims(type);
H5Tget_array_dims(type, dims, NULL);
assert(ndims>=1 && ndims<=H5S_MAX_RANK);
/* Calculate the number of array elements */
for (k = 0, nelmts = 1; k < ndims; k++)
nelmts *= dims[k];
/* Print the opening bracket */
h5dump_str_append(str, "%s", OPT(info->arr_pre, "["));
for (i = 0; i < nelmts; i++) {
if (i)
h5dump_str_append(str, "%s",
OPT(info->arr_sep, "," OPTIONAL_LINE_BREAK));
if (info->arr_linebreak && i && 0 == i % dims[ndims - 1]) {
h5dump_str_append(str, "%s", "\n");
/*need to indent some more here*/
if (ctx->indent_level >= 0)
h5dump_str_append(str, "%s", OPT(info->line_pre, ""));
for (x = 0; x < ctx->indent_level + 1; x++)
h5dump_str_append(str,"%s",OPT(info->line_indent,""));
} /* end if */
ctx->indent_level++;
/* Dump the array element */
h5dump_sprint(str, info, container, memb, cp_vp + i * size, ctx);
ctx->indent_level--;
} /* end for */
/* Print the closing bracket */
h5dump_str_append(str, "%s", OPT(info->arr_suf, "]"));
H5Tclose(memb);
} else if (H5T_VLEN==H5Tget_class(type)) {
unsigned int i;
/* Get the VL sequences's base datatype for each element */
memb=H5Tget_super(type);
size = H5Tget_size(memb);
/* Print the opening bracket */
h5dump_str_append(str, "%s", OPT(info->vlen_pre, "("));
/* Get the number of sequence elements */
nelmts = ((hvl_t *)cp_vp)->len;
for (i = 0; i < nelmts; i++) {
if (i)
h5dump_str_append(str, "%s",
OPT(info->arr_sep, "," OPTIONAL_LINE_BREAK));
#ifdef LATER
/* Need to fix so VL data breaks at correct location on end of line -QAK */
if (info->arr_linebreak && h5dump_str_len(str)>=info->line_ncols) {
int x;
h5dump_str_append(str, "%s", "\n");
/* need to indent some more here */
if (ctx->indent_level >= 0)
h5dump_str_append(str, "%s", OPT(info->line_pre, ""));
for (x = 0; x < ctx->indent_level + 1; x++)
h5dump_str_append(str,"%s",OPT(info->line_indent,""));
} /* end if */
#endif /* LATER */
ctx->indent_level++;
/* Dump the array element */
h5dump_sprint(str, info, container, memb, ((char *)(((hvl_t *)cp_vp)->p)) + i * size, ctx);
ctx->indent_level--;
} /* end for */
h5dump_str_append(str, "%s", OPT(info->vlen_suf, ")"));
H5Tclose(memb);
} else {
/* All other types get printed as hexadecimal */
unsigned int i;
h5dump_str_append(str, "0x");
n = H5Tget_size(type);
for (i = 0; i < n; i++)
h5dump_str_append(str, "%02x", ((unsigned char *)vp)[i]);
}
return h5dump_str_fmt(str, start, OPT(info->elmt_fmt, "%s"));
}
/*-------------------------------------------------------------------------
* Function: h5dump_ncols
*
* Purpose: Count the number of columns in a string. This is the number
* of characters in the string not counting line-control
* characters.
*
* Return: Success: Width of string.
*
* Failure: 0
*
* Programmer: Robb Matzke
* Tuesday, April 27, 1999
*
* Modifications:
*
*-------------------------------------------------------------------------
*/
static size_t
h5dump_ncols(const char *s)
{
size_t i;
for (i = 0; *s; s++)
if (*s >= ' ')
i++;
return i;
}
/*-------------------------------------------------------------------------
* Function: h5dump_simple_prefix
*
* Purpose: If ctx->need_prefix is set then terminate the current line
* (if applicable), calculate the prefix string, and display it
* at the start of a line.
*
* Return: void
*
* Programmer: Robb Matzke
* Monday, April 26, 1999
*
* Modifications:
* Robb Matzke, 1999-09-29
* If a new prefix is printed then the current element number is
* set back to zero.
*-------------------------------------------------------------------------
*/
static void
h5dump_simple_prefix(FILE *stream, const h5dump_t *info,
h5dump_context_t *ctx, hsize_t elmtno, int secnum)
{
h5dump_str_t prefix;
size_t templength = 0;
int i, indentlevel = 0;
memset(&prefix, 0, sizeof(h5dump_str_t));
if (!ctx->need_prefix)
return;
/* Terminate previous line, if any */
if (ctx->cur_column) {
fputs(OPT(info->line_suf, ""), stream);
#if 0 /*why?*/
if (info->line_ncols != ctx->cur_column) {
putc('\n', stream);
}
#endif
putc('\n',stream);
fputs(OPT(info->line_sep, ""), stream);
}
/* Calculate new prefix */
h5dump_prefix(&prefix, info, elmtno, ctx->ndims,
ctx->p_min_idx, ctx->p_max_idx);
/* Write new prefix to output */
if (ctx->indent_level >= 0) {
indentlevel = ctx->indent_level;
} else {
/* this is because sometimes we dont print out all the header
* info for the data(like the tattr-2.ddl example. if that happens
* the ctx->indent_level a negative so we need to skip the above
* and just print out the default indent levels. */
indentlevel = ctx->default_indent_level;
}
if (elmtno == 0 && secnum == 0 && info->line_1st)
fputs(h5dump_str_fmt(&prefix, 0, info->line_1st), stream);
else if (secnum && info->line_cont)
fputs(h5dump_str_fmt(&prefix, 0, info->line_cont), stream);
else
fputs(h5dump_str_fmt(&prefix, 0, info->line_pre), stream);
templength = h5dump_str_len(&prefix);
for (i = 0; i < indentlevel; i++){
fputs(h5dump_str_fmt(&prefix, 0, info->line_indent), stream);
templength += h5dump_str_len(&prefix);
}
ctx->cur_column = ctx->prev_prefix_len = templength;
ctx->cur_elmt = 0;
ctx->need_prefix = 0;
/* Free string */
h5dump_str_close(&prefix);
}
/*-------------------------------------------------------------------------
* Function: h5dump_simple_data
*
* Purpose: Prints some (NELMTS) data elements to output STREAM. The
* elements are stored in _MEM as type TYPE and are printed
* according to the format described in INFO. The CTX struct
* contains context information shared between calls to this
* function. The FLAGS is a bit field that indicates whether
* the data supplied in this call falls at the beginning or end
* of the total data to be printed (START_OF_DATA and
* END_OF_DATA).
*
* Return: void
*
* Programmer: Robb Matzke
* Monday, April 26, 1999
*
* Modifications:
* Robb Matzke, 1999-06-04
* The `container' argument is the optional dataset for
* reference types.
*
* Robb Matzke, 1999-09-29
* Understands the `per_line' property which indicates that
* every Nth element should begin a new line.
*
*-------------------------------------------------------------------------
*/
static void
h5dump_simple_data(FILE *stream, const h5dump_t *info, hid_t container,
h5dump_context_t *ctx/*in,out*/, unsigned flags,
hsize_t nelmts, hid_t type, void *_mem)
{
unsigned char *mem = (unsigned char*)_mem;
hsize_t i; /*element counter */
char *s, *section; /*a section of output */
int secnum; /*section sequence number */
size_t size; /*size of each datum */
size_t ncols=80; /*available output width */
h5dump_str_t buffer; /*string into which to render */
int multiline; /*datum was multiline */
int elmt_counter=0; /*counts the # elements printed.
* I (ptl?) needed something that
* isnt going to get reset when a new
* line is formed. I'm going to use
* this var to count elements and
* break after we see a number equal
* to the ctx->size_last_dim. */
/* Setup */
memset(&buffer, 0, sizeof(h5dump_str_t));
size = H5Tget_size(type);
if (info->line_ncols > 0)
ncols = info->line_ncols;
h5dump_simple_prefix(stream, info, ctx, (hsize_t)0, 0);
for (i = 0; i < nelmts; i++, ctx->cur_elmt++, elmt_counter++) {
/* Render the element */
h5dump_str_reset(&buffer);
h5dump_sprint(&buffer, info, container, type, mem + i * size, ctx);
if (i + 1 < nelmts || 0 == (flags & END_OF_DATA))
h5dump_str_append(&buffer, "%s", OPT(info->elmt_suf1, ","));
s = h5dump_str_fmt(&buffer, 0, "%s");
/*
* If the element would split on multiple lines if printed at our
* current location...
*/
if (info->line_multi_new == 1 &&
(ctx->cur_column + h5dump_ncols(s) +
strlen(OPT(info->elmt_suf2, " ")) +
strlen(OPT(info->line_suf, ""))) > ncols) {
if (ctx->prev_multiline) {
/*
* ... and the previous element also occupied more than one
* line, then start this element at the beginning of a line.
*/
ctx->need_prefix = TRUE;
} else if ((ctx->prev_prefix_len + h5dump_ncols(s) +
strlen(OPT(info->elmt_suf2, " ")) +
strlen(OPT(info->line_suf, ""))) <= ncols) {
/*
* ...but *could* fit on one line otherwise, then we
* should end the current line and start this element on its
* own line.
*/
ctx->need_prefix = TRUE;
}
}
/*
* We need to break after each row of a dimension---> we should
* break at the end of the each last dimension well that is the
* way the dumper did it before
*/
if (info->arr_linebreak && ctx->cur_elmt) {
if (ctx->size_last_dim && (ctx->cur_elmt % ctx->size_last_dim) == 0)
ctx->need_prefix = TRUE;
if (elmt_counter == ctx->size_last_dim) {
ctx->need_prefix = TRUE;
elmt_counter = 0;
}
}
/*
* If the previous element occupied multiple lines and this element
* is too long to fit on a line then start this element at the
* beginning of the line.
*/
if (info->line_multi_new == 1 && ctx->prev_multiline &&
(ctx->cur_column + h5dump_ncols(s) +
strlen(OPT(info->elmt_suf2, " ")) +
strlen(OPT(info->line_suf, ""))) > ncols)
ctx->need_prefix = TRUE;
/*
* If too many elements have already been printed then we need to
* start a new line.
*/
if (info->line_per_line > 0 && ctx->cur_elmt >= info->line_per_line)
ctx->need_prefix = TRUE;
/*
* Each OPTIONAL_LINE_BREAK embedded in the rendered string can cause
* the data to split across multiple lines. We display the sections
* one-at a time.
*/
for (secnum = 0, multiline = 0;
(section = strtok(secnum ? NULL : s, OPTIONAL_LINE_BREAK));
secnum++) {
/*
* If the current section plus possible suffix and end-of-line
* information would cause the output to wrap then we need to
* start a new line.
*/
/*
* Added the info->skip_first because the dumper does not want
* this check to happen for the first line
*/
if ((!info->skip_first || i) &&
(ctx->cur_column + strlen(section) +
strlen(OPT(info->elmt_suf2, " ")) +
strlen(OPT(info->line_suf, ""))) > ncols)
ctx->need_prefix = 1;
/*
* Print the prefix or separate the beginning of this element
* from the previous element.
*/
if (ctx->need_prefix) {
if (secnum)
multiline++;
h5dump_simple_prefix(stream, info, ctx, i, secnum);
} else if ((i || ctx->continuation) && secnum == 0) {
fputs(OPT(info->elmt_suf2, " "), stream);
ctx->cur_column += strlen(OPT(info->elmt_suf2, " "));
}
/* Print the section */
fputs(section, stream);
ctx->cur_column += strlen(section);
}
ctx->prev_multiline = multiline;
}
h5dump_str_close(&buffer);
}
/*-------------------------------------------------------------------------
* Function: h5dump_simple_dset
*
* Purpose: Print some values from a dataset with a simple data space.
* This is a special case of h5dump_dset(). This function only
* intended for dumping datasets -- it does strip mining and
* some other things which are unnecessary for smaller objects
* such as attributes (to print small objects like attributes
* simply read the attribute and call h5dump_simple_mem()).
*
* Return: Success: 0
*
* Failure: -1
*
* Programmer: Robb Matzke
* Thursday, July 23, 1998
*
* Modifications:
*
*-------------------------------------------------------------------------
*/
static int
h5dump_simple_dset(FILE *stream, const h5dump_t *info, hid_t dset,
hid_t p_type, int indentlevel)
{
hid_t f_space; /*file data space */
hsize_t elmtno, i; /*counters */
int carry; /*counter carry value */
hssize_t zero[8]; /*vector of zeros */
unsigned flags; /*buffer extent flags */
hsize_t total_size[H5S_MAX_RANK];/*total size of dataset*/
/* Print info */
h5dump_context_t ctx; /*print context */
size_t p_type_nbytes; /*size of memory type */
hsize_t p_nelmts; /*total selected elmts */
/* Stripmine info */
hsize_t sm_size[H5S_MAX_RANK]; /*stripmine size */
hsize_t sm_nbytes; /*bytes per stripmine */
hsize_t sm_nelmts; /*elements per stripmine*/
unsigned char *sm_buf=NULL; /*buffer for raw data */
hid_t sm_space; /*stripmine data space */
/* Hyperslab info */
hssize_t hs_offset[H5S_MAX_RANK];/*starting offset */
hsize_t hs_size[H5S_MAX_RANK]; /*size this pass */
hsize_t hs_nelmts; /*elements in request */
/* VL data special information */
unsigned vl_data=0; /* Whether the dataset contains VL datatypes */
#if 0
hsize_t dim_n_size;
#endif
/*
* Check that everything looks okay. The dimensionality must not be too
* great and the dimensionality of the items selected for printing must
* match the dimensionality of the dataset.
*/
memset(&ctx, 0, sizeof ctx);
ctx.indent_level = indentlevel;
ctx.need_prefix = 1;
f_space = H5Dget_space(dset);
ctx.ndims = H5Sget_simple_extent_ndims(f_space);
if ((size_t)ctx.ndims > NELMTS(sm_size))
return -1;
/* Assume entire data space to be printed */
if(ctx.ndims>0)
for (i = 0; i < (hsize_t)ctx.ndims; i++)
ctx.p_min_idx[i] = 0;
H5Sget_simple_extent_dims(f_space, total_size, NULL);
if(ctx.ndims>0)
for (i = 0, p_nelmts = 1; i < (hsize_t)ctx.ndims; i++)
p_nelmts *= total_size[i];
else
p_nelmts = 1;
if (p_nelmts == 0) {
H5Sclose(f_space);
return 0; /*nothing to print*/
}
ctx.size_last_dim = total_size[ctx.ndims - 1];
/* Check if we have VL data in the dataset's datatype */
if(H5Tdetect_class(p_type,H5T_VLEN)==TRUE)
vl_data=TRUE;
/*
* Determine the strip mine size and allocate a buffer. The strip mine is
* a hyperslab whose size is manageable.
*/
p_type_nbytes = H5Tget_size(p_type);
if(ctx.ndims>0)
for (i = ctx.ndims, sm_nbytes = p_type_nbytes; i > 0; --i) {
sm_size[i - 1] = MIN(total_size[i - 1], H5DUMP_BUFSIZE / sm_nbytes);
sm_nbytes *= sm_size[i - 1];
assert(sm_nbytes > 0);
}
else
sm_nbytes = p_type_nbytes;
assert(sm_nbytes==(hsize_t)((size_t)sm_nbytes)); /*check for overflow*/
sm_buf = malloc((size_t)sm_nbytes);
sm_nelmts = sm_nbytes / p_type_nbytes;
sm_space = H5Screate_simple(1, &sm_nelmts, NULL);
/* The stripmine loop */
memset(hs_offset, 0, sizeof hs_offset);
memset(zero, 0, sizeof zero);
for (elmtno = 0; elmtno < p_nelmts; elmtno += hs_nelmts) {
/* Calculate the hyperslab size */
if (ctx.ndims > 0) {
for (i = 0, hs_nelmts = 1; i < (hsize_t)ctx.ndims; i++) {
hs_size[i] = MIN(total_size[i] - hs_offset[i], sm_size[i]);
ctx.p_max_idx[i] = ctx.p_min_idx[i] + hs_size[i];
hs_nelmts *= hs_size[i];
}
H5Sselect_hyperslab(f_space, H5S_SELECT_SET, hs_offset, NULL,
hs_size, NULL);
H5Sselect_hyperslab(sm_space, H5S_SELECT_SET, zero, NULL,
&hs_nelmts, NULL);
} else {
H5Sselect_all(f_space);
H5Sselect_all(sm_space);
hs_nelmts = 1;
}
/* Read the data */
if (H5Dread(dset, p_type, sm_space, f_space, H5P_DEFAULT, sm_buf) < 0) {
H5Sclose(f_space);
H5Sclose(sm_space);
free(sm_buf);
return -1;
}
/* Print the data */
flags = (elmtno == 0) ? START_OF_DATA : 0;
flags |= ((elmtno + hs_nelmts) >= p_nelmts) ? END_OF_DATA : 0;
h5dump_simple_data(stream, info, dset, &ctx, flags, hs_nelmts,
p_type, sm_buf);
/* Reclaim any VL memory, if necessary */
if(vl_data)
H5Dvlen_reclaim(p_type,sm_space,H5P_DEFAULT,sm_buf);
/* Calculate the next hyperslab offset */
for (i = ctx.ndims, carry = 1; i > 0 && carry; --i) {
ctx.p_min_idx[i - 1] = ctx.p_max_idx[i - 1];
hs_offset[i - 1] += hs_size[i - 1];
if (hs_offset[i - 1] == (hssize_t)total_size[i - 1])
hs_offset[i-1] = 0;
else
carry = 0;
}
ctx.continuation++;
}
/* Terminate the output */
if (ctx.cur_column) {
fputs(OPT(info->line_suf, ""), stream);
putc('\n', stream);
fputs(OPT(info->line_sep, ""), stream);
}
H5Sclose(sm_space);
H5Sclose(f_space);
free(sm_buf);
return 0;
}
/*-------------------------------------------------------------------------
* Function: h5dump_simple_mem
*
* Purpose: Print some values from memory with a simple data space.
* This is a special case of h5dump_mem().
*
* Return: Success: 0
*
* Failure: -1
*
* Programmer: Robb Matzke
* Thursday, July 23, 1998
*
* Modifications:
*
*-------------------------------------------------------------------------
*/
static int
h5dump_simple_mem(FILE *stream, const h5dump_t *info, hid_t obj_id, hid_t type,
hid_t space, void *mem, int indentlevel)
{
hsize_t i; /*counters */
hsize_t nelmts; /*total selected elmts */
h5dump_context_t ctx; /*printing context */
/*
* Check that everything looks okay. The dimensionality must not be too
* great and the dimensionality of the items selected for printing must
* match the dimensionality of the dataset.
*/
memset(&ctx, 0, sizeof(ctx));
ctx.ndims = H5Sget_simple_extent_ndims(space);
if ((size_t)ctx.ndims > NELMTS(ctx.p_min_idx))
return -1;
ctx.indent_level = indentlevel;
ctx.need_prefix = 1;
/* Assume entire data space to be printed */
for (i = 0; i < (hsize_t)ctx.ndims; i++)
ctx.p_min_idx[i] = 0;
H5Sget_simple_extent_dims(space, ctx.p_max_idx, NULL);
for (i = 0, nelmts = 1; ctx.ndims != 0 && i < (hsize_t)ctx.ndims; i++)
nelmts *= ctx.p_max_idx[i] - ctx.p_min_idx[i];
if (nelmts == 0)
return 0; /*nothing to print*/
ctx.size_last_dim = ctx.p_max_idx[ctx.ndims - 1];
/* Print it */
h5dump_simple_data(stream, info, obj_id, &ctx,
START_OF_DATA|END_OF_DATA, nelmts, type, mem);
/* Terminate the output */
if (ctx.cur_column) {
fputs(OPT(info->line_suf, ""), stream);
putc('\n', stream);
fputs(OPT(info->line_sep, ""), stream);
}
return 0;
}
/*-------------------------------------------------------------------------
* Function: h5dump_fixtype
*
* Purpose: Given a file data type choose a memory data type which is
* appropriate for printing the data.
*
* Return: Success: Memory data type
*
* Failure: FAIL
*
* Programmer: Robb Matzke
* Thursday, July 23, 1998
*
* Modifications:
* Robb Matzke, 1999-06-04
* Added support for references.
*
*-------------------------------------------------------------------------
*/
hid_t
h5dump_fixtype(hid_t f_type)
{
hid_t m_type = FAIL, f_memb;
hid_t *memb = NULL;
char **name = NULL;
int nmembs = 0, i;
int ndims;
hsize_t dim[H5S_MAX_RANK];
size_t size, offset;
hid_t array_base;
/* H5T_str_t strpad; */
size = H5Tget_size(f_type);
switch (H5Tget_class(f_type)) {
case H5T_INTEGER:
/*
* Use the smallest native integer type of the same sign as the file
* such that the memory type is at least as large as the file type.
* If there is no memory type large enough then use the largest
* memory type available.
*/
if (size <= sizeof(char)) {
m_type = H5Tcopy(H5T_NATIVE_SCHAR);
} else if (size <= sizeof(short)) {
m_type = H5Tcopy(H5T_NATIVE_SHORT);
} else if (size <= sizeof(int)) {
m_type = H5Tcopy(H5T_NATIVE_INT);
} else if (size <= sizeof(long)) {
m_type = H5Tcopy(H5T_NATIVE_LONG);
} else {
m_type = H5Tcopy(H5T_NATIVE_LLONG);
}
H5Tset_sign(m_type, H5Tget_sign(f_type));
break;
case H5T_FLOAT:
/*
* Use the smallest native floating point type available such that
* its size is at least as large as the file type. If there is not
* native type large enough then use the largest native type.
*/
if (size <= sizeof(float)) {
m_type = H5Tcopy(H5T_NATIVE_FLOAT);
} else if (size <= sizeof(double)) {
m_type = H5Tcopy(H5T_NATIVE_DOUBLE);
} else {
m_type = H5Tcopy(H5T_NATIVE_LDOUBLE);
}
break;
case H5T_STRING:
/*
* This is needed because the function in dumputil.c is the case where
* strDUAction == TRUE. if it is false we will do the original action
* here.
*/
m_type = H5Tcopy(f_type);
H5Tset_cset(m_type, H5T_CSET_ASCII);
break;
case H5T_COMPOUND:
/*
* We have to do this in two steps. The first step scans the file
* type and converts the members to native types and remembers all
* their names and sizes, computing the size of the memory compound
* type at the same time. Then we create the memory compound type
* and add the members.
*/
nmembs = H5Tget_nmembers(f_type);
assert(nmembs>0);
memb = calloc((size_t)nmembs, sizeof(hid_t));
name = calloc((size_t)nmembs, sizeof(char *));
for (i = 0, size = 0; i < nmembs; i++) {
/* Get the member type and fix it */
f_memb = H5Tget_member_type(f_type, i);
memb[i] = h5dump_fixtype(f_memb);
H5Tclose(f_memb);
if (memb[i] < 0)
goto done;
/* Get the member name */
name[i] = H5Tget_member_name(f_type, i);
if (name[i] == NULL)
goto done;
/*
* Compute the new offset so each member is aligned on a byte
* boundary which is the same as the member size.
*/
size = ALIGN(size, H5Tget_size(memb[i])) + H5Tget_size(memb[i]);
}
m_type = H5Tcreate(H5T_COMPOUND, size);
for (i = 0, offset = 0; i < nmembs; i++) {
if (offset)
offset = ALIGN(offset, H5Tget_size(memb[i]));
H5Tinsert(m_type, name[i], offset, memb[i]);
offset += H5Tget_size(memb[i]);
}
break;
case H5T_ARRAY:
/* Get the array information */
ndims = H5Tget_array_ndims(f_type);
H5Tget_array_dims(f_type, dim, NULL);
/* Get the array's base type and convert it to the printable version */
f_memb = H5Tget_super(f_type);
array_base = h5dump_fixtype(f_memb);
/* Copy the array */
m_type = H5Tarray_create(array_base, ndims, dim, NULL);
/* Close the temporary datatypes */
H5Tclose(array_base);
H5Tclose(f_memb);
break;
case H5T_VLEN:
/* Get the VL sequence's base type and convert it to the printable version */
f_memb = H5Tget_super(f_type);
array_base = h5dump_fixtype(f_memb);
/* Copy the VL type */
m_type = H5Tvlen_create(array_base);
/* Close the temporary datatypes */
H5Tclose(array_base);
H5Tclose(f_memb);
break;
case H5T_ENUM:
case H5T_REFERENCE:
case H5T_OPAQUE:
/* Same as file type */
m_type = H5Tcopy(f_type);
break;
case H5T_BITFIELD:
/*
* Same as the file except the offset is set to zero and the byte
* order is set to little endian.
*/
m_type = H5Tcopy(f_type);
H5Tset_offset(m_type, 0);
H5Tset_order(m_type, H5T_ORDER_LE);
break;
case H5T_TIME:
/*
* These type classes are not implemented yet.
*/
break;
default:
/* What the heck? */
break;
}
done:
/* Clean up temp buffers */
if (memb && name) {
int j;
for (j = 0; j < nmembs; j++) {
if (memb[j] >= 0)
H5Tclose(memb[j]);
if (name[j])
free(name[j]);
}
free(memb);
free(name);
}
return m_type;
}
/*-------------------------------------------------------------------------
* Function: h5dump_dset
*
* Purpose: Print some values from a dataset DSET to the file STREAM
* after converting all types to P_TYPE (which should be a
* native type). If P_TYPE is a negative value then it will be
* computed from the dataset type using only native types.
*
* Note: This function is intended only for datasets since it does
* some things like strip mining which are unnecessary for
* smaller objects such as attributes. The easiest way to print
* small objects is to read the object into memory and call
* h5dump_mem().
*
* Return: Success: 0
*
* Failure: -1
*
* Programmer: Robb Matzke
* Thursday, July 23, 1998
*
* Modifications:
* Robb Matzke, 1999-06-07
* If info->raw is set then the memory datatype will be the same
* as the file datatype.
*
*-------------------------------------------------------------------------
*/
int
h5dump_dset(FILE *stream, const h5dump_t *info, hid_t dset, hid_t _p_type,
int indentlevel)
{
hid_t f_space;
hid_t p_type = _p_type;
hid_t f_type;
int status = -1;
h5dump_t info_dflt;
/* Use default values */
if (!stream)
stream = stdout;
if (!info) {
memset(&info_dflt, 0, sizeof info_dflt);
info = &info_dflt;
}
if (p_type < 0) {
f_type = H5Dget_type(dset);
if (info->raw)
p_type = H5Tcopy(f_type);
else
p_type = h5dump_fixtype(f_type);
H5Tclose(f_type);
if (p_type < 0)
goto done;
}
/* Check the data space */
f_space = H5Dget_space(dset);
/* Print the data */
if (H5Sis_simple(f_space) > 0) {
status = h5dump_simple_dset(rawdatastream, info, dset, p_type,
indentlevel);
}
/* Close the dataspace */
H5Sclose(f_space);
done:
if (p_type != _p_type)
H5Tclose(p_type);
return status;
}
/*-------------------------------------------------------------------------
* Function: h5dump_mem
*
* Purpose: Displays the data contained in MEM. MEM must have the
* specified data TYPE and SPACE. Currently only simple data
* spaces are allowed and only the `all' selection.
*
* Return: Success: 0
*
* Failure: -1
*
* Programmer: Robb Matzke
* Wednesday, January 20, 1999
*
* Modifications:
*
*-------------------------------------------------------------------------
*/
int
h5dump_mem(FILE *stream, const h5dump_t *info, hid_t obj_id, hid_t type, hid_t space,
void *mem,int indentlevel)
{
h5dump_t info_dflt;
/* Use default values */
if (!stream)
stream = stdout;
if (!info) {
memset(&info_dflt, 0, sizeof info_dflt);
info = &info_dflt;
}
/* Check the data space */
if (H5Sis_simple(space) <= 0)
return -1;
return h5dump_simple_mem(stream, info, obj_id, type, space, mem, indentlevel);
}
/*************************************************************************/
/*************************************************************************/
/*************************************************************************/
/*************************************************************************/
/*************************************************************************/
/*************************************************************************/
/*from h5dumputil.c*/
/*************************************************************************/
/*************************************************************************/
/*************************************************************************/
/*************************************************************************/
/*************************************************************************/
/*************************************************************************/
/*-------------------------------------------------------------------------
* Function: indentation
*
* Purpose: Print spaces for indentation
*
* Return: void
*
* Programmer: Ruey-Hsia Li
*
* Modifications:
*
*-----------------------------------------------------------------------*/
void indentation(int x)
{
if (x < nCols) {
while (x-- > 0)
printf(" ");
} else {
printf("The indentation exceeds the number of cols. Exiting....\n");
exit(1);
}
}
/*-------------------------------------------------------------------------
* Function: print_version
*
* Purpose: Print the program name and the version information which is
* defined the same as the HDF5 library version.
*
* Return: void
*
* Programmer: unknown
*
* Modifications:
*
*-----------------------------------------------------------------------*/
void
print_version(const char *program_name)
{
printf("%s: Version %u.%u.%u%s%s\n",
program_name, H5_VERS_MAJOR, H5_VERS_MINOR, H5_VERS_RELEASE,
H5_VERS_SUBRELEASE[0] ? "-" : "", H5_VERS_SUBRELEASE);
}
/*
*
* THE FUNCTIONS BELOW ARE FROM THE H5FINSHD.C FILE
*
*/
/*-------------------------------------------------------------------------
* Function: init_table
*
* Purpose: allocate and initialize tables for shared groups, datasets,
* and committed types
*
* Return: void
*
* Programmer: Ruey-Hsia Li
*
* Modifications:
*
*-----------------------------------------------------------------------*/
void
init_table(table_t** temp)
{
int i;
table_t *table = malloc(sizeof(table_t));
table->size = 20;
table->nobjs = 0;
table->objs = (obj_t*) malloc(table->size*sizeof(obj_t));
for (i = 0; i < table->size; i++) {
table->objs[i].objno[0] = table->objs[i].objno[1] = 0;
table->objs[i].displayed = 0;
table->objs[i].recorded = 0;
table->objs[i].objflag = 0;
}
*temp = table;
}
/*-------------------------------------------------------------------------
* Function: init_prefix
*
* Purpose: allocate and initialize prefix
*
* Return: void
*
* Modifications:
*
*-----------------------------------------------------------------------*/
void
init_prefix(char **prefix, int prefix_len)
{
assert(prefix_len > 0);
*prefix = calloc((size_t)prefix_len, 1);
}
/*-------------------------------------------------------------------------
* Function: free_table
*
* Purpose: free tables for shared groups, datasets,
* and committed types
*
* Return: void
*
* Programmer: Paul Harten
*
* Modifications:
*
*-----------------------------------------------------------------------*/
void
free_table(table_t **table)
{
HDfree((*table)->objs);
}
/*-------------------------------------------------------------------------
* Function: search_obj
*
* Purpose: search the object specified by objno in the table
*
* Return: an integer, the location of the object
* -1 if object is not found
*
*
* Programmer: Ruey-Hsia Li
*
* Modifications:
*
*-----------------------------------------------------------------------*/
int
search_obj(table_t *table, unsigned long *objno)
{
int i;
for (i = 0; i < table->nobjs; i++)
if (table->objs[i].objno[0] == *objno && table->objs[i].objno[1] == *(objno + 1))
return i;
return -1;
}
/*-------------------------------------------------------------------------
* Function: add_obj
*
* Purpose: add a shared object to the table
* realloc the table if necessary
*
* Return: void
*
* Programmer: Ruey-Hsia Li
*
* Modifications:
*
*-----------------------------------------------------------------------*/
static void
add_obj (table_t *table, unsigned long *objno, char *objname)
{
int i;
if (table->nobjs == table->size) {
table->size *= 2;
table->objs = realloc(table->objs, table->size*sizeof(obj_t));
for (i = table->nobjs; i < table->size; i++) {
table->objs[i].objno[0] = table->objs[i].objno[1] = 0;
table->objs[i].displayed = 0;
table->objs[i].recorded = 0;
table->objs[i].objflag = 0;
}
}
i = table->nobjs++;
table->objs[i].objno[0] = *objno;
table->objs[i].objno[1] = *(objno + 1);
strcpy(table->objs[i].objname, objname);
}
/*-------------------------------------------------------------------------
* Function: Find_objs
*
* Purpose: Find objects, committed types and store them in tables
*
* Return: Success: SUCCEED
*
* Failure: FAIL
*
* Programmer: Ruey-Hsia Li
*
* Modifications:
*
*-----------------------------------------------------------------------*/
herr_t
find_objs(hid_t group, const char *name, void *op_data)
{
hid_t obj, type;
H5G_stat_t statbuf;
char *tmp;
int i;
find_objs_t *info = (find_objs_t*)op_data;
if (info->threshold > 1)
/*will get an infinite loop if greater than 1*/
return FAIL;
H5Gget_objinfo(group, name, TRUE, &statbuf);
tmp = malloc(strlen(info->prefix) + strlen(name) + 2);
strcpy(tmp, info->prefix);
switch (statbuf.type) {
case H5G_GROUP:
if ((obj = H5Gopen(group, name)) >= 0) {
if (info->prefix_len < (int)(strlen(info->prefix) + strlen(name) + 2)) {
info->prefix_len *= 2;
info->prefix = realloc(info->prefix,
info->prefix_len * sizeof(char));
}
strcat(strcat(info->prefix,"/"), name);
if (statbuf.nlink > info->threshold) {
if (search_obj(info->group_table, statbuf.objno) < 0) {
add_obj(info->group_table, statbuf.objno, info->prefix);
H5Giterate(obj, ".", NULL, find_objs, (void *)info);
}
} else {
H5Giterate (obj, ".", NULL, find_objs, (void *)info);
}
strcpy(info->prefix, tmp);
H5Gclose (obj);
} else {
info->status = 1;
}
break;
case H5G_DATASET:
strcat(tmp,"/");
strcat(tmp,name); /* absolute name of the data set */
if (statbuf.nlink > info->threshold &&
search_obj(info->dset_table, statbuf.objno) < 0)
add_obj(info->dset_table, statbuf.objno, tmp);
if ((obj = H5Dopen (group, name)) >= 0) {
type = H5Dget_type(obj);
if (H5Tcommitted(type) > 0) {
H5Gget_objinfo(type, ".", TRUE, &statbuf);
if (search_obj (info->type_table, statbuf.objno) < 0) {
add_obj(info->type_table, statbuf.objno, tmp);
info->type_table->objs[info->type_table->nobjs - 1].objflag = 0;
}
}
H5Tclose(type);
H5Dclose (obj);
} else {
info->status = 1;
}
break;
case H5G_TYPE:
strcat(tmp,"/");
strcat(tmp,name); /* absolute name of the type */
i = search_obj(info->type_table, statbuf.objno);
if (i < 0) {
add_obj(info->type_table, statbuf.objno, tmp) ;
/* named data type */
info->type_table->objs[info->type_table->nobjs-1].recorded = 1;
/* named data type */
info->type_table->objs[info->type_table->nobjs-1].objflag = 1;
} else {
strcpy (info->type_table->objs[i].objname, tmp);
info->type_table->objs[i].recorded = 1;
/* named data type */
info->type_table->objs[info->type_table->nobjs-1].objflag = 1;
}
break;
default:
break;
}
free(tmp);
return SUCCEED;
}
/*-------------------------------------------------------------------------
* Function: dump_tables
*
* Purpose: display the contents of tables for debugging purposes
*
* Return: void
*
* Programmer: Ruey-Hsia Li
*
* Modifications:
*
*-----------------------------------------------------------------------*/
void
dump_table(char* tablename, table_t *table)
{
int i;
printf("%s: # of entries = %d\n", tablename,table->nobjs);
for ( i = 0; i < table->nobjs; i++)
printf("%lu %lu %s %d\n", table->objs[i].objno[0],
table->objs[i].objno[1],
table->objs[i].objname,
table->objs[i].objflag);
}
/*-------------------------------------------------------------------------
* Function: get_table_idx
*
* Purpose: Determine if objects are in a link loop
*
* Return: Success: table index of object detected to be in loop
*
* Failure: FAIL
*
* Programmer: Paul Harten
*
*-----------------------------------------------------------------------*/
int
get_table_idx(table_t *table, unsigned long *objno)
{
return search_obj(table, objno);
}
/*-------------------------------------------------------------------------
* Function: Get table flag setting
*
* Purpose: Keep the structures and variables used private to
* this file.
*
* Return: Success: Boolean setting of the i'th element of the
* object table flag
*
* Failure: FAIL
*
* Programmer: Paul Harten
*
*-----------------------------------------------------------------------*/
int
get_tableflag(table_t *table, int idx)
{
return table->objs[idx].objflag;
}
/*-------------------------------------------------------------------------
* Function: Set table flag setting
*
* Purpose: Keep the structures and variables used private to
* this file.
*
* Return: Success: Boolean setting of the i'th element of the
* object table flag
*
* Failure: FAIL
*
* Programmer: Paul Harten
*
*-----------------------------------------------------------------------*/
int
set_tableflag(table_t *table, int idx)
{
table->objs[idx].objflag = TRUE;
return SUCCEED;
}
/*-------------------------------------------------------------------------
* Function: Get name of i'th object in table
*
* Purpose:
*
* Return: Success: strdup() of object name character string
*
* Failure: NULL
*
* Programmer: Paul Harten
*
*-----------------------------------------------------------------------*/
char *
get_objectname(table_t* table, int idx)
{
return strdup(table->objs[idx].objname);
}
/*-------------------------------------------------------------------------
* Function: opens a file using the list of drivers
*
* Purpose: Attempts to open a file with various VFL drivers.
*
* Return: Success: a file id for the opened file. If
* DRIVERNAME is non-null then the first
* DRIVERNAME_SIZE-1 characters of the driver
* name are copied into the DRIVERNAME array
* and null terminated.
*
* Failure: -1. If DRIVERNAME is non-null then the
* first byte is set to the null terminator.
*
* Modifications:
* Robb Matzke, 2000-06-23
* We only have to initialize driver[] on the first call,
* thereby preventing memory leaks from repeated calls to
* H5Pcreate().
*
* Robb Matzke, 2000-06-23
* Added DRIVERNAME_SIZE arg to prevent overflows when
* writing to DRIVERNAME.
*
* Robb Matzke, 2000-06-23
* Added test to prevent coredump when the file could not be
* opened by any driver.
*
* Robb Matzke, 2000-06-23
* Changed name from H5ToolsFopen() so it jives better with
* the names we already have at the top of this source file.
*
* Thomas Radke, 2000-09-12
* Added Stream VFD to the driver[] array.
*
* Bill Wendling, 2001-01-10
* Changed macro behavior so that if we have a version other
* than 1.2.x (i.e., > 1.2), then we do the drivers check.
*-----------------------------------------------------------------------*/
hid_t
h5dump_fopen(const char *fname, char *drivername, size_t drivername_size)
{
static struct {
const char *name;
hid_t fapl;
} driver[16];
static int ndrivers = 0;
hid_t fid=(-1);
#ifndef VERSION12
hid_t fapl = H5P_DEFAULT;
#endif
int drivernum;
if (!ndrivers) {
/* Build a list of file access property lists which we should try
* when opening the file. Eventually we'd like some way for the
* user to augment/replace this list interactively. */
driver[ndrivers].name = "sec2";
driver[ndrivers].fapl = H5P_DEFAULT;
ndrivers++;
#ifndef VERSION12
driver[ndrivers].name = "family";
driver[ndrivers].fapl = fapl = H5Pcreate(H5P_FILE_ACCESS);
H5Pset_fapl_family(fapl, (hsize_t)0, H5P_DEFAULT);
ndrivers++;
driver[ndrivers].name = "split";
driver[ndrivers].fapl = fapl = H5Pcreate(H5P_FILE_ACCESS);
H5Pset_fapl_split(fapl, "-m.h5", H5P_DEFAULT, "-r.h5", H5P_DEFAULT);
ndrivers++;
driver[ndrivers].name = "multi";
driver[ndrivers].fapl = fapl = H5Pcreate(H5P_FILE_ACCESS);
H5Pset_fapl_multi(fapl, NULL, NULL, NULL, NULL, TRUE);
ndrivers++;
#ifdef H5_HAVE_STREAM
driver[ndrivers].name = "stream";
driver[ndrivers].fapl = fapl = H5Pcreate(H5P_FILE_ACCESS);
H5Pset_fapl_stream(fapl, NULL);
ndrivers++;
#endif /* H5_HAVE_STREAM */
#endif /* !VERSION12 */
}
/* Try to open the file using each of the drivers */
for (drivernum = 0; drivernum < ndrivers; drivernum++) {
H5E_BEGIN_TRY {
fid = H5Fopen(fname, H5F_ACC_RDONLY, driver[drivernum].fapl);
} H5E_END_TRY;
if (fid >= 0)
break;
}
/* Save the driver name */
if (drivername && drivername_size){
if (fid >= 0) {
strncpy(drivername, driver[drivernum].name, drivername_size);
drivername[drivername_size - 1] = '\0';
} else {
drivername[0] = '\0'; /*no file opened*/
}
}
return fid;
}
Reference in New Issue View Git Blame Copy Permalink