diff options
Diffstat (limited to 'tools/lib/h5tools.c')
| -rw-r--r-- | tools/lib/h5tools.c | 2448 |
1 files changed, 2448 insertions, 0 deletions
diff --git a/tools/lib/h5tools.c b/tools/lib/h5tools.c new file mode 100644 index 0000000..8ac51ef --- /dev/null +++ b/tools/lib/h5tools.c @@ -0,0 +1,2448 @@ +/* + * Copyright (c) 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 <stdarg.h> +#include <stdio.h> +#include <stdlib.h> + +#include "h5tools.h" +#include "h5tools_str.h" +#include "hdf5.h" +#include "H5private.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 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" + +/* 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) */ + +/* Output variables */ +typedef struct h5tools_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 */ +} h5tools_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: error_msg + * + * Purpose: Print a nicely formatted error message to stderr flushing the + * stdout stream first. + * + * Return: Nothing + * + * Programmer: Bill Wendling + * Tuesday, 20. February 2001 + * + * Modifications: + * + *------------------------------------------------------------------------- + */ +void +error_msg(const char *progname, const char *fmt, ...) +{ + va_list ap; + + va_start(ap, fmt); + fflush(stdout); + fprintf(stderr, "%s error: ", progname); + vfprintf(stderr, fmt, ap); + va_end(ap); +} + + +/*------------------------------------------------------------------------- + * Function: warn_msg + * + * Purpose: Print a nicely formatted warning message to stderr flushing + * the stdout stream first. + * + * Return: Nothing + * + * Programmer: Bill Wendling + * Tuesday, 20. February 2001 + * + * Modifications: + * + *------------------------------------------------------------------------- + */ +void +warn_msg(const char *progname, const char *fmt, ...) +{ + va_list ap; + + va_start(ap, fmt); + fflush(stdout); + fprintf(stderr, "%s warning: ", progname); + vfprintf(stderr, fmt, ap); + va_end(ap); +} + + +/*------------------------------------------------------------------------- + * 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: h5tools_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 * +h5tools_escape(char *s/*in,out*/, size_t size, int escape_spaces) +{ + register size_t i; + size_t n = strlen(s); + 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: h5tools_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 +h5tools_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, h5tools_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; + + h5tools_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; + + h5tools_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++) + h5tools_str_append(str, "%s%lu", j ? "," : "(", + (unsigned long)ptdata[i * 2 * ndims + j]); + + for (j = 0; j < ndims; j++) + h5tools_str_append(str, "%s%lu", j ? "," : ")-(", + (unsigned long)ptdata[i * 2 * ndims + j + ndims]); + + h5tools_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; + + h5tools_str_append(str, info->dset_ptformat_pre , + i ? "," OPTIONAL_LINE_BREAK " " : "", + (unsigned long)i); + + for (j = 0; j < ndims; j++) + h5tools_str_append(str, "%s%lu", j ? "," : "(", + (unsigned long)(ptdata[i * ndims + j])); + + h5tools_str_append(str, ")"); + } + + free(ptdata); + } + + h5tools_str_append(str, "}"); + return 0; +} + +/*------------------------------------------------------------------------- + * Function: h5tools_print_char + * + * Purpose: Shove a character into the STR. + * + * Return: Nothing + * + * Programmer: Bill Wendling + * Tuesday, 20. February 2001 + * + * Modifications: + * + *------------------------------------------------------------------------- + */ +static void +h5tools_print_char(h5tools_str_t *str, const h5dump_t *info, unsigned char ch) +{ + if (info->str_locale == ESCAPE_HTML) { + if (ch <= ' ' || ch > '~') + h5tools_str_append(str, "%%%02x", ch); + else + h5tools_str_append(str, "%c", (char)ch); + } else { + switch (ch) { + case '"': + h5tools_str_append(str, "\\\""); + break; + case '\\': + h5tools_str_append(str, "\\\\"); + break; + case '\b': + h5tools_str_append(str, "\\b"); + break; + case '\f': + h5tools_str_append(str, "\\f"); + break; + case '\n': + h5tools_str_append(str, "\\n"); + break; + case '\r': + h5tools_str_append(str, "\\r"); + break; + case '\t': + h5tools_str_append(str, "\\t"); + break; + default: + if (isprint(ch)) + h5tools_str_append(str, "%c", (char)ch); + else + h5tools_str_append(str, "\\%03o", ch); + + break; + } + } +} + +/*------------------------------------------------------------------------- + * Function: h5tools_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 * +h5tools_sprint(h5tools_str_t *str/*in,out*/, const h5dump_t *info, + hid_t container, hid_t type, void *vp, h5tools_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 + */ + double tempdouble; + float tempfloat; + unsigned long_long tempullong; + long_long templlong; + unsigned long tempulong; + long templong; + unsigned int tempuint; + int tempint; + unsigned short tempushort; + short tempshort; + + /* 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 = h5tools_str_len(str); + + if (info->raw) { + size_t i; + + h5tools_str_append(str, "0x"); + n = H5Tget_size(type); + + for (i = 0; i < n; i++) + h5tools_str_append(str, OPT(info->fmt_raw, "%02x"), ucp_vp[i]); + } else if (H5Tequal(type, H5T_NATIVE_FLOAT)) { + memcpy(&tempfloat, vp, sizeof(float)); + h5tools_str_append(str, OPT(info->fmt_float, "%g"), tempfloat); + } else if (H5Tequal(type, H5T_NATIVE_DOUBLE)) { + memcpy(&tempdouble, vp, sizeof(double)); + h5tools_str_append(str, OPT(info->fmt_double, "%g"), tempdouble); + } else if (info->ascii && (H5Tequal(type, H5T_NATIVE_SCHAR) || + H5Tequal(type, H5T_NATIVE_UCHAR))) { + h5tools_print_char(str, info, *ucp_vp); + } else if (H5T_STRING == H5Tget_class(type)) { + unsigned int i; + + quote = '\0'; + size = H5Tget_size(type); + 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) + h5tools_str_append(str, "%c", quote); + + quote = '\''; + h5tools_str_append(str, "%s%c", i ? " " : "", quote); + } else if (!quote) { + quote = '"'; + h5tools_str_append(str, "%s%c", i ? " " : "", quote); + } + + /* Print the character */ + h5tools_print_char(str, info, ucp_vp[i]); + + /* Print the repeat count */ + if (info->str_repeat && j > info->str_repeat) { +#ifdef REPEAT_VERBOSE + h5tools_str_append(str, "%c repeats %d times", quote, j - 1); +#else + h5tools_str_append(str, "%c*%d", quote, j - 1); +#endif + quote = '\0'; + i += j - 1; + } + + } + + if (quote) + h5tools_str_append(str, "%c", quote); + + if (i == 0) + /*empty string*/ + h5tools_str_append(str, "\"\""); + } else if (H5Tequal(type, H5T_NATIVE_INT)) { + memcpy(&tempint, vp, sizeof(int)); + h5tools_str_append(str, OPT(info->fmt_int, "%d"), tempint); + } else if (H5Tequal(type, H5T_NATIVE_UINT)) { + memcpy(&tempuint, vp, sizeof(unsigned int)); + h5tools_str_append(str, OPT(info->fmt_uint, "%u"), tempuint); + } else if (H5Tequal(type, H5T_NATIVE_SCHAR)) { + h5tools_str_append(str, OPT(info->fmt_schar, "%d"), *cp_vp); + } else if (H5Tequal(type, H5T_NATIVE_UCHAR)) { + h5tools_str_append(str, OPT(info->fmt_uchar, "%u"), *ucp_vp); + } else if (H5Tequal(type, H5T_NATIVE_SHORT)) { + memcpy(&tempshort, vp, sizeof(short)); + h5tools_str_append(str, OPT(info->fmt_short, "%d"), tempshort); + } else if (H5Tequal(type, H5T_NATIVE_USHORT)) { + memcpy(&tempushort, vp, sizeof(unsigned short)); + h5tools_str_append(str, OPT(info->fmt_ushort, "%u"), tempushort); + } else if (H5Tequal(type, H5T_NATIVE_LONG)) { + memcpy(&templong, vp, sizeof(long)); + h5tools_str_append(str, OPT(info->fmt_long, "%ld"), templong); + } else if (H5Tequal(type, H5T_NATIVE_ULONG)) { + memcpy(&tempulong, vp, sizeof(unsigned long)); + h5tools_str_append(str, OPT(info->fmt_ulong, "%lu"), tempulong); + } else if (H5Tequal(type, H5T_NATIVE_LLONG)) { + memcpy(&templlong, vp, sizeof(long_long)); + h5tools_str_append(str, OPT(info->fmt_llong, fmt_llong), templlong); + } else if (H5Tequal(type, H5T_NATIVE_ULLONG)) { + memcpy(&tempullong, vp, sizeof(unsigned long_long)); + h5tools_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)); + h5tools_str_append(str, OPT(info->fmt_int, "%d"), tempint); + } else if (sizeof(hssize_t) == sizeof(long)) { + memcpy(&templong, vp, sizeof(long)); + h5tools_str_append(str, OPT(info->fmt_long, "%ld"), templong); + } else { + memcpy(&templlong, vp, sizeof(long_long)); + h5tools_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)); + h5tools_str_append(str, OPT(info->fmt_uint, "%u"), tempuint); + } else if (sizeof(hsize_t) == sizeof(long)) { + memcpy(&tempulong, vp, sizeof(long)); + h5tools_str_append(str, OPT(info->fmt_ulong, "%lu"), tempulong); + } else { + memcpy(&tempullong, vp, sizeof(unsigned long_long)); + h5tools_str_append(str, OPT(info->fmt_ullong, fmt_ullong), tempullong); + } + } else if (H5Tget_class(type) == H5T_COMPOUND) { + int j; + + nmembs = H5Tget_nmembers(type); + h5tools_str_append(str, "%s", OPT(info->cmpd_pre, "{")); + + for (j = 0; j < nmembs; j++) { + if (j) + h5tools_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') { + int x; + + h5tools_str_append(str, OPT(info->line_pre, ""), ""); + + for (x = 0; x < ctx->indent_level + 1; x++) + h5tools_str_append(str, "%s", OPT(info->line_indent, "")); + } + + /* The name */ + name = H5Tget_member_name(type, j); + h5tools_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++; + h5tools_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). */ + h5tools_str_append(str, "%s", OPT(info->cmpd_end, "")); + + if (ctx->indent_level >= 0 && str->len && str->s[str->len - 1] == '\n') { + int x; + + h5tools_str_append(str, OPT(info->line_pre, ""), ""); + + for (x = 0; x < ctx->indent_level; x++) + h5tools_str_append(str, "%s", OPT(info->line_indent, "")); + } + + h5tools_str_append(str, "%s", OPT(info->cmpd_suf, "}")); + } else if (H5Tget_class(type) == H5T_ENUM) { + char enum_name[1024]; + + if (H5Tenum_nameof(type, vp, enum_name, sizeof enum_name) >= 0) { + h5tools_str_append(str, h5tools_escape(enum_name, sizeof(enum_name), TRUE)); + } else { + size_t i; + + h5tools_str_append(str, "0x"); + n = H5Tget_size(type); + + for (i = 0; i < n; i++) + h5tools_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 (h5tools_is_zero(vp, H5Tget_size(type))) { + h5tools_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) + h5tools_str_append(str, info->dset_format, sb.objno[1], sb.objno[0]); + else + h5tools_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 (h5tools_is_zero(vp, H5Tget_size(type))) { + h5tools_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: + h5tools_str_append(str, GROUPNAME); + H5Gclose(obj); + break; + case H5G_DATASET: + h5tools_str_append(str, DATASET); + H5Dclose(obj); + break; + case H5G_TYPE: + h5tools_str_append(str, DATATYPE); + H5Tclose(obj); + break; + default: + h5tools_str_append(str, "%u-", otype); + break; + } + + /* Print OID */ + if (info->obj_hidefileno) { + h5tools_str_append(str, info->obj_format, sb.objno[1], sb.objno[0]); + } else { + h5tools_str_append(str, info->obj_format, + sb.fileno[1], sb.fileno[0], sb.objno[1], sb.objno[0]); + } + } + } else if (H5Tget_class(type) == H5T_ARRAY) { + int k, ndims; + hsize_t i, dims[H5S_MAX_RANK]; + + /* 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 */ + h5tools_str_append(str, "%s", OPT(info->arr_pre, "[")); + + for (i = 0; i < nelmts; i++) { + if (i) + h5tools_str_append(str, "%s", + OPT(info->arr_sep, "," OPTIONAL_LINE_BREAK)); + + if (info->arr_linebreak && i && i % dims[ndims - 1] == 0) { + int x; + + h5tools_str_append(str, "%s", "\n"); + + /*need to indent some more here*/ + if (ctx->indent_level >= 0) + h5tools_str_append(str, "%s", OPT(info->line_pre, "")); + + for (x = 0; x < ctx->indent_level + 1; x++) + h5tools_str_append(str,"%s",OPT(info->line_indent,"")); + } /* end if */ + + ctx->indent_level++; + + /* Dump the array element */ + h5tools_sprint(str, info, container, memb, cp_vp + i * size, ctx); + + ctx->indent_level--; + } /* end for */ + + /* Print the closing bracket */ + h5tools_str_append(str, "%s", OPT(info->arr_suf, "]")); + H5Tclose(memb); + } else if (H5Tget_class(type) == H5T_VLEN) { + 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 */ + h5tools_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) + h5tools_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 && h5tools_str_len(str)>=info->line_ncols) { + int x; + + h5tools_str_append(str, "%s", "\n"); + + /* need to indent some more here */ + if (ctx->indent_level >= 0) + h5tools_str_append(str, "%s", OPT(info->line_pre, "")); + + for (x = 0; x < ctx->indent_level + 1; x++) + h5tools_str_append(str,"%s",OPT(info->line_indent,"")); + } /* end if */ +#endif /* LATER */ + + ctx->indent_level++; + + /* Dump the array element */ + h5tools_sprint(str, info, container, memb, + ((char *)(((hvl_t *)cp_vp)->p)) + i * size, ctx); + + ctx->indent_level--; + } /* end for */ + + h5tools_str_append(str, "%s", OPT(info->vlen_suf, ")")); + H5Tclose(memb); + } else { + /* All other types get printed as hexadecimal */ + size_t i; + + h5tools_str_append(str, "0x"); + n = H5Tget_size(type); + + for (i = 0; i < n; i++) + h5tools_str_append(str, "%02x", ucp_vp[i]); + } + + return h5tools_str_fmt(str, start, OPT(info->elmt_fmt, "%s")); +} + +/*------------------------------------------------------------------------- + * Function: h5tools_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 +h5tools_ncols(const char *s) +{ + register 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, + h5tools_context_t *ctx, hsize_t elmtno, int secnum) +{ + h5tools_str_t prefix; + size_t templength = 0; + int i, indentlevel = 0; + + memset(&prefix, 0, sizeof(h5tools_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 */ + h5tools_str_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(h5tools_str_fmt(&prefix, 0, info->line_1st), stream); + else if (secnum && info->line_cont) + fputs(h5tools_str_fmt(&prefix, 0, info->line_cont), stream); + else + fputs(h5tools_str_fmt(&prefix, 0, info->line_pre), stream); + + templength = h5tools_str_len(&prefix); + + for (i = 0; i < indentlevel; i++){ + fputs(h5tools_str_fmt(&prefix, 0, info->line_indent), stream); + templength += h5tools_str_len(&prefix); + } + + ctx->cur_column = ctx->prev_prefix_len = templength; + ctx->cur_elmt = 0; + ctx->need_prefix = 0; + + /* Free string */ + h5tools_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, + h5tools_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 */ + h5tools_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(h5tools_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 */ + h5tools_str_reset(&buffer); + h5tools_sprint(&buffer, info, container, type, mem + i * size, ctx); + + if (i + 1 < nelmts || 0 == (flags & END_OF_DATA)) + h5tools_str_append(&buffer, "%s", OPT(info->elmt_suf1, ",")); + + s = h5tools_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 + h5tools_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 + h5tools_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 + h5tools_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; + } + + h5tools_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 */ + h5tools_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 */ + h5tools_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) { + register 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 { + fprintf(stderr, "error: the indentation exceeds the number of cols.\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 *progname) +{ + printf("%s: Version %u.%u.%u%s%s\n", + progname, 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 = 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) +{ + register 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) +{ + register 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; + find_objs_t *info = (find_objs_t*)op_data; + register int i; + + 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) +{ + register 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_objectname + * + * Purpose: Get name of i'th object in table + * + * 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: h5dump_fopen + * + * 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 /* !VERSION12 */ + 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; +} |