mirror of
https://github.com/HDFGroup/hdf5.git
synced 2024-12-09 07:32:32 +08:00
a613b70f93
Bring changes from hdf5_1_8_coverity branch back to trunk:
r20878:
Issue 76: Check if H5Tget_nmembers(type) fails and simply return(FALSE). Also move printf to after check.
r20880:
Issue 192: Create ret_val var set to -1. Add out label for failures to jump to, return ret_val at bottom.
r20882:
Fixes for coverity:
1) bug #1679: remove dead code in test/mf.c
2) bug #1680: remove dead code in tools/lib/h5diff_dset.c
r20883:
Fix coverity issue 585
Description:
Changed variable "c" in processStrData in h5import.c to an int, to match fgetc
return value, and removed call to feof, instead checking if c == EOF.
Tested on:
MacOSX/64 10.9.3 (amazon) w/C++, FORTRAN & parallel
(too minor to require h5committest)
4394 lines
147 KiB
C
4394 lines
147 KiB
C
/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
|
|
* Copyright by The HDF Group. *
|
|
* Copyright by the Board of Trustees of the University of Illinois. *
|
|
* All rights reserved. *
|
|
* *
|
|
* This file is part of HDF5. The full HDF5 copyright notice, including *
|
|
* terms governing use, modification, and redistribution, is contained in *
|
|
* the files COPYING and Copyright.html. COPYING can be found at the root *
|
|
* of the source code distribution tree; Copyright.html can be found at the *
|
|
* root level of an installed copy of the electronic HDF5 document set and *
|
|
* is linked from the top-level documents page. It can also be found at *
|
|
* http://hdfgroup.org/HDF5/doc/Copyright.html. If you do not have *
|
|
* access to either file, you may request a copy from help@hdfgroup.org. *
|
|
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
|
|
|
|
#include "hdf5.h"
|
|
#include "H5private.h"
|
|
#include <stdio.h>
|
|
#include <math.h>
|
|
#include <string.h>
|
|
#include <ctype.h>
|
|
#include "h5import.h"
|
|
#include "h5tools.h"
|
|
#include "h5tools_utils.h"
|
|
|
|
/* Name of tool */
|
|
#define PROGRAMNAME "h5import"
|
|
|
|
#ifdef H5_HAVE_WIN32_API
|
|
#define READ_OPEN_FLAGS "rb"
|
|
#else
|
|
#define READ_OPEN_FLAGS "r"
|
|
#endif
|
|
|
|
/* Local function declarations */
|
|
static int gtoken(char *s);
|
|
static int process(struct Options *opt);
|
|
static int processConfigurationFile(char *infile, struct Input *in);
|
|
static int mapKeywordToIndex(char *key);
|
|
static int parsePathInfo(struct path_info *path, char *strm);
|
|
static int parseDimensions(struct Input *in, char *strm);
|
|
static int getInputSize(struct Input *in, int ival);
|
|
static int getInputClass(struct Input *in, char * strm);
|
|
static int getInputClassType(struct Input *in, char * strm);
|
|
static int InputClassStrToInt(char *temp);
|
|
static int getRank(struct Input *in, FILE *strm);
|
|
static int getDimensionSizes(struct Input *in, FILE *strm);
|
|
static int getOutputSize(struct Input *in, FILE *strm);
|
|
static int getOutputClass(struct Input *in, FILE *strm);
|
|
static int OutputClassStrToInt(char *temp);
|
|
static int getOutputArchitecture(struct Input *in, FILE *strm);
|
|
static int OutputArchStrToInt(const char *temp);
|
|
static int getOutputByteOrder(struct Input *in, FILE *strm);
|
|
static int OutputByteOrderStrToInt(const char *temp);
|
|
static int getChunkedDimensionSizes(struct Input *in, FILE *strm);
|
|
static int getCompressionType(struct Input *in, FILE *strm);
|
|
static int CompressionTypeStrToInt(char *temp);
|
|
static int getCompressionParameter(struct Input *in, FILE *strm);
|
|
static int getExternalFilename(struct Input *in, FILE *strm);
|
|
static int getMaximumDimensionSizes(struct Input *in, FILE *strm);
|
|
static int processDataFile(char *infile, struct Input *in, hid_t file_id);
|
|
static int readIntegerData(FILE *strm, struct Input *in);
|
|
static int readFloatData(FILE *strm, struct Input *in);
|
|
static int allocateIntegerStorage(struct Input *in);
|
|
static int allocateFloatStorage(struct Input *in);
|
|
static int readUIntegerData(FILE *strm, struct Input *in);
|
|
static int allocateUIntegerStorage(struct Input *in);
|
|
static int validateConfigurationParameters(struct Input *in);
|
|
static int processStrData(FILE *strm, struct Input *in, hid_t file_id);
|
|
static int processStrHDFData(FILE *strm, struct Input *in, hid_t file_id);
|
|
|
|
int main(int argc, char *argv[])
|
|
{
|
|
struct Options opt;
|
|
int outfile_named = FALSE;
|
|
int token;
|
|
int i;
|
|
int state = 0;
|
|
struct Input *in = NULL;
|
|
|
|
const char *err1 = "Invalid number of arguments: %d.\n";
|
|
const char *err2 = "Error in state table.\n";
|
|
const char *err3 = "No output file given.\n";
|
|
const char *err4 = "Program aborted.\n";
|
|
const char *err5 = "Invalid path %s.\n";
|
|
const char *err6 = "Invalid dimensions - %s.\n";
|
|
const char *err7 = "Invalid type of data - %s.\n";
|
|
const char *err8 = "Invalid size of data - %s.\n";
|
|
const char *err9 = "Cannot specify more than 30 input files in one call to h5import.\n";
|
|
|
|
h5tools_setprogname(PROGRAMNAME);
|
|
h5tools_setstatus(EXIT_SUCCESS);
|
|
|
|
/* Initialize h5tools lib */
|
|
h5tools_init();
|
|
|
|
(void) HDsetvbuf(stderr, (char *) NULL, _IOLBF, 0);
|
|
(void) HDsetvbuf(stdout, (char *) NULL, _IOLBF, 0);
|
|
|
|
if (argv[1] && (HDstrcmp("-V", argv[1]) == 0)) {
|
|
print_version(PROGRAMNAME);
|
|
HDexit(EXIT_SUCCESS);
|
|
}
|
|
|
|
/*
|
|
* validate the number of command line arguments
|
|
*/
|
|
if (argc < 2) {
|
|
(void) HDfprintf(stderr, err1, argc);
|
|
usage(argv[0]);
|
|
goto err;
|
|
}
|
|
|
|
/* Initialize the file structure to 0 */
|
|
HDmemset(&opt, 0, sizeof(struct Options));
|
|
|
|
/*
|
|
* parse the command line
|
|
*/
|
|
for (i = 1; i < argc; i++) {
|
|
if ((token = gtoken(argv[i])) == ERR) {
|
|
usage(argv[0]);
|
|
goto err;
|
|
}
|
|
|
|
state = state_table[state][token];
|
|
|
|
switch (state) {
|
|
|
|
case 1: /* counting input files */
|
|
if (opt.fcount < 29) {
|
|
(void) HDstrcpy(opt.infiles[opt.fcount].datafile, argv[i]);
|
|
in = &(opt.infiles[opt.fcount].in);
|
|
opt.infiles[opt.fcount].config = 0;
|
|
setDefaultValues(in, opt.fcount);
|
|
opt.fcount++;
|
|
}
|
|
else {
|
|
(void) HDfprintf(stderr, err9, argv[i]);
|
|
goto err;
|
|
}
|
|
|
|
break;
|
|
|
|
case 2: /* -c found; look for configfile */
|
|
break;
|
|
|
|
case 3: /* get configfile name */
|
|
(void) HDstrcpy(opt.infiles[opt.fcount-1].configfile, argv[i]);
|
|
opt.infiles[opt.fcount - 1].config = 1;
|
|
break;
|
|
|
|
case 4: /* -o found; look for outfile */
|
|
break;
|
|
|
|
case 5: /* get outfile found */
|
|
(void) HDstrcpy(opt.outfile, argv[i]);
|
|
outfile_named = TRUE;
|
|
break;
|
|
|
|
case 6: /* -h found; help, then exit */
|
|
help(argv[0]);
|
|
HDexit(EXIT_SUCCESS);
|
|
break;
|
|
|
|
case 7: /* -d found; look for dimensions */
|
|
break;
|
|
|
|
case 8: /* read dimensions */
|
|
if (parseDimensions(in, argv[i]) == -1) {
|
|
(void) HDfprintf(stderr, err6, argv[i]);
|
|
goto err;
|
|
}
|
|
break;
|
|
|
|
case 9: /* -p found; look for path name */
|
|
break;
|
|
|
|
case 10: /* read path name */
|
|
if (parsePathInfo(&in->path, argv[i]) == -1) {
|
|
(void) HDfprintf(stderr, err5, argv[i]);
|
|
goto err;
|
|
}
|
|
break;
|
|
|
|
case 11: /* -t found; look for data type */
|
|
break;
|
|
|
|
case 12: /* read data type */
|
|
if (getInputClass(in, argv[i]) == -1) {
|
|
(void) HDfprintf(stderr, err7, argv[i]);
|
|
goto err;
|
|
}
|
|
|
|
if (in->inputClass == 0 || in->inputClass == 4)
|
|
in->outputClass = 0;
|
|
if (in->inputClass == 1 || in->inputClass == 2 || in->inputClass == 3)
|
|
in->outputClass = 1;
|
|
if (in->inputClass == 6 || in->inputClass == 7)
|
|
in->outputClass = 2;
|
|
break;
|
|
|
|
case 13: /* -s found; look for data size */
|
|
break;
|
|
|
|
case 14: /* read data size */
|
|
if (getInputSize(in, (int) HDstrtol(argv[i], NULL, BASE_10)) == -1) {
|
|
(void) HDfprintf(stderr, err8, argv[i]);
|
|
goto err;
|
|
}
|
|
/*set default value for output-size */
|
|
in->outputSize = in->inputSize;
|
|
break;
|
|
|
|
case ERR: /* command syntax error */
|
|
default:
|
|
(void) HDfprintf(stderr, "%s", err2);
|
|
usage(argv[0]);
|
|
goto err;
|
|
}
|
|
}
|
|
|
|
if (FALSE == outfile_named) {
|
|
(void) HDfprintf(stderr, "%s", err3);
|
|
usage(argv[0]);
|
|
goto err;
|
|
}
|
|
|
|
if (process(&opt) == -1)
|
|
goto err;
|
|
|
|
for (i = 0; i < opt.fcount; i++) {
|
|
in = &(opt.infiles[i].in);
|
|
if (in->sizeOfDimension)
|
|
HDfree(in->sizeOfDimension);
|
|
if (in->sizeOfChunk)
|
|
HDfree(in->sizeOfChunk);
|
|
if (in->maxsizeOfDimension)
|
|
HDfree(in->maxsizeOfDimension);
|
|
if (in->externFilename)
|
|
HDfree(in->externFilename);
|
|
if (in->data)
|
|
HDfree(in->data);
|
|
}
|
|
|
|
return (EXIT_SUCCESS);
|
|
err:
|
|
(void) HDfprintf(stderr, "%s", err4);
|
|
for (i = 0; i < opt.fcount; i++) {
|
|
in = &(opt.infiles[i].in);
|
|
if (in->sizeOfDimension)
|
|
HDfree(in->sizeOfDimension);
|
|
if (in->sizeOfChunk)
|
|
HDfree(in->sizeOfChunk);
|
|
if (in->maxsizeOfDimension)
|
|
HDfree(in->maxsizeOfDimension);
|
|
if (in->externFilename)
|
|
HDfree(in->externFilename);
|
|
if (in->data)
|
|
HDfree(in->data);
|
|
}
|
|
return (EXIT_FAILURE);
|
|
}
|
|
|
|
static int gtoken(char *s)
|
|
{
|
|
size_t len;
|
|
int token;
|
|
|
|
const char *err1 = "Illegal argument: %s.\n";
|
|
|
|
/*
|
|
* identify the token type
|
|
*/
|
|
if (s[0] == '-') { /* option name (or negative number) */
|
|
len = HDstrlen(&s[1]);
|
|
switch (s[1]) {
|
|
case 'o':
|
|
if (!HDstrncmp("outfile", &s[1], len))
|
|
token = OPT_o;
|
|
break;
|
|
|
|
case 'c':
|
|
if (!HDstrncmp("config", &s[1], len))
|
|
token = OPT_c;
|
|
break;
|
|
|
|
case 'h':
|
|
if (!HDstrncmp("help", &s[1], len))
|
|
token = OPT_h;
|
|
break;
|
|
|
|
case 'd':
|
|
if (!HDstrncmp("dims", &s[1], len))
|
|
token = OPT_d;
|
|
break;
|
|
|
|
case 'p':
|
|
if (!HDstrncmp("path", &s[1], len))
|
|
token = OPT_p;
|
|
break;
|
|
|
|
case 't':
|
|
if (!HDstrncmp("type", &s[1], len))
|
|
token = OPT_t;
|
|
break;
|
|
|
|
case 's':
|
|
if (!HDstrncmp("size", &s[1], len))
|
|
token = OPT_s;
|
|
break;
|
|
default:
|
|
token = ERR; /* not a supported option tag */
|
|
break;
|
|
}
|
|
|
|
if (token == ERR)
|
|
(void) HDfprintf(stderr, err1, s);
|
|
}
|
|
else { /* filename */
|
|
token = FILNAME;
|
|
}
|
|
return (token);
|
|
}
|
|
|
|
/*-------------------------------------------------------------------------
|
|
* Function: processDataFile
|
|
*
|
|
* Purpose: allocate memory and read data file
|
|
*
|
|
* Return: 0, success, -1, error
|
|
*
|
|
* Programmer: pkmat
|
|
*
|
|
* Modifications: pvn
|
|
* 7/23/2007. Added support for STR type, extra parameter FILE_ID
|
|
*
|
|
*-------------------------------------------------------------------------
|
|
*/
|
|
|
|
static int processDataFile(char *infile, struct Input *in, hid_t file_id)
|
|
{
|
|
FILE *strm = NULL;
|
|
const char *err1 = "Unable to open the input file %s for reading.\n";
|
|
const char *err2 = "Error in allocating integer data storage.\n";
|
|
const char *err3 = "Error in allocating floating-point data storage.\n";
|
|
const char *err4 = "Error in reading integer data.\n";
|
|
const char *err5 = "Error in reading floating-point data.\n";
|
|
const char *err6 = "Error in allocating unsigned integer data storage.\n";
|
|
const char *err7 = "Error in reading unsigned integer data.\n";
|
|
const char *err10 = "Unrecognized input class type.\n";
|
|
const char *err11 = "Error in reading string data.\n";
|
|
int retval = -1;
|
|
|
|
/*-------------------------------------------------------------------------
|
|
* special case for opening binary classes in H5_HAVE_WIN32_API
|
|
* "FP" denotes a floating point binary file,
|
|
* "IN" denotes a signed integer binary file,
|
|
* "UIN" denotes an unsigned integer binary file,
|
|
*-------------------------------------------------------------------------
|
|
*/
|
|
if (in->inputClass == 4 /* "IN" */|| in->inputClass == 3 /* "FP" */|| in->inputClass == 7 /* "UIN" */) {
|
|
|
|
if ((strm = HDfopen(infile, READ_OPEN_FLAGS)) == NULL) {
|
|
(void) HDfprintf(stderr, err1, infile);
|
|
goto error;
|
|
}
|
|
}
|
|
/*-------------------------------------------------------------------------
|
|
* if the input class is not binary, just use "r"
|
|
*-------------------------------------------------------------------------
|
|
*/
|
|
else {
|
|
if ((strm = HDfopen(infile, "r")) == NULL) {
|
|
(void) HDfprintf(stderr, err1, infile);
|
|
goto error;
|
|
}
|
|
}
|
|
|
|
switch (in->inputClass) {
|
|
case 0: /* TEXTIN */
|
|
case 4: /* IN */
|
|
if (allocateIntegerStorage(in) == -1) {
|
|
(void) HDfprintf(stderr, err2, infile);
|
|
goto error;
|
|
}
|
|
|
|
if (readIntegerData(strm, in) == -1) {
|
|
(void) HDfprintf(stderr, err4, infile);
|
|
goto error;
|
|
}
|
|
break;
|
|
|
|
case 1: /* TEXTFP */
|
|
case 2: /* TEXTFPE */
|
|
case 3: /* FP */
|
|
if (allocateFloatStorage(in) == -1) {
|
|
(void) HDfprintf(stderr, err3, infile);
|
|
goto error;
|
|
|
|
}
|
|
|
|
if (readFloatData(strm, in) == -1) {
|
|
(void) HDfprintf(stderr, err5, infile);
|
|
goto error;
|
|
}
|
|
break;
|
|
|
|
case 5: /* STR */
|
|
if (in->h5dumpInput) {
|
|
if (processStrHDFData(strm, in, file_id) == -1) {
|
|
(void) HDfprintf(stderr, err11, infile);
|
|
goto error;
|
|
}
|
|
}
|
|
else {
|
|
if (processStrData(strm, in, file_id) == -1) {
|
|
(void) HDfprintf(stderr, err11, infile);
|
|
goto error;
|
|
}
|
|
}
|
|
|
|
break;
|
|
|
|
case 6: /* TEXTUIN */
|
|
case 7: /* UIN */
|
|
if (allocateUIntegerStorage(in) == -1) {
|
|
(void) HDfprintf(stderr, err6, infile);
|
|
goto error;
|
|
}
|
|
if (readUIntegerData(strm, in) == -1) {
|
|
(void) HDfprintf(stderr, err7, infile);
|
|
goto error;
|
|
}
|
|
break;
|
|
|
|
default:
|
|
(void) HDfprintf(stderr, "%s", err10);
|
|
goto error;
|
|
}
|
|
|
|
/* Set success return value */
|
|
retval = 0;
|
|
|
|
error:
|
|
if(strm)
|
|
HDfclose(strm);
|
|
return(retval);
|
|
}
|
|
|
|
static int readIntegerData(FILE *strm, struct Input *in)
|
|
{
|
|
H5DT_INT8 *in08;
|
|
H5DT_INT16 *in16;
|
|
H5DT_INT16 temp;
|
|
H5DT_INT32 *in32;
|
|
#ifdef H5_SIZEOF_LONG_LONG
|
|
H5DT_INT64 *in64;
|
|
char buffer[256];
|
|
#endif
|
|
hsize_t len = 1;
|
|
hsize_t i;
|
|
int j;
|
|
|
|
const char *err1 = "Unable to get integer value from file.\n";
|
|
const char *err2 = "Unrecognized input class type.\n";
|
|
const char *err3 = "Invalid input size.\n";
|
|
|
|
for (j = 0; j < in->rank; j++)
|
|
len *= in->sizeOfDimension[j];
|
|
|
|
switch (in->inputSize) {
|
|
case 8:
|
|
switch (in->inputClass) {
|
|
case 0: /* TEXTIN */
|
|
in08 = (H5DT_INT8 *) in->data;
|
|
for (i = 0; i < len; i++, in08++) {
|
|
if (fscanf(strm, "%hd", &temp) != 1) {
|
|
(void) HDfprintf(stderr, "%s", err1);
|
|
return (-1);
|
|
}
|
|
(*in08) = (H5DT_INT8) temp;
|
|
}
|
|
break;
|
|
|
|
case 4: /* IN */
|
|
in08 = (H5DT_INT8 *) in->data;
|
|
for (i = 0; i < len; i++, in08++) {
|
|
if (HDfread((char *) in08, sizeof(H5DT_INT8), 1, strm) != 1) {
|
|
(void) HDfprintf(stderr, "%s", err1);
|
|
return (-1);
|
|
}
|
|
}
|
|
break;
|
|
|
|
default:
|
|
(void) HDfprintf(stderr, "%s", err2);
|
|
return (-1);
|
|
}
|
|
break;
|
|
|
|
case 16:
|
|
in16 = (H5DT_INT16 *) in->data;
|
|
switch (in->inputClass) {
|
|
case 0: /* TEXTIN */
|
|
for (i = 0; i < len; i++, in16++) {
|
|
if (fscanf(strm, "%hd", in16) != 1) {
|
|
(void) HDfprintf(stderr, "%s", err1);
|
|
return (-1);
|
|
}
|
|
}
|
|
in16 = (H5DT_INT16 *) in->data;
|
|
break;
|
|
|
|
case 4: /* IN */
|
|
for (i = 0; i < len; i++, in16++) {
|
|
if (HDfread((char *) in16, sizeof(H5DT_INT16), 1, strm) != 1) {
|
|
(void) HDfprintf(stderr, "%s", err1);
|
|
return (-1);
|
|
}
|
|
}
|
|
break;
|
|
|
|
default:
|
|
(void) HDfprintf(stderr, "%s", err2);
|
|
return (-1);
|
|
}
|
|
break;
|
|
|
|
case 32:
|
|
in32 = (H5DT_INT32 *) in->data;
|
|
switch (in->inputClass) {
|
|
case 0: /* TEXTIN */
|
|
for (i = 0; i < len; i++, in32++) {
|
|
if (fscanf(strm, "%d", in32) != 1) {
|
|
(void) HDfprintf(stderr, "%s", err1);
|
|
return (-1);
|
|
}
|
|
}
|
|
break;
|
|
|
|
case 4: /* IN */
|
|
for (i = 0; i < len; i++, in32++) {
|
|
if (HDfread((char *) in32, sizeof(H5DT_INT32), 1, strm) != 1) {
|
|
(void) HDfprintf(stderr, "%s", err1);
|
|
return (-1);
|
|
}
|
|
}
|
|
break;
|
|
|
|
default:
|
|
(void) HDfprintf(stderr, "%s", err2);
|
|
return (-1);
|
|
}
|
|
break;
|
|
|
|
#ifdef H5_SIZEOF_LONG_LONG
|
|
case 64:
|
|
in64 = (H5DT_INT64 *) in->data;
|
|
switch (in->inputClass) {
|
|
case 0: /* TEXTIN */
|
|
for (i = 0; i < len; i++, in64++) {
|
|
if (fscanf(strm, "%s", buffer) < 1) {
|
|
(void) HDfprintf(stderr, "%s", err1);
|
|
return (-1);
|
|
}
|
|
*in64 = (H5DT_INT64) HDstrtoll(buffer, NULL, 10);
|
|
}
|
|
break;
|
|
|
|
case 4: /* IN */
|
|
for (i = 0; i < len; i++, in64++) {
|
|
if (HDfread((char *) in64, sizeof(H5DT_INT64), 1, strm) != 1) {
|
|
(void) HDfprintf(stderr, "%s", err1);
|
|
return (-1);
|
|
}
|
|
}
|
|
break;
|
|
|
|
default:
|
|
(void) HDfprintf(stderr, "%s", err2);
|
|
return (-1);
|
|
}
|
|
break;
|
|
#endif /* ifdef H5_SIZEOF_LONG_LONG */
|
|
|
|
default:
|
|
(void) HDfprintf(stderr, "%s", err3);
|
|
break;
|
|
}
|
|
return (0);
|
|
}
|
|
|
|
static int readUIntegerData(FILE *strm, struct Input *in)
|
|
{
|
|
H5DT_UINT8 *in08;
|
|
H5DT_UINT16 *in16;
|
|
H5DT_UINT16 temp;
|
|
H5DT_UINT32 *in32;
|
|
#ifdef H5_SIZEOF_LONG_LONG
|
|
H5DT_UINT64 *in64;
|
|
char buffer[256];
|
|
#endif
|
|
hsize_t len = 1;
|
|
hsize_t i;
|
|
int j;
|
|
const char *err1 = "Unable to get unsigned integer value from file.\n";
|
|
const char *err2 = "Unrecognized input class type.\n";
|
|
const char *err3 = "Invalid input size.\n";
|
|
|
|
for (j = 0; j < in->rank; j++)
|
|
len *= in->sizeOfDimension[j];
|
|
|
|
switch (in->inputSize) {
|
|
case 8:
|
|
switch (in->inputClass) {
|
|
case 6: /* TEXTUIN */
|
|
in08 = (H5DT_UINT8 *) in->data;
|
|
for (i = 0; i < len; i++, in08++) {
|
|
if (fscanf(strm, "%hu", &temp) != 1) {
|
|
(void) HDfprintf(stderr, "%s", err1);
|
|
return (-1);
|
|
}
|
|
(*in08) = (H5DT_UINT8) temp;
|
|
}
|
|
break;
|
|
|
|
case 7: /* UIN */
|
|
in08 = (H5DT_UINT8 *) in->data;
|
|
for (i = 0; i < len; i++, in08++) {
|
|
if (HDfread((char *) in08, sizeof(H5DT_UINT8), 1, strm) != 1) {
|
|
(void) HDfprintf(stderr, "%s", err1);
|
|
return (-1);
|
|
}
|
|
}
|
|
break;
|
|
|
|
default:
|
|
(void) HDfprintf(stderr, "%s", err2);
|
|
return (-1);
|
|
}
|
|
break;
|
|
|
|
case 16:
|
|
in16 = (H5DT_UINT16 *) in->data;
|
|
switch (in->inputClass) {
|
|
case 6: /* TEXTUIN */
|
|
for (i = 0; i < len; i++, in16++) {
|
|
if (fscanf(strm, "%hu", in16) != 1) {
|
|
(void) HDfprintf(stderr, "%s", err1);
|
|
return (-1);
|
|
}
|
|
}
|
|
break;
|
|
|
|
case 7: /* UIN */
|
|
for (i = 0; i < len; i++, in16++) {
|
|
if (HDfread((char *) in16, sizeof(H5DT_UINT16), 1, strm) != 1) {
|
|
(void) HDfprintf(stderr, "%s", err1);
|
|
return (-1);
|
|
}
|
|
}
|
|
break;
|
|
|
|
default:
|
|
(void) HDfprintf(stderr, "%s", err2);
|
|
return (-1);
|
|
}
|
|
break;
|
|
|
|
case 32:
|
|
in32 = (H5DT_UINT32 *) in->data;
|
|
switch (in->inputClass) {
|
|
case 6: /* TEXTUIN */
|
|
for (i = 0; i < len; i++, in32++) {
|
|
if (fscanf(strm, "%u", in32) != 1) {
|
|
(void) HDfprintf(stderr, "%s", err1);
|
|
return (-1);
|
|
}
|
|
}
|
|
break;
|
|
|
|
case 7: /* UIN */
|
|
for (i = 0; i < len; i++, in32++) {
|
|
if (HDfread((char *) in32, sizeof(H5DT_UINT32), 1, strm) != 1) {
|
|
(void) HDfprintf(stderr, "%s", err1);
|
|
return (-1);
|
|
}
|
|
}
|
|
break;
|
|
|
|
default:
|
|
(void) HDfprintf(stderr, "%s", err2);
|
|
return (-1);
|
|
}
|
|
break;
|
|
|
|
#ifdef H5_SIZEOF_LONG_LONG
|
|
case 64:
|
|
in64 = (H5DT_UINT64 *) in->data;
|
|
switch (in->inputClass) {
|
|
case 6: /* TEXTUIN */
|
|
for (i = 0; i < len; i++, in64++) {
|
|
if (fscanf(strm, "%s", buffer) < 1) {
|
|
(void) HDfprintf(stderr, "%s", err1);
|
|
return (-1);
|
|
}
|
|
*in64 = (H5DT_UINT64) HDstrtoll(buffer, NULL, 10);
|
|
}
|
|
break;
|
|
|
|
case 7: /* UIN */
|
|
for (i = 0; i < len; i++, in64++) {
|
|
if (HDfread((char *) in64, sizeof(H5DT_UINT64), 1, strm) != 1) {
|
|
(void) HDfprintf(stderr, "%s", err1);
|
|
return (-1);
|
|
}
|
|
}
|
|
break;
|
|
|
|
default:
|
|
(void) HDfprintf(stderr, "%s", err2);
|
|
return (-1);
|
|
}
|
|
break;
|
|
#endif /* ifdef H5_SIZEOF_LONG_LONG */
|
|
|
|
default:
|
|
(void) HDfprintf(stderr, "%s", err3);
|
|
break;
|
|
}
|
|
return (0);
|
|
}
|
|
|
|
static int readFloatData(FILE *strm, struct Input *in)
|
|
{
|
|
H5DT_FLOAT32 *fp32;
|
|
H5DT_FLOAT64 *fp64;
|
|
|
|
hsize_t len = 1;
|
|
hsize_t i;
|
|
int j;
|
|
const char *err1 = "Unable to get integer value from file.\n";
|
|
const char *err2 = "Unrecognized input class type.\n";
|
|
const char *err3 = "Invalid input size type.\n";
|
|
|
|
for (j = 0; j < in->rank; j++)
|
|
len *= in->sizeOfDimension[j];
|
|
|
|
switch (in->inputSize) {
|
|
case 32:
|
|
fp32 = (H5DT_FLOAT32 *) in->data;
|
|
switch (in->inputClass) {
|
|
case 1: /* TEXTFP */
|
|
for (i = 0; i < len; i++, fp32++) {
|
|
if (fscanf(strm, "%f", fp32) != 1) {
|
|
(void) HDfprintf(stderr, "%s", err1);
|
|
return (-1);
|
|
}
|
|
}
|
|
|
|
fp32 = (H5DT_FLOAT32 *) in->data;
|
|
break;
|
|
|
|
/* same as TEXTFP */
|
|
case 2: /*TEXTFPE */
|
|
|
|
for (i = 0; i < len; i++, fp32++) {
|
|
if (fscanf(strm, "%f", fp32) != 1) {
|
|
(void) HDfprintf(stderr, "%s", err1);
|
|
return (-1);
|
|
}
|
|
}
|
|
|
|
fp32 = (H5DT_FLOAT32 *) in->data;
|
|
break;
|
|
|
|
case 3: /* FP */
|
|
for (i = 0; i < len; i++, fp32++) {
|
|
if (HDfread((char *) fp32, sizeof(H5DT_FLOAT32), 1, strm) != 1) {
|
|
(void) HDfprintf(stderr, "%s", err1);
|
|
return (-1);
|
|
}
|
|
}
|
|
break;
|
|
|
|
default:
|
|
(void) HDfprintf(stderr, "%s", err2);
|
|
return (-1);
|
|
}
|
|
break;
|
|
|
|
case 64:
|
|
fp64 = (H5DT_FLOAT64 *) in->data;
|
|
switch (in->inputClass) {
|
|
case 1: /* TEXTFP */
|
|
for (i = 0; i < len; i++, fp64++) {
|
|
if (fscanf(strm, "%lf", fp64) != 1) {
|
|
(void) HDfprintf(stderr, "%s", err1);
|
|
return (-1);
|
|
}
|
|
}
|
|
|
|
fp64 = (H5DT_FLOAT64 *) in->data;
|
|
break;
|
|
|
|
/* same as TEXTFP */
|
|
case 2: /*TEXTFPE */
|
|
|
|
for (i = 0; i < len; i++, fp64++) {
|
|
if (fscanf(strm, "%lf", fp64) != 1) {
|
|
(void) HDfprintf(stderr, "%s", err1);
|
|
return (-1);
|
|
}
|
|
}
|
|
|
|
fp64 = (H5DT_FLOAT64 *) in->data;
|
|
break;
|
|
|
|
case 3: /* FP */
|
|
for (i = 0; i < len; i++, fp64++) {
|
|
if (HDfread((char *) fp64, sizeof(H5DT_FLOAT64), 1, strm) != 1) {
|
|
(void) HDfprintf(stderr, "%s", err1);
|
|
return (-1);
|
|
}
|
|
}
|
|
break;
|
|
|
|
default:
|
|
(void) HDfprintf(stderr, "%s", err2);
|
|
return (-1);
|
|
}
|
|
break;
|
|
|
|
default:
|
|
(void) HDfprintf(stderr, "%s", err3);
|
|
break;
|
|
}
|
|
return (0);
|
|
}
|
|
|
|
/*-------------------------------------------------------------------------
|
|
* Function: processStrData
|
|
*
|
|
* Purpose: read an ASCII file with string data and generate an HDF5 dataset
|
|
* with a variable length type
|
|
*
|
|
* Return: 0, ok, -1 no
|
|
*
|
|
* Programmer: Pedro Vicente, pvn@hdfgroup.org
|
|
*
|
|
* Date: July, 26, 2007
|
|
*
|
|
*-------------------------------------------------------------------------
|
|
*/
|
|
static int processStrData(FILE *strm, struct Input *in, hid_t file_id)
|
|
{
|
|
hid_t group_id;
|
|
hid_t dset_id;
|
|
hid_t space_id;
|
|
hid_t mspace_id;
|
|
hid_t type_id;
|
|
hid_t handle;
|
|
hsize_t dims[1];
|
|
char str[1024];
|
|
int c;
|
|
int i = 0;
|
|
int j;
|
|
hsize_t nlines = 0;
|
|
hsize_t line;
|
|
|
|
/*-------------------------------------------------------------------------
|
|
* get number of lines in the input file
|
|
*-------------------------------------------------------------------------
|
|
*/
|
|
|
|
while(EOF != (c = HDfgetc(strm)))
|
|
if (c == 10) /* eol */
|
|
nlines++;
|
|
|
|
if (!nlines)
|
|
return 0;
|
|
|
|
/* number of records */
|
|
dims[0] = nlines;
|
|
|
|
/* rewind */
|
|
HDfseek(strm, 0L, 0);
|
|
|
|
/*-------------------------------------------------------------------------
|
|
* read file again and generate an HDF5 dataset
|
|
*-------------------------------------------------------------------------
|
|
*/
|
|
|
|
if ((type_id = H5Tcopy(H5T_C_S1)) < 0)
|
|
goto out;
|
|
|
|
if (H5Tset_size(type_id, H5T_VARIABLE) < 0)
|
|
goto out;
|
|
|
|
/* disable error reporting */
|
|
H5E_BEGIN_TRY
|
|
{
|
|
/* create parent groups */
|
|
if (in->path.count > 1) {
|
|
j = 0;
|
|
handle = file_id;
|
|
while (j < in->path.count - 1) {
|
|
if ((group_id = H5Gopen2(handle, in->path.group[j], H5P_DEFAULT)) < 0) {
|
|
group_id = H5Gcreate2(handle, in->path.group[j++], H5P_DEFAULT, H5P_DEFAULT, H5P_DEFAULT);
|
|
for (; j < in->path.count - 1; j++)
|
|
group_id = H5Gcreate2(group_id, in->path.group[j], H5P_DEFAULT, H5P_DEFAULT, H5P_DEFAULT);
|
|
handle = group_id;
|
|
break;
|
|
}
|
|
handle = group_id;
|
|
j++;
|
|
}
|
|
}
|
|
else {
|
|
handle = file_id;
|
|
j = 0;
|
|
}
|
|
|
|
/*enable error reporting */
|
|
}
|
|
H5E_END_TRY;
|
|
|
|
if ((space_id = H5Screate_simple(1, dims, NULL)) < 0)
|
|
goto out;
|
|
|
|
if ((mspace_id = H5Screate(H5S_SCALAR)) < 0)
|
|
goto out;
|
|
|
|
if ((dset_id = H5Dcreate2(handle, in->path.group[j], type_id, space_id, H5P_DEFAULT, H5P_DEFAULT, H5P_DEFAULT)) < 0)
|
|
goto out;
|
|
|
|
line = 0;
|
|
|
|
while(EOF != (c = HDfgetc(strm))) {
|
|
str[i] = (char)c;
|
|
|
|
i++;
|
|
|
|
if (c == 10) { /* eol */
|
|
char *str2 = str;
|
|
hid_t fspace_id;
|
|
hsize_t start[1];
|
|
hsize_t count[1] = { 1 };
|
|
|
|
str[i - 1] = '\0'; /* terminate string */
|
|
|
|
if ((fspace_id = H5Dget_space(dset_id)) < 0)
|
|
goto out;
|
|
|
|
start[0] = line++;
|
|
|
|
if (H5Sselect_hyperslab(fspace_id, H5S_SELECT_SET, start, NULL, count, NULL) < 0)
|
|
goto out;
|
|
|
|
if (H5Dwrite(dset_id, type_id, mspace_id, fspace_id, H5P_DEFAULT, &str2) < 0)
|
|
goto out;
|
|
|
|
if (H5Sclose(fspace_id) < 0)
|
|
goto out;
|
|
|
|
i = 0;
|
|
str[0] = '\0';
|
|
|
|
}
|
|
}
|
|
|
|
/* close */
|
|
H5Dclose(dset_id);
|
|
H5Sclose(space_id);
|
|
H5Sclose(mspace_id);
|
|
H5Tclose(type_id);
|
|
|
|
return (0);
|
|
|
|
out:
|
|
|
|
return (-1);
|
|
}
|
|
|
|
/*-------------------------------------------------------------------------
|
|
* Function: processStrData
|
|
*
|
|
* Purpose: read an ASCII file with string data and generate an HDF5 dataset
|
|
* with a variable length type
|
|
*
|
|
* Return: 0, ok, -1 no
|
|
*
|
|
*-------------------------------------------------------------------------
|
|
*/
|
|
static int processStrHDFData(FILE *strm, struct Input *in, hid_t file_id)
|
|
{
|
|
hid_t group_id;
|
|
hid_t dset_id;
|
|
hid_t space_id;
|
|
hid_t mspace_id;
|
|
hid_t type_id;
|
|
hid_t handle;
|
|
char *str1 = NULL;
|
|
char *str2 = NULL;
|
|
char *str3 = NULL;
|
|
char str[1024] = "";
|
|
int j;
|
|
hsize_t line;
|
|
|
|
/*-------------------------------------------------------------------------
|
|
* read file and generate an HDF5 dataset
|
|
*-------------------------------------------------------------------------
|
|
*/
|
|
#ifdef H5DEBUGIMPORT
|
|
printf("processStrHDFData DATATYPE STRING\n");
|
|
#endif
|
|
|
|
if ((type_id = H5Tcopy(H5T_C_S1)) < 0)
|
|
goto out;
|
|
|
|
if (H5Tset_size(type_id, H5T_VARIABLE) < 0)
|
|
goto out;
|
|
|
|
/* disable error reporting */
|
|
H5E_BEGIN_TRY
|
|
{
|
|
/* create parent groups */
|
|
if (in->path.count > 1) {
|
|
j = 0;
|
|
handle = file_id;
|
|
while (j < in->path.count - 1) {
|
|
if ((group_id = H5Gopen2(handle, in->path.group[j], H5P_DEFAULT)) < 0) {
|
|
group_id = H5Gcreate2(handle, in->path.group[j++], H5P_DEFAULT, H5P_DEFAULT, H5P_DEFAULT);
|
|
for (; j < in->path.count - 1; j++)
|
|
group_id = H5Gcreate2(group_id, in->path.group[j], H5P_DEFAULT, H5P_DEFAULT, H5P_DEFAULT);
|
|
handle = group_id;
|
|
break;
|
|
}
|
|
handle = group_id;
|
|
j++;
|
|
}
|
|
}
|
|
else {
|
|
handle = file_id;
|
|
j = 0;
|
|
}
|
|
|
|
/*enable error reporting */
|
|
}
|
|
H5E_END_TRY;
|
|
#ifdef H5DEBUGIMPORT
|
|
printf("processStrHDFData DATATYPE STRING groups created\n");
|
|
#endif
|
|
|
|
if ((space_id = H5Screate_simple(in->rank, in->sizeOfDimension, NULL)) < 0)
|
|
goto out;
|
|
|
|
if ((mspace_id = H5Screate(H5S_SCALAR)) < 0)
|
|
goto out;
|
|
|
|
if ((dset_id = H5Dcreate2(handle, in->path.group[j], type_id, space_id, H5P_DEFAULT, H5P_DEFAULT, H5P_DEFAULT)) < 0)
|
|
goto out;
|
|
|
|
#ifdef H5DEBUGIMPORT
|
|
printf("processStrHDFData DATATYPE STRING ready to process strings\n");
|
|
#endif
|
|
line = 0;
|
|
j = 0;
|
|
|
|
while (HDfgets(str,sizeof(str),strm)) {
|
|
str1 = str;
|
|
str2 = NULL;
|
|
str3 = NULL;
|
|
#ifdef H5DEBUGIMPORT
|
|
printf("processStrHDFData DATATYPE STRING[%llu]={%s}\n", (unsigned long long)line, str1);
|
|
#endif
|
|
/* process string to remove the first and last quote char */
|
|
str2 = strchr(str1, '"');
|
|
if (str2 != NULL) {
|
|
#ifdef H5DEBUGIMPORT
|
|
printf("processStrHDFData DATATYPE STRING len:%d for {%s}\n", strlen(str2), str2);
|
|
#endif
|
|
str2++;
|
|
#ifdef H5DEBUGIMPORT
|
|
printf("processStrHDFData DATATYPE STRING len:%d for {%s}\n", strlen(str2), str2);
|
|
#endif
|
|
str3 = strrchr(str2, '"');
|
|
if (str3 != NULL) {
|
|
#ifdef H5DEBUGIMPORT
|
|
printf("processStrHDFData DATATYPE STRING len:%d for {%s}\n", strlen(str3), str3);
|
|
#endif
|
|
*str3 = '\0';
|
|
|
|
#ifdef H5DEBUGIMPORT
|
|
printf("processStrHDFData DATATYPE STRING len:%d for {%s}\n", strlen(str2), str2);
|
|
#endif
|
|
|
|
if(strlen(str2) > 0) {
|
|
hid_t fspace_id;
|
|
hsize_t start[1];
|
|
hsize_t count[1] = { 1 };
|
|
|
|
#ifdef H5DEBUGIMPORT
|
|
printf("processStrHDFData DATATYPE STRING[%llu] store %s\n", (unsigned long long)line, str2);
|
|
#endif
|
|
if ((fspace_id = H5Dget_space(dset_id)) < 0)
|
|
goto out;
|
|
|
|
start[0] = line++;
|
|
|
|
if (H5Sselect_hyperslab(fspace_id, H5S_SELECT_SET, start, NULL, count, NULL) < 0)
|
|
goto out;
|
|
|
|
if (H5Dwrite(dset_id, type_id, mspace_id, fspace_id, H5P_DEFAULT, &str2) < 0)
|
|
goto out;
|
|
|
|
if (H5Sclose(fspace_id) < 0)
|
|
goto out;
|
|
}
|
|
}
|
|
}
|
|
str[0] = '\0';
|
|
j++;
|
|
}
|
|
#ifdef H5DEBUGIMPORT
|
|
printf("processStrHDFData DATATYPE STRING eof reached\n");
|
|
#endif
|
|
|
|
/* close */
|
|
H5Dclose(dset_id);
|
|
H5Sclose(space_id);
|
|
H5Sclose(mspace_id);
|
|
H5Tclose(type_id);
|
|
|
|
return (0);
|
|
|
|
out:
|
|
#ifdef H5DEBUGIMPORT
|
|
printf("processStrHDFData DATATYPE STRING error exit\n");
|
|
#endif
|
|
/* disable error reporting */
|
|
H5E_BEGIN_TRY
|
|
{
|
|
/* close */
|
|
H5Dclose(dset_id);
|
|
H5Sclose(space_id);
|
|
H5Sclose(mspace_id);
|
|
H5Tclose(type_id);
|
|
}
|
|
H5E_END_TRY;
|
|
|
|
return (-1);
|
|
}
|
|
|
|
static int allocateIntegerStorage(struct Input *in)
|
|
{
|
|
hsize_t len = 1;
|
|
int j;
|
|
const char *err1 = "Unable to allocate dynamic memory.\n";
|
|
const char *err2 = "Invalid storage size for integer input data.\n";
|
|
|
|
for (j = 0; j < in->rank; j++)
|
|
len *= in->sizeOfDimension[j];
|
|
|
|
switch (in->inputSize) {
|
|
case 8:
|
|
if ((in->data = (VOIDP) HDmalloc((size_t) len * sizeof(H5DT_INT8))) == NULL) {
|
|
(void) HDfprintf(stderr, "%s", err1);
|
|
return (-1);
|
|
}
|
|
break;
|
|
|
|
case 16:
|
|
if ((in->data = (VOIDP) HDmalloc((size_t) len * sizeof(H5DT_INT16))) == NULL) {
|
|
(void) HDfprintf(stderr, "%s", err1);
|
|
return (-1);
|
|
}
|
|
break;
|
|
|
|
case 32:
|
|
if ((in->data = (VOIDP) HDmalloc((size_t) len * sizeof(H5DT_INT32))) == NULL) {
|
|
(void) HDfprintf(stderr, "%s", err1);
|
|
return (-1);
|
|
}
|
|
break;
|
|
|
|
case 64:
|
|
if ((in->data = (VOIDP) HDmalloc((size_t) len * sizeof(H5DT_INT64))) == NULL) {
|
|
(void) HDfprintf(stderr, "%s", err1);
|
|
return (-1);
|
|
}
|
|
break;
|
|
|
|
default:
|
|
(void) HDfprintf(stderr, "%s", err2);
|
|
break;
|
|
}
|
|
return (0);
|
|
}
|
|
|
|
static int allocateUIntegerStorage(struct Input *in)
|
|
{
|
|
hsize_t len = 1;
|
|
const char *err1 = "Unable to allocate dynamic memory.\n";
|
|
const char *err2 = "Invalid storage size for unsigned integer input data.\n";
|
|
int j;
|
|
|
|
for (j = 0; j < in->rank; j++)
|
|
len *= in->sizeOfDimension[j];
|
|
|
|
switch (in->inputSize) {
|
|
case 8:
|
|
if ((in->data = (VOIDP) HDmalloc((size_t) len * sizeof(H5DT_UINT8))) == NULL) {
|
|
(void) HDfprintf(stderr, "%s", err1);
|
|
return (-1);
|
|
}
|
|
break;
|
|
|
|
case 16:
|
|
if ((in->data = (VOIDP) HDmalloc((size_t) len * sizeof(H5DT_UINT16))) == NULL) {
|
|
(void) HDfprintf(stderr, "%s", err1);
|
|
return (-1);
|
|
}
|
|
break;
|
|
|
|
case 32:
|
|
if ((in->data = (VOIDP) HDmalloc((size_t) len * sizeof(H5DT_UINT32))) == NULL) {
|
|
(void) HDfprintf(stderr, "%s", err1);
|
|
return (-1);
|
|
}
|
|
break;
|
|
|
|
case 64:
|
|
if ((in->data = (VOIDP) HDmalloc((size_t) len * sizeof(H5DT_UINT64))) == NULL) {
|
|
(void) HDfprintf(stderr, "%s", err1);
|
|
return (-1);
|
|
}
|
|
break;
|
|
|
|
default:
|
|
(void) HDfprintf(stderr, "%s", err2);
|
|
break;
|
|
}
|
|
return (0);
|
|
}
|
|
|
|
static int allocateFloatStorage(struct Input *in)
|
|
{
|
|
hsize_t len = 1;
|
|
int j;
|
|
const char *err1 = "Unable to allocate dynamic memory.\n";
|
|
const char *err2 = "Invalid storage size for float input data.\n";
|
|
|
|
for (j = 0; j < in->rank; j++)
|
|
len *= in->sizeOfDimension[j];
|
|
|
|
switch (in->inputSize) {
|
|
case 32:
|
|
if ((in->data = (VOIDP) HDmalloc((size_t) len * sizeof(H5DT_FLOAT32))) == NULL) {
|
|
(void) HDfprintf(stderr, "%s", err1);
|
|
return (-1);
|
|
}
|
|
break;
|
|
|
|
case 64:
|
|
if ((in->data = (VOIDP) HDmalloc((size_t) len * sizeof(H5DT_FLOAT64))) == NULL) {
|
|
(void) HDfprintf(stderr, "%s", err1);
|
|
return (-1);
|
|
}
|
|
break;
|
|
|
|
default:
|
|
(void) HDfprintf(stderr, "%s", err2);
|
|
break;
|
|
}
|
|
return (0);
|
|
}
|
|
|
|
static int processConfigurationFile(char *infile, struct Input *in)
|
|
{
|
|
FILE *strm = NULL;
|
|
char key[255];
|
|
int kindex;
|
|
char temp[255];
|
|
int ival;
|
|
int scanret;
|
|
int retval = -1;
|
|
|
|
const char *err1 = "Unable to open the configuration file: %s for reading.\n";
|
|
const char *err2 = "Unknown keyword in configuration file: %s\n";
|
|
const char *err3a = "PATH keyword appears twice in %s.\n";
|
|
const char *err3b = "Error in parsing the path information from %s.\n";
|
|
const char *err4a = "INPUT-CLASS keyword appears twice in %s.\n";
|
|
const char *err4b = "Error in retrieving the input class from %s.\n";
|
|
const char *err5a = "INPUT-SIZE keyword appears twice in %s.\n";
|
|
const char *err5b = "Error in retrieving the input size from %s.\n";
|
|
const char *err6a = "RANK keyword appears twice in %s.\n";
|
|
const char *err6b = "Error in retrieving the rank from %s.\n";
|
|
const char *err7a = "DIMENSION-SIZES keyword appears twice in %s.\n";
|
|
const char *err7b = "DIMENSION-SIZES cannot appear before RANK is provided.\n";
|
|
const char *err7c = "Error in retrieving the dimension sizes from %s.\n";
|
|
const char *err8a = "OUTPUT-CLASS keyword appears twice in %s.\n";
|
|
const char *err8b = "Error in retrieving the output class from %s.\n";
|
|
const char *err9a = "OUTPUT-SIZE keyword appears twice in %s.\n";
|
|
const char *err9b = "Error in retrieving the output size from %s.\n";
|
|
const char *err10a = "OUTPUT-ARCHITECTURE keyword appears twice in %s.\n";
|
|
const char *err10b = "Error in retrieving the output architecture from %s.\n";
|
|
const char *err11a = "OUTPUT-BYTE-ORDER keyword appears twice in %s.\n";
|
|
const char *err11b = "Error in retrieving the output byte order from %s.\n";
|
|
const char *err12a = "CHUNKED-DIMENSION-SIZES keyword appears twice in %s.\n";
|
|
const char *err12b = "CHUNKED-DIMENSION-SIZES cannot appear before DIMENSION-SIZES are provided.\n";
|
|
const char *err12c = "Error in retrieving the chunked dimension sizes from %s.\n";
|
|
const char *err13a = "COMPRESSION-TYPE keyword appears twice in %s.\n";
|
|
const char *err13b = "Error in retrieving the compression type from %s.\n";
|
|
const char *err14a = "COMPRESSION-PARAM keyword appears twice in %s.\n";
|
|
const char *err14b = "Error in retrieving the compression parameter from %s.\n";
|
|
const char *err15a = "EXTERNAL-STORAGE keyword appears twice in %s.\n";
|
|
const char *err15b = "Error in retrieving the external storage paramters from %s.\n";
|
|
const char *err16a = "MAXIMUM-DIMENSIONS keyword appears twice in %s.\n";
|
|
const char *err16b = "MAXIMUM-DIMENSIONS cannot appear before DIMENSION-SIZES are provided.\n";
|
|
const char *err16c = "Error in retrieving the maximum dimension sizes from %s.\n";
|
|
const char *err17 = "Configuration parameters are invalid in %s.\n";
|
|
const char *err18 = "Unable to get string value.\n";
|
|
const char *err19 = "Unable to get integer value.\n";
|
|
|
|
/* create vector to map which keywords have been found
|
|
check vector after each keyword to check for violation
|
|
at the end check vector to see if required fields have been provided
|
|
process the output file according to the options
|
|
*/
|
|
|
|
if ((strm = HDfopen(infile, "r")) == NULL) {
|
|
(void) HDfprintf(stderr, err1, infile);
|
|
goto error;
|
|
}
|
|
|
|
scanret = fscanf(strm, "%s", key);
|
|
if((scanret == 1) && !HDstrcmp("HDF5", key)) {
|
|
#ifdef H5DEBUGIMPORT
|
|
int pndx;
|
|
printf("\nh5dump file\n");
|
|
#endif
|
|
in->h5dumpInput = 1;
|
|
scanret = fscanf(strm, "%s", temp); /* filename */
|
|
scanret = fscanf(strm, "%s", temp); /* start bracket */
|
|
scanret = fscanf(strm, "%s", key); /* DATASET */
|
|
while (scanret == 1) {
|
|
if(!HDstrcmp("DATASET", key)) { /* PATH */
|
|
#ifdef H5DEBUGIMPORT
|
|
printf("h5dump DATASET key\n");
|
|
#endif
|
|
if (in->configOptionVector[PATH] == 1) {
|
|
(void) HDfprintf(stderr, err3a, infile);
|
|
goto error;
|
|
}
|
|
if (fscanf(strm, "%s", temp) != 1) {
|
|
(void) HDfprintf(stderr, "%s", err18);
|
|
goto error;
|
|
}
|
|
#ifdef H5DEBUGIMPORT
|
|
printf("h5dump DATASET %s found\n", temp);
|
|
#endif
|
|
if (parsePathInfo(&in->path, temp) == -1) {
|
|
(void) HDfprintf(stderr, err3b, infile);
|
|
goto error;
|
|
}
|
|
in->configOptionVector[PATH] = 1;
|
|
scanret = fscanf(strm, "%s", temp); /* start bracket */
|
|
#ifdef H5DEBUGIMPORT
|
|
printf("h5dump DATASET %s found\n", temp);
|
|
#endif
|
|
} /* if(!HDstrcmp("DATASET", key)) PATH */
|
|
else if(!HDstrcmp("DATATYPE", key)) { /* INPUT-CLASS */
|
|
#ifdef H5DEBUGIMPORT
|
|
printf("h5dump DATATYPE key\n");
|
|
#endif
|
|
if (in->configOptionVector[INPUT_CLASS] == 1) {
|
|
(void) HDfprintf(stderr, err4a, infile);
|
|
goto error;
|
|
}
|
|
|
|
if (fscanf(strm, "%s", temp) != 1) {
|
|
(void) HDfprintf(stderr, "%s", err18);
|
|
goto error;
|
|
}
|
|
#ifdef H5DEBUGIMPORT
|
|
printf("h5dump DATATYPE %s found\n", temp);
|
|
#endif
|
|
if ((kindex = getInputClassType(in, temp)) == -1) {
|
|
(void) HDfprintf(stderr, err4b, infile);
|
|
goto error;
|
|
}
|
|
#ifdef H5DEBUGIMPORT
|
|
printf("h5dump DATATYPE type %d inputClass\n", in->inputClass);
|
|
#endif
|
|
|
|
in->configOptionVector[INPUT_CLASS] = 1;
|
|
|
|
/*set default value for output-class */
|
|
if (in->configOptionVector[OUTPUT_CLASS] == 0) {
|
|
if (in->inputClass == 0 || in->inputClass == 4)
|
|
in->outputClass = 0;
|
|
if (in->inputClass == 1 || in->inputClass == 2
|
|
|| in->inputClass == 3)
|
|
in->outputClass = 1;
|
|
if (in->inputClass == 6 || in->inputClass == 7)
|
|
in->outputClass = 2;
|
|
}
|
|
#ifdef H5DEBUGIMPORT
|
|
printf("h5dump DATATYPE type %d outputClass\n", in->outputClass);
|
|
#endif
|
|
|
|
if(in->inputClass == 5) { /* STRING */
|
|
int get_next_prop = 1;
|
|
in->outputClass = -1;
|
|
#ifdef H5DEBUGIMPORT
|
|
printf("h5dump DATATYPE STRING found\n");
|
|
#endif
|
|
if (fscanf(strm, "%s", temp) != 1) { /* start bracket */
|
|
(void) HDfprintf(stderr, "%s", err18);
|
|
goto error;
|
|
}
|
|
#ifdef H5DEBUGIMPORT
|
|
printf("h5dump DATATYPE STRING %s found\n", temp);
|
|
#endif
|
|
if (fscanf(strm, "%s", temp) != 1) { /* string properties */
|
|
(void) HDfprintf(stderr, "%s", err18);
|
|
goto error;
|
|
}
|
|
while (get_next_prop) {
|
|
if(!HDstrcmp("STRSIZE", temp)) { /* STRSIZE */
|
|
if (fscanf(strm, "%s", temp) != 1) {
|
|
(void) HDfprintf(stderr, "%s", err19);
|
|
goto error;
|
|
}
|
|
#ifdef H5DEBUGIMPORT
|
|
printf("h5dump DATATYPE STRING STRSIZE %s found\n", temp);
|
|
#endif
|
|
if (HDstrcmp("H5T_VARIABLE;", temp)) {
|
|
char *more = temp;
|
|
ival = HDstrtol(more, &more, 10);
|
|
if (getInputSize(in, ival) == -1) {
|
|
(void) HDfprintf(stderr, err5b, infile);
|
|
goto error;
|
|
}
|
|
#ifdef H5DEBUGIMPORT
|
|
printf("h5dump DATATYPE STRING %d InputSize\n", in->inputSize);
|
|
#endif
|
|
}
|
|
}
|
|
else if(!HDstrcmp("STRPAD", temp)) { /* STRPAD */
|
|
if (fscanf(strm, "%s", temp) != 1) { /* STRPAD type */
|
|
(void) HDfprintf(stderr, "%s", err18);
|
|
goto error;
|
|
}
|
|
#ifdef H5DEBUGIMPORT
|
|
printf("h5dump DATATYPE STRING STRPAD %s found\n", temp);
|
|
#endif
|
|
}
|
|
else if(!HDstrcmp("CSET", key)) { /* CSET */
|
|
if (fscanf(strm, "%s", temp) != 1) { /* CSET type */
|
|
(void) HDfprintf(stderr, "%s", err18);
|
|
goto error;
|
|
}
|
|
#ifdef H5DEBUGIMPORT
|
|
printf("h5dump DATATYPE STRING CSET %s found\n", temp);
|
|
#endif
|
|
|
|
}
|
|
else if(!HDstrcmp("CTYPE", temp)) { /* CTYPE */
|
|
if (fscanf(strm, "%s", temp) != 1) { /* CTYPE type */
|
|
(void) HDfprintf(stderr, "%s", err18);
|
|
goto error;
|
|
}
|
|
#ifdef H5DEBUGIMPORT
|
|
printf("h5dump DATATYPE STRING CTYPE %s found\n", temp);
|
|
#endif
|
|
} /* if(!HDstrcmp("CSET", key)) */
|
|
if (fscanf(strm, "%s", temp) != 1) {
|
|
(void) HDfprintf(stderr, "%s", err18);
|
|
goto error;
|
|
}
|
|
#ifdef H5DEBUGIMPORT
|
|
printf("h5dump DATATYPE STRING %s found\n", temp);
|
|
#endif
|
|
if(!HDstrcmp("}", temp)) { /* end bracket */
|
|
get_next_prop = 0;
|
|
}
|
|
} /* while (get_next_prop) */
|
|
} /* if(kindex == 5) STRING */
|
|
} /* else if(!HDstrcmp("DATATYPE", key)) INPUT-CLASS */
|
|
else if(!HDstrcmp("DATASPACE", key)) { /* RANK and DIMENSIONS */
|
|
hsize_t temp_dims[MAX_NUM_DIMENSION];
|
|
|
|
#ifdef H5DEBUGIMPORT
|
|
printf("h5dump DATASPACE key\n");
|
|
#endif
|
|
if (fscanf(strm, "%s", temp) != 1) {
|
|
(void) HDfprintf(stderr, "%s", err18);
|
|
goto error;
|
|
}
|
|
if(!HDstrcmp("SCALAR", temp)) { /* SCALAR */
|
|
in->rank = 0;
|
|
} /* if(!HDstrcmp("SCALAR", key)) */
|
|
else if(!HDstrcmp("NULL", temp)) { /* NULL */
|
|
(void) HDfprintf(stderr, err6b, infile);
|
|
goto error;
|
|
} /* else if(!HDstrcmp("NULL", key)) */
|
|
else if(!HDstrcmp("SIMPLE", temp)) { /* SIMPLE */
|
|
int icount = 0;
|
|
#ifdef H5DEBUGIMPORT
|
|
printf("h5dump DATASPACE SIMPLE found\n");
|
|
#endif
|
|
if (fscanf(strm, "%s", temp) != 1) { /* start bracket */
|
|
(void) HDfprintf(stderr, err6b, infile);
|
|
goto error;
|
|
}
|
|
#ifdef H5DEBUGIMPORT
|
|
printf("h5dump DATASPACE SIMPLE %s found\n", temp);
|
|
#endif
|
|
if (fscanf(strm, "%s", temp) != 1) { /* start paren */
|
|
(void) HDfprintf(stderr, err6b, infile);
|
|
goto error;
|
|
}
|
|
#ifdef H5DEBUGIMPORT
|
|
printf("h5dump DATASPACE SIMPLE %s found\n", temp);
|
|
#endif
|
|
if(!HDstrcmp("(", temp)) { /* start paren */
|
|
int get_next_dim = 1;
|
|
int i = 0;
|
|
|
|
if (fscanf(strm, "%s", temp) != 1) { /* Dimension with optional comma */
|
|
(void) HDfprintf(stderr, err16c, infile);
|
|
goto error;
|
|
}
|
|
#ifdef H5DEBUGIMPORT
|
|
printf("h5dump DATASPACE SIMPLE %s found\n", temp);
|
|
#endif
|
|
while (get_next_dim) {
|
|
char *more = temp;
|
|
temp_dims[icount] = HDstrtoull(more, &more, 10);
|
|
if (fscanf(strm, "%s", temp) != 1) { /* Dimension or end paren */
|
|
(void) HDfprintf(stderr, err6b, infile);
|
|
goto error;
|
|
}
|
|
#ifdef H5DEBUGIMPORT
|
|
printf("h5dump DATASPACE SIMPLE %s found\n", temp);
|
|
#endif
|
|
if(!HDstrcmp(")", temp)) { /* end paren */
|
|
in->rank = ++icount;
|
|
in->configOptionVector[RANK] = 1;
|
|
get_next_dim = 0;
|
|
}
|
|
else { /* Dimension */
|
|
icount++;
|
|
if (icount > MAX_NUM_DIMENSION) {
|
|
(void) HDfprintf(stderr, "Invalid value for rank.\n");
|
|
goto error;
|
|
}
|
|
}
|
|
} /* while (get_next_dim) */
|
|
|
|
if ((in->sizeOfDimension = (hsize_t *) HDmalloc ((size_t) in->rank * sizeof(hsize_t))) == NULL) {
|
|
goto error;
|
|
}
|
|
#ifdef H5DEBUGIMPORT
|
|
printf("h5dump DATASPACE SIMPLE %d rank\n", in->rank);
|
|
#endif
|
|
for (i = 0; i < in->rank; i++) {
|
|
in->sizeOfDimension[i] = temp_dims[i];
|
|
}
|
|
#ifdef H5DEBUGIMPORT
|
|
printf("h5dump DATASPACE SIMPLE dims:", in->rank);
|
|
for (pndx = 0; pndx < in->rank; pndx++) {
|
|
printf(" %d", in->sizeOfDimension[pndx]);
|
|
}
|
|
printf("\n");
|
|
#endif
|
|
in->configOptionVector[DIM] = 1;
|
|
} /* if(!HDstrcmp("(", key)) start paren */
|
|
else {
|
|
(void) HDfprintf(stderr, err5b, infile);
|
|
goto error;
|
|
}
|
|
if (fscanf(strm, "%s", temp) != 1) {
|
|
(void) HDfprintf(stderr, "%s", err18);
|
|
goto error;
|
|
}
|
|
#ifdef H5DEBUGIMPORT
|
|
printf("h5dump DATASPACE SIMPLE %s found\n", temp);
|
|
#endif
|
|
if(!HDstrcmp("/", temp)) { /* / max dims */
|
|
if ((in->maxsizeOfDimension = (hsize_t *) HDmalloc ((size_t) in->rank * sizeof(hsize_t))) == NULL) {
|
|
goto error;
|
|
}
|
|
if (fscanf(strm, "%s", temp) != 1) { /* start paren */
|
|
(void) HDfprintf(stderr, err6b, infile);
|
|
goto error;
|
|
}
|
|
#ifdef H5DEBUGIMPORT
|
|
printf("h5dump DATASPACE SIMPLE %s found\n", temp);
|
|
#endif
|
|
if(!HDstrcmp("(", temp)) { /* start paren */
|
|
int get_next_dim = 1;
|
|
int i = 0;
|
|
|
|
#ifdef H5DEBUGIMPORT
|
|
printf("h5dump DATASPACE SIMPLE process max dim values\n");
|
|
#endif
|
|
if (fscanf(strm, "%s", temp) != 1) { /* max dim with optional comma */
|
|
(void) HDfprintf(stderr, err16c, infile);
|
|
goto error;
|
|
}
|
|
#ifdef H5DEBUGIMPORT
|
|
printf("h5dump DATASPACE SIMPLE %s found\n", temp);
|
|
#endif
|
|
while (get_next_dim) {
|
|
#ifdef H5DEBUGIMPORT
|
|
printf("h5dump DATASPACE SIMPLE get max dim value\n");
|
|
#endif
|
|
if(!HDstrcmp("H5S_UNLIMITED", temp) || !HDstrcmp("H5S_UNLIMITED,", temp)) { /* unlimited */
|
|
in->maxsizeOfDimension[i] = H5S_UNLIMITED;
|
|
in->configOptionVector[EXTEND] = 1;
|
|
}
|
|
else {
|
|
char *more = temp;
|
|
in->maxsizeOfDimension[i] = HDstrtoull(more, &more, 10);
|
|
}
|
|
if (fscanf(strm, "%s", temp) != 1) { /* max dim or end paren */
|
|
(void) HDfprintf(stderr, err16c, infile);
|
|
goto error;
|
|
}
|
|
#ifdef H5DEBUGIMPORT
|
|
printf("h5dump DATASPACE SIMPLE %s found\n", temp);
|
|
#endif
|
|
if(!HDstrcmp(")", temp)) { /* end paren */
|
|
get_next_dim = 0;
|
|
}
|
|
else { /* comma */
|
|
i++;
|
|
if (i > MAX_NUM_DIMENSION) {
|
|
(void) HDfprintf(stderr, "Invalid value for rank.\n");
|
|
goto error;
|
|
}
|
|
}
|
|
} /* while (get_next_dim) */
|
|
#ifdef H5DEBUGIMPORT
|
|
printf("h5dump DATASPACE SIMPLE maxdims:", in->rank);
|
|
for (pndx = 0; pndx < in->rank; pndx++) {
|
|
printf(" %d", in->maxsizeOfDimension[pndx]);
|
|
}
|
|
printf("\n");
|
|
printf("h5dump DATASPACE SIMPLE get max dim finished\n");
|
|
#endif
|
|
} /* if(!HDstrcmp("(", key)) start paren */
|
|
else {
|
|
(void) HDfprintf(stderr, err16c, infile);
|
|
goto error;
|
|
}
|
|
scanret = fscanf(strm, "%s", temp); /* end bracket */
|
|
#ifdef H5DEBUGIMPORT
|
|
printf("h5dump DATASPACE SIMPLE %s found\n", temp);
|
|
#endif
|
|
} /* if(!HDstrcmp("/", key)) max dims separator */
|
|
} /* else if(!HDstrcmp("SIMPLE", key)) */
|
|
else {
|
|
(void) HDfprintf(stderr, err5b, infile);
|
|
goto error;
|
|
}
|
|
} /* else if(!HDstrcmp("DATASPACE", key)) RANK and DIMENSIONS */
|
|
else if(!HDstrcmp("STORAGE_LAYOUT", key)) { /* CHUNKED-DIMENSION-SIZES */
|
|
#ifdef H5DEBUGIMPORT
|
|
printf("h5dump STORAGE_LAYOUT key\n");
|
|
#endif
|
|
if (fscanf(strm, "%s", temp) != 1) { /* start bracket */
|
|
(void) HDfprintf(stderr, err6b, infile);
|
|
goto error;
|
|
}
|
|
#ifdef H5DEBUGIMPORT
|
|
printf("h5dump STORAGE_LAYOUT %s found\n", temp);
|
|
#endif
|
|
if (fscanf(strm, "%s", temp) != 1) { /* CHUNKED */
|
|
(void) HDfprintf(stderr, err6b, infile);
|
|
goto error;
|
|
}
|
|
#ifdef H5DEBUGIMPORT
|
|
printf("h5dump STORAGE_LAYOUT %s found\n", temp);
|
|
#endif
|
|
if(!HDstrcmp("CHUNKED", temp)) { /* CHUNKED */
|
|
if ((in->sizeOfChunk = (hsize_t *) HDmalloc ((size_t) in->rank * sizeof(hsize_t))) == NULL) {
|
|
(void) HDfprintf(stderr, "Unable to allocate dynamic memory.\n");
|
|
goto error;
|
|
}
|
|
if (fscanf(strm, "%s", temp) != 1) { /* start paren */
|
|
(void) HDfprintf(stderr, err6b, infile);
|
|
goto error;
|
|
}
|
|
#ifdef H5DEBUGIMPORT
|
|
printf("h5dump STORAGE_LAYOUT CHUNKED %s found\n", temp);
|
|
#endif
|
|
if(!HDstrcmp("(", temp)) { /* start paren */
|
|
int get_next_dim = 1;
|
|
int icount = 0;
|
|
|
|
if (fscanf(strm, "%s", temp) != 1) { /* Dimension with optional comma */
|
|
(void) HDfprintf(stderr, err16c, infile);
|
|
goto error;
|
|
}
|
|
#ifdef H5DEBUGIMPORT
|
|
printf("h5dump STORAGE_LAYOUT CHUNKED %s found\n", temp);
|
|
#endif
|
|
while (get_next_dim) {
|
|
char *more = temp;
|
|
in->sizeOfChunk[icount] = HDstrtoull(more, &more, 10);
|
|
if (fscanf(strm, "%s", temp) != 1) { /* Dimension or end paren */
|
|
(void) HDfprintf(stderr, err6b, infile);
|
|
goto error;
|
|
}
|
|
#ifdef H5DEBUGIMPORT
|
|
printf("h5dump STORAGE_LAYOUT CHUNKED %s found\n", temp);
|
|
#endif
|
|
if(!HDstrcmp(")", temp)) { /* end paren */
|
|
in->configOptionVector[RANK] = 1;
|
|
get_next_dim = 0;
|
|
}
|
|
else { /* Dimension */
|
|
icount++;
|
|
if (icount > MAX_NUM_DIMENSION) {
|
|
(void) HDfprintf(stderr, "Invalid value for rank.\n");
|
|
goto error;
|
|
}
|
|
}
|
|
} /* while (get_next_dim) */
|
|
#ifdef H5DEBUGIMPORT
|
|
printf("h5dump STORAGE_LAYOUT CHUNKED dims:", in->rank);
|
|
for (pndx = 0; pndx < in->rank; pndx++) {
|
|
printf(" %d", in->sizeOfChunk[pndx]);
|
|
}
|
|
printf("\n");
|
|
#endif
|
|
in->configOptionVector[DIM] = 1;
|
|
} /* if(!HDstrcmp("(", key)) start paren */
|
|
else {
|
|
(void) HDfprintf(stderr, err5b, infile);
|
|
goto error;
|
|
}
|
|
if (fscanf(strm, "%s", temp) != 1) { /* SIZE */
|
|
(void) HDfprintf(stderr, err6b, infile);
|
|
goto error;
|
|
}
|
|
#ifdef H5DEBUGIMPORT
|
|
printf("h5dump STORAGE_LAYOUT CHUNKED %s found\n", temp);
|
|
#endif
|
|
if(!HDstrcmp("SIZE", temp)) { /* SIZE */
|
|
if (fscanf(strm, "%d", (&ival)) != 1) {
|
|
(void) HDfprintf(stderr, "%s", err19);
|
|
goto error;
|
|
}
|
|
#ifdef H5DEBUGIMPORT
|
|
printf("h5dump STORAGE_LAYOUT CHUNKED SIZE %d found\n", ival);
|
|
#endif
|
|
}
|
|
while (HDstrcmp("}", temp)) {
|
|
if (fscanf(strm, "%s", temp) != 1) { /* end bracket */
|
|
(void) HDfprintf(stderr, "%s", err18);
|
|
goto error;
|
|
}
|
|
#ifdef H5DEBUGIMPORT
|
|
printf("h5dump STORAGE_LAYOUT CHUNKED %s found\n", temp);
|
|
#endif
|
|
}
|
|
in->configOptionVector[CHUNK] = 1;
|
|
} /* if(!HDstrcmp("CHUNKED", key)) CHUNKED */
|
|
} /* else if(!HDstrcmp("STORAGE_LAYOUT", key)) CHUNKED-DIMENSION-SIZES */
|
|
else if(!HDstrcmp("FILTERS", key)) { /* FILTERS */
|
|
#ifdef H5DEBUGIMPORT
|
|
printf("h5dump FILTERS key\n");
|
|
#endif
|
|
if (fscanf(strm, "%s", temp) != 1) { /* start bracket */
|
|
(void) HDfprintf(stderr, err6b, infile);
|
|
goto error;
|
|
}
|
|
#ifdef H5DEBUGIMPORT
|
|
printf("h5dump FILTERS %s found\n", temp);
|
|
#endif
|
|
if (fscanf(strm, "%s", temp) != 1) {
|
|
(void) HDfprintf(stderr, err6b, infile);
|
|
goto error;
|
|
}
|
|
#ifdef H5DEBUGIMPORT
|
|
printf("h5dump FILTERS %s found\n", temp);
|
|
#endif
|
|
if(!HDstrcmp("COMPRESSION", temp)) { /* COMPRESSION */
|
|
#ifdef H5DEBUGIMPORT
|
|
printf("h5dump FILTERS COMPRESSION found\n");
|
|
#endif
|
|
if (fscanf(strm, "%s", temp) != 1) { /* DEFLATE */
|
|
(void) HDfprintf(stderr, "%s", err18);
|
|
goto error;
|
|
}
|
|
#ifdef H5DEBUGIMPORT
|
|
printf("h5dump FILTERS COMPRESSION %s found\n", temp);
|
|
#endif
|
|
if (fscanf(strm, "%s", temp) != 1) { /* bgin bracket */
|
|
(void) HDfprintf(stderr, "%s", err18);
|
|
goto error;
|
|
}
|
|
#ifdef H5DEBUGIMPORT
|
|
printf("h5dump FILTERS COMPRESSION %s found\n", temp);
|
|
#endif
|
|
if (fscanf(strm, "%s", temp) != 1) { /* LEVEL */
|
|
(void) HDfprintf(stderr, "%s", err18);
|
|
goto error;
|
|
}
|
|
#ifdef H5DEBUGIMPORT
|
|
printf("h5dump FILTERS COMPRESSION %s found\n", temp);
|
|
#endif
|
|
if (fscanf(strm, "%d", (&ival)) != 1) {
|
|
(void) HDfprintf(stderr, "%s", err19);
|
|
goto error;
|
|
}
|
|
#ifdef H5DEBUGIMPORT
|
|
printf("h5dump FILTERS COMPRESSION LEVEL %d found\n", ival);
|
|
#endif
|
|
in->compressionParam = ival;
|
|
if (fscanf(strm, "%s", temp) != 1) { /* end bracket */
|
|
(void) HDfprintf(stderr, "%s", err18);
|
|
goto error;
|
|
}
|
|
#ifdef H5DEBUGIMPORT
|
|
printf("h5dump FILTERS COMPRESSION %s found\n", temp);
|
|
#endif
|
|
in->compressionType = 0; /* ONLY GZIP supported */
|
|
in->configOptionVector[COMPRESS] = 1;
|
|
}
|
|
else if(!HDstrcmp("CONTIGUOUS", temp)) { /* CONTIGUOUS */
|
|
#ifdef H5DEBUGIMPORT
|
|
printf("h5dump FILTERS CONTIGUOUS found\n");
|
|
#endif
|
|
in->configOptionVector[COMPRESS] = 0;
|
|
}
|
|
else if(!HDstrcmp("NONE", temp)) { /* NONE */
|
|
#ifdef H5DEBUGIMPORT
|
|
printf("h5dump FILTERS NONE found\n");
|
|
#endif
|
|
in->configOptionVector[COMPRESS] = 0;
|
|
}
|
|
if (fscanf(strm, "%s", temp) != 1) { /* end bracket */
|
|
(void) HDfprintf(stderr, "%s", err18);
|
|
goto error;
|
|
}
|
|
#ifdef H5DEBUGIMPORT
|
|
printf("h5dump FILTERS %s found\n", temp);
|
|
#endif
|
|
}
|
|
else if(!HDstrcmp("DATA", key)) { /* FINSHED */
|
|
#ifdef H5DEBUGIMPORT
|
|
printf("h5dump DATA key\n");
|
|
#endif
|
|
scanret = 0;
|
|
break;
|
|
}
|
|
scanret = fscanf(strm, "%s", key);
|
|
}
|
|
#ifdef H5DEBUGIMPORT
|
|
printf("h5dump path");
|
|
for (pndx = 0; pndx < in->path.count; pndx++) {
|
|
printf(" : %s", in->path.group[pndx]);
|
|
}
|
|
printf("\n");
|
|
printf("h5dump inputClass=%d\n", in->inputClass);
|
|
printf("h5dump inputSize=%d\n", in->inputSize);
|
|
printf("h5dump rank=%d\n", in->rank);
|
|
printf("h5dump outputClass=%d\n", in->outputClass);
|
|
printf("h5dump outputSize=%d\n", in->outputSize);
|
|
printf("h5dump outputArchitecture=%d\n", in->outputArchitecture);
|
|
printf("h5dump outputByteOrder=%d\n", in->outputByteOrder);
|
|
printf("h5dump compressionType=%d\n", in->compressionType);
|
|
printf("h5dump compressionParam=%d\n", in->compressionParam);
|
|
printf("h5dump externFilename=%s\n", in->externFilename);
|
|
printf("h5dump configOptionVector:\n");
|
|
for (pndx = 0; pndx < NUM_KEYS; pndx++) {
|
|
printf(" %s=%d\n", keytable[pndx], in->configOptionVector[pndx]);
|
|
}
|
|
#endif
|
|
}
|
|
else {
|
|
while (scanret == 1) {
|
|
if ((kindex = mapKeywordToIndex(key)) == -1) {
|
|
(void) HDfprintf(stderr, err2, infile);
|
|
goto error;
|
|
}
|
|
switch (kindex) {
|
|
case 0: /* PATH */
|
|
if (in->configOptionVector[PATH] == 1) {
|
|
(void) HDfprintf(stderr, err3a, infile);
|
|
goto error;
|
|
}
|
|
if (fscanf(strm, "%s", temp) != 1) {
|
|
(void) HDfprintf(stderr, "%s", err18);
|
|
goto error;
|
|
}
|
|
if (parsePathInfo(&in->path, temp) == -1) {
|
|
(void) HDfprintf(stderr, err3b, infile);
|
|
goto error;
|
|
}
|
|
in->configOptionVector[PATH] = 1;
|
|
break;
|
|
|
|
case 1: /* INPUT-CLASS */
|
|
if (in->configOptionVector[INPUT_CLASS] == 1) {
|
|
(void) HDfprintf(stderr, err4a, infile);
|
|
goto error;
|
|
}
|
|
|
|
if (fscanf(strm, "%s", temp) != 1) {
|
|
(void) HDfprintf(stderr, "%s", err18);
|
|
goto error;
|
|
}
|
|
if (getInputClass(in, temp) == -1) {
|
|
(void) HDfprintf(stderr, err4b, infile);
|
|
goto error;
|
|
}
|
|
|
|
in->configOptionVector[INPUT_CLASS] = 1;
|
|
|
|
/*set default value for output-class */
|
|
if (in->configOptionVector[OUTPUT_CLASS] == 0) {
|
|
if (in->inputClass == 0 || in->inputClass == 4)
|
|
in->outputClass = 0;
|
|
if (in->inputClass == 1 || in->inputClass == 2
|
|
|| in->inputClass == 3)
|
|
in->outputClass = 1;
|
|
if (in->inputClass == 6 || in->inputClass == 7)
|
|
in->outputClass = 2;
|
|
}
|
|
break;
|
|
|
|
case 2: /* INPUT-SIZE */
|
|
if (in->configOptionVector[INPUT_SIZE] == 1) {
|
|
(void) HDfprintf(stderr, err5a, infile);
|
|
goto error;
|
|
}
|
|
if (fscanf(strm, "%d", (&ival)) != 1) {
|
|
(void) HDfprintf(stderr, "%s", err19);
|
|
goto error;
|
|
}
|
|
if (getInputSize(in, ival) == -1) {
|
|
(void) HDfprintf(stderr, err5b, infile);
|
|
goto error;
|
|
}
|
|
in->configOptionVector[INPUT_SIZE] = 1;
|
|
|
|
/*set default value for output-size */
|
|
if (in->configOptionVector[OUTPUT_SIZE] == 0)
|
|
in->outputSize = in->inputSize;
|
|
break;
|
|
|
|
case 3: /* RANK */
|
|
if (in->configOptionVector[RANK] == 1) {
|
|
(void) HDfprintf(stderr, err6a, infile);
|
|
goto error;
|
|
}
|
|
|
|
if (getRank(in, strm) == -1) {
|
|
(void) HDfprintf(stderr, err6b, infile);
|
|
goto error;
|
|
}
|
|
in->configOptionVector[RANK] = 1;
|
|
break;
|
|
|
|
case 4: /* DIMENSION-SIZES */
|
|
if (in->configOptionVector[DIM] == 1) {
|
|
(void) HDfprintf(stderr, err7a, infile);
|
|
goto error;
|
|
}
|
|
|
|
if (in->configOptionVector[RANK] == 0) {
|
|
(void) HDfprintf(stderr, err7b, infile);
|
|
goto error;
|
|
}
|
|
if (getDimensionSizes(in, strm) == -1) {
|
|
(void) HDfprintf(stderr, err7c, infile);
|
|
goto error;
|
|
}
|
|
in->configOptionVector[DIM] = 1;
|
|
break;
|
|
|
|
case 5: /* OUTPUT-CLASS */
|
|
if (in->configOptionVector[OUTPUT_CLASS] == 1) {
|
|
(void) HDfprintf(stderr, err8a, infile);
|
|
goto error;
|
|
}
|
|
|
|
if (getOutputClass(in, strm) == -1) {
|
|
(void) HDfprintf(stderr, err8b, infile);
|
|
goto error;
|
|
}
|
|
in->configOptionVector[OUTPUT_CLASS] = 1;
|
|
break;
|
|
|
|
case 6: /* OUTPUT-SIZE */
|
|
if (in->configOptionVector[OUTPUT_SIZE] == 1) {
|
|
(void) HDfprintf(stderr, err9a, infile);
|
|
goto error;
|
|
}
|
|
|
|
if (getOutputSize(in, strm) == -1) {
|
|
(void) HDfprintf(stderr, err9b, infile);
|
|
goto error;
|
|
}
|
|
in->configOptionVector[OUTPUT_SIZE] = 1;
|
|
break;
|
|
|
|
case 7: /* OUTPUT-ARCHITECTURE */
|
|
if (in->configOptionVector[OUTPUT_ARCH] == 1) {
|
|
(void) HDfprintf(stderr, err10a, infile);
|
|
goto error;
|
|
}
|
|
|
|
if (getOutputArchitecture(in, strm) == -1) {
|
|
(void) HDfprintf(stderr, err10b, infile);
|
|
goto error;
|
|
}
|
|
in->configOptionVector[OUTPUT_ARCH] = 1;
|
|
break;
|
|
|
|
case 8: /* OUTPUT-BYTE-ORDER */
|
|
if (in->configOptionVector[OUTPUT_B_ORDER] == 1) {
|
|
(void) HDfprintf(stderr, err11a, infile);
|
|
goto error;
|
|
}
|
|
|
|
if (getOutputByteOrder(in, strm) == -1) {
|
|
(void) HDfprintf(stderr, err11b, infile);
|
|
goto error;
|
|
}
|
|
in->configOptionVector[OUTPUT_B_ORDER] = 1;
|
|
break;
|
|
|
|
case 9: /* CHUNKED-DIMENSION-SIZES */
|
|
if (in->configOptionVector[CHUNK] == 1) {
|
|
(void) HDfprintf(stderr, err12a, infile);
|
|
goto error;
|
|
}
|
|
/* cant appear before dimension sizes have been provided */
|
|
if (in->configOptionVector[DIM] == 0) {
|
|
(void) HDfprintf(stderr, err12b, infile);
|
|
goto error;
|
|
}
|
|
|
|
if (getChunkedDimensionSizes(in, strm) == -1) {
|
|
(void) HDfprintf(stderr, err12c, infile);
|
|
goto error;
|
|
}
|
|
in->configOptionVector[CHUNK] = 1;
|
|
break;
|
|
|
|
case 10: /* COMPRESSION-TYPE */
|
|
if (in->configOptionVector[COMPRESS] == 1) {
|
|
(void) HDfprintf(stderr, err13a, infile);
|
|
goto error;
|
|
}
|
|
|
|
if (getCompressionType(in, strm) == -1) {
|
|
(void) HDfprintf(stderr, err13b, infile);
|
|
goto error;
|
|
}
|
|
in->configOptionVector[COMPRESS] = 1;
|
|
|
|
if (in->configOptionVector[COMPRESS_PARAM] == 0) {
|
|
if (in->compressionType == 0)
|
|
in->compressionParam = 6; /* default value if compressionType is GZIP */
|
|
}
|
|
break;
|
|
|
|
case 11: /* COMPRESSION-PARAM */
|
|
if (in->configOptionVector[COMPRESS_PARAM] == 1) {
|
|
(void) HDfprintf(stderr, err14a, infile);
|
|
goto error;
|
|
}
|
|
|
|
if (getCompressionParameter(in, strm) == -1) {
|
|
(void) HDfprintf(stderr, err14b, infile);
|
|
goto error;
|
|
}
|
|
|
|
in->configOptionVector[COMPRESS_PARAM] = 1;
|
|
|
|
if (in->configOptionVector[COMPRESS] == 0)
|
|
in->compressionType = 0;
|
|
|
|
break;
|
|
|
|
case 12: /* EXTERNAL-STORAGE */
|
|
if (in->configOptionVector[EXTERNALSTORE] == 1) {
|
|
(void) HDfprintf(stderr, err15a, infile);
|
|
goto error;
|
|
}
|
|
|
|
if (getExternalFilename(in, strm) == -1) {
|
|
(void) HDfprintf(stderr, err15b, infile);
|
|
goto error;
|
|
}
|
|
in->configOptionVector[EXTERNALSTORE] = 1;
|
|
break;
|
|
|
|
case 13: /* MAXIMUM-DIMENSIONS */
|
|
if (in->configOptionVector[EXTEND] == 1) {
|
|
(void) HDfprintf(stderr, err16a, infile);
|
|
goto error;
|
|
}
|
|
/* cant appear before dimension sizes have been provided */
|
|
if (in->configOptionVector[DIM] == 0) {
|
|
(void) HDfprintf(stderr, err16b, infile);
|
|
goto error;
|
|
}
|
|
if (getMaximumDimensionSizes(in, strm) == -1) {
|
|
(void) HDfprintf(stderr, err16c, infile);
|
|
goto error;
|
|
}
|
|
in->configOptionVector[EXTEND] = 1;
|
|
break;
|
|
|
|
default:
|
|
break;
|
|
}
|
|
scanret = fscanf(strm, "%s", key);
|
|
}
|
|
}
|
|
|
|
/*
|
|
check if keywords obtained are valid
|
|
if yes, return 0 else error
|
|
*/
|
|
|
|
if (validateConfigurationParameters(in) == -1) {
|
|
(void) HDfprintf(stderr, err17, infile);
|
|
goto error;
|
|
}
|
|
|
|
/* Set success return value */
|
|
retval = 0;
|
|
|
|
error:
|
|
if(strm)
|
|
HDfclose(strm);
|
|
return(retval);
|
|
}
|
|
|
|
static int validateConfigurationParameters(struct Input *in)
|
|
{
|
|
const char *err1 = "One or more of the required fields (RANK, DIMENSION-SIZES) missing.\n";
|
|
const char *err2 = "Cannot specify chunking or compression or extendible data sets with the external file option.\n";
|
|
const char *err3 = "Cannot specify the compression or the extendible data sets without the chunking option.\n";
|
|
const char *err4a = "OUTPUT-ARCHITECTURE cannot be STD if OUTPUT-CLASS is floating point (FP).\n";
|
|
const char *err4b = "OUTPUT-ARCHITECTURE cannot be IEEE if OUTPUT-CLASS is integer (IN).\n";
|
|
const char *err5 = "For OUTPUT-CLASS FP, valid values for OUTPUT-SIZE are (32, 64) .\n";
|
|
#ifndef H5_SIZEOF_LONG_LONG
|
|
const char *err6 = "No support for reading 64-bit integer (INPUT-CLASS: IN, TEXTIN, UIN, TEXTUIN files\n";
|
|
#endif
|
|
|
|
/* for class STR other parameters are ignored */
|
|
if (in->inputClass == 5) /* STR */
|
|
return (0);
|
|
|
|
if ((in->configOptionVector[DIM] != 1) || (in->configOptionVector[RANK] != 1)) {
|
|
(void) HDfprintf(stderr, "%s", err1);
|
|
return (-1);
|
|
}
|
|
|
|
if (in->configOptionVector[EXTERNALSTORE] == 1) {
|
|
if ((in->configOptionVector[COMPRESS] == 1) || (in->configOptionVector[CHUNK] == 1) || (in->configOptionVector[EXTEND] == 1)) {
|
|
(void) HDfprintf(stderr, "%s", err2);
|
|
return (-1);
|
|
}
|
|
}
|
|
|
|
if ((in->configOptionVector[COMPRESS] == 1) || (in->configOptionVector[EXTEND] == 1)) {
|
|
if (in->configOptionVector[CHUNK] != 1) {
|
|
(void) HDfprintf(stderr, "%s", err3);
|
|
return (-1);
|
|
}
|
|
}
|
|
|
|
/* Arch cant be STD if O/p class is FP */
|
|
if (in->outputArchitecture == 1)
|
|
if (in->outputClass == 1) {
|
|
(void) HDfprintf(stderr, "%s", err4a);
|
|
return (-1);
|
|
}
|
|
|
|
/* Arch cant be IEEE if O/p class is IN */
|
|
if (in->outputArchitecture == 2)
|
|
if (in->outputClass == 0) {
|
|
(void) HDfprintf(stderr, "%s", err4b);
|
|
return (-1);
|
|
}
|
|
|
|
if (in->outputClass == 1)
|
|
if (in->outputSize != 32 && in->outputSize != 64) {
|
|
(void) HDfprintf(stderr, "%s", err5);
|
|
return (-1);
|
|
}
|
|
|
|
#ifndef H5_SIZEOF_LONG_LONG
|
|
if (in->inputSize == 64 && (in->inputClass == 0 || in->inputClass == 4 || in->inputClass == 6 || in->inputClass == 7) ) {
|
|
(void) HDfprintf(stderr, "%s", err6);
|
|
return -1;
|
|
}
|
|
#endif
|
|
return (0);
|
|
}
|
|
|
|
static int mapKeywordToIndex(char *key)
|
|
{
|
|
int i;
|
|
|
|
for (i = 0; i < NUM_KEYS; i++)
|
|
if (!HDstrcmp(keytable[i], key))
|
|
return i;
|
|
return -1;
|
|
}
|
|
|
|
static int parsePathInfo(struct path_info *path, char *temp)
|
|
{
|
|
const char delimiter[] = "/\"";
|
|
char *token;
|
|
int i = 0;
|
|
const char *err1 = "Path string larger than MAX_PATH_NAME_LENGTH.\n";
|
|
|
|
token = HDstrtok (temp, delimiter);
|
|
if (HDstrlen(token) >= MAX_PATH_NAME_LENGTH) {
|
|
(void) HDfprintf(stderr, err1);
|
|
return (-1);
|
|
}
|
|
HDstrcpy(path->group[i++],token);
|
|
|
|
while (1) {
|
|
token = HDstrtok (NULL, delimiter);
|
|
if (token == NULL)
|
|
break;
|
|
if (HDstrlen(token) >= MAX_PATH_NAME_LENGTH) {
|
|
(void) HDfprintf(stderr, err1);
|
|
return (-1);
|
|
}
|
|
HDstrcpy(path->group[i++],token);
|
|
}
|
|
path->count = i;
|
|
return (0);
|
|
}
|
|
|
|
static int parseDimensions(struct Input *in, char *strm)
|
|
{
|
|
const char delimiter[] = ",";
|
|
char temp[255];
|
|
char *token;
|
|
int i = 0;
|
|
const char *err1 = "Unable to allocate dynamic memory.\n";
|
|
|
|
HDstrncpy(temp, strm, sizeof(temp));
|
|
temp[sizeof(temp) - 1] = '\0';
|
|
HDstrtok (temp, delimiter);
|
|
|
|
while (1) {
|
|
token = HDstrtok (NULL, delimiter);
|
|
if (token == NULL)
|
|
break;
|
|
i++;
|
|
}
|
|
in->rank = i + 1;
|
|
if ((in->sizeOfDimension = (hsize_t *) HDmalloc ((size_t) in->rank * sizeof(hsize_t))) == NULL) {
|
|
(void) HDfprintf(stderr, "%s", err1);
|
|
return (-1);
|
|
}
|
|
|
|
i = 0;
|
|
HDstrncpy(temp, strm, sizeof(temp));
|
|
temp[sizeof(temp) - 1] = '\0';
|
|
in->sizeOfDimension[i++]
|
|
= HDstrtol(HDstrtok (temp, delimiter), NULL, BASE_10);
|
|
|
|
while (1) {
|
|
token = HDstrtok (NULL, delimiter);
|
|
if (token == NULL)
|
|
break;
|
|
in->sizeOfDimension[i++] = HDstrtol(token, NULL, BASE_10);
|
|
}
|
|
return (0);
|
|
}
|
|
|
|
static int getOutputClass(struct Input *in, FILE *strm)
|
|
{
|
|
char temp[255];
|
|
int kindex;
|
|
const char *err1 = "Unable to get 'string' value.\n";
|
|
const char *err2 = "Invalid value for output class.\n";
|
|
|
|
if (fscanf(strm, "%s", temp) != 1) {
|
|
(void) HDfprintf(stderr, "%s", err1);
|
|
return (-1);
|
|
}
|
|
|
|
if ((kindex = OutputClassStrToInt(temp)) == -1) {
|
|
(void) HDfprintf(stderr, "%s", err2);
|
|
return (-1);
|
|
}
|
|
|
|
in->outputClass = kindex;
|
|
return (0);
|
|
}
|
|
|
|
static int OutputClassStrToInt(char *temp)
|
|
{
|
|
int i;
|
|
char classKeywordTable[3][15] = { "IN", "FP", "UIN" };
|
|
for (i = 0; i < 3; i++)
|
|
if (!HDstrcmp(classKeywordTable[i], temp))
|
|
return i;
|
|
|
|
return -1;
|
|
}
|
|
/* same as getInputSize. But defined separately for extensibility */
|
|
static int getOutputSize(struct Input *in, FILE *strm)
|
|
{
|
|
int ival;
|
|
int i;
|
|
int outputSizeValidValues[4] = { 8, 16, 32, 64 };
|
|
const char *err1 = "Unable to get integer value.\n";
|
|
const char *err2 = "Invalid value for output size.\n";
|
|
|
|
if (fscanf(strm, "%d", (&ival)) != 1) {
|
|
(void) HDfprintf(stderr, "%s", err1);
|
|
return (-1);
|
|
}
|
|
|
|
for (i = 0; i < 4; i++)
|
|
if (outputSizeValidValues[i] == ival) {
|
|
in->outputSize = ival;
|
|
return (0);
|
|
}
|
|
(void) HDfprintf(stderr, "%s", err2);
|
|
return (-1);
|
|
}
|
|
|
|
static int getInputClass(struct Input *in, char * temp)
|
|
{
|
|
int kindex;
|
|
const char *err1 = "Invalid value for input class.\n";
|
|
|
|
if ((kindex = InputClassStrToInt(temp)) == -1) {
|
|
(void) HDfprintf(stderr, "%s", err1);
|
|
return (-1);
|
|
}
|
|
|
|
in->inputClass = kindex;
|
|
return (0);
|
|
}
|
|
|
|
static int getInputClassType(struct Input *in, char * buffer)
|
|
{
|
|
int kindex = -1;
|
|
const char *err1 = "Invalid value for input class.\n";
|
|
const char *err2 = "Invalid value for output architecture.\n";
|
|
const char *err3 = "Invalid value for output byte-order.\n";
|
|
|
|
if (!HDstrcmp(buffer, "H5T_STD_I8BE")) {
|
|
in->inputSize = 8;
|
|
in->configOptionVector[INPUT_SIZE] = 1;
|
|
|
|
if ((kindex = OutputArchStrToInt("STD")) == -1) {
|
|
(void) HDfprintf(stderr, "%s", err2);
|
|
return (-1);
|
|
}
|
|
in->outputArchitecture = kindex;
|
|
|
|
if ((kindex = OutputByteOrderStrToInt("BE")) == -1) {
|
|
(void) HDfprintf(stderr, "%s", err3);
|
|
return (-1);
|
|
}
|
|
in->outputByteOrder = kindex;
|
|
|
|
kindex = 4;
|
|
}
|
|
else if (!HDstrcmp(buffer, "H5T_STD_I8LE")) {
|
|
in->inputSize = 8;
|
|
in->configOptionVector[INPUT_SIZE] = 1;
|
|
|
|
if ((kindex = OutputArchStrToInt("STD")) == -1) {
|
|
(void) HDfprintf(stderr, "%s", err2);
|
|
return (-1);
|
|
}
|
|
in->outputArchitecture = kindex;
|
|
|
|
if ((kindex = OutputByteOrderStrToInt("LE")) == -1) {
|
|
(void) HDfprintf(stderr, "%s", err3);
|
|
return (-1);
|
|
}
|
|
in->outputByteOrder = kindex;
|
|
|
|
kindex = 4;
|
|
}
|
|
else if (!HDstrcmp(buffer, "H5T_STD_I16BE")) {
|
|
in->inputSize = 16;
|
|
in->configOptionVector[INPUT_SIZE] = 1;
|
|
|
|
if ((kindex = OutputArchStrToInt("STD")) == -1) {
|
|
(void) HDfprintf(stderr, "%s", err2);
|
|
return (-1);
|
|
}
|
|
in->outputArchitecture = kindex;
|
|
|
|
if ((kindex = OutputByteOrderStrToInt("BE")) == -1) {
|
|
(void) HDfprintf(stderr, "%s", err3);
|
|
return (-1);
|
|
}
|
|
in->outputByteOrder = kindex;
|
|
|
|
kindex = 4;
|
|
}
|
|
else if (!HDstrcmp(buffer, "H5T_STD_I16LE")) {
|
|
in->inputSize = 16;
|
|
in->configOptionVector[INPUT_SIZE] = 1;
|
|
|
|
if ((kindex = OutputArchStrToInt("STD")) == -1) {
|
|
(void) HDfprintf(stderr, "%s", err2);
|
|
return (-1);
|
|
}
|
|
in->outputArchitecture = kindex;
|
|
|
|
if ((kindex = OutputByteOrderStrToInt("LE")) == -1) {
|
|
(void) HDfprintf(stderr, "%s", err3);
|
|
return (-1);
|
|
}
|
|
in->outputByteOrder = kindex;
|
|
|
|
kindex = 4;
|
|
}
|
|
else if (!HDstrcmp(buffer, "H5T_STD_I32BE")) {
|
|
in->inputSize = 32;
|
|
in->configOptionVector[INPUT_SIZE] = 1;
|
|
|
|
if ((kindex = OutputArchStrToInt("STD")) == -1) {
|
|
(void) HDfprintf(stderr, "%s", err2);
|
|
return (-1);
|
|
}
|
|
in->outputArchitecture = kindex;
|
|
|
|
if ((kindex = OutputByteOrderStrToInt("BE")) == -1) {
|
|
(void) HDfprintf(stderr, "%s", err3);
|
|
return (-1);
|
|
}
|
|
in->outputByteOrder = kindex;
|
|
|
|
kindex = 4;
|
|
}
|
|
else if (!HDstrcmp(buffer, "H5T_STD_I32LE")) {
|
|
in->inputSize = 32;
|
|
in->configOptionVector[INPUT_SIZE] = 1;
|
|
|
|
if ((kindex = OutputArchStrToInt("STD")) == -1) {
|
|
(void) HDfprintf(stderr, "%s", err2);
|
|
return (-1);
|
|
}
|
|
in->outputArchitecture = kindex;
|
|
|
|
if ((kindex = OutputByteOrderStrToInt("LE")) == -1) {
|
|
(void) HDfprintf(stderr, "%s", err3);
|
|
return (-1);
|
|
}
|
|
in->outputByteOrder = kindex;
|
|
|
|
kindex = 4;
|
|
}
|
|
else if (!HDstrcmp(buffer, "H5T_STD_I64BE")) {
|
|
in->inputSize = 64;
|
|
in->configOptionVector[INPUT_SIZE] = 1;
|
|
|
|
if ((kindex = OutputArchStrToInt("STD")) == -1) {
|
|
(void) HDfprintf(stderr, "%s", err2);
|
|
return (-1);
|
|
}
|
|
in->outputArchitecture = kindex;
|
|
|
|
if ((kindex = OutputByteOrderStrToInt("BE")) == -1) {
|
|
(void) HDfprintf(stderr, "%s", err3);
|
|
return (-1);
|
|
}
|
|
in->outputByteOrder = kindex;
|
|
|
|
kindex = 4;
|
|
}
|
|
else if (!HDstrcmp(buffer, "H5T_STD_I64LE")) {
|
|
in->inputSize = 64;
|
|
in->configOptionVector[INPUT_SIZE] = 1;
|
|
|
|
if ((kindex = OutputArchStrToInt("STD")) == -1) {
|
|
(void) HDfprintf(stderr, "%s", err2);
|
|
return (-1);
|
|
}
|
|
in->outputArchitecture = kindex;
|
|
|
|
if ((kindex = OutputByteOrderStrToInt("LE")) == -1) {
|
|
(void) HDfprintf(stderr, "%s", err3);
|
|
return (-1);
|
|
}
|
|
in->outputByteOrder = kindex;
|
|
|
|
kindex = 4;
|
|
}
|
|
else if (!HDstrcmp(buffer, "H5T_STD_U8BE")) {
|
|
in->inputSize = 8;
|
|
in->configOptionVector[INPUT_SIZE] = 1;
|
|
|
|
if ((kindex = OutputArchStrToInt("STD")) == -1) {
|
|
(void) HDfprintf(stderr, "%s", err2);
|
|
return (-1);
|
|
}
|
|
in->outputArchitecture = kindex;
|
|
|
|
if ((kindex = OutputByteOrderStrToInt("BE")) == -1) {
|
|
(void) HDfprintf(stderr, "%s", err3);
|
|
return (-1);
|
|
}
|
|
in->outputByteOrder = kindex;
|
|
|
|
kindex = 7;
|
|
}
|
|
else if (!HDstrcmp(buffer, "H5T_STD_U8LE")) {
|
|
in->inputSize = 8;
|
|
in->configOptionVector[INPUT_SIZE] = 1;
|
|
|
|
if ((kindex = OutputArchStrToInt("STD")) == -1) {
|
|
(void) HDfprintf(stderr, "%s", err2);
|
|
return (-1);
|
|
}
|
|
in->outputArchitecture = kindex;
|
|
|
|
if ((kindex = OutputByteOrderStrToInt("LE")) == -1) {
|
|
(void) HDfprintf(stderr, "%s", err3);
|
|
return (-1);
|
|
}
|
|
in->outputByteOrder = kindex;
|
|
|
|
kindex = 7;
|
|
}
|
|
else if (!HDstrcmp(buffer, "H5T_STD_U16BE")) {
|
|
in->inputSize = 16;
|
|
in->configOptionVector[INPUT_SIZE] = 1;
|
|
|
|
if ((kindex = OutputArchStrToInt("STD")) == -1) {
|
|
(void) HDfprintf(stderr, "%s", err2);
|
|
return (-1);
|
|
}
|
|
in->outputArchitecture = kindex;
|
|
|
|
if ((kindex = OutputByteOrderStrToInt("BE")) == -1) {
|
|
(void) HDfprintf(stderr, "%s", err3);
|
|
return (-1);
|
|
}
|
|
in->outputByteOrder = kindex;
|
|
|
|
kindex = 7;
|
|
}
|
|
else if (!HDstrcmp(buffer, "H5T_STD_U16LE")) {
|
|
in->inputSize = 16;
|
|
in->configOptionVector[INPUT_SIZE] = 1;
|
|
|
|
if ((kindex = OutputArchStrToInt("STD")) == -1) {
|
|
(void) HDfprintf(stderr, "%s", err2);
|
|
return (-1);
|
|
}
|
|
in->outputArchitecture = kindex;
|
|
|
|
if ((kindex = OutputByteOrderStrToInt("LE")) == -1) {
|
|
(void) HDfprintf(stderr, "%s", err3);
|
|
return (-1);
|
|
}
|
|
in->outputByteOrder = kindex;
|
|
|
|
kindex = 7;
|
|
}
|
|
else if (!HDstrcmp(buffer, "H5T_STD_U32BE")) {
|
|
in->inputSize = 32;
|
|
in->configOptionVector[INPUT_SIZE] = 1;
|
|
|
|
if ((kindex = OutputArchStrToInt("STD")) == -1) {
|
|
(void) HDfprintf(stderr, "%s", err2);
|
|
return (-1);
|
|
}
|
|
in->outputArchitecture = kindex;
|
|
|
|
if ((kindex = OutputByteOrderStrToInt("BE")) == -1) {
|
|
(void) HDfprintf(stderr, "%s", err3);
|
|
return (-1);
|
|
}
|
|
in->outputByteOrder = kindex;
|
|
|
|
kindex = 7;
|
|
}
|
|
else if (!HDstrcmp(buffer, "H5T_STD_U32LE")) {
|
|
in->inputSize = 32;
|
|
in->configOptionVector[INPUT_SIZE] = 1;
|
|
|
|
if ((kindex = OutputArchStrToInt("STD")) == -1) {
|
|
(void) HDfprintf(stderr, "%s", err2);
|
|
return (-1);
|
|
}
|
|
in->outputArchitecture = kindex;
|
|
|
|
if ((kindex = OutputByteOrderStrToInt("LE")) == -1) {
|
|
(void) HDfprintf(stderr, "%s", err3);
|
|
return (-1);
|
|
}
|
|
in->outputByteOrder = kindex;
|
|
|
|
kindex = 7;
|
|
}
|
|
else if (!HDstrcmp(buffer, "H5T_STD_U64BE")) {
|
|
in->inputSize = 64;
|
|
in->configOptionVector[INPUT_SIZE] = 1;
|
|
|
|
if ((kindex = OutputArchStrToInt("STD")) == -1) {
|
|
(void) HDfprintf(stderr, "%s", err2);
|
|
return (-1);
|
|
}
|
|
in->outputArchitecture = kindex;
|
|
|
|
if ((kindex = OutputByteOrderStrToInt("BE")) == -1) {
|
|
(void) HDfprintf(stderr, "%s", err3);
|
|
return (-1);
|
|
}
|
|
in->outputByteOrder = kindex;
|
|
|
|
kindex = 7;
|
|
}
|
|
else if (!HDstrcmp(buffer, "H5T_STD_U64LE")) {
|
|
in->inputSize = 64;
|
|
in->configOptionVector[INPUT_SIZE] = 1;
|
|
|
|
if ((kindex = OutputArchStrToInt("STD")) == -1) {
|
|
(void) HDfprintf(stderr, "%s", err2);
|
|
return (-1);
|
|
}
|
|
in->outputArchitecture = kindex;
|
|
|
|
if ((kindex = OutputByteOrderStrToInt("LE")) == -1) {
|
|
(void) HDfprintf(stderr, "%s", err3);
|
|
return (-1);
|
|
}
|
|
in->outputByteOrder = kindex;
|
|
|
|
kindex = 7;
|
|
}
|
|
else if (!HDstrcmp(buffer, "H5T_NATIVE_SCHAR")) {
|
|
in->inputSize = 8;
|
|
in->configOptionVector[INPUT_SIZE] = 1;
|
|
|
|
if ((kindex = OutputArchStrToInt("NATIVE")) == -1) {
|
|
(void) HDfprintf(stderr, "%s", err2);
|
|
return (-1);
|
|
}
|
|
in->outputArchitecture = kindex;
|
|
|
|
kindex = 4;
|
|
}
|
|
else if (!HDstrcmp(buffer, "H5T_NATIVE_UCHAR")) {
|
|
in->inputSize = 8;
|
|
in->configOptionVector[INPUT_SIZE] = 1;
|
|
|
|
if ((kindex = OutputArchStrToInt("NATIVE")) == -1) {
|
|
(void) HDfprintf(stderr, "%s", err2);
|
|
return (-1);
|
|
}
|
|
in->outputArchitecture = kindex;
|
|
|
|
kindex = 7;
|
|
}
|
|
else if (!HDstrcmp(buffer, "H5T_NATIVE_SHORT")) {
|
|
in->inputSize = 16;
|
|
in->configOptionVector[INPUT_SIZE] = 1;
|
|
|
|
if ((kindex = OutputArchStrToInt("NATIVE")) == -1) {
|
|
(void) HDfprintf(stderr, "%s", err2);
|
|
return (-1);
|
|
}
|
|
in->outputArchitecture = kindex;
|
|
|
|
kindex = 4;
|
|
}
|
|
else if (!HDstrcmp(buffer, "H5T_NATIVE_USHORT")) {
|
|
in->inputSize = 16;
|
|
in->configOptionVector[INPUT_SIZE] = 1;
|
|
|
|
if ((kindex = OutputArchStrToInt("NATIVE")) == -1) {
|
|
(void) HDfprintf(stderr, "%s", err2);
|
|
return (-1);
|
|
}
|
|
in->outputArchitecture = kindex;
|
|
|
|
kindex = 7;
|
|
}
|
|
else if (!HDstrcmp(buffer, "H5T_NATIVE_INT")) {
|
|
in->inputSize = 32;
|
|
in->configOptionVector[INPUT_SIZE] = 1;
|
|
|
|
if ((kindex = OutputArchStrToInt("NATIVE")) == -1) {
|
|
(void) HDfprintf(stderr, "%s", err2);
|
|
return (-1);
|
|
}
|
|
in->outputArchitecture = kindex;
|
|
|
|
kindex = 4;
|
|
}
|
|
else if (!HDstrcmp(buffer, "H5T_NATIVE_UINT")) {
|
|
in->inputSize = 32;
|
|
in->configOptionVector[INPUT_SIZE] = 1;
|
|
|
|
if ((kindex = OutputArchStrToInt("NATIVE")) == -1) {
|
|
(void) HDfprintf(stderr, "%s", err2);
|
|
return (-1);
|
|
}
|
|
in->outputArchitecture = kindex;
|
|
|
|
kindex = 7;
|
|
}
|
|
else if (!HDstrcmp(buffer, "H5T_NATIVE_LONG")) {
|
|
in->inputSize = 32;
|
|
in->configOptionVector[INPUT_SIZE] = 1;
|
|
|
|
if ((kindex = OutputArchStrToInt("NATIVE")) == -1) {
|
|
(void) HDfprintf(stderr, "%s", err2);
|
|
return (-1);
|
|
}
|
|
in->outputArchitecture = kindex;
|
|
|
|
kindex = 4;
|
|
}
|
|
else if (!HDstrcmp(buffer, "H5T_NATIVE_ULONG")) {
|
|
in->inputSize = 32;
|
|
in->configOptionVector[INPUT_SIZE] = 1;
|
|
|
|
if ((kindex = OutputArchStrToInt("NATIVE")) == -1) {
|
|
(void) HDfprintf(stderr, "%s", err2);
|
|
return (-1);
|
|
}
|
|
in->outputArchitecture = kindex;
|
|
|
|
kindex = 7;
|
|
}
|
|
else if (!HDstrcmp(buffer, "H5T_NATIVE_LLONG")) {
|
|
in->inputSize = 64;
|
|
in->configOptionVector[INPUT_SIZE] = 1;
|
|
|
|
if ((kindex = OutputArchStrToInt("NATIVE")) == -1) {
|
|
(void) HDfprintf(stderr, "%s", err2);
|
|
return (-1);
|
|
}
|
|
in->outputArchitecture = kindex;
|
|
|
|
kindex = 4;
|
|
}
|
|
else if (!HDstrcmp(buffer, "H5T_NATIVE_ULLONG")) {
|
|
in->inputSize = 64;
|
|
in->configOptionVector[INPUT_SIZE] = 1;
|
|
|
|
if ((kindex = OutputArchStrToInt("NATIVE")) == -1) {
|
|
(void) HDfprintf(stderr, "%s", err2);
|
|
return (-1);
|
|
}
|
|
in->outputArchitecture = kindex;
|
|
|
|
kindex = 7;
|
|
}
|
|
else if (!HDstrcmp(buffer, "H5T_IEEE_F32BE")) {
|
|
in->inputSize = 32;
|
|
in->configOptionVector[INPUT_SIZE] = 1;
|
|
|
|
if ((kindex = OutputArchStrToInt("IEEE")) == -1) {
|
|
(void) HDfprintf(stderr, "%s", err2);
|
|
return (-1);
|
|
}
|
|
in->outputArchitecture = kindex;
|
|
|
|
if ((kindex = OutputByteOrderStrToInt("BE")) == -1) {
|
|
(void) HDfprintf(stderr, "%s", err3);
|
|
return (-1);
|
|
}
|
|
in->outputByteOrder = kindex;
|
|
|
|
kindex = 3;
|
|
}
|
|
else if (!HDstrcmp(buffer, "H5T_IEEE_F32LE")) {
|
|
in->inputSize = 32;
|
|
in->configOptionVector[INPUT_SIZE] = 1;
|
|
|
|
if ((kindex = OutputArchStrToInt("IEEE")) == -1) {
|
|
(void) HDfprintf(stderr, "%s", err2);
|
|
return (-1);
|
|
}
|
|
in->outputArchitecture = kindex;
|
|
|
|
if ((kindex = OutputByteOrderStrToInt("LE")) == -1) {
|
|
(void) HDfprintf(stderr, "%s", err3);
|
|
return (-1);
|
|
}
|
|
in->outputByteOrder = kindex;
|
|
|
|
kindex = 3;
|
|
}
|
|
else if (!HDstrcmp(buffer, "H5T_IEEE_F64BE")) {
|
|
in->inputSize = 64;
|
|
in->configOptionVector[INPUT_SIZE] = 1;
|
|
|
|
if ((kindex = OutputArchStrToInt("IEEE")) == -1) {
|
|
(void) HDfprintf(stderr, "%s", err2);
|
|
return (-1);
|
|
}
|
|
in->outputArchitecture = kindex;
|
|
|
|
if ((kindex = OutputByteOrderStrToInt("BE")) == -1) {
|
|
(void) HDfprintf(stderr, "%s", err3);
|
|
return (-1);
|
|
}
|
|
in->outputByteOrder = kindex;
|
|
|
|
kindex = 3;
|
|
}
|
|
else if (!HDstrcmp(buffer, "H5T_IEEE_F64LE")) {
|
|
in->inputSize = 64;
|
|
in->configOptionVector[INPUT_SIZE] = 1;
|
|
|
|
if ((kindex = OutputArchStrToInt("IEEE")) == -1) {
|
|
(void) HDfprintf(stderr, "%s", err2);
|
|
return (-1);
|
|
}
|
|
in->outputArchitecture = kindex;
|
|
|
|
if ((kindex = OutputByteOrderStrToInt("LE")) == -1) {
|
|
(void) HDfprintf(stderr, "%s", err3);
|
|
return (-1);
|
|
}
|
|
in->outputByteOrder = kindex;
|
|
|
|
kindex = 3;
|
|
}
|
|
else if (!HDstrcmp(buffer, "H5T_VAX_F32")) {
|
|
in->inputSize = 32;
|
|
in->configOptionVector[INPUT_SIZE] = 1;
|
|
|
|
kindex = 3;
|
|
}
|
|
else if (!HDstrcmp(buffer, "H5T_VAX_F64")) {
|
|
in->inputSize = 64;
|
|
in->configOptionVector[INPUT_SIZE] = 1;
|
|
|
|
kindex = 3;
|
|
}
|
|
else if (!HDstrcmp(buffer, "H5T_NATIVE_FLOAT")) {
|
|
in->inputSize = 32;
|
|
in->configOptionVector[INPUT_SIZE] = 1;
|
|
|
|
if ((kindex = OutputArchStrToInt("NATIVE")) == -1) {
|
|
(void) HDfprintf(stderr, "%s", err2);
|
|
return (-1);
|
|
}
|
|
in->outputArchitecture = kindex;
|
|
|
|
kindex = 3;
|
|
}
|
|
else if (!HDstrcmp(buffer, "H5T_NATIVE_DOUBLE")) {
|
|
in->inputSize = 64;
|
|
in->configOptionVector[INPUT_SIZE] = 1;
|
|
|
|
if ((kindex = OutputArchStrToInt("NATIVE")) == -1) {
|
|
(void) HDfprintf(stderr, "%s", err2);
|
|
return (-1);
|
|
}
|
|
in->outputArchitecture = kindex;
|
|
|
|
kindex = 3;
|
|
}
|
|
#if H5_SIZEOF_LONG_DOUBLE !=0
|
|
else if (!HDstrcmp(buffer, "H5T_NATIVE_LDOUBLE")) {
|
|
in->inputSize = H5_SIZEOF_LONG_DOUBLE;
|
|
in->configOptionVector[INPUT_SIZE] = 1;
|
|
|
|
if ((kindex = OutputArchStrToInt("NATIVE")) == -1) {
|
|
(void) HDfprintf(stderr, "%s", err2);
|
|
return (-1);
|
|
}
|
|
in->outputArchitecture = kindex;
|
|
|
|
kindex = 3;
|
|
}
|
|
#endif
|
|
else if(!HDstrcmp(buffer, "H5T_TIME: not yet implemented")) {
|
|
kindex = -1;
|
|
}
|
|
else if(!HDstrcmp(buffer, "H5T_STRING")) {
|
|
kindex = 5;
|
|
}
|
|
/* case H5T_BITFIELD: */
|
|
else if (!HDstrcmp(buffer, "H5T_STD_B8BE")) {
|
|
|
|
if ((kindex = OutputArchStrToInt("STD")) == -1) {
|
|
(void) HDfprintf(stderr, "%s", err2);
|
|
return (-1);
|
|
}
|
|
in->outputArchitecture = kindex;
|
|
|
|
if ((kindex = OutputByteOrderStrToInt("BE")) == -1) {
|
|
(void) HDfprintf(stderr, "%s", err3);
|
|
return (-1);
|
|
}
|
|
in->outputByteOrder = kindex;
|
|
|
|
kindex = -1;
|
|
}
|
|
else if (!HDstrcmp(buffer, "H5T_STD_B8LE")) {
|
|
|
|
if ((kindex = OutputArchStrToInt("STD")) == -1) {
|
|
(void) HDfprintf(stderr, "%s", err2);
|
|
return (-1);
|
|
}
|
|
in->outputArchitecture = kindex;
|
|
|
|
if ((kindex = OutputByteOrderStrToInt("LE")) == -1) {
|
|
(void) HDfprintf(stderr, "%s", err3);
|
|
return (-1);
|
|
}
|
|
in->outputByteOrder = kindex;
|
|
|
|
kindex = -1;
|
|
}
|
|
else if (!HDstrcmp(buffer, "H5T_STD_B16BE")) {
|
|
|
|
if ((kindex = OutputArchStrToInt("STD")) == -1) {
|
|
(void) HDfprintf(stderr, "%s", err2);
|
|
return (-1);
|
|
}
|
|
in->outputArchitecture = kindex;
|
|
|
|
if ((kindex = OutputByteOrderStrToInt("BE")) == -1) {
|
|
(void) HDfprintf(stderr, "%s", err3);
|
|
return (-1);
|
|
}
|
|
in->outputByteOrder = kindex;
|
|
|
|
kindex = -1;
|
|
}
|
|
else if (!HDstrcmp(buffer, "H5T_STD_B16LE")) {
|
|
|
|
if ((kindex = OutputArchStrToInt("STD")) == -1) {
|
|
(void) HDfprintf(stderr, "%s", err2);
|
|
return (-1);
|
|
}
|
|
in->outputArchitecture = kindex;
|
|
|
|
if ((kindex = OutputByteOrderStrToInt("LE")) == -1) {
|
|
(void) HDfprintf(stderr, "%s", err3);
|
|
return (-1);
|
|
}
|
|
in->outputByteOrder = kindex;
|
|
|
|
kindex = -1;
|
|
}
|
|
else if (!HDstrcmp(buffer, "H5T_STD_B32BE")) {
|
|
|
|
if ((kindex = OutputArchStrToInt("STD")) == -1) {
|
|
(void) HDfprintf(stderr, "%s", err2);
|
|
return (-1);
|
|
}
|
|
in->outputArchitecture = kindex;
|
|
|
|
if ((kindex = OutputByteOrderStrToInt("BE")) == -1) {
|
|
(void) HDfprintf(stderr, "%s", err3);
|
|
return (-1);
|
|
}
|
|
in->outputByteOrder = kindex;
|
|
|
|
kindex = -1;
|
|
}
|
|
else if (!HDstrcmp(buffer, "H5T_STD_B32LE")) {
|
|
|
|
if ((kindex = OutputArchStrToInt("STD")) == -1) {
|
|
(void) HDfprintf(stderr, "%s", err2);
|
|
return (-1);
|
|
}
|
|
in->outputArchitecture = kindex;
|
|
|
|
if ((kindex = OutputByteOrderStrToInt("LE")) == -1) {
|
|
(void) HDfprintf(stderr, "%s", err3);
|
|
return (-1);
|
|
}
|
|
in->outputByteOrder = kindex;
|
|
|
|
kindex = -1;
|
|
}
|
|
else if (!HDstrcmp(buffer, "H5T_STD_B64BE")) {
|
|
|
|
if ((kindex = OutputArchStrToInt("STD")) == -1) {
|
|
(void) HDfprintf(stderr, "%s", err2);
|
|
return (-1);
|
|
}
|
|
in->outputArchitecture = kindex;
|
|
|
|
if ((kindex = OutputByteOrderStrToInt("BE")) == -1) {
|
|
(void) HDfprintf(stderr, "%s", err3);
|
|
return (-1);
|
|
}
|
|
in->outputByteOrder = kindex;
|
|
|
|
kindex = -1;
|
|
}
|
|
else if (!HDstrcmp(buffer, "H5T_STD_B64LE")) {
|
|
|
|
if ((kindex = OutputArchStrToInt("STD")) == -1) {
|
|
(void) HDfprintf(stderr, "%s", err2);
|
|
return (-1);
|
|
}
|
|
in->outputArchitecture = kindex;
|
|
|
|
if ((kindex = OutputByteOrderStrToInt("LE")) == -1) {
|
|
(void) HDfprintf(stderr, "%s", err3);
|
|
return (-1);
|
|
}
|
|
in->outputByteOrder = kindex;
|
|
|
|
kindex = -1;
|
|
}
|
|
/* case H5T_OPAQUE: */
|
|
else if(!HDstrcmp(buffer, "H5T_OPAQUE")) {
|
|
kindex = -1;
|
|
}
|
|
/* case H5T_COMPOUND: */
|
|
else if(!HDstrcmp(buffer, "H5T_COMPOUND")) {
|
|
kindex = -1;
|
|
}
|
|
/* case H5T_REFERENCE: */
|
|
else if(!HDstrcmp(buffer, "H5T_REFERENCE")) {
|
|
kindex = -1;
|
|
}
|
|
/* case H5T_ENUM: */
|
|
else if(!HDstrcmp(buffer, "H5T_ENUM")) {
|
|
kindex = -1;
|
|
}
|
|
/* case H5T_VLEN: */
|
|
else if(!HDstrcmp(buffer, "H5T_VLEN")) {
|
|
kindex = -1;
|
|
}
|
|
/* case H5T_ARRAY: */
|
|
else if(!HDstrcmp(buffer, "H5T_ARRAY")) {
|
|
kindex = -1;
|
|
}
|
|
|
|
if (kindex == -1) {
|
|
(void) HDfprintf(stderr, "%s", err1);
|
|
return (-1);
|
|
}
|
|
|
|
/*set default value for output-size */
|
|
if (in->configOptionVector[OUTPUT_SIZE] == 0)
|
|
in->outputSize = in->inputSize;
|
|
#ifdef H5DEBUGIMPORT
|
|
printf("h5dump DATATYPE STRING %d inputSize\n", in->inputSize);
|
|
printf("h5dump DATATYPE STRING %d outputSize\n", in->outputSize);
|
|
#endif
|
|
|
|
in->inputClass = kindex;
|
|
return (0);
|
|
}
|
|
|
|
static int InputClassStrToInt(char *temp)
|
|
{
|
|
int i;
|
|
char classKeywordTable[8][15] = { "TEXTIN", "TEXTFP", "TEXTFPE", "FP", "IN", "STR", "TEXTUIN", "UIN" };
|
|
for (i = 0; i < 8; i++)
|
|
if (!HDstrcmp(classKeywordTable[i], temp))
|
|
return i;
|
|
return -1;
|
|
}
|
|
|
|
/* same as getOutputSize. But defined separately for extensibility */
|
|
static int getInputSize(struct Input *in, int ival)
|
|
{
|
|
int i;
|
|
int inputSizeValidValues[4] = { 8, 16, 32, 64 };
|
|
const char *err1 = "Invalid value for input size.\n";
|
|
|
|
for (i = 0; i < 4; i++)
|
|
if (inputSizeValidValues[i] == ival) {
|
|
in->inputSize = ival;
|
|
return (0);
|
|
}
|
|
(void) HDfprintf(stderr, "%s", err1);
|
|
return (-1);
|
|
}
|
|
|
|
static int getRank(struct Input *in, FILE *strm)
|
|
{
|
|
int ival;
|
|
|
|
const char *err1 = "Unable to get integer value.\n";
|
|
const char *err2 = "Invalid value for rank.\n";
|
|
|
|
if (fscanf(strm, "%d", (&ival)) != 1) {
|
|
(void) HDfprintf(stderr, "%s", err1);
|
|
return (-1);
|
|
}
|
|
if (ival >= MIN_NUM_DIMENSION && ival <= MAX_NUM_DIMENSION) {
|
|
in->rank = ival;
|
|
return (0);
|
|
}
|
|
|
|
(void) HDfprintf(stderr, "%s", err2);
|
|
return (-1);
|
|
}
|
|
|
|
/* same as getChunkedDimensionSizes. But defined separately for extensibility */
|
|
static int getDimensionSizes(struct Input *in, FILE *strm)
|
|
{
|
|
int ival;
|
|
int i = 0;
|
|
|
|
const char *err1 = "Unable to allocate dynamic memory.\n";
|
|
const char *err2 = "No. of dimensions for which dimension sizes provided is not equal to provided rank.\n";
|
|
|
|
if ((in->sizeOfDimension = (hsize_t *) HDmalloc ((size_t) in->rank * sizeof(hsize_t))) == NULL) {
|
|
(void) HDfprintf(stderr, "%s", err1);
|
|
return (-1);
|
|
}
|
|
|
|
while (fscanf(strm, "%d", (&ival)) == 1)
|
|
in->sizeOfDimension[i++] = ival;
|
|
|
|
if (in->rank != i) {
|
|
(void) HDfprintf(stderr, "%s", err2);
|
|
return (-1);
|
|
}
|
|
return (0);
|
|
}
|
|
/* same as getDimensionSizes. But defined separately for extensibility */
|
|
static int getChunkedDimensionSizes(struct Input *in, FILE *strm)
|
|
{
|
|
int ival;
|
|
int i = 0;
|
|
|
|
const char *err1 = "Unable to allocate dynamic memory.\n";
|
|
const char *err2 = "No. of dimensions for which chunked dimension sizes provided is not equal to provided rank.\n";
|
|
const char *err3 = "The CHUNKED-DIMENSION-SIZES cannot exceed the sizes of DIMENSION-SIZES\n";
|
|
|
|
if ((in->sizeOfChunk = (hsize_t *) HDmalloc ((size_t) in->rank * sizeof(hsize_t))) == NULL) {
|
|
(void) HDfprintf(stderr, "%s", err1);
|
|
return (-1);
|
|
}
|
|
|
|
while (fscanf(strm, "%d", (&ival)) == 1)
|
|
in->sizeOfChunk[i++] = ival;
|
|
|
|
if (in->rank != i) {
|
|
(void) HDfprintf(stderr, "%s", err2);
|
|
return (-1);
|
|
}
|
|
|
|
for (i = 0; i < in->rank; i++)
|
|
if (in->sizeOfChunk[i] > in->sizeOfDimension[i]) {
|
|
(void) HDfprintf(stderr, "%s", err3);
|
|
return (-1);
|
|
}
|
|
return (0);
|
|
}
|
|
|
|
static int getMaximumDimensionSizes(struct Input *in, FILE *strm)
|
|
{
|
|
int ival;
|
|
int i = 0;
|
|
|
|
const char *err1 = "Unable to allocate dynamic memory.\n";
|
|
const char *err2 = "No. of dimensions for which maximum dimension sizes provided is not equal to provided rank.\n";
|
|
const char *err3 = "The MAXIMUM-DIMENSIONS cannot be less than the sizes of DIMENSION-SIZES. Exception: can be -1 to indicate unlimited size\n";
|
|
|
|
if ((in->maxsizeOfDimension = (hsize_t *) HDmalloc ((size_t) in->rank * sizeof(hsize_t))) == NULL) {
|
|
(void) HDfprintf(stderr, "%s", err1);
|
|
return (-1);
|
|
}
|
|
|
|
while (fscanf(strm, "%d", (&ival)) == 1) {
|
|
if (ival == -1)
|
|
in->maxsizeOfDimension[i++] = H5S_UNLIMITED;
|
|
else
|
|
in->maxsizeOfDimension[i++] = ival;
|
|
}
|
|
|
|
if (in->rank != i) {
|
|
(void) HDfprintf(stderr, "%s", err2);
|
|
return (-1);
|
|
}
|
|
|
|
for (i = 0; i < in->rank; i++) {
|
|
if (in->maxsizeOfDimension[i] != H5S_UNLIMITED)
|
|
if (in->maxsizeOfDimension[i] < in->sizeOfDimension[i]) {
|
|
(void) HDfprintf(stderr, "%s", err3);
|
|
return (-1);
|
|
}
|
|
}
|
|
return (0);
|
|
}
|
|
|
|
static int getOutputArchitecture(struct Input *in, FILE *strm)
|
|
{
|
|
char temp[255];
|
|
int kindex;
|
|
const char *err1 = "Unable to get 'string' value.\n";
|
|
const char *err2 = "Invalid value for output architecture.\n";
|
|
|
|
if (fscanf(strm, "%s", temp) != 1) {
|
|
(void) HDfprintf(stderr, "%s", err1);
|
|
return (-1);
|
|
}
|
|
|
|
if ((kindex = OutputArchStrToInt(temp)) == -1) {
|
|
(void) HDfprintf(stderr, "%s", err2);
|
|
return (-1);
|
|
}
|
|
|
|
in->outputArchitecture = kindex;
|
|
return (0);
|
|
}
|
|
|
|
static int OutputArchStrToInt(const char *temp)
|
|
{
|
|
int i;
|
|
char outputArchKeywordTable[8][15] = { "NATIVE", "STD", "IEEE", "INTEL",
|
|
"CRAY", "MIPS", "ALPHA", "UNIX" };
|
|
for (i = 0; i < 8; i++)
|
|
if (!HDstrcmp(outputArchKeywordTable[i], temp))
|
|
return i;
|
|
return -1;
|
|
}
|
|
|
|
static int getOutputByteOrder(struct Input *in, FILE *strm)
|
|
{
|
|
char temp[255];
|
|
int kindex;
|
|
const char *err1 = "Unable to get 'string' value.\n";
|
|
const char *err2 = "Invalid value for output byte-order.\n";
|
|
|
|
if (fscanf(strm, "%s", temp) != 1) {
|
|
(void) HDfprintf(stderr, "%s", err1);
|
|
return (-1);
|
|
}
|
|
|
|
if ((kindex = OutputByteOrderStrToInt(temp)) == -1) {
|
|
(void) HDfprintf(stderr, "%s", err2);
|
|
return (-1);
|
|
}
|
|
|
|
in->outputByteOrder = kindex;
|
|
return (0);
|
|
}
|
|
|
|
static int OutputByteOrderStrToInt(const char *temp)
|
|
{
|
|
int i;
|
|
char outputByteOrderKeywordTable[2][15] = { "BE", "LE" };
|
|
for (i = 0; i < 2; i++)
|
|
if (!HDstrcmp(outputByteOrderKeywordTable[i], temp))
|
|
return i;
|
|
return -1;
|
|
}
|
|
|
|
static int getCompressionType(struct Input *in, FILE *strm)
|
|
{
|
|
char temp[255];
|
|
int kindex;
|
|
const char *err1 = "Unable to get 'string' value.\n";
|
|
const char *err2 = "Invalid value for compression.\n";
|
|
|
|
if (fscanf(strm, "%s", temp) != 1) {
|
|
(void) HDfprintf(stderr, "%s", err1);
|
|
return (-1);
|
|
}
|
|
|
|
if ((kindex = CompressionTypeStrToInt(temp)) == -1) {
|
|
(void) HDfprintf(stderr, "%s", err2);
|
|
return (-1);
|
|
}
|
|
|
|
in->compressionType = kindex;
|
|
return (0);
|
|
|
|
}
|
|
|
|
static int CompressionTypeStrToInt(char *temp)
|
|
{
|
|
/* currently supports only GZIP */
|
|
/* can be extended by adding fields to the table */
|
|
|
|
int i;
|
|
char CompressionTypeKeywordTable[1][15] = { "GZIP" };
|
|
for (i = 0; i < 1; i++)
|
|
if (!HDstrcmp(CompressionTypeKeywordTable[i], temp))
|
|
return i;
|
|
return -1;
|
|
}
|
|
|
|
static int getCompressionParameter(struct Input *in, FILE *strm)
|
|
{
|
|
/* currently supports only GZIP */
|
|
/* can be extended by adding more values to COMPRESSION-TYPE and */
|
|
/* handling the paramters here by adding more cases */
|
|
|
|
int ival;
|
|
const char *err1 = "Unable to get integer value.\n";
|
|
const char *err2 = "Invalid value for compression paramter.\n";
|
|
const char *err3 = "Unsupported Compression Type.\n";
|
|
|
|
switch (in->compressionType) {
|
|
case 0: /* GZIP */
|
|
if (fscanf(strm, "%d", (&ival)) != 1) {
|
|
(void) HDfprintf(stderr, "%s", err1);
|
|
return (-1);
|
|
}
|
|
|
|
if (ival < 0 || ival > 9) {
|
|
(void) HDfprintf(stderr, "%s", err2);
|
|
return (-1);
|
|
}
|
|
in->compressionParam = ival;
|
|
return (0);
|
|
|
|
default:
|
|
(void) HDfprintf(stderr, "%s", err3);
|
|
return (-1);
|
|
}
|
|
}
|
|
|
|
static int getExternalFilename(struct Input *in, FILE *strm)
|
|
{
|
|
char temp[255];
|
|
const char *err1 = "Unable to get 'string' value.\n";
|
|
|
|
if (fscanf(strm, "%s", temp) != 1) {
|
|
(void) HDfprintf(stderr, "%s", err1);
|
|
return (-1);
|
|
}
|
|
|
|
in->externFilename = (char *) HDmalloc ((size_t) (HDstrlen(temp)) * sizeof(char));
|
|
(void) HDstrcpy(in->externFilename, temp);
|
|
return (0);
|
|
}
|
|
|
|
void setDefaultValues(struct Input *in, int count)
|
|
{
|
|
int i;
|
|
char temp[255];
|
|
char num[255];
|
|
|
|
in->h5dumpInput = 0;
|
|
in->inputClass = 3; /* FP */
|
|
in->inputSize = 32;
|
|
in->outputClass = 1; /* FP */
|
|
in->outputSize = 32;
|
|
in->rank = 0;
|
|
in->path.count = 1;
|
|
|
|
HDstrcpy(temp, "dataset");
|
|
sprintf(num, "%d", count);
|
|
HDstrcat(temp, num);
|
|
HDstrcpy(in->path.group[0], temp);
|
|
|
|
in->outputArchitecture = 0; /* NATIVE */
|
|
in->outputByteOrder = -1; /* use default */
|
|
in->compressionType = 0; /* GZIP */
|
|
for (i = 0; i < NUM_KEYS; i++)
|
|
in->configOptionVector[i] = 0;
|
|
}
|
|
|
|
hid_t createOutputDataType(struct Input *in)
|
|
{
|
|
hid_t new_type = (-1);
|
|
const char *err1 = "Invalid value for output class.\n";
|
|
const char *err2 = "Invalid value for output size.\n";
|
|
const char *err3 = "Invalid value for output byte order.\n";
|
|
const char *err4 = "Invalid value for output architecture.\n";
|
|
const char *err5 = "STD not supported for float.\n";
|
|
const char *err6 = "IEEE not supported for INT.\n";
|
|
|
|
switch (in->outputClass) {
|
|
case 0:
|
|
switch (in->outputArchitecture) {
|
|
case 0: /* NATIVE */
|
|
switch (in->outputSize) {
|
|
case 8:
|
|
new_type = H5Tcopy(H5T_NATIVE_CHAR);
|
|
break;
|
|
|
|
case 16:
|
|
new_type = H5Tcopy(H5T_NATIVE_SHORT);
|
|
break;
|
|
|
|
case 32:
|
|
new_type = H5Tcopy(H5T_NATIVE_INT);
|
|
break;
|
|
|
|
case 64:
|
|
new_type = H5Tcopy(H5T_NATIVE_LLONG);
|
|
break;
|
|
|
|
default:
|
|
(void) HDfprintf(stderr, "%s", err2);
|
|
return (-1);
|
|
}
|
|
switch (in->outputByteOrder) {
|
|
case -1: /* default */
|
|
break;
|
|
case 0:
|
|
H5Tset_order(new_type, H5T_ORDER_BE);
|
|
break;
|
|
|
|
case 1:
|
|
H5Tset_order(new_type, H5T_ORDER_LE);
|
|
break;
|
|
|
|
default:
|
|
(void) HDfprintf(stderr, "%s", err3);
|
|
return (-1);
|
|
}
|
|
break;
|
|
|
|
case 1: /* STD */
|
|
switch (in->outputSize) {
|
|
case 8:
|
|
switch (in->outputByteOrder) {
|
|
case -1:
|
|
case 0:
|
|
new_type = H5Tcopy(H5T_STD_I8BE);
|
|
break;
|
|
|
|
case 1:
|
|
new_type = H5Tcopy(H5T_STD_I8LE);
|
|
break;
|
|
|
|
default:
|
|
(void) HDfprintf(stderr, "%s", err3);
|
|
return (-1);
|
|
}
|
|
break;
|
|
|
|
case 16:
|
|
switch (in->outputByteOrder) {
|
|
case -1:
|
|
case 0:
|
|
new_type = H5Tcopy(H5T_STD_I16BE);
|
|
break;
|
|
|
|
case 1:
|
|
new_type = H5Tcopy(H5T_STD_I16LE);
|
|
break;
|
|
|
|
default:
|
|
(void) HDfprintf(stderr, "%s", err3);
|
|
return (-1);
|
|
}
|
|
break;
|
|
|
|
case 32:
|
|
switch (in->outputByteOrder) {
|
|
case -1:
|
|
case 0:
|
|
new_type = H5Tcopy(H5T_STD_I32BE);
|
|
break;
|
|
|
|
case 1:
|
|
new_type = H5Tcopy(H5T_STD_I32LE);
|
|
break;
|
|
|
|
default:
|
|
(void) HDfprintf(stderr, "%s", err3);
|
|
return (-1);
|
|
}
|
|
break;
|
|
|
|
case 64:
|
|
switch (in->outputByteOrder) {
|
|
case -1:
|
|
case 0:
|
|
new_type = H5Tcopy(H5T_STD_I64BE);
|
|
break;
|
|
|
|
case 1:
|
|
new_type = H5Tcopy(H5T_STD_I64LE);
|
|
break;
|
|
|
|
default:
|
|
(void) HDfprintf(stderr, "%s", err3);
|
|
return (-1);
|
|
}
|
|
break;
|
|
|
|
default:
|
|
(void) HDfprintf(stderr, "%s", err2);
|
|
return (-1);
|
|
}
|
|
break;
|
|
|
|
default:
|
|
(void) HDfprintf(stderr, "%s", err4);
|
|
return (-1);
|
|
}
|
|
break;
|
|
|
|
case 1:
|
|
switch (in->outputArchitecture) {
|
|
case 0:
|
|
switch (in->outputSize) {
|
|
case 32:
|
|
new_type = H5Tcopy(H5T_NATIVE_FLOAT);
|
|
break;
|
|
|
|
case 64:
|
|
new_type = H5Tcopy(H5T_NATIVE_DOUBLE);
|
|
break;
|
|
|
|
default:
|
|
(void) HDfprintf(stderr, "%s", err2);
|
|
return (-1);
|
|
}
|
|
switch (in->outputByteOrder) {
|
|
case -1: /* DEFAULT */
|
|
break;
|
|
case 0:
|
|
H5Tset_order(new_type, H5T_ORDER_BE);
|
|
break;
|
|
|
|
case 1:
|
|
H5Tset_order(new_type, H5T_ORDER_LE);
|
|
break;
|
|
|
|
default:
|
|
(void) HDfprintf(stderr, "%s", err3);
|
|
return (-1);
|
|
}
|
|
break;
|
|
|
|
case 1:
|
|
(void) HDfprintf(stderr, "%s", err5);
|
|
return (-1);
|
|
|
|
case 2:
|
|
switch (in->outputSize) {
|
|
case 32:
|
|
switch (in->outputByteOrder) {
|
|
case -1:
|
|
case 0:
|
|
new_type = H5Tcopy(H5T_IEEE_F32BE);
|
|
break;
|
|
|
|
case 1:
|
|
new_type = H5Tcopy(H5T_IEEE_F32LE);
|
|
break;
|
|
|
|
default:
|
|
(void) HDfprintf(stderr, "%s", err3);
|
|
return (-1);
|
|
}
|
|
break;
|
|
|
|
case 64:
|
|
switch (in->outputByteOrder) {
|
|
case -1:
|
|
case 0:
|
|
new_type = H5Tcopy(H5T_IEEE_F64BE);
|
|
break;
|
|
|
|
case 1:
|
|
new_type = H5Tcopy(H5T_IEEE_F64LE);
|
|
break;
|
|
|
|
default:
|
|
(void) HDfprintf(stderr, "%s", err3);
|
|
return (-1);
|
|
}
|
|
break;
|
|
|
|
default:
|
|
(void) HDfprintf(stderr, "%s", err2);
|
|
return (-1);
|
|
}
|
|
break;
|
|
|
|
default:
|
|
(void) HDfprintf(stderr, "%s", err4);
|
|
return (-1);
|
|
}
|
|
break;
|
|
|
|
case 2:
|
|
switch (in->outputArchitecture) {
|
|
case 0:
|
|
switch (in->outputSize) {
|
|
case 8:
|
|
new_type = H5Tcopy(H5T_NATIVE_UCHAR);
|
|
break;
|
|
|
|
case 16:
|
|
new_type = H5Tcopy(H5T_NATIVE_USHORT);
|
|
break;
|
|
|
|
case 32:
|
|
new_type = H5Tcopy(H5T_NATIVE_UINT);
|
|
break;
|
|
|
|
case 64:
|
|
new_type = H5Tcopy(H5T_NATIVE_ULLONG);
|
|
break;
|
|
|
|
default:
|
|
(void) HDfprintf(stderr, "%s", err2);
|
|
return (-1);
|
|
}
|
|
switch (in->outputByteOrder) {
|
|
case -1: /* Default */
|
|
break;
|
|
case 0:
|
|
H5Tset_order(new_type, H5T_ORDER_BE);
|
|
break;
|
|
|
|
case 1:
|
|
H5Tset_order(new_type, H5T_ORDER_LE);
|
|
break;
|
|
|
|
default:
|
|
(void) HDfprintf(stderr, "%s", err3);
|
|
return (-1);
|
|
}
|
|
break;
|
|
|
|
case 1:
|
|
switch (in->outputSize) {
|
|
case 8:
|
|
switch (in->outputByteOrder) {
|
|
case -1:
|
|
case 0:
|
|
new_type = H5Tcopy(H5T_STD_U8BE);
|
|
break;
|
|
|
|
case 1:
|
|
new_type = H5Tcopy(H5T_STD_U8LE);
|
|
break;
|
|
|
|
default:
|
|
(void) HDfprintf(stderr, "%s", err3);
|
|
return (-1);
|
|
}
|
|
break;
|
|
|
|
case 16:
|
|
switch (in->outputByteOrder) {
|
|
case -1:
|
|
case 0:
|
|
new_type = H5Tcopy(H5T_STD_U16BE);
|
|
break;
|
|
|
|
case 1:
|
|
new_type = H5Tcopy(H5T_STD_U16LE);
|
|
break;
|
|
|
|
default:
|
|
(void) HDfprintf(stderr, "%s", err3);
|
|
return (-1);
|
|
}
|
|
break;
|
|
|
|
case 32:
|
|
switch (in->outputByteOrder) {
|
|
case -1:
|
|
case 0:
|
|
new_type = H5Tcopy(H5T_STD_U32BE);
|
|
break;
|
|
|
|
case 1:
|
|
new_type = H5Tcopy(H5T_STD_U32LE);
|
|
break;
|
|
|
|
default:
|
|
(void) HDfprintf(stderr, "%s", err3);
|
|
return (-1);
|
|
}
|
|
break;
|
|
|
|
case 64:
|
|
switch (in->outputByteOrder) {
|
|
case -1:
|
|
case 0:
|
|
new_type = H5Tcopy(H5T_STD_U64BE);
|
|
break;
|
|
|
|
case 1:
|
|
new_type = H5Tcopy(H5T_STD_U64LE);
|
|
break;
|
|
|
|
default:
|
|
(void) HDfprintf(stderr, "%s", err3);
|
|
return (-1);
|
|
}
|
|
break;
|
|
|
|
default:
|
|
(void) HDfprintf(stderr, "%s", err2);
|
|
return (-1);
|
|
}
|
|
break;
|
|
|
|
case 2:
|
|
(void) HDfprintf(stderr, "%s", err6);
|
|
return (-1);
|
|
|
|
default:
|
|
(void) HDfprintf(stderr, "%s", err4);
|
|
return (-1);
|
|
}
|
|
break;
|
|
|
|
default:
|
|
(void) HDfprintf(stderr, "%s", err1);
|
|
return (-1);
|
|
}
|
|
return new_type;
|
|
}
|
|
|
|
hid_t createInputDataType(struct Input *in)
|
|
{
|
|
hid_t new_type = (-1);
|
|
const char *err1 = "Invalid value for input class.\n";
|
|
const char *err2 = "Invalid value for output size.\n";
|
|
|
|
switch (in->inputClass) {
|
|
case 0:
|
|
case 4:
|
|
switch (in->inputSize) {
|
|
case 8:
|
|
new_type = H5Tcopy(H5T_NATIVE_CHAR);
|
|
break;
|
|
|
|
case 16:
|
|
new_type = H5Tcopy(H5T_NATIVE_SHORT);
|
|
break;
|
|
|
|
case 32:
|
|
new_type = H5Tcopy(H5T_NATIVE_INT);
|
|
break;
|
|
|
|
case 64:
|
|
new_type = H5Tcopy(H5T_NATIVE_LLONG);
|
|
break;
|
|
|
|
default:
|
|
(void) HDfprintf(stderr, "%s", err2);
|
|
return (-1);
|
|
}
|
|
break;
|
|
|
|
case 1:
|
|
case 2:
|
|
case 3:
|
|
switch (in->inputSize) {
|
|
case 32:
|
|
new_type = H5Tcopy(H5T_NATIVE_FLOAT);
|
|
break;
|
|
|
|
case 64:
|
|
new_type = H5Tcopy(H5T_NATIVE_DOUBLE);
|
|
break;
|
|
|
|
default:
|
|
(void) HDfprintf(stderr, "%s", err2);
|
|
return (-1);
|
|
}
|
|
break;
|
|
|
|
case 5:
|
|
(void) HDfprintf(stderr, "%s", err1);
|
|
return (-1);
|
|
break;
|
|
|
|
case 6:
|
|
case 7:
|
|
switch (in->inputSize) {
|
|
case 8:
|
|
new_type = H5Tcopy(H5T_NATIVE_UCHAR);
|
|
break;
|
|
|
|
case 16:
|
|
new_type = H5Tcopy(H5T_NATIVE_USHORT);
|
|
break;
|
|
|
|
case 32:
|
|
new_type = H5Tcopy(H5T_NATIVE_UINT);
|
|
break;
|
|
|
|
case 64:
|
|
new_type = H5Tcopy(H5T_NATIVE_ULLONG);
|
|
break;
|
|
|
|
default:
|
|
(void) HDfprintf(stderr, "%s", err2);
|
|
return (-1);
|
|
}
|
|
break;
|
|
|
|
default:
|
|
(void) HDfprintf(stderr, "%s", err1);
|
|
return (-1);
|
|
}
|
|
return new_type;
|
|
}
|
|
|
|
static int process(struct Options *opt)
|
|
{
|
|
struct Input *in;
|
|
FILE *extfile;
|
|
hid_t file_id;
|
|
hid_t group_id;
|
|
hid_t handle;
|
|
hid_t dataset;
|
|
hid_t dataspace = (-1);
|
|
hid_t intype;
|
|
hid_t outtype;
|
|
hid_t proplist;
|
|
hsize_t numOfElements = 1;
|
|
int j;
|
|
int k;
|
|
|
|
const char *err1 = "Error creating HDF output file: %s.\n";
|
|
const char *err2 = "Error in processing the configuration file: %s.\n";
|
|
const char *err3 = "Error in reading the input file: %s.\n";
|
|
const char *err4 = "Error in creating or opening external file.\n";
|
|
const char *err5 = "Error in creating the output data set. Dataset with the same name may exist at the specified path\n";
|
|
const char *err6 = "Error in writing the output data set.\n";
|
|
|
|
H5E_BEGIN_TRY
|
|
{
|
|
if ((file_id = H5Fopen(opt->outfile, H5F_ACC_RDWR, H5P_DEFAULT)) < 0) {
|
|
if ((file_id = H5Fcreate(opt->outfile, H5F_ACC_TRUNC, H5P_DEFAULT, H5P_DEFAULT)) == FAIL) {
|
|
(void) HDfprintf(stderr, err1, opt->outfile);
|
|
return (-1);
|
|
}
|
|
}
|
|
}
|
|
H5E_END_TRY;
|
|
|
|
for (k = 0; k < opt->fcount; k++) {
|
|
in = &(opt->infiles[k].in);
|
|
if (opt->infiles[k].config == 1) {
|
|
if (processConfigurationFile(opt->infiles[k].configfile, in) == -1) {
|
|
(void) HDfprintf(stderr, err2, opt->infiles[k].configfile);
|
|
return (-1);
|
|
}
|
|
}
|
|
|
|
if (processDataFile(opt->infiles[k].datafile, in, file_id) == -1) {
|
|
(void) HDfprintf(stderr, err3, opt->infiles[k].datafile);
|
|
return (-1);
|
|
}
|
|
|
|
if (in->inputClass != 5) { /* STR */
|
|
for (j = 0; j < in->rank; j++)
|
|
numOfElements *= in->sizeOfDimension[j];
|
|
|
|
/* disable error reporting */
|
|
H5E_BEGIN_TRY
|
|
{
|
|
/* create parent groups */
|
|
if (in->path.count > 1) {
|
|
j = 0;
|
|
handle = file_id;
|
|
while (j < in->path.count - 1) {
|
|
if ((group_id = H5Gopen2(handle, in->path.group[j], H5P_DEFAULT)) < 0) {
|
|
group_id = H5Gcreate2(handle, in->path.group[j++], H5P_DEFAULT, H5P_DEFAULT, H5P_DEFAULT);
|
|
for (; j < in->path.count - 1; j++)
|
|
group_id = H5Gcreate2(group_id, in->path.group[j], H5P_DEFAULT, H5P_DEFAULT, H5P_DEFAULT);
|
|
handle = group_id;
|
|
break;
|
|
}
|
|
handle = group_id;
|
|
j++;
|
|
}
|
|
}
|
|
else {
|
|
handle = file_id;
|
|
j = 0;
|
|
}
|
|
|
|
/*enable error reporting */
|
|
}
|
|
H5E_END_TRY;
|
|
|
|
/*create data type */
|
|
intype = createInputDataType(in);
|
|
outtype = createOutputDataType(in);
|
|
#ifdef H5DEBUGIMPORT
|
|
printf("process intype %d outtype %d\n", intype, outtype);
|
|
#endif
|
|
|
|
/* create property list */
|
|
proplist = H5Pcreate(H5P_DATASET_CREATE);
|
|
if (in->configOptionVector[CHUNK] == 1) {
|
|
H5Pset_layout(proplist, H5D_CHUNKED);
|
|
/* not reqd chunking is implied if set_chunk is used */
|
|
H5Pset_chunk(proplist, in->rank, in->sizeOfChunk);
|
|
}
|
|
|
|
if (in->configOptionVector[COMPRESS] == 1) {
|
|
H5Pset_deflate(proplist, (unsigned) in->compressionParam);
|
|
}
|
|
|
|
if (in->configOptionVector[EXTERNALSTORE] == 1) {
|
|
/* creating the external file if it doesnt exist */
|
|
if ((extfile = HDfopen(in->externFilename, "ab")) == NULL) {
|
|
(void) HDfprintf(stderr, "%s", err4);
|
|
H5Pclose(proplist);
|
|
H5Sclose(dataspace);
|
|
H5Fclose(file_id);
|
|
return (-1);
|
|
}
|
|
HDfclose(extfile);
|
|
H5Pset_external(proplist, in->externFilename, (off_t) 0, numOfElements * in->inputSize / 8);
|
|
}
|
|
|
|
/* create dataspace */
|
|
if (in->configOptionVector[EXTEND] == 1)
|
|
dataspace = H5Screate_simple(in->rank, in->sizeOfDimension, in->maxsizeOfDimension);
|
|
else
|
|
dataspace = H5Screate_simple(in->rank, in->sizeOfDimension, NULL);
|
|
|
|
/* disable error reporting */
|
|
H5E_BEGIN_TRY
|
|
{
|
|
/* create data set */
|
|
if ((dataset = H5Dcreate2(handle, in->path.group[j], outtype, dataspace, H5P_DEFAULT, proplist, H5P_DEFAULT)) < 0) {
|
|
(void) HDfprintf(stderr, "%s", err5);
|
|
H5Pclose(proplist);
|
|
H5Sclose(dataspace);
|
|
H5Fclose(file_id);
|
|
return (-1);
|
|
}
|
|
|
|
/*enable error reporting */
|
|
}
|
|
H5E_END_TRY;
|
|
|
|
/* write dataset */
|
|
if (H5Dwrite(dataset, intype, H5S_ALL, H5S_ALL, H5P_DEFAULT, (VOIDP) in->data) < 0) {
|
|
(void) HDfprintf(stderr, "%s", err6);
|
|
H5Dclose(dataset);
|
|
H5Pclose(proplist);
|
|
H5Sclose(dataspace);
|
|
H5Fclose(file_id);
|
|
return (-1);
|
|
}
|
|
|
|
H5Dclose(dataset);
|
|
H5Pclose(proplist);
|
|
H5Sclose(dataspace);
|
|
}
|
|
|
|
} /* STR */
|
|
|
|
H5Fclose(file_id);
|
|
return (0);
|
|
}
|
|
|
|
/*
|
|
* Name:
|
|
* help
|
|
*
|
|
* Purpose:
|
|
* Print a helpful summary of command usage and features.
|
|
*/
|
|
|
|
void help(char *name)
|
|
{
|
|
(void) HDfprintf(stdout, "Name:\n\n");
|
|
(void) HDfprintf(stdout, "\t%s\n\n", name);
|
|
(void) HDfprintf(stdout, "\t TOOL NAME:\n");
|
|
(void) HDfprintf(stdout, "\t %s\n", name);
|
|
(void) HDfprintf(stdout, "\t SYNTAX:\n");
|
|
(void) HDfprintf(stdout, "\t %s -h[elp], OR\n", name);
|
|
(void) HDfprintf(stdout,
|
|
"\t %s <infile> -c[onfig] <configfile> [<infile> -c[config] <configfile>...]", name);
|
|
(void) HDfprintf(stdout, "\t\t\t\t -o[utfile] <outfile>\n\n");
|
|
(void) HDfprintf(stdout, "\t PURPOSE:\n");
|
|
(void) HDfprintf(stdout,
|
|
"\t To convert data stored in one or more ASCII or binary files\n");
|
|
(void) HDfprintf(stdout,
|
|
"\t into one or more datasets (in accordance with the \n");
|
|
(void) HDfprintf(stdout,
|
|
"\t user-specified type and storage properties) in an existing \n");
|
|
(void) HDfprintf(stdout, "\t or new HDF5 file.\n\n");
|
|
(void) HDfprintf(stdout, "\t DESCRIPTION:\n");
|
|
(void) HDfprintf(stdout,
|
|
"\t The primary objective of the utility is to convert floating\n");
|
|
(void) HDfprintf(stdout,
|
|
"\t point or integer data stored in ASCII text or binary form \n");
|
|
(void) HDfprintf(stdout,
|
|
"\t into a data-set according to the type and storage properties\n");
|
|
(void) HDfprintf(stdout,
|
|
"\t specified by the user. The utility can also accept ASCII\n");
|
|
(void) HDfprintf(stdout,
|
|
"\t text files and store the contents in a compact form as an\n");
|
|
(void) HDfprintf(stdout, "\t array of one-dimensional strings.\n\n");
|
|
(void) HDfprintf(stdout,
|
|
"\t The input data to be written as a data-set can be provided\n");
|
|
(void) HDfprintf(stdout, "\t to the utility in one of the following forms:\n");
|
|
(void) HDfprintf(stdout,
|
|
"\t 1. ASCII text file with numeric data (floating point or \n");
|
|
(void) HDfprintf(stdout, "\t integer data). \n");
|
|
(void) HDfprintf(stdout,
|
|
"\t 2. Binary file with native floating point data (32-bit or \n");
|
|
(void) HDfprintf(stdout, "\t 64-bit) \n");
|
|
(void) HDfprintf(stdout,
|
|
"\t 3. Binary file with native integer (signed or unsigned)\n");
|
|
(void) HDfprintf(stdout, "\t data (8-bit or 16-bit or 32-bit or 64-bit). \n");
|
|
(void) HDfprintf(stdout,
|
|
"\t 4. ASCII text file containing strings (text data).\n");
|
|
(void) HDfprintf(stdout, "\t \n");
|
|
(void) HDfprintf(stdout,
|
|
"\t Every input file is associated with a configuration file \n");
|
|
(void) HDfprintf(stdout,
|
|
"\t also provided as an input to the utility. (See Section \n");
|
|
(void) HDfprintf(stdout,
|
|
"\t \"CONFIGURATION FILE\" to know how it is to be organized).\n");
|
|
(void) HDfprintf(stdout,
|
|
"\t The class, size and dimensions of the input data is \n");
|
|
(void) HDfprintf(stdout,
|
|
"\t specified in this configuration file. A point to note is\n");
|
|
(void) HDfprintf(stdout,
|
|
"\t that the floating point data in the ASCII text file may be\n");
|
|
(void) HDfprintf(stdout,
|
|
"\t organized in the fixed floating form (for example 323.56)\n");
|
|
(void) HDfprintf(stdout,
|
|
"\t or in a scientific notation (for example 3.23E+02). A \n");
|
|
(void) HDfprintf(stdout,
|
|
"\t different input-class specification is to be used for both\n");
|
|
(void) HDfprintf(stdout, "\t forms.\n\n");
|
|
(void) HDfprintf(stdout,
|
|
"\t The utility extracts the input data from the input file \n");
|
|
(void) HDfprintf(stdout,
|
|
"\t according to the specified parameters and saves it into \n");
|
|
(void) HDfprintf(stdout, "\t an H5 dataset. \n\n");
|
|
(void) HDfprintf(stdout,
|
|
"\t The user can specify output type and storage properties in \n");
|
|
(void) HDfprintf(stdout,
|
|
"\t the configuration file. The user is required to specify the \n");
|
|
(void) HDfprintf(stdout,
|
|
"\t path of the dataset. If the groups in the path leading to \n");
|
|
(void) HDfprintf(stdout,
|
|
"\t the data-set do not exist, the groups will be created by the\n");
|
|
(void) HDfprintf(stdout,
|
|
"\t utility. If no group is specified, the dataset will be\n");
|
|
(void) HDfprintf(stdout, "\t created under the root group.\n\n");
|
|
(void) HDfprintf(stdout,
|
|
"\t In addition to the name, the user is also required to \n");
|
|
(void) HDfprintf(stdout,
|
|
"\t provide the class and size of output data to be written to \n");
|
|
(void) HDfprintf(stdout,
|
|
"\t the dataset and may optionally specify the output-architecture,\n");
|
|
(void) HDfprintf(stdout,
|
|
"\t and the output-byte-order. If output-architecture is not \n");
|
|
(void) HDfprintf(stdout,
|
|
"\t specified the default is NATIVE. Output-byte-orders are fixed\n");
|
|
(void) HDfprintf(stdout,
|
|
"\t for some architectures and may be specified only if output-\n");
|
|
(void) HDfprintf(stdout, "\t architecture is IEEE, UNIX or STD.\n\n");
|
|
(void) HDfprintf(stdout,
|
|
"\t Also, layout and other storage properties such as \n");
|
|
(void) HDfprintf(stdout,
|
|
"\t compression, external storage and extendible data-sets may be\n");
|
|
(void) HDfprintf(stdout,
|
|
"\t optionally specified. The layout and storage properties \n");
|
|
(void) HDfprintf(stdout,
|
|
"\t denote how raw data is to be organized on the disk. If these \n");
|
|
(void) HDfprintf(stdout,
|
|
"\t options are not specified the default is Contiguous layout \n");
|
|
(void) HDfprintf(stdout, "\t and storage.\n\n");
|
|
(void) HDfprintf(stdout,
|
|
"\t The dataset can be organized in any of the following ways:\n");
|
|
(void) HDfprintf(stdout, "\t 1. Contiguous.\n");
|
|
(void) HDfprintf(stdout, "\t 2. Chunked.\n");
|
|
(void) HDfprintf(stdout,
|
|
"\t 3. External Storage File (has to be contiguous)\n");
|
|
(void) HDfprintf(stdout,
|
|
"\t 4. Extendible data sets (has to be chunked)\n");
|
|
(void) HDfprintf(stdout, "\t 5. Compressed. (has to be chunked)\n");
|
|
(void) HDfprintf(stdout,
|
|
"\t 6. Compressed & Extendible (has to be chunked)\n\n");
|
|
(void) HDfprintf(stdout,
|
|
"\t If the user wants to store raw data in a non-HDF file then \n");
|
|
(void) HDfprintf(stdout,
|
|
"\t the external storage file option is to be used and the name \n");
|
|
(void) HDfprintf(stdout, "\t of the file is to be specified. \n\n");
|
|
(void) HDfprintf(stdout,
|
|
"\t If the user wants the dimensions of the data-set to be\n");
|
|
(void) HDfprintf(stdout,
|
|
"\t unlimited, the extendible data set option can be chosen. \n\n");
|
|
(void) HDfprintf(stdout,
|
|
"\t The user may also specify the type of compression and the \n");
|
|
(void) HDfprintf(stdout,
|
|
"\t level to which the data set must be compresses by setting \n");
|
|
(void) HDfprintf(stdout, "\t the compressed option.\n\n");
|
|
(void) HDfprintf(stdout, "\t SYNOPSIS:\n");
|
|
(void) HDfprintf(stdout, "\t h5import -h[elp], OR\n");
|
|
(void) HDfprintf( stdout,
|
|
"\t h5import <infile> -c[onfig] <configfile> \
|
|
[<infile> -c[config] <confile2>...] -o[utfile] <outfile>\n\n");
|
|
(void) HDfprintf(stdout, "\t -h[elp]:\n");
|
|
(void) HDfprintf(stdout,
|
|
"\t Prints this summary of usage, and exits.\n\n");
|
|
(void) HDfprintf(stdout, "\t <infile(s)>:\n");
|
|
(void) HDfprintf(stdout,
|
|
"\t Name of the Input file(s), containing a \n");
|
|
(void) HDfprintf(stdout,
|
|
"\t single n-dimensional floating point or integer array \n");
|
|
(void) HDfprintf(stdout,
|
|
"\t in either ASCII text, native floating point(32-bit \n");
|
|
(void) HDfprintf(stdout,
|
|
"\t or 64-bit) or native integer(8-bit or 16-bit or \n");
|
|
(void) HDfprintf(stdout,
|
|
"\t 32-bit or 64-bit). Data to be specified in the order\n");
|
|
(void) HDfprintf(stdout, "\t of fastest changing dimensions first.\n\n");
|
|
(void) HDfprintf(stdout, "\t -c[config] <configfile>:\n");
|
|
(void) HDfprintf(stdout,
|
|
"\t Every input file should be associated with a \n");
|
|
(void) HDfprintf(stdout,
|
|
"\t configuration file and this is done by the -c option.\n");
|
|
(void) HDfprintf(stdout,
|
|
"\t <configfile> is the name of the configuration file.\n");
|
|
(void) HDfprintf(stdout, "\t (See Section \"CONFIGURATION FILE\")\n\n");
|
|
(void) HDfprintf(stdout, "\t -o[utfile] <outfile>:\n");
|
|
(void) HDfprintf(stdout,
|
|
"\t Name of the HDF5 output file. Data from one or more \n");
|
|
(void) HDfprintf(stdout,
|
|
"\t input files are stored as one or more data sets in \n");
|
|
(void) HDfprintf(stdout,
|
|
"\t <outfile>. The output file may be an existing file or \n");
|
|
(void) HDfprintf(stdout,
|
|
"\t it maybe new in which case it will be created.\n\n\n");
|
|
(void) HDfprintf(stdout, "\t CONFIGURATION FILE:\n");
|
|
(void) HDfprintf(stdout,
|
|
"\t The configuration file is an ASCII text file and must be \n");
|
|
(void) HDfprintf(stdout,
|
|
"\t the ddl formatted file (without data values) produced by h5dump \n");
|
|
(void) HDfprintf(stdout,
|
|
"\t when used with the options '-o outfilename -b' of a single dataset (-d) \n");
|
|
(void) HDfprintf(stdout,
|
|
"\t OR organized as \"CONFIG-KEYWORD VALUE\" pairs, one pair on each \n");
|
|
(void) HDfprintf(stdout, "\t line.\n\n");
|
|
(void) HDfprintf(stdout,
|
|
"\t The configuration file may have the following keywords each \n");
|
|
(void) HDfprintf(stdout, "\t followed by an acceptable value.\n\n");
|
|
(void) HDfprintf(stdout, "\t Required KEYWORDS:\n");
|
|
(void) HDfprintf(stdout, "\t PATH\n");
|
|
(void) HDfprintf(stdout, "\t INPUT-CLASS\n");
|
|
(void) HDfprintf(stdout, "\t INPUT-SIZE\n");
|
|
(void) HDfprintf(stdout, "\t RANK\n");
|
|
(void) HDfprintf(stdout, "\t DIMENSION-SIZES\n");
|
|
(void) HDfprintf(stdout, "\t OUTPUT-CLASS\n");
|
|
(void) HDfprintf(stdout, "\t OUTPUT-SIZE\n\n");
|
|
(void) HDfprintf(stdout, "\t Optional KEYWORDS:\n");
|
|
(void) HDfprintf(stdout, "\t OUTPUT-ARCHITECTURE\n");
|
|
(void) HDfprintf(stdout, "\t OUTPUT-BYTE-ORDER\n");
|
|
(void) HDfprintf(stdout, "\t CHUNKED-DIMENSION-SIZES\n");
|
|
(void) HDfprintf(stdout, "\t COMPRESSION-TYPE\n");
|
|
(void) HDfprintf(stdout, "\t COMPRESSION-PARAM\n");
|
|
(void) HDfprintf(stdout, "\t EXTERNAL-STORAGE\n");
|
|
(void) HDfprintf(stdout, "\t MAXIMUM-DIMENSIONS\n\n\n");
|
|
(void) HDfprintf(stdout, "\t Values for keywords:\n");
|
|
(void) HDfprintf(stdout, "\t PATH:\n");
|
|
(void) HDfprintf(stdout, "\t Strings separated by spaces to represent\n");
|
|
(void) HDfprintf(stdout, "\t the path of the data-set. If the groups in\n");
|
|
(void) HDfprintf(stdout,
|
|
"\t the path do not exist, they will be created. \n");
|
|
(void) HDfprintf(stdout, "\t For example,\n");
|
|
(void) HDfprintf(stdout, "\t PATH grp1/grp2/dataset1\n");
|
|
(void) HDfprintf(stdout, "\t PATH: keyword\n");
|
|
(void) HDfprintf(stdout, "\t grp1: group under the root. If\n");
|
|
(void) HDfprintf(stdout, "\t non-existent will be created.\n");
|
|
(void) HDfprintf(stdout, "\t grp2: group under grp1. If \n");
|
|
(void) HDfprintf(stdout, "\t non-existent will be created \n");
|
|
(void) HDfprintf(stdout, "\t under grp1.\n");
|
|
(void) HDfprintf(stdout, "\t dataset1: the name of the data-set \n");
|
|
(void) HDfprintf(stdout, "\t to be created.\n\n");
|
|
(void) HDfprintf(stdout, "\t INPUT-CLASS:\n");
|
|
(void) HDfprintf(stdout, "\t String denoting the type of input data.\n");
|
|
(void) HDfprintf(stdout, "\t (\"TEXTIN\", \"TEXTFP\", \"FP\", \"IN\", \n");
|
|
(void) HDfprintf(stdout, "\t \"STR\", \"TEXTUIN\", \"UIN\"). \n");
|
|
(void) HDfprintf(stdout,
|
|
"\t INPUT-CLASS \"TEXTIN\" denotes an ASCII text \n");
|
|
(void) HDfprintf(stdout,
|
|
"\t file with signed integer data in ASCII form,\n");
|
|
(void) HDfprintf(stdout,
|
|
"\t INPUT-CLASS \"TEXTUIN\" denotes an ASCII text \n");
|
|
(void) HDfprintf(stdout,
|
|
"\t file with unsigned integer data in ASCII form,\n");
|
|
(void) HDfprintf(stdout,
|
|
"\t \"TEXTFP\" denotes an ASCII text file containing\n");
|
|
(void) HDfprintf(stdout, "\t floating point data in the fixed notation\n");
|
|
(void) HDfprintf(stdout, "\t (325.34),\n");
|
|
(void) HDfprintf(stdout,
|
|
"\t \"FP\" denotes a floating point binary file,\n");
|
|
(void) HDfprintf(stdout,
|
|
"\t \"IN\" denotes a signed integer binary file,\n");
|
|
(void) HDfprintf(stdout,
|
|
"\t \"UIN\" denotes an unsigned integer binary file,\n");
|
|
(void) HDfprintf(stdout, "\t & \"STR\" denotes an ASCII text file the \n");
|
|
(void) HDfprintf(stdout,
|
|
"\t contents of which should be stored as an 1-D \n");
|
|
(void) HDfprintf(stdout, "\t array of strings.\n");
|
|
(void) HDfprintf(stdout, "\t If INPUT-CLASS is \"STR\", then RANK, \n");
|
|
(void) HDfprintf(stdout,
|
|
"\t DIMENSION-SIZES, OUTPUT-CLASS, OUTPUT-SIZE, \n");
|
|
(void) HDfprintf(stdout, "\t OUTPUT-ARCHITECTURE and OUTPUT-BYTE-ORDER \n");
|
|
(void) HDfprintf(stdout, "\t will be ignored.\n\n\n");
|
|
(void) HDfprintf(stdout, "\t INPUT-SIZE:\n");
|
|
(void) HDfprintf(stdout,
|
|
"\t Integer denoting the size of the input data \n");
|
|
(void) HDfprintf(stdout, "\t (8, 16, 32, 64). \n\n");
|
|
(void) HDfprintf(stdout, "\t For floating point,\n");
|
|
(void) HDfprintf(stdout, "\t INPUT-SIZE can be 32 or 64.\n");
|
|
(void) HDfprintf(stdout, "\t For integers (signed and unsigned)\n");
|
|
(void) HDfprintf(stdout, "\t INPUT-SIZE can be 8, 16, 32 or 64.\n\n");
|
|
(void) HDfprintf(stdout, "\t RANK:\n");
|
|
(void) HDfprintf(stdout,
|
|
"\t Integer denoting the number of dimensions.\n\n");
|
|
(void) HDfprintf(stdout, "\t DIMENSION-SIZES:\n");
|
|
(void) HDfprintf(stdout,
|
|
"\t Integers separated by spaces to denote the \n");
|
|
(void) HDfprintf(stdout, "\t dimension sizes for the no. of dimensions \n");
|
|
(void) HDfprintf(stdout, "\t determined by rank.\n\n");
|
|
(void) HDfprintf(stdout, "\t OUTPUT-CLASS:\n");
|
|
(void) HDfprintf(stdout,
|
|
"\t String dentoting data type of the dataset to \n");
|
|
(void) HDfprintf(stdout, "\t be written (\"IN\",\"FP\", \"UIN\")\n\n");
|
|
(void) HDfprintf(stdout, "\t OUTPUT-SIZE:\n");
|
|
(void) HDfprintf(stdout,
|
|
"\t Integer denoting the size of the data in the \n");
|
|
(void) HDfprintf(stdout, "\t output dataset to be written.\n");
|
|
(void) HDfprintf(stdout,
|
|
"\t If OUTPUT-CLASS is \"FP\", OUTPUT-SIZE can be \n");
|
|
(void) HDfprintf(stdout, "\t 32 or 64.\n");
|
|
(void) HDfprintf(stdout,
|
|
"\t If OUTPUT-CLASS is \"IN\" or \"UIN\", OUTPUT-SIZE\n");
|
|
(void) HDfprintf(stdout, "\t can be 8, 16, 32 or 64.\n\n");
|
|
(void) HDfprintf(stdout, "\t OUTPUT-ARCHITECTURE:\n");
|
|
(void) HDfprintf(stdout, "\t STRING denoting the type of output \n");
|
|
(void) HDfprintf(stdout,
|
|
"\t architecture. Can accept the following values\n");
|
|
(void) HDfprintf(stdout, "\t STD\n");
|
|
(void) HDfprintf(stdout, "\t IEEE\n");
|
|
(void) HDfprintf(stdout, "\t INTEL\n");
|
|
(void) HDfprintf(stdout, "\t CRAY\n");
|
|
(void) HDfprintf(stdout, "\t MIPS\n");
|
|
(void) HDfprintf(stdout, "\t ALPHA\n");
|
|
(void) HDfprintf(stdout, "\t NATIVE (default)\n");
|
|
(void) HDfprintf(stdout, "\t UNIX\n\n");
|
|
(void) HDfprintf(stdout, "\t OUTPUT-BYTE-ORDER:\n");
|
|
(void) HDfprintf(stdout,
|
|
"\t String denoting the output-byte-order. Ignored\n");
|
|
(void) HDfprintf(stdout,
|
|
"\t if the OUTPUT-ARCHITECTURE is not specified or\n");
|
|
(void) HDfprintf(stdout, "\t if it is IEEE, UNIX or STD. Can accept the \n");
|
|
(void) HDfprintf(stdout, "\t following values.\n");
|
|
(void) HDfprintf(stdout, "\t BE (default)\n");
|
|
(void) HDfprintf(stdout, "\t LE\n\n");
|
|
(void) HDfprintf(stdout, "\t CHUNKED-DIMENSION-SIZES:\n");
|
|
(void) HDfprintf(stdout, "\t Integers separated by spaces to denote the \n");
|
|
(void) HDfprintf(stdout,
|
|
"\t dimension sizes of the chunk for the no. of \n");
|
|
(void) HDfprintf(stdout,
|
|
"\t dimensions determined by rank. Required field\n");
|
|
(void) HDfprintf(stdout,
|
|
"\t to denote that the dataset will be stored with\n");
|
|
(void) HDfprintf(stdout,
|
|
"\t chunked storage. If this field is absent the\n");
|
|
(void) HDfprintf(stdout,
|
|
"\t dataset will be stored with contiguous storage.\n\n");
|
|
(void) HDfprintf(stdout, "\t COMPRESSION-TYPE:\n");
|
|
(void) HDfprintf(stdout,
|
|
"\t String denoting the type of compression to be\n");
|
|
(void) HDfprintf(stdout, "\t used with the chunked storage. Requires the\n");
|
|
(void) HDfprintf(stdout,
|
|
"\t CHUNKED-DIMENSION-SIZES to be specified. The only \n");
|
|
(void) HDfprintf(stdout,
|
|
"\t currently supported compression method is GZIP. \n");
|
|
(void) HDfprintf(stdout, "\t Will accept the following value\n");
|
|
(void) HDfprintf(stdout, "\t GZIP\n\n");
|
|
(void) HDfprintf(stdout, "\t COMPRESSION-PARAM:\n");
|
|
(void) HDfprintf(stdout,
|
|
"\t Integer used to denote compression level and \n");
|
|
(void) HDfprintf(stdout, "\t this option is to be always specified when \n");
|
|
(void) HDfprintf(stdout,
|
|
"\t the COMPRESSION-TYPE option is specified. The\n");
|
|
(void) HDfprintf(stdout, "\t values are applicable only to GZIP \n");
|
|
(void) HDfprintf(stdout, "\t compression.\n");
|
|
(void) HDfprintf(stdout, "\t Value 1-9: The level of Compression. \n");
|
|
(void) HDfprintf(stdout, "\t 1 will result in the fastest \n");
|
|
(void) HDfprintf(stdout, "\t compression while 9 will result in \n");
|
|
(void) HDfprintf(stdout, "\t the best compression ratio. The default\n");
|
|
(void) HDfprintf(stdout, "\t level of compression is 6.\n\n");
|
|
(void) HDfprintf(stdout, "\t EXTERNAL-STORAGE:\n");
|
|
(void) HDfprintf(stdout,
|
|
"\t String to denote the name of the non-HDF5 file \n");
|
|
(void) HDfprintf(stdout,
|
|
"\t to store data to. Cannot be used if CHUNKED-\n");
|
|
(void) HDfprintf(stdout,
|
|
"\t DIMENSIONS or COMPRESSION-TYPE or EXTENDIBLE-\n");
|
|
(void) HDfprintf(stdout, "\t DATASET is specified.\n");
|
|
(void) HDfprintf(stdout, "\t Value <external-filename>: the name of the \n");
|
|
(void) HDfprintf(stdout, "\t external file as a string to be used.\n\n");
|
|
(void) HDfprintf(stdout, "\t MAXIMUM-DIMENSIONS:\n");
|
|
(void) HDfprintf(stdout, "\t Integers separated by spaces to denote the \n");
|
|
(void) HDfprintf(stdout, "\t maximum dimension sizes of all the \n");
|
|
(void) HDfprintf(stdout, "\t dimensions determined by rank. Requires the\n");
|
|
(void) HDfprintf(stdout,
|
|
"\t CHUNKED-DIMENSION-SIZES to be specified. A value of \n");
|
|
(void) HDfprintf(stdout, "\t -1 for any dimension implies UNLIMITED \n");
|
|
(void) HDfprintf(stdout,
|
|
"\t DIMENSION size for that particular dimension.\n\n");
|
|
(void) HDfprintf(stdout, "\t EXAMPLES:\n");
|
|
(void) HDfprintf(stdout, "\t 1. Configuration File may look like:\n\n");
|
|
(void) HDfprintf(stdout, "\t PATH work h5 pkamat First-set\n");
|
|
(void) HDfprintf(stdout, "\t INPUT-CLASS TEXTFP\n");
|
|
(void) HDfprintf(stdout, "\t RANK 3\n");
|
|
(void) HDfprintf(stdout, "\t DIMENSION-SIZES 5 2 4\n");
|
|
(void) HDfprintf(stdout, "\t OUTPUT-CLASS FP\n");
|
|
(void) HDfprintf(stdout, "\t OUTPUT-SIZE 64\n");
|
|
(void) HDfprintf(stdout, "\t OUTPUT-ARCHITECTURE IEEE\n");
|
|
(void) HDfprintf(stdout, "\t OUTPUT-BYTE-ORDER LE\n");
|
|
(void) HDfprintf(stdout, "\t CHUNKED-DIMENSION-SIZES 2 2 2 \n\n");
|
|
(void) HDfprintf(stdout,
|
|
"\t The above configuration will accept a floating point array \n");
|
|
(void) HDfprintf(stdout,
|
|
"\t (5 x 2 x 4) in an ASCII file with the rank and dimension sizes \n");
|
|
(void) HDfprintf(stdout,
|
|
"\t specified and will save it in a chunked data-set (of pattern \n");
|
|
(void) HDfprintf(stdout,
|
|
"\t 2 X 2 X 2) of 64-bit floating point in the little-endian order \n");
|
|
(void) HDfprintf(stdout,
|
|
"\t and IEEE architecture. The dataset will be stored at\n");
|
|
(void) HDfprintf(stdout, "\t \"/work/h5/pkamat/First-set\"\n\n");
|
|
(void) HDfprintf(stdout, "\t 2. Another configuration could be:\n\n");
|
|
(void) HDfprintf(stdout, "\t PATH Second-set\n");
|
|
(void) HDfprintf(stdout, "\t INPUT-CLASS IN \n");
|
|
(void) HDfprintf(stdout, "\t RANK 5\n");
|
|
(void) HDfprintf(stdout, "\t DIMENSION-SIZES 6 3 5 2 4\n");
|
|
(void) HDfprintf(stdout, "\t OUTPUT-CLASS IN\n");
|
|
(void) HDfprintf(stdout, "\t OUTPUT-SIZE 32\n");
|
|
(void) HDfprintf(stdout, "\t CHUNKED-DIMENSION-SIZES 2 2 2 2 2\n");
|
|
(void) HDfprintf(stdout, "\t EXTENDIBLE-DATASET 1 3 \n");
|
|
(void) HDfprintf(stdout, "\t COMPRESSION-TYPE GZIP\n");
|
|
(void) HDfprintf(stdout, "\t COMPRESSION-PARAM 7\n\n\n");
|
|
(void) HDfprintf(stdout,
|
|
"\t The above configuration will accept an integer array \n");
|
|
(void) HDfprintf(stdout,
|
|
"\t (6 X 3 X 5 x 2 x 4) in a binary file with the rank and \n");
|
|
(void) HDfprintf(stdout,
|
|
"\t dimension sizes specified and will save it in a chunked data-set\n");
|
|
(void) HDfprintf(stdout,
|
|
"\t (of pattern 2 X 2 X 2 X 2 X 2) of 32-bit floating point in \n");
|
|
(void) HDfprintf(stdout,
|
|
"\t native format (as output-architecture is not specified). The \n");
|
|
(void) HDfprintf(stdout,
|
|
"\t first and the third dimension will be defined as unlimited. The \n");
|
|
(void) HDfprintf(stdout,
|
|
"\t data-set will be compressed using GZIP and a compression level \n");
|
|
(void) HDfprintf(stdout, "\t of 7.\n");
|
|
(void) HDfprintf(stdout,
|
|
"\t The dataset will be stored at \"/Second-set\"\n\n");
|
|
return;
|
|
}
|
|
|
|
void usage(char *name)
|
|
{
|
|
(void) HDfprintf(stdout, "\nUsage:\t%s -h[elp], OR\n", name);
|
|
(void) HDfprintf(stdout,
|
|
"\t%s <infile> -c[onfig] <configfile> \
|
|
[<infile> -c[config] <configfile>...] -o[utfile] <outfile> \n\n", name);
|
|
return;
|
|
}
|
|
|