diff options
author | Allen Byrne <byrn@hdfgroup.org> | 2020-10-01 14:04:36 (GMT) |
---|---|---|
committer | Allen Byrne <byrn@hdfgroup.org> | 2020-10-01 14:04:36 (GMT) |
commit | f1ba03cea5b82699a984c80bd2deac14fdc8df18 (patch) | |
tree | ebe777c3e0b83f4c4cec9212731da9ebe0a0cfd3 /tools/src/h5import | |
parent | 10343c197906415388f2a4c8d292e21d25cf7381 (diff) | |
download | hdf5-f1ba03cea5b82699a984c80bd2deac14fdc8df18.zip hdf5-f1ba03cea5b82699a984c80bd2deac14fdc8df18.tar.gz hdf5-f1ba03cea5b82699a984c80bd2deac14fdc8df18.tar.bz2 |
Source formatted
Diffstat (limited to 'tools/src/h5import')
-rw-r--r-- | tools/src/h5import/h5import.c | 4932 | ||||
-rw-r--r-- | tools/src/h5import/h5import.h | 196 |
2 files changed, 2532 insertions, 2596 deletions
diff --git a/tools/src/h5import/h5import.c b/tools/src/h5import/h5import.c index 4a642e0..14de44b 100644 --- a/tools/src/h5import/h5import.c +++ b/tools/src/h5import/h5import.c @@ -27,68 +27,69 @@ #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 getInputByteOrder(struct Input *in, FILE *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); -uint16_t swap_uint16(uint16_t val); -int16_t swap_int16(int16_t val); -uint32_t swap_uint32(uint32_t val); -int32_t swap_int32(int32_t val); -int64_t swap_int64(int64_t val); -uint64_t swap_uint64(uint64_t val); - -int main(int argc, char *argv[]) +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 getInputByteOrder(struct Input *in, FILE *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); +uint16_t swap_uint16(uint16_t val); +int16_t swap_int16(int16_t val); +uint32_t swap_uint32(uint32_t val); +int32_t swap_int32(int32_t val); +int64_t swap_int64(int64_t val); +uint64_t swap_uint64(uint64_t val); + +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"; - const char *err10 = "Length of output file name limited to 255 chars.\n"; + 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"; + const char *err10 = "Length of output file name limited to 255 chars.\n"; h5tools_setprogname(PROGRAMNAME); h5tools_setstatus(EXIT_SUCCESS); @@ -96,10 +97,10 @@ int main(int argc, char *argv[]) /* Initialize h5tools lib */ h5tools_init(); - (void) HDsetvbuf(stderr, (char *) NULL, _IOLBF, 0); - (void) HDsetvbuf(stdout, (char *) NULL, _IOLBF, 0); + (void)HDsetvbuf(stderr, (char *)NULL, _IOLBF, 0); + (void)HDsetvbuf(stdout, (char *)NULL, _IOLBF, 0); - if((opt = (struct Options *)HDcalloc(1, sizeof(struct Options))) == NULL) + if ((opt = (struct Options *)HDcalloc(1, sizeof(struct Options))) == NULL) goto err; if (argv[1] && (HDstrcmp("-V", argv[1]) == 0)) { @@ -111,7 +112,7 @@ int main(int argc, char *argv[]) * validate the number of command line arguments */ if (argc < 2) { - (void) HDfprintf(stderr, err1, argc); + (void)HDfprintf(stderr, err1, argc); usage(argv[0]); goto err; } @@ -129,105 +130,105 @@ int main(int argc, char *argv[]) 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; - } + 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; + break; - case 2: /* -c found; look for configfile */ - 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 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 4: /* -o found; look for outfile */ + break; - case 5: /* get outfile found */ - if (HDstrlen(argv[i]) > MAX_PATH_NAME_LENGTH) { - (void) HDfprintf(stderr, err10, argv[i]); - goto err; - } - (void) HDstrcpy(opt->outfile, argv[i]); - outfile_named = TRUE; - break; + case 5: /* get outfile found */ + if (HDstrlen(argv[i]) > MAX_PATH_NAME_LENGTH) { + (void)HDfprintf(stderr, err10, argv[i]); + goto err; + } + (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 6: /* -h found; help, then exit */ + help(argv[0]); + HDexit(EXIT_SUCCESS); + break; - case 7: /* -d found; look for dimensions */ - 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 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 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 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 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; - } + 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; + 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 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 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; + 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); + (void)HDfprintf(stderr, "%s", err3); usage(argv[0]); goto err; } @@ -252,7 +253,7 @@ int main(int argc, char *argv[]) return EXIT_SUCCESS; err: - (void) HDfprintf(stderr, "%s", err4); + (void)HDfprintf(stderr, "%s", err4); for (i = 0; i < opt->fcount; i++) { in = &(opt->infiles[i].in); if (in->sizeOfDimension) @@ -271,10 +272,11 @@ err: return EXIT_FAILURE; } -static int gtoken(char *s) +static int +gtoken(char *s) { - size_t len; - int token = ERR; + size_t len; + int token = ERR; const char *err1 = "Illegal argument: %s.\n"; @@ -284,47 +286,47 @@ static int gtoken(char *s) 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 'o': + if (!HDstrncmp("outfile", &s[1], len)) + token = OPT_o; + break; - case 'c': - if (!HDstrncmp("config", &s[1], len)) - token = OPT_c; - 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 'h': + if (!HDstrncmp("help", &s[1], len)) + token = OPT_h; + break; - case 'd': - if (!HDstrncmp("dims", &s[1], len)) - token = OPT_d; - 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 'p': + if (!HDstrncmp("path", &s[1], len)) + token = OPT_p; + break; - case 't': - if (!HDstrncmp("type", &s[1], len)) - token = OPT_t; - 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; + 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); + (void)HDfprintf(stderr, err1, s); } else { /* filename */ token = FILNAME; @@ -347,19 +349,20 @@ static int gtoken(char *s) *------------------------------------------------------------------------- */ -static int processDataFile(char *infile, struct Input *in, hid_t 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; + 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 @@ -368,10 +371,10 @@ static int processDataFile(char *infile, struct Input *in, hid_t file_id) * "UIN" denotes an unsigned integer binary file, *------------------------------------------------------------------------- */ - if (in->inputClass == 4 /* "IN" */|| in->inputClass == 3 /* "FP" */|| in->inputClass == 7 /* "UIN" */) { + 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); + (void)HDfprintf(stderr, err1, infile); goto error; } } @@ -381,85 +384,85 @@ static int processDataFile(char *infile, struct Input *in, hid_t file_id) */ else { if ((strm = HDfopen(infile, "r")) == NULL) { - (void) HDfprintf(stderr, err1, infile); + (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; - } + 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; + 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; + 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; - 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 5: /* STR */ - if (in->h5dumpInput) { - if (processStrHDFData(strm, in, file_id) == -1) { - (void) HDfprintf(stderr, err11, infile); + case 6: /* TEXTUIN */ + case 7: /* UIN */ + if (allocateUIntegerStorage(in) == -1) { + (void)HDfprintf(stderr, err6, infile); goto error; } - } - else { - if (processStrData(strm, in, file_id) == -1) { - (void) HDfprintf(stderr, err11, infile); + if (readUIntegerData(strm, in) == -1) { + (void)HDfprintf(stderr, err7, infile); goto error; } - } - - break; + 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); + default: + (void)HDfprintf(stderr, "%s", err10); goto error; - } - break; - - default: - (void) HDfprintf(stderr, "%s", err10); - goto error; } /* Set success return value */ retval = 0; error: - if(strm) + if (strm) HDfclose(strm); - return(retval); + return (retval); } -static int readIntegerData(FILE *strm, struct Input *in) +static int +readIntegerData(FILE *strm, struct Input *in) { - H5DT_INT8 *in08; + H5DT_INT8 * in08; H5DT_INT16 *in16; H5DT_INT16 temp16; H5DT_INT32 *in32; @@ -469,9 +472,9 @@ static int readIntegerData(FILE *strm, struct Input *in) H5DT_INT64 temp64; char buffer[256]; #endif - hsize_t len = 1; - hsize_t i; - int j; + 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"; @@ -481,160 +484,161 @@ static int readIntegerData(FILE *strm, struct Input *in) 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", &temp16) != 1) { - (void) HDfprintf(stderr, "%s", err1); - return (-1); - } - (*in08) = (H5DT_INT8) temp16; - } - break; + case 8: + switch (in->inputClass) { + case 0: /* TEXTIN */ + in08 = (H5DT_INT8 *)in->data; + for (i = 0; i < len; i++, in08++) { + if (fscanf(strm, "%hd", &temp16) != 1) { + (void)HDfprintf(stderr, "%s", err1); + return (-1); + } + (*in08) = (H5DT_INT8)temp16; + } + 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); - } + 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); + } #ifdef H5DEBUGIMPORT - HDprintf("readIntegerData %d (0x%.8X)\n", *in08, *in08); + HDprintf("readIntegerData %d (0x%.8X)\n", *in08, *in08); #endif - } - break; - - default: - (void) HDfprintf(stderr, "%s", err2); - return (-1); - } - break; + } + 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); + default: + (void)HDfprintf(stderr, "%s", err2); return (-1); - } } - in16 = (H5DT_INT16 *) in->data; break; - case 4: /* IN */ - for (i = 0; i < len; i++, in16++) { - if (HDfread((char *)&temp16, sizeof(H5DT_INT16), 1, strm) != 1) { - (void) HDfprintf(stderr, "%s", err1); - return (-1); - } -/* - if (in-> h5dumpInput && (in->inputByteOrder != in->outputByteOrder)) - *in16 = swap_int16(temp16); - else -*/ - *in16 = temp16; + 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 *)&temp16, sizeof(H5DT_INT16), 1, strm) != 1) { + (void)HDfprintf(stderr, "%s", err1); + return (-1); + } + /* + if (in-> h5dumpInput && (in->inputByteOrder != in->outputByteOrder)) + *in16 = swap_int16(temp16); + else + */ + *in16 = temp16; #ifdef H5DEBUGIMPORT - HDprintf("readIntegerData %d (0x%.8X)\n", *in16, temp16); + HDprintf("readIntegerData %d (0x%.8X)\n", *in16, temp16); #endif - } - break; - - default: - (void) HDfprintf(stderr, "%s", err2); - return (-1); - } - break; + } + 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); + default: + (void)HDfprintf(stderr, "%s", err2); return (-1); - } } break; - case 4: /* IN */ - for (i = 0; i < len; i++, in32++) { - if (HDfread((char *)&temp32, sizeof(H5DT_INT32), 1, strm) != 1) { - (void) HDfprintf(stderr, "%s", err1); - return (-1); - } -/* - if (in-> h5dumpInput && (in->inputByteOrder != in->outputByteOrder)) - *in32 = swap_int32(temp32); - else -*/ - *in32 = temp32; + 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 *)&temp32, sizeof(H5DT_INT32), 1, strm) != 1) { + (void)HDfprintf(stderr, "%s", err1); + return (-1); + } + /* + if (in-> h5dumpInput && (in->inputByteOrder != in->outputByteOrder)) + *in32 = swap_int32(temp32); + else + */ + *in32 = temp32; #ifdef H5DEBUGIMPORT - HDprintf("readIntegerData %d (0x%.8X = 0x%.8X)\n", *in32, *in32, temp32); + HDprintf("readIntegerData %d (0x%.8X = 0x%.8X)\n", *in32, *in32, temp32); #endif - } - break; - - default: - (void) HDfprintf(stderr, "%s", err2); - return (-1); - } - break; + } + 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); + default: + (void)HDfprintf(stderr, "%s", err2); return (-1); - } - *in64 = (H5DT_INT64) HDstrtoll(buffer, NULL, 10); } break; - case 4: /* IN */ - for (i = 0; i < len; i++, in64++) { - if (HDfread((char *)&temp64, sizeof(H5DT_INT64), 1, strm) != 1) { - (void) HDfprintf(stderr, "%s", err1); - return (-1); - } -/* - if (in-> h5dumpInput && (in->inputByteOrder != in->outputByteOrder)) - *in64 = swap_int64(temp64); - else -*/ - *in64 = temp64; +#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 *)&temp64, sizeof(H5DT_INT64), 1, strm) != 1) { + (void)HDfprintf(stderr, "%s", err1); + return (-1); + } + /* + if (in-> h5dumpInput && (in->inputByteOrder != in->outputByteOrder)) + *in64 = swap_int64(temp64); + else + */ + *in64 = temp64; #ifdef H5DEBUGIMPORT - HDprintf("readIntegerData %d (0x%.8X)\n", *in64, temp64); + HDprintf("readIntegerData %d (0x%.8X)\n", *in64, temp64); #endif + } + break; + + default: + (void)HDfprintf(stderr, "%s", err2); + 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; + default: + (void)HDfprintf(stderr, "%s", err3); + break; } return (0); } -static int readUIntegerData(FILE *strm, struct Input *in) +static int +readUIntegerData(FILE *strm, struct Input *in) { - H5DT_UINT8 *in08; + H5DT_UINT8 * in08; H5DT_UINT16 *in16; H5DT_UINT16 temp16; H5DT_UINT32 *in32; @@ -642,7 +646,7 @@ static int readUIntegerData(FILE *strm, struct Input *in) #ifdef H5_SIZEOF_LONG_LONG H5DT_UINT64 *in64; H5DT_UINT64 temp64; - char buffer[256]; + char buffer[256]; #endif hsize_t len = 1; hsize_t i; @@ -655,161 +659,162 @@ static int readUIntegerData(FILE *strm, struct Input *in) 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", &temp16) != 1) { - (void) HDfprintf(stderr, "%s", err1); - return (-1); - } - (*in08) = (H5DT_UINT8) temp16; - } - 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; + case 8: + switch (in->inputClass) { + case 6: /* TEXTUIN */ + in08 = (H5DT_UINT8 *)in->data; + for (i = 0; i < len; i++, in08++) { + if (fscanf(strm, "%hu", &temp16) != 1) { + (void)HDfprintf(stderr, "%s", err1); + return (-1); + } + (*in08) = (H5DT_UINT8)temp16; + } + break; - default: - (void) HDfprintf(stderr, "%s", err2); - return (-1); - } - 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; - 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); + default: + (void)HDfprintf(stderr, "%s", err2); return (-1); - } } break; - case 7: /* UIN */ - for (i = 0; i < len; i++, in16++) { - if (HDfread((char *)&temp16, sizeof(H5DT_UINT16), 1, strm) != 1) { - (void) HDfprintf(stderr, "%s", err1); - return (-1); - } -/* - if (in-> h5dumpInput && (in->inputByteOrder != in->outputByteOrder)) - *in16 = swap_uint16(temp16); - else -*/ - *in16 = temp16; + 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 *)&temp16, sizeof(H5DT_UINT16), 1, strm) != 1) { + (void)HDfprintf(stderr, "%s", err1); + return (-1); + } + /* + if (in-> h5dumpInput && (in->inputByteOrder != in->outputByteOrder)) + *in16 = swap_uint16(temp16); + else + */ + *in16 = temp16; #ifdef H5DEBUGIMPORT - HDprintf("readUIntegerData %d (0x%.4X = 0x%.4X)\n", *in16, *in16, temp16); + HDprintf("readUIntegerData %d (0x%.4X = 0x%.4X)\n", *in16, *in16, temp16); #endif - } - break; - - default: - (void) HDfprintf(stderr, "%s", err2); - return (-1); - } - break; + } + 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); + default: + (void)HDfprintf(stderr, "%s", err2); return (-1); - } } break; - case 7: /* UIN */ - for (i = 0; i < len; i++, in32++) { - if (HDfread((char *)&temp32, sizeof(H5DT_UINT32), 1, strm) != 1) { - (void) HDfprintf(stderr, "%s", err1); - return (-1); - } -/* - if (in-> h5dumpInput && (in->inputByteOrder != in->outputByteOrder)) - *in32 = swap_uint32(temp32); - else -*/ - *in32 = temp32; + 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 *)&temp32, sizeof(H5DT_UINT32), 1, strm) != 1) { + (void)HDfprintf(stderr, "%s", err1); + return (-1); + } + /* + if (in-> h5dumpInput && (in->inputByteOrder != in->outputByteOrder)) + *in32 = swap_uint32(temp32); + else + */ + *in32 = temp32; #ifdef H5DEBUGIMPORT - HDprintf("readUIntegerData %d (0x%.8X = 0x%.8X)\n", *in32, *in32, temp32); + HDprintf("readUIntegerData %d (0x%.8X = 0x%.8X)\n", *in32, *in32, temp32); #endif - } - break; - - default: - (void) HDfprintf(stderr, "%s", err2); - return (-1); - } - break; + } + 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); + default: + (void)HDfprintf(stderr, "%s", err2); return (-1); - } - *in64 = (H5DT_UINT64) HDstrtoll(buffer, NULL, 10); } break; - case 7: /* UIN */ - for (i = 0; i < len; i++, in64++) { - if (HDfread((char *)&temp64, sizeof(H5DT_UINT64), 1, strm) != 1) { - (void) HDfprintf(stderr, "%s", err1); - return (-1); - } -/* - if (in-> h5dumpInput && (in->inputByteOrder != in->outputByteOrder)) - *in64 = swap_uint64(temp64); - else -*/ - *in64 = temp64; +#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 *)&temp64, sizeof(H5DT_UINT64), 1, strm) != 1) { + (void)HDfprintf(stderr, "%s", err1); + return (-1); + } + /* + if (in-> h5dumpInput && (in->inputByteOrder != in->outputByteOrder)) + *in64 = swap_uint64(temp64); + else + */ + *in64 = temp64; #ifdef H5DEBUGIMPORT - HDprintf("readUIntegerData %ld (0x%.8X = 0x%.8X)\n", *in64, *in64, temp64); + HDprintf("readUIntegerData %ld (0x%.8X = 0x%.8X)\n", *in64, *in64, temp64); #endif + } + break; + + default: + (void)HDfprintf(stderr, "%s", err2); + 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; + default: + (void)HDfprintf(stderr, "%s", err3); + break; } return (0); } -static int readFloatData(FILE *strm, struct Input *in) +static int +readFloatData(FILE *strm, struct Input *in) { H5DT_FLOAT32 *fp32; - uint32_t *bfp32; - uint32_t temp32; + uint32_t * bfp32; + uint32_t temp32; H5DT_FLOAT64 *fp64; - uint64_t *bfp64; - uint64_t temp64; + uint64_t * bfp64; + uint64_t temp64; hsize_t len = 1; hsize_t i; @@ -822,113 +827,113 @@ static int readFloatData(FILE *strm, struct Input *in) 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); - } - } + 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; + fp32 = (H5DT_FLOAT32 *)in->data; + break; - /* same as TEXTFP */ - case 2: /*TEXTFPE */ + /* 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); - } - } + 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; + fp32 = (H5DT_FLOAT32 *)in->data; + break; - case 3: /* FP */ - bfp32 = (uint32_t *) in->data; - for (i = 0; i < len; i++, bfp32++) { - if (HDfread((char *)&temp32, sizeof(uint32_t), 1, strm) != 1) { - (void) HDfprintf(stderr, "%s", err1); - return (-1); - } -/* - if (in-> h5dumpInput && (in->inputByteOrder != in->outputByteOrder)) - *bfp32 = swap_uint32(temp32); - else -*/ - *bfp32 = temp32; + case 3: /* FP */ + bfp32 = (uint32_t *)in->data; + for (i = 0; i < len; i++, bfp32++) { + if (HDfread((char *)&temp32, sizeof(uint32_t), 1, strm) != 1) { + (void)HDfprintf(stderr, "%s", err1); + return (-1); + } + /* + if (in-> h5dumpInput && (in->inputByteOrder != in->outputByteOrder)) + *bfp32 = swap_uint32(temp32); + else + */ + *bfp32 = temp32; #ifdef H5DEBUGIMPORT - HDprintf("readFloatData %ld (0x%.8X = 0x%.8X)\n", *bfp32, *bfp32, temp32); + HDprintf("readFloatData %ld (0x%.8X = 0x%.8X)\n", *bfp32, *bfp32, temp32); #endif - } - break; - - default: - (void) HDfprintf(stderr, "%s", err2); - return (-1); - } - break; + } + 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); + default: + (void)HDfprintf(stderr, "%s", err2); return (-1); - } } - - fp64 = (H5DT_FLOAT64 *) in->data; break; - /* same as TEXTFP */ - case 2: /*TEXTFPE */ + 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; - for (i = 0; i < len; i++, fp64++) { - if (fscanf(strm, "%lf", fp64) != 1) { - (void) HDfprintf(stderr, "%s", err1); - return (-1); - } - } + /* same as TEXTFP */ + case 2: /*TEXTFPE */ - fp64 = (H5DT_FLOAT64 *) in->data; - break; + for (i = 0; i < len; i++, fp64++) { + if (fscanf(strm, "%lf", fp64) != 1) { + (void)HDfprintf(stderr, "%s", err1); + return (-1); + } + } - case 3: /* FP */ - bfp64 = (uint64_t *) in->data; - for (i = 0; i < len; i++, bfp64++) { - if (HDfread((char *)&temp64, sizeof(uint64_t), 1, strm) != 1) { - (void) HDfprintf(stderr, "%s", err1); - return (-1); - } -/* - if (in-> h5dumpInput && (in->inputByteOrder != in->outputByteOrder)) - *bfp64 = swap_uint64(temp64); - else -*/ - *bfp64 = temp64; + fp64 = (H5DT_FLOAT64 *)in->data; + break; + + case 3: /* FP */ + bfp64 = (uint64_t *)in->data; + for (i = 0; i < len; i++, bfp64++) { + if (HDfread((char *)&temp64, sizeof(uint64_t), 1, strm) != 1) { + (void)HDfprintf(stderr, "%s", err1); + return (-1); + } + /* + if (in-> h5dumpInput && (in->inputByteOrder != in->outputByteOrder)) + *bfp64 = swap_uint64(temp64); + else + */ + *bfp64 = temp64; #ifdef H5DEBUGIMPORT - HDprintf("readFloatData %ld (0x%.16lX)\n", *bfp64, temp64); + HDprintf("readFloatData %ld (0x%.16lX)\n", *bfp64, temp64); #endif + } + break; + + default: + (void)HDfprintf(stderr, "%s", err2); + return (-1); } break; default: - (void) HDfprintf(stderr, "%s", err2); - return (-1); - } - break; - - default: - (void) HDfprintf(stderr, "%s", err3); - break; + (void)HDfprintf(stderr, "%s", err3); + break; } return (0); } @@ -947,7 +952,8 @@ static int readFloatData(FILE *strm, struct Input *in) * *------------------------------------------------------------------------- */ -static int processStrData(FILE *strm, struct Input *in, hid_t file_id) +static int +processStrData(FILE *strm, struct Input *in, hid_t file_id) { hid_t group_id; hid_t dset_id; @@ -968,8 +974,8 @@ static int processStrData(FILE *strm, struct Input *in, hid_t file_id) *------------------------------------------------------------------------- */ - while(EOF != (c = HDfgetc(strm))) - if (c == 10) /* eol */ + while (EOF != (c = HDfgetc(strm))) + if (c == 10) /* eol */ nlines++; if (!nlines) @@ -997,13 +1003,14 @@ static int processStrData(FILE *strm, struct Input *in, hid_t file_id) { /* create parent groups */ if (in->path.count > 1) { - j = 0; + 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); + group_id = + H5Gcreate2(group_id, in->path.group[j], H5P_DEFAULT, H5P_DEFAULT, H5P_DEFAULT); handle = group_id; break; } @@ -1013,7 +1020,7 @@ static int processStrData(FILE *strm, struct Input *in, hid_t file_id) } else { handle = file_id; - j = 0; + j = 0; } /*enable error reporting */ @@ -1026,21 +1033,22 @@ static int processStrData(FILE *strm, struct Input *in, hid_t file_id) 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) + 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))) { + while (EOF != (c = HDfgetc(strm))) { str[i] = (char)c; i++; if (c == 10) { /* eol */ - char *str2 = str; - hid_t fspace_id; + char * str2 = str; + hid_t fspace_id; hsize_t start[1]; - hsize_t count[1] = { 1 }; + hsize_t count[1] = {1}; str[i - 1] = '\0'; /* terminate string */ @@ -1058,9 +1066,8 @@ static int processStrData(FILE *strm, struct Input *in, hid_t file_id) if (H5Sclose(fspace_id) < 0) goto out; - i = 0; + i = 0; str[0] = '\0'; - } } @@ -1087,20 +1094,21 @@ out: * *------------------------------------------------------------------------- */ -static int processStrHDFData(FILE *strm, struct Input *in, hid_t file_id) +static int +processStrHDFData(FILE *strm, struct Input *in, hid_t file_id) { - hid_t group_id = H5I_INVALID_HID; - hid_t dset_id = H5I_INVALID_HID; - hid_t space_id = H5I_INVALID_HID; - hid_t mspace_id = H5I_INVALID_HID; - hid_t type_id = H5I_INVALID_HID; - hid_t handle = H5I_INVALID_HID; - char *str1 = NULL; - char *str2 = NULL; - char *str3 = NULL; - char str[1024] = ""; + hid_t group_id = H5I_INVALID_HID; + hid_t dset_id = H5I_INVALID_HID; + hid_t space_id = H5I_INVALID_HID; + hid_t mspace_id = H5I_INVALID_HID; + hid_t type_id = H5I_INVALID_HID; + hid_t handle = H5I_INVALID_HID; + char * str1 = NULL; + char * str2 = NULL; + char * str3 = NULL; + char str[1024] = ""; int j; - hsize_t line; + hsize_t line; /*------------------------------------------------------------------------- * read file and generate an HDF5 dataset @@ -1121,13 +1129,14 @@ static int processStrHDFData(FILE *strm, struct Input *in, hid_t file_id) { /* create parent groups */ if (in->path.count > 1) { - j = 0; + 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); + group_id = + H5Gcreate2(group_id, in->path.group[j], H5P_DEFAULT, H5P_DEFAULT, H5P_DEFAULT); handle = group_id; break; } @@ -1137,7 +1146,7 @@ static int processStrHDFData(FILE *strm, struct Input *in, hid_t file_id) } else { handle = file_id; - j = 0; + j = 0; } /*enable error reporting */ @@ -1153,67 +1162,69 @@ static int processStrHDFData(FILE *strm, struct Input *in, hid_t file_id) 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) + if ((dset_id = H5Dcreate2(handle, in->path.group[j], type_id, space_id, H5P_DEFAULT, H5P_DEFAULT, + H5P_DEFAULT)) < 0) goto out; #ifdef H5DEBUGIMPORT HDprintf("processStrHDFData DATATYPE STRING ready to process strings\n"); #endif line = 0; - j = 0; + j = 0; - while (HDfgets(str,sizeof(str),strm)) { + while (HDfgets(str, sizeof(str), strm)) { str1 = str; str2 = NULL; str3 = NULL; #ifdef H5DEBUGIMPORT - HDprintf("processStrHDFData DATATYPE STRING[%llu]={%s}\n", (unsigned long long)line, str1); + HDprintf("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) { + /* process string to remove the first and last quote char */ + str2 = strchr(str1, '"'); + if (str2 != NULL) { #ifdef H5DEBUGIMPORT - HDprintf("processStrHDFData DATATYPE STRING len:%d for {%s}\n", HDstrlen(str2), str2); + HDprintf("processStrHDFData DATATYPE STRING len:%d for {%s}\n", HDstrlen(str2), str2); #endif - str2++; + str2++; #ifdef H5DEBUGIMPORT - HDprintf("processStrHDFData DATATYPE STRING len:%d for {%s}\n", HDstrlen(str2), str2); + HDprintf("processStrHDFData DATATYPE STRING len:%d for {%s}\n", HDstrlen(str2), str2); #endif - str3 = strrchr(str2, '"'); - if (str3 != NULL) { + str3 = strrchr(str2, '"'); + if (str3 != NULL) { #ifdef H5DEBUGIMPORT - HDprintf("processStrHDFData DATATYPE STRING len:%d for {%s}\n", HDstrlen(str3), str3); + HDprintf("processStrHDFData DATATYPE STRING len:%d for {%s}\n", HDstrlen(str3), str3); #endif - *str3 = '\0'; + *str3 = '\0'; #ifdef H5DEBUGIMPORT - HDprintf("processStrHDFData DATATYPE STRING len:%d for {%s}\n", HDstrlen(str2), str2); + HDprintf("processStrHDFData DATATYPE STRING len:%d for {%s}\n", HDstrlen(str2), str2); #endif - if(HDstrlen(str2) > 0) { - hid_t fspace_id; - hsize_t start[1]; - hsize_t count[1] = { 1 }; + if (HDstrlen(str2) > 0) { + hid_t fspace_id; + hsize_t start[1]; + hsize_t count[1] = {1}; #ifdef H5DEBUGIMPORT - HDprintf("processStrHDFData DATATYPE STRING[%llu] store %s\n", (unsigned long long)line, str2); + HDprintf("processStrHDFData DATATYPE STRING[%llu] store %s\n", (unsigned long long)line, + str2); #endif - if ((fspace_id = H5Dget_space(dset_id)) < 0) - goto out; + if ((fspace_id = H5Dget_space(dset_id)) < 0) + goto out; - start[0] = line++; + start[0] = line++; - if (H5Sselect_hyperslab(fspace_id, H5S_SELECT_SET, start, NULL, count, NULL) < 0) - goto out; + 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 (H5Dwrite(dset_id, type_id, mspace_id, fspace_id, H5P_DEFAULT, &str2) < 0) + goto out; - if (H5Sclose(fspace_id) < 0) - goto out; - } + if (H5Sclose(fspace_id) < 0) + goto out; } } + } str[0] = '\0'; j++; } @@ -1233,21 +1244,22 @@ out: #ifdef H5DEBUGIMPORT HDprintf("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; + /* 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) +static int +allocateIntegerStorage(struct Input *in) { hsize_t len = 1; int j; @@ -1258,44 +1270,45 @@ static int allocateIntegerStorage(struct Input *in) 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 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 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 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; + 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; + default: + (void)HDfprintf(stderr, "%s", err2); + break; } return (0); } -static int allocateUIntegerStorage(struct Input *in) +static int +allocateUIntegerStorage(struct Input *in) { - hsize_t len = 1; + 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; @@ -1304,42 +1317,43 @@ static int allocateUIntegerStorage(struct Input *in) 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 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 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 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; + 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; + default: + (void)HDfprintf(stderr, "%s", err2); + break; } return (0); } -static int allocateFloatStorage(struct Input *in) +static int +allocateFloatStorage(struct Input *in) { hsize_t len = 1; int j; @@ -1350,54 +1364,55 @@ static int allocateFloatStorage(struct Input *in) 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 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; + 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; + default: + (void)HDfprintf(stderr, "%s", err2); + break; } return (0); } -static int processConfigurationFile(char *infile, struct Input *in) +static int +processConfigurationFile(char *infile, struct Input *in) { - FILE *strm = NULL; - char key[MAX_PATH_NAME_LENGTH]; - int kindex; - char temp[MAX_PATH_NAME_LENGTH]; - 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: %s 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"; + FILE *strm = NULL; + char key[MAX_PATH_NAME_LENGTH]; + int kindex; + char temp[MAX_PATH_NAME_LENGTH]; + 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: %s 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"; @@ -1417,10 +1432,10 @@ static int processConfigurationFile(char *infile, struct Input *in) 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"; - const char *err20 = "Unable to get subset values.\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"; + const char *err20 = "Unable to get subset values.\n"; /* create vector to map which keywords have been found check vector after each keyword to check for violation @@ -1429,17 +1444,17 @@ static int processConfigurationFile(char *infile, struct Input *in) */ /* Initialize machine endian */ - volatile uint32_t ibyte=0x01234567; + volatile uint32_t ibyte = 0x01234567; /* 0 for big endian, 1 for little endian. */ - if ((*((volatile uint8_t*)(&ibyte))) == 0x67) { + if ((*((volatile uint8_t *)(&ibyte))) == 0x67) { if ((kindex = OutputByteOrderStrToInt("LE")) == -1) { - (void) HDfprintf(stderr, "%s", err11e); + (void)HDfprintf(stderr, "%s", err11e); return (-1); } } else { if ((kindex = OutputByteOrderStrToInt("BE")) == -1) { - (void) HDfprintf(stderr, "%s", err11e); + (void)HDfprintf(stderr, "%s", err11e); return (-1); } } @@ -1450,64 +1465,64 @@ static int processConfigurationFile(char *infile, struct Input *in) in->inputArchitecture = 0; /* default to NATIVE */ if ((strm = HDfopen(infile, "r")) == NULL) { - (void) HDfprintf(stderr, err1, infile); + (void)HDfprintf(stderr, err1, infile); goto error; } scanret = fscanf(strm, "%254s", key); - if((scanret == 1) && !HDstrcmp("HDF5", key)) { + if ((scanret == 1) && !HDstrcmp("HDF5", key)) { #ifdef H5DEBUGIMPORT int pndx; HDprintf("\nh5dump file\n"); #endif in->h5dumpInput = 1; - scanret = fscanf(strm, "%254s", temp); /* filename */ - scanret = fscanf(strm, "%254s", temp); /* start bracket */ - scanret = fscanf(strm, "%254s", key); /* DATASET */ + scanret = fscanf(strm, "%254s", temp); /* filename */ + scanret = fscanf(strm, "%254s", temp); /* start bracket */ + scanret = fscanf(strm, "%254s", key); /* DATASET */ while (scanret == 1) { - if(!HDstrcmp("DATASET", key)) { /* PATH */ + if (!HDstrcmp("DATASET", key)) { /* PATH */ #ifdef H5DEBUGIMPORT HDprintf("h5dump DATASET key\n"); #endif if (in->configOptionVector[PATH] == 1) { - (void) HDfprintf(stderr, err3a, infile); + (void)HDfprintf(stderr, err3a, infile); goto error; } if (fscanf(strm, "%254s", temp) != 1) { - (void) HDfprintf(stderr, "%s", err18); + (void)HDfprintf(stderr, "%s", err18); goto error; } #ifdef H5DEBUGIMPORT HDprintf("h5dump DATASET %s found\n", temp); #endif if (parsePathInfo(&in->path, temp) == -1) { - (void) HDfprintf(stderr, err3b, infile); + (void)HDfprintf(stderr, err3b, infile); goto error; } in->configOptionVector[PATH] = 1; - scanret = fscanf(strm, "%254s", temp); /* start bracket */ + scanret = fscanf(strm, "%254s", temp); /* start bracket */ #ifdef H5DEBUGIMPORT HDprintf("h5dump DATASET %s found\n", temp); #endif - } /* if(!HDstrcmp("DATASET", key)) PATH */ - else if(!HDstrcmp("DATATYPE", key)) { /* INPUT-CLASS */ + } /* if(!HDstrcmp("DATASET", key)) PATH */ + else if (!HDstrcmp("DATATYPE", key)) { /* INPUT-CLASS */ #ifdef H5DEBUGIMPORT HDprintf("h5dump DATATYPE key\n"); #endif if (in->configOptionVector[INPUT_CLASS] == 1) { - (void) HDfprintf(stderr, err4a, infile); + (void)HDfprintf(stderr, err4a, infile); goto error; } if (fscanf(strm, "%254s", temp) != 1) { - (void) HDfprintf(stderr, "%s", err18); + (void)HDfprintf(stderr, "%s", err18); goto error; } #ifdef H5DEBUGIMPORT HDprintf("h5dump DATATYPE %s found\n", temp); #endif if ((kindex = getInputClassType(in, temp)) == -1) { - (void) HDfprintf(stderr, err4b, infile); + (void)HDfprintf(stderr, err4b, infile); goto error; } #ifdef H5DEBUGIMPORT @@ -1520,8 +1535,7 @@ static int processConfigurationFile(char *infile, struct Input *in) 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) + if (in->inputClass == 1 || in->inputClass == 2 || in->inputClass == 3) in->outputClass = 1; if (in->inputClass == 6 || in->inputClass == 7) in->outputClass = 2; @@ -1530,27 +1544,27 @@ static int processConfigurationFile(char *infile, struct Input *in) HDprintf("h5dump DATATYPE type %d outputClass\n", in->outputClass); #endif - if(in->inputClass == 5) { /* STRING */ + if (in->inputClass == 5) { /* STRING */ int get_next_prop = 1; - in->outputClass = -1; + in->outputClass = -1; #ifdef H5DEBUGIMPORT HDprintf("h5dump DATATYPE STRING found\n"); #endif if (fscanf(strm, "%254s", temp) != 1) { /* start bracket */ - (void) HDfprintf(stderr, "%s", err18); + (void)HDfprintf(stderr, "%s", err18); goto error; } #ifdef H5DEBUGIMPORT HDprintf("h5dump DATATYPE STRING %s found\n", temp); #endif if (fscanf(strm, "%254s", temp) != 1) { /* string properties */ - (void) HDfprintf(stderr, "%s", err18); + (void)HDfprintf(stderr, "%s", err18); goto error; } while (get_next_prop) { - if(!HDstrcmp("STRSIZE", temp)) { /* STRSIZE */ + if (!HDstrcmp("STRSIZE", temp)) { /* STRSIZE */ if (fscanf(strm, "%254s", temp) != 1) { - (void) HDfprintf(stderr, "%s", err19); + (void)HDfprintf(stderr, "%s", err19); goto error; } #ifdef H5DEBUGIMPORT @@ -1558,9 +1572,9 @@ static int processConfigurationFile(char *infile, struct Input *in) #endif if (HDstrcmp("H5T_VARIABLE;", temp)) { char *more = temp; - ival = (int)HDstrtol(more, &more, 10); + ival = (int)HDstrtol(more, &more, 10); if (getInputSize(in, ival) == -1) { - (void) HDfprintf(stderr, err5b, infile); + (void)HDfprintf(stderr, err5b, infile); goto error; } #ifdef H5DEBUGIMPORT @@ -1568,28 +1582,27 @@ static int processConfigurationFile(char *infile, struct Input *in) #endif } } - else if(!HDstrcmp("STRPAD", temp)) { /* STRPAD */ + else if (!HDstrcmp("STRPAD", temp)) { /* STRPAD */ if (fscanf(strm, "%254s", temp) != 1) { /* STRPAD type */ - (void) HDfprintf(stderr, "%s", err18); + (void)HDfprintf(stderr, "%s", err18); goto error; } #ifdef H5DEBUGIMPORT HDprintf("h5dump DATATYPE STRING STRPAD %s found\n", temp); #endif } - else if(!HDstrcmp("CSET", key)) { /* CSET */ + else if (!HDstrcmp("CSET", key)) { /* CSET */ if (fscanf(strm, "%254s", temp) != 1) { /* CSET type */ - (void) HDfprintf(stderr, "%s", err18); + (void)HDfprintf(stderr, "%s", err18); goto error; } #ifdef H5DEBUGIMPORT HDprintf("h5dump DATATYPE STRING CSET %s found\n", temp); #endif - } - else if(!HDstrcmp("CTYPE", temp)) { /* CTYPE */ + else if (!HDstrcmp("CTYPE", temp)) { /* CTYPE */ if (fscanf(strm, "%254s", temp) != 1) { /* CTYPE type */ - (void) HDfprintf(stderr, "%s", err18); + (void)HDfprintf(stderr, "%s", err18); goto error; } #ifdef H5DEBUGIMPORT @@ -1597,90 +1610,91 @@ static int processConfigurationFile(char *infile, struct Input *in) #endif } /* if(!HDstrcmp("CSET", key)) */ if (fscanf(strm, "%254s", temp) != 1) { - (void) HDfprintf(stderr, "%s", err18); + (void)HDfprintf(stderr, "%s", err18); goto error; } #ifdef H5DEBUGIMPORT HDprintf("h5dump DATATYPE STRING %s found\n", temp); #endif - if(!HDstrcmp("}", temp)) { /* end bracket */ + 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]; + } /* 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 HDprintf("h5dump DATASPACE key\n"); #endif if (fscanf(strm, "%254s", temp) != 1) { - (void) HDfprintf(stderr, "%s", err18); + (void)HDfprintf(stderr, "%s", err18); goto error; } - if(!HDstrcmp("SCALAR", temp)) { /* SCALAR */ + if (!HDstrcmp("SCALAR", temp)) { /* SCALAR */ in->rank = 0; - } /* if(!HDstrcmp("SCALAR", key)) */ - else if(!HDstrcmp("NULL", temp)) { /* NULL */ - (void) HDfprintf(stderr, err6b, infile); + } /* 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 */ + } /* else if(!HDstrcmp("NULL", key)) */ + else if (!HDstrcmp("SIMPLE", temp)) { /* SIMPLE */ int icount = 0; #ifdef H5DEBUGIMPORT HDprintf("h5dump DATASPACE SIMPLE found\n"); #endif if (fscanf(strm, "%254s", temp) != 1) { /* start bracket */ - (void) HDfprintf(stderr, err6b, infile); + (void)HDfprintf(stderr, err6b, infile); goto error; } #ifdef H5DEBUGIMPORT HDprintf("h5dump DATASPACE SIMPLE %s found\n", temp); #endif if (fscanf(strm, "%254s", temp) != 1) { /* start paren */ - (void) HDfprintf(stderr, err6b, infile); + (void)HDfprintf(stderr, err6b, infile); goto error; } #ifdef H5DEBUGIMPORT HDprintf("h5dump DATASPACE SIMPLE %s found\n", temp); #endif - if(!HDstrcmp("(", temp)) { /* start paren */ + if (!HDstrcmp("(", temp)) { /* start paren */ int get_next_dim = 1; - int i = 0; + int i = 0; if (fscanf(strm, "%254s", temp) != 1) { /* Dimension with optional comma */ - (void) HDfprintf(stderr, err16c, infile); + (void)HDfprintf(stderr, err16c, infile); goto error; } #ifdef H5DEBUGIMPORT HDprintf("h5dump DATASPACE SIMPLE %s found\n", temp); #endif while (get_next_dim) { - char *more = temp; + char *more = temp; temp_dims[icount] = HDstrtoull(more, &more, 10); if (fscanf(strm, "%254s", temp) != 1) { /* Dimension or end paren */ - (void) HDfprintf(stderr, err6b, infile); + (void)HDfprintf(stderr, err6b, infile); goto error; } #ifdef H5DEBUGIMPORT HDprintf("h5dump DATASPACE SIMPLE %s found\n", temp); #endif - if(!HDstrcmp(")", temp)) { /* end paren */ - in->rank = ++icount; + if (!HDstrcmp(")", temp)) { /* end paren */ + in->rank = ++icount; in->configOptionVector[RANK] = 1; - get_next_dim = 0; + get_next_dim = 0; } else { /* Dimension */ icount++; if (icount > MAX_NUM_DIMENSION) { - (void) HDfprintf(stderr, "Invalid value for rank.\n"); + (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) { + if ((in->sizeOfDimension = (hsize_t *)HDmalloc((size_t)in->rank * sizeof(hsize_t))) == + NULL) { goto error; } #ifdef H5DEBUGIMPORT @@ -1699,36 +1713,37 @@ static int processConfigurationFile(char *infile, struct Input *in) in->configOptionVector[DIM] = 1; } /* if(!HDstrcmp("(", key)) start paren */ else { - (void) HDfprintf(stderr, err5b, infile); + (void)HDfprintf(stderr, err5b, infile); goto error; } if (fscanf(strm, "%254s", temp) != 1) { - (void) HDfprintf(stderr, "%s", err18); + (void)HDfprintf(stderr, "%s", err18); goto error; } #ifdef H5DEBUGIMPORT HDprintf("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) { + if (!HDstrcmp("/", temp)) { /* / max dims */ + if ((in->maxsizeOfDimension = + (hsize_t *)HDmalloc((size_t)in->rank * sizeof(hsize_t))) == NULL) { goto error; } if (fscanf(strm, "%254s", temp) != 1) { /* start paren */ - (void) HDfprintf(stderr, err6b, infile); + (void)HDfprintf(stderr, err6b, infile); goto error; } #ifdef H5DEBUGIMPORT HDprintf("h5dump DATASPACE SIMPLE %s found\n", temp); #endif - if(!HDstrcmp("(", temp)) { /* start paren */ + if (!HDstrcmp("(", temp)) { /* start paren */ int get_next_dim = 1; - int i = 0; + int i = 0; #ifdef H5DEBUGIMPORT HDprintf("h5dump DATASPACE SIMPLE process max dim values\n"); #endif if (fscanf(strm, "%254s", temp) != 1) { /* max dim with optional comma */ - (void) HDfprintf(stderr, err16c, infile); + (void)HDfprintf(stderr, err16c, infile); goto error; } #ifdef H5DEBUGIMPORT @@ -1738,28 +1753,29 @@ static int processConfigurationFile(char *infile, struct Input *in) #ifdef H5DEBUGIMPORT HDprintf("h5dump DATASPACE SIMPLE get max dim value\n"); #endif - if(!HDstrcmp("H5S_UNLIMITED", temp) || !HDstrcmp("H5S_UNLIMITED,", temp)) { /* unlimited */ - in->maxsizeOfDimension[i] = H5S_UNLIMITED; + if (!HDstrcmp("H5S_UNLIMITED", temp) || + !HDstrcmp("H5S_UNLIMITED,", temp)) { /* unlimited */ + in->maxsizeOfDimension[i] = H5S_UNLIMITED; in->configOptionVector[EXTEND] = 1; } else { - char *more = temp; + char *more = temp; in->maxsizeOfDimension[i] = HDstrtoull(more, &more, 10); } if (fscanf(strm, "%254s", temp) != 1) { /* max dim or end paren */ - (void) HDfprintf(stderr, err16c, infile); + (void)HDfprintf(stderr, err16c, infile); goto error; } #ifdef H5DEBUGIMPORT HDprintf("h5dump DATASPACE SIMPLE %s found\n", temp); #endif - if(!HDstrcmp(")", temp)) { /* end paren */ + 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"); + (void)HDfprintf(stderr, "Invalid value for rank.\n"); goto error; } } @@ -1774,7 +1790,7 @@ static int processConfigurationFile(char *infile, struct Input *in) #endif } /* if(!HDstrcmp("(", key)) start paren */ else { - (void) HDfprintf(stderr, err16c, infile); + (void)HDfprintf(stderr, err16c, infile); goto error; } scanret = fscanf(strm, "%254s", temp); /* end bracket */ @@ -1782,71 +1798,71 @@ static int processConfigurationFile(char *infile, struct Input *in) HDprintf("h5dump DATASPACE SIMPLE %s found\n", temp); #endif } /* if(!HDstrcmp("/", key)) max dims separator */ - } /* else if(!HDstrcmp("SIMPLE", key)) */ + } /* else if(!HDstrcmp("SIMPLE", key)) */ else { - (void) HDfprintf(stderr, err5b, infile); + (void)HDfprintf(stderr, err5b, infile); goto error; } } /* else if(!HDstrcmp("DATASPACE", key)) RANK and DIMENSIONS */ - else if(!HDstrcmp("STORAGE_LAYOUT", key)) { /* CHUNKED-DIMENSION-SIZES */ + else if (!HDstrcmp("STORAGE_LAYOUT", key)) { /* CHUNKED-DIMENSION-SIZES */ #ifdef H5DEBUGIMPORT HDprintf("h5dump STORAGE_LAYOUT key\n"); #endif if (fscanf(strm, "%254s", temp) != 1) { /* start bracket */ - (void) HDfprintf(stderr, err6b, infile); + (void)HDfprintf(stderr, err6b, infile); goto error; } #ifdef H5DEBUGIMPORT HDprintf("h5dump STORAGE_LAYOUT %s found\n", temp); #endif if (fscanf(strm, "%254s", temp) != 1) { /* CHUNKED */ - (void) HDfprintf(stderr, err6b, infile); + (void)HDfprintf(stderr, err6b, infile); goto error; } #ifdef H5DEBUGIMPORT HDprintf("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"); + 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, "%254s", temp) != 1) { /* start paren */ - (void) HDfprintf(stderr, err6b, infile); + (void)HDfprintf(stderr, err6b, infile); goto error; } #ifdef H5DEBUGIMPORT HDprintf("h5dump STORAGE_LAYOUT CHUNKED %s found\n", temp); #endif - if(!HDstrcmp("(", temp)) { /* start paren */ + if (!HDstrcmp("(", temp)) { /* start paren */ int get_next_dim = 1; - int icount = 0; + int icount = 0; if (fscanf(strm, "%254s", temp) != 1) { /* Dimension with optional comma */ - (void) HDfprintf(stderr, err16c, infile); + (void)HDfprintf(stderr, err16c, infile); goto error; } #ifdef H5DEBUGIMPORT HDprintf("h5dump STORAGE_LAYOUT CHUNKED %s found\n", temp); #endif while (get_next_dim) { - char *more = temp; + char *more = temp; in->sizeOfChunk[icount] = HDstrtoull(more, &more, 10); if (fscanf(strm, "%254s", temp) != 1) { /* Dimension or end paren */ - (void) HDfprintf(stderr, err6b, infile); + (void)HDfprintf(stderr, err6b, infile); goto error; } #ifdef H5DEBUGIMPORT HDprintf("h5dump STORAGE_LAYOUT CHUNKED %s found\n", temp); #endif - if(!HDstrcmp(")", temp)) { /* end paren */ + if (!HDstrcmp(")", temp)) { /* end paren */ in->configOptionVector[RANK] = 1; - get_next_dim = 0; + get_next_dim = 0; } else { /* Dimension */ icount++; if (icount > MAX_NUM_DIMENSION) { - (void) HDfprintf(stderr, "Invalid value for rank.\n"); + (void)HDfprintf(stderr, "Invalid value for rank.\n"); goto error; } } @@ -1861,19 +1877,19 @@ static int processConfigurationFile(char *infile, struct Input *in) in->configOptionVector[DIM] = 1; } /* if(!HDstrcmp("(", key)) start paren */ else { - (void) HDfprintf(stderr, err5b, infile); + (void)HDfprintf(stderr, err5b, infile); goto error; } if (fscanf(strm, "%254s", temp) != 1) { /* SIZE */ - (void) HDfprintf(stderr, err6b, infile); + (void)HDfprintf(stderr, err6b, infile); goto error; } #ifdef H5DEBUGIMPORT HDprintf("h5dump STORAGE_LAYOUT CHUNKED %s found\n", temp); #endif - if(!HDstrcmp("SIZE", temp)) { /* SIZE */ + if (!HDstrcmp("SIZE", temp)) { /* SIZE */ if (fscanf(strm, "%d", (&ival)) != 1) { - (void) HDfprintf(stderr, "%s", err19); + (void)HDfprintf(stderr, "%s", err19); goto error; } #ifdef H5DEBUGIMPORT @@ -1882,7 +1898,7 @@ static int processConfigurationFile(char *infile, struct Input *in) } while (HDstrcmp("}", temp)) { if (fscanf(strm, "%254s", temp) != 1) { /* end bracket */ - (void) HDfprintf(stderr, "%s", err18); + (void)HDfprintf(stderr, "%s", err18); goto error; } #ifdef H5DEBUGIMPORT @@ -1891,52 +1907,52 @@ static int processConfigurationFile(char *infile, struct Input *in) } in->configOptionVector[CHUNK] = 1; } /* if(!HDstrcmp("CHUNKED", key)) CHUNKED */ - } /* else if(!HDstrcmp("STORAGE_LAYOUT", key)) CHUNKED-DIMENSION-SIZES */ - else if(!HDstrcmp("FILTERS", key)) { /* FILTERS */ + } /* else if(!HDstrcmp("STORAGE_LAYOUT", key)) CHUNKED-DIMENSION-SIZES */ + else if (!HDstrcmp("FILTERS", key)) { /* FILTERS */ #ifdef H5DEBUGIMPORT HDprintf("h5dump FILTERS key\n"); #endif if (fscanf(strm, "%254s", temp) != 1) { /* start bracket */ - (void) HDfprintf(stderr, err6b, infile); + (void)HDfprintf(stderr, err6b, infile); goto error; } #ifdef H5DEBUGIMPORT HDprintf("h5dump FILTERS %s found\n", temp); #endif if (fscanf(strm, "%254s", temp) != 1) { - (void) HDfprintf(stderr, err6b, infile); + (void)HDfprintf(stderr, err6b, infile); goto error; } #ifdef H5DEBUGIMPORT HDprintf("h5dump FILTERS %s found\n", temp); #endif - if(!HDstrcmp("COMPRESSION", temp)) { /* COMPRESSION */ + if (!HDstrcmp("COMPRESSION", temp)) { /* COMPRESSION */ #ifdef H5DEBUGIMPORT HDprintf("h5dump FILTERS COMPRESSION found\n"); #endif if (fscanf(strm, "%254s", temp) != 1) { /* DEFLATE */ - (void) HDfprintf(stderr, "%s", err18); + (void)HDfprintf(stderr, "%s", err18); goto error; } #ifdef H5DEBUGIMPORT HDprintf("h5dump FILTERS COMPRESSION %s found\n", temp); #endif if (fscanf(strm, "%254s", temp) != 1) { /* bgin bracket */ - (void) HDfprintf(stderr, "%s", err18); + (void)HDfprintf(stderr, "%s", err18); goto error; } #ifdef H5DEBUGIMPORT HDprintf("h5dump FILTERS COMPRESSION %s found\n", temp); #endif if (fscanf(strm, "%254s", temp) != 1) { /* LEVEL */ - (void) HDfprintf(stderr, "%s", err18); + (void)HDfprintf(stderr, "%s", err18); goto error; } #ifdef H5DEBUGIMPORT HDprintf("h5dump FILTERS COMPRESSION %s found\n", temp); #endif if (fscanf(strm, "%d", (&ival)) != 1) { - (void) HDfprintf(stderr, "%s", err19); + (void)HDfprintf(stderr, "%s", err19); goto error; } #ifdef H5DEBUGIMPORT @@ -1944,95 +1960,95 @@ static int processConfigurationFile(char *infile, struct Input *in) #endif in->compressionParam = ival; if (fscanf(strm, "%254s", temp) != 1) { /* end bracket */ - (void) HDfprintf(stderr, "%s", err18); + (void)HDfprintf(stderr, "%s", err18); goto error; } #ifdef H5DEBUGIMPORT HDprintf("h5dump FILTERS COMPRESSION %s found\n", temp); #endif - in->compressionType = 0; /* ONLY GZIP supported */ + in->compressionType = 0; /* ONLY GZIP supported */ in->configOptionVector[COMPRESS] = 1; } - else if(!HDstrcmp("CONTIGUOUS", temp)) { /* CONTIGUOUS */ + else if (!HDstrcmp("CONTIGUOUS", temp)) { /* CONTIGUOUS */ #ifdef H5DEBUGIMPORT - HDprintf("h5dump FILTERS CONTIGUOUS found\n"); + HDprintf("h5dump FILTERS CONTIGUOUS found\n"); #endif in->configOptionVector[COMPRESS] = 0; } - else if(!HDstrcmp("NONE", temp)) { /* NONE */ + else if (!HDstrcmp("NONE", temp)) { /* NONE */ #ifdef H5DEBUGIMPORT - HDprintf("h5dump FILTERS NONE found\n"); + HDprintf("h5dump FILTERS NONE found\n"); #endif in->configOptionVector[COMPRESS] = 0; } if (fscanf(strm, "%254s", temp) != 1) { /* end bracket */ - (void) HDfprintf(stderr, "%s", err18); + (void)HDfprintf(stderr, "%s", err18); goto error; } #ifdef H5DEBUGIMPORT HDprintf("h5dump FILTERS %s found\n", temp); #endif } - else if(!HDstrcmp("SUBSET", key)) { /* reduce dimensions */ - hsize_t temp_dims[MAX_NUM_DIMENSION]; - int get_next_prop = 1; + else if (!HDstrcmp("SUBSET", key)) { /* reduce dimensions */ + hsize_t temp_dims[MAX_NUM_DIMENSION]; + int get_next_prop = 1; #ifdef H5DEBUGIMPORT HDprintf("h5dump SUBSET key\n"); #endif if (fscanf(strm, "%254s", temp) != 1) { /* start bracket */ - (void) HDfprintf(stderr, err20, infile); + (void)HDfprintf(stderr, err20, infile); goto error; } #ifdef H5DEBUGIMPORT HDprintf("h5dump SUBSET %s found\n", temp); #endif if (fscanf(strm, "%254s", temp) != 1) { /* SUBSET keyword */ - (void) HDfprintf(stderr, "%s", err18); + (void)HDfprintf(stderr, "%s", err18); goto error; } #ifdef H5DEBUGIMPORT HDprintf("h5dump SUBSET %s found\n", temp); #endif while (get_next_prop) { - if(!HDstrcmp("COUNT", temp)) { /* COUNT */ + if (!HDstrcmp("COUNT", temp)) { /* COUNT */ int icount = 0; if (fscanf(strm, "%254s", temp) != 1) { /* start paren */ - (void) HDfprintf(stderr, err6b, infile); + (void)HDfprintf(stderr, err6b, infile); goto error; } #ifdef H5DEBUGIMPORT HDprintf("h5dump SUBSET %s found\n", temp); #endif - if(!HDstrcmp("(", temp)) { /* start paren */ + if (!HDstrcmp("(", temp)) { /* start paren */ int get_next_dim = 1; - int i = 0; + int i = 0; if (fscanf(strm, "%254s", temp) != 1) { /* Dimension with optional comma */ - (void) HDfprintf(stderr, err16c, infile); + (void)HDfprintf(stderr, err16c, infile); goto error; } #ifdef H5DEBUGIMPORT HDprintf("h5dump SUBSET COUNT [%s] found\n", temp); #endif while (get_next_dim) { - char *more = temp; + char *more = temp; temp_dims[icount] = HDstrtoull(more, &more, 10); if (fscanf(strm, "%254s", temp) != 1) { /* Dimension or end paren */ - (void) HDfprintf(stderr, err6b, infile); + (void)HDfprintf(stderr, err6b, infile); goto error; } #ifdef H5DEBUGIMPORT HDprintf("h5dump SUBSET COUNT %s found\n", temp); #endif - if(!HDstrcmp(");", temp)) { /* end paren */ - in->rank = ++icount; + if (!HDstrcmp(");", temp)) { /* end paren */ + in->rank = ++icount; in->configOptionVector[RANK] = 1; - get_next_dim = 0; + get_next_dim = 0; } else { /* Dimension */ icount++; if (icount >= MAX_NUM_DIMENSION) { - (void) HDfprintf(stderr, "Invalid value for rank.\n"); + (void)HDfprintf(stderr, "Invalid value for rank.\n"); goto error; } } @@ -2048,47 +2064,47 @@ static int processConfigurationFile(char *infile, struct Input *in) HDprintf("\n"); #endif in->configOptionVector[DIM] = 1; - } /* if(!HDstrcmp("(", key)) start paren */ - } /* if(!HDstrcmp("COUNT", temp)) COUNT */ - if(!HDstrcmp("BLOCK", temp)) { /* BLOCK */ + } /* if(!HDstrcmp("(", key)) start paren */ + } /* if(!HDstrcmp("COUNT", temp)) COUNT */ + if (!HDstrcmp("BLOCK", temp)) { /* BLOCK */ int icount = 0; if (fscanf(strm, "%254s", temp) != 1) { /* start paren */ - (void) HDfprintf(stderr, err6b, infile); + (void)HDfprintf(stderr, err6b, infile); goto error; } #ifdef H5DEBUGIMPORT HDprintf("h5dump SUBSET %s found\n", temp); #endif - if(!HDstrcmp("(", temp)) { /* start paren */ + if (!HDstrcmp("(", temp)) { /* start paren */ int get_next_dim = 1; - int i = 0; + int i = 0; if (fscanf(strm, "%254s", temp) != 1) { /* Dimension with optional comma */ - (void) HDfprintf(stderr, err16c, infile); + (void)HDfprintf(stderr, err16c, infile); goto error; } #ifdef H5DEBUGIMPORT - HDprintf("h5dump SUBSET BLOCK [%s] found\n", temp); + HDprintf("h5dump SUBSET BLOCK [%s] found\n", temp); #endif while (get_next_dim) { - char *more = temp; + char *more = temp; temp_dims[icount] = HDstrtoull(more, &more, 10); if (fscanf(strm, "%254s", temp) != 1) { /* Dimension or end paren */ - (void) HDfprintf(stderr, err6b, infile); + (void)HDfprintf(stderr, err6b, infile); goto error; } #ifdef H5DEBUGIMPORT HDprintf("h5dump SUBSET BLOCK %s found\n", temp); #endif - if(!HDstrcmp(");", temp)) { /* end paren */ - in->rank = ++icount; + if (!HDstrcmp(");", temp)) { /* end paren */ + in->rank = ++icount; in->configOptionVector[RANK] = 1; - get_next_dim = 0; + get_next_dim = 0; } else { /* Dimension */ icount++; if (icount > MAX_NUM_DIMENSION) { - (void) HDfprintf(stderr, "Invalid value for rank.\n"); + (void)HDfprintf(stderr, "Invalid value for rank.\n"); goto error; } } @@ -2105,20 +2121,20 @@ static int processConfigurationFile(char *infile, struct Input *in) #endif in->configOptionVector[DIM] = 1; } /* if(!HDstrcmp("(", key)) start paren */ - } /* if(!HDstrcmp("BLOCK", temp)) BLOCK */ + } /* if(!HDstrcmp("BLOCK", temp)) BLOCK */ if (fscanf(strm, "%254s", temp) != 1) { - (void) HDfprintf(stderr, "%s", err18); + (void)HDfprintf(stderr, "%s", err18); goto error; } #ifdef H5DEBUGIMPORT HDprintf("h5dump SUBSET %s found\n", temp); #endif - if(!HDstrcmp("}", temp)) { /* end bracket */ + if (!HDstrcmp("}", temp)) { /* end bracket */ get_next_prop = 0; } - } /* while (get_next_prop) */ - } /* else if(!HDstrcmp("SUBSET", key)) */ - else if(!HDstrcmp("DATA", key)) { /* FINSHED */ + } /* while (get_next_prop) */ + } /* else if(!HDstrcmp("SUBSET", key)) */ + else if (!HDstrcmp("DATA", key)) { /* FINSHED */ #ifdef H5DEBUGIMPORT HDprintf("h5dump DATA key\n"); #endif @@ -2157,256 +2173,255 @@ static int processConfigurationFile(char *infile, struct Input *in) #endif while (scanret == 1) { if ((kindex = mapKeywordToIndex(key)) == -1) { - (void) HDfprintf(stderr, err2, key, infile); + (void)HDfprintf(stderr, err2, key, infile); goto error; } switch (kindex) { - case 0: /* PATH */ - if (in->configOptionVector[PATH] == 1) { - (void) HDfprintf(stderr, err3a, infile); - goto error; - } - if (fscanf(strm, "%254s", 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 0: /* PATH */ + if (in->configOptionVector[PATH] == 1) { + (void)HDfprintf(stderr, err3a, infile); + goto error; + } + if (fscanf(strm, "%254s", 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; - } + case 1: /* INPUT-CLASS */ + if (in->configOptionVector[INPUT_CLASS] == 1) { + (void)HDfprintf(stderr, err4a, infile); + goto error; + } - if (fscanf(strm, "%254s", temp) != 1) { - (void) HDfprintf(stderr, "%s", err18); - goto error; - } - if (getInputClass(in, temp) == -1) { - (void) HDfprintf(stderr, err4b, infile); - goto error; - } + if (fscanf(strm, "%254s", 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; + 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; + /*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, "%254d", (&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; + case 2: /* INPUT-SIZE */ + if (in->configOptionVector[INPUT_SIZE] == 1) { + (void)HDfprintf(stderr, err5a, infile); + goto error; + } + if (fscanf(strm, "%254d", (&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; + /*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; - } + 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; + 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; - } + 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; + 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; - } + 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; + 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; - } + 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; + 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; - } + 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; + 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; - } + 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; + 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; - } + 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; + 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; - } + 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 (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; + 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; - } + 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; - } + if (getCompressionParameter(in, strm) == -1) { + (void)HDfprintf(stderr, err14b, infile); + goto error; + } - in->configOptionVector[COMPRESS_PARAM] = 1; + in->configOptionVector[COMPRESS_PARAM] = 1; - if (in->configOptionVector[COMPRESS] == 0) - in->compressionType = 0; + if (in->configOptionVector[COMPRESS] == 0) + in->compressionType = 0; - break; + break; - case 12: /* EXTERNAL-STORAGE */ - if (in->configOptionVector[EXTERNALSTORE] == 1) { - (void) HDfprintf(stderr, err15a, infile); - goto error; - } + 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; + 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; + 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; - case 14: /* INPUT-BYTE-ORDER */ - if (in->configOptionVector[INPUT_B_ORDER] == 1) { - (void) HDfprintf(stderr, err11c, infile); - goto error; - } + case 14: /* INPUT-BYTE-ORDER */ + if (in->configOptionVector[INPUT_B_ORDER] == 1) { + (void)HDfprintf(stderr, err11c, infile); + goto error; + } - if (getInputByteOrder(in, strm) == -1) { - (void) HDfprintf(stderr, err11d, infile); - goto error; - } - in->configOptionVector[INPUT_B_ORDER] = 1; - break; + if (getInputByteOrder(in, strm) == -1) { + (void)HDfprintf(stderr, err11d, infile); + goto error; + } + in->configOptionVector[INPUT_B_ORDER] = 1; + break; - default: - break; + default: + break; } scanret = fscanf(strm, "%254s", key); } @@ -2417,7 +2432,7 @@ static int processConfigurationFile(char *infile, struct Input *in) */ if (validateConfigurationParameters(in) == -1) { - (void) HDfprintf(stderr, err17, infile); + (void)HDfprintf(stderr, err17, infile); goto error; } } @@ -2426,19 +2441,22 @@ static int processConfigurationFile(char *infile, struct Input *in) retval = 0; error: - if(strm) + if (strm) HDfclose(strm); - return(retval); + return (retval); } -static int validateConfigurationParameters(struct Input *in) +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 *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"; + 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 @@ -2448,20 +2466,21 @@ static int validateConfigurationParameters(struct Input *in) return (0); if ((in->configOptionVector[DIM] != 1) || (in->configOptionVector[RANK] != 1)) { - (void) HDfprintf(stderr, "%s", err1); + (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); + 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); + (void)HDfprintf(stderr, "%s", err3); return (-1); } } @@ -2469,33 +2488,35 @@ static int validateConfigurationParameters(struct Input *in) /* Arch cant be STD if O/p class is FP */ if (in->outputArchitecture == 1) if (in->outputClass == 1) { - (void) HDfprintf(stderr, "%s", err4a); + (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); + (void)HDfprintf(stderr, "%s", err4b); return (-1); } if (in->outputClass == 1) if (in->outputSize != 32 && in->outputSize != 64) { - (void) HDfprintf(stderr, "%s", err5); + (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); + 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) +static int +mapKeywordToIndex(char *key) { int i; @@ -2505,66 +2526,67 @@ static int mapKeywordToIndex(char *key) return -1; } -static int parsePathInfo(struct path_info *path, char *temp) +static int +parsePathInfo(struct path_info *path, char *temp) { const char delimiter[] = "/\""; - char *token; - int i = 0; + char * token; + int i = 0; const char *err1 = "Path string larger than MAX_PATH_NAME_LENGTH.\n"; - token = HDstrtok (temp, delimiter); + token = HDstrtok(temp, delimiter); if (HDstrlen(token) >= MAX_PATH_NAME_LENGTH) { - (void) HDfprintf(stderr, err1); + (void)HDfprintf(stderr, err1); return (-1); } - HDstrcpy(path->group[i++],token); + HDstrcpy(path->group[i++], token); while (1) { - token = HDstrtok (NULL, delimiter); + token = HDstrtok(NULL, delimiter); if (token == NULL) break; if (HDstrlen(token) >= MAX_PATH_NAME_LENGTH) { - (void) HDfprintf(stderr, err1); + (void)HDfprintf(stderr, err1); return (-1); } - HDstrcpy(path->group[i++],token); + HDstrcpy(path->group[i++], token); } path->count = i; return (0); } -static int parseDimensions(struct Input *in, char *strm) +static int +parseDimensions(struct Input *in, char *strm) { const char delimiter[] = ","; char temp[255]; - char *token; - int i = 0; + 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); + HDstrtok(temp, delimiter); while (1) { - token = HDstrtok (NULL, delimiter); + 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); + 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++] - = HDstrtoull(HDstrtok (temp, delimiter), NULL, BASE_10); + temp[sizeof(temp) - 1] = '\0'; + in->sizeOfDimension[i++] = HDstrtoull(HDstrtok(temp, delimiter), NULL, BASE_10); while (1) { - token = HDstrtok (NULL, delimiter); + token = HDstrtok(NULL, delimiter); if (token == NULL) break; in->sizeOfDimension[i++] = HDstrtoull(token, NULL, BASE_10); @@ -2572,7 +2594,8 @@ static int parseDimensions(struct Input *in, char *strm) return (0); } -static int getOutputClass(struct Input *in, FILE *strm) +static int +getOutputClass(struct Input *in, FILE *strm) { char temp[255]; int kindex; @@ -2580,12 +2603,12 @@ static int getOutputClass(struct Input *in, FILE *strm) const char *err2 = "Invalid value for output class.\n"; if (fscanf(strm, "%254s", temp) != 1) { - (void) HDfprintf(stderr, "%s", err1); + (void)HDfprintf(stderr, "%s", err1); return (-1); } if ((kindex = OutputClassStrToInt(temp)) == -1) { - (void) HDfprintf(stderr, "%s", err2); + (void)HDfprintf(stderr, "%s", err2); return (-1); } @@ -2593,10 +2616,11 @@ static int getOutputClass(struct Input *in, FILE *strm) return (0); } -static int OutputClassStrToInt(char *temp) +static int +OutputClassStrToInt(char *temp) { - int i; - char classKeywordTable[3][15] = { "IN", "FP", "UIN" }; + int i; + char classKeywordTable[3][15] = {"IN", "FP", "UIN"}; for (i = 0; i < 3; i++) if (!HDstrcmp(classKeywordTable[i], temp)) return i; @@ -2604,16 +2628,17 @@ static int OutputClassStrToInt(char *temp) return -1; } /* same as getInputSize. But defined separately for extensibility */ -static int getOutputSize(struct Input *in, FILE *strm) +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"; + 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); + (void)HDfprintf(stderr, "%s", err1); return (-1); } @@ -2622,17 +2647,18 @@ static int getOutputSize(struct Input *in, FILE *strm) in->outputSize = ival; return (0); } - (void) HDfprintf(stderr, "%s", err2); + (void)HDfprintf(stderr, "%s", err2); return (-1); } -static int getInputClass(struct Input *in, char * temp) +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); + (void)HDfprintf(stderr, "%s", err1); return (-1); } @@ -2640,355 +2666,356 @@ static int getInputClass(struct Input *in, char * temp) return (0); } -static int getInputClassType(struct Input *in, char * buffer) +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 input byte-order.\n"; + const char *err1 = "Invalid value for input class.\n"; + const char *err2 = "Invalid value for output architecture.\n"; + const char *err3 = "Invalid value for input byte-order.\n"; if (!HDstrcmp(buffer, "H5T_STD_I8BE")) { - in->inputSize = 8; + in->inputSize = 8; in->configOptionVector[INPUT_SIZE] = 1; if ((kindex = OutputArchStrToInt("STD")) == -1) { - (void) HDfprintf(stderr, "%s", err2); + (void)HDfprintf(stderr, "%s", err2); return (-1); } in->outputArchitecture = kindex; if ((kindex = OutputByteOrderStrToInt("BE")) == -1) { - (void) HDfprintf(stderr, "%s", err3); + (void)HDfprintf(stderr, "%s", err3); return (-1); } in->outputByteOrder = kindex; - #ifdef H5DEBUGIMPORT +#ifdef H5DEBUGIMPORT HDprintf("h5dump inputByteOrder %d\n", in->inputByteOrder); - #endif +#endif kindex = 4; } else if (!HDstrcmp(buffer, "H5T_STD_I8LE")) { - in->inputSize = 8; + in->inputSize = 8; in->configOptionVector[INPUT_SIZE] = 1; if ((kindex = OutputArchStrToInt("STD")) == -1) { - (void) HDfprintf(stderr, "%s", err2); + (void)HDfprintf(stderr, "%s", err2); return (-1); } in->outputArchitecture = kindex; if ((kindex = OutputByteOrderStrToInt("LE")) == -1) { - (void) HDfprintf(stderr, "%s", err3); + (void)HDfprintf(stderr, "%s", err3); return (-1); } in->outputByteOrder = kindex; - #ifdef H5DEBUGIMPORT +#ifdef H5DEBUGIMPORT HDprintf("h5dump inputByteOrder %d\n", in->inputByteOrder); - #endif +#endif kindex = 4; } else if (!HDstrcmp(buffer, "H5T_STD_I16BE")) { - in->inputSize = 16; + in->inputSize = 16; in->configOptionVector[INPUT_SIZE] = 1; if ((kindex = OutputArchStrToInt("STD")) == -1) { - (void) HDfprintf(stderr, "%s", err2); + (void)HDfprintf(stderr, "%s", err2); return (-1); } in->outputArchitecture = kindex; if ((kindex = OutputByteOrderStrToInt("BE")) == -1) { - (void) HDfprintf(stderr, "%s", err3); + (void)HDfprintf(stderr, "%s", err3); return (-1); } in->outputByteOrder = kindex; - #ifdef H5DEBUGIMPORT +#ifdef H5DEBUGIMPORT HDprintf("h5dump inputByteOrder %d\n", in->inputByteOrder); - #endif +#endif kindex = 4; } else if (!HDstrcmp(buffer, "H5T_STD_I16LE")) { - in->inputSize = 16; + in->inputSize = 16; in->configOptionVector[INPUT_SIZE] = 1; if ((kindex = OutputArchStrToInt("STD")) == -1) { - (void) HDfprintf(stderr, "%s", err2); + (void)HDfprintf(stderr, "%s", err2); return (-1); } in->outputArchitecture = kindex; if ((kindex = OutputByteOrderStrToInt("LE")) == -1) { - (void) HDfprintf(stderr, "%s", err3); + (void)HDfprintf(stderr, "%s", err3); return (-1); } in->outputByteOrder = kindex; - #ifdef H5DEBUGIMPORT +#ifdef H5DEBUGIMPORT HDprintf("h5dump inputByteOrder %d\n", in->inputByteOrder); - #endif +#endif kindex = 4; } else if (!HDstrcmp(buffer, "H5T_STD_I32BE")) { - in->inputSize = 32; + in->inputSize = 32; in->configOptionVector[INPUT_SIZE] = 1; if ((kindex = OutputArchStrToInt("STD")) == -1) { - (void) HDfprintf(stderr, "%s", err2); + (void)HDfprintf(stderr, "%s", err2); return (-1); } in->outputArchitecture = kindex; if ((kindex = OutputByteOrderStrToInt("BE")) == -1) { - (void) HDfprintf(stderr, "%s", err3); + (void)HDfprintf(stderr, "%s", err3); return (-1); } in->outputByteOrder = kindex; - #ifdef H5DEBUGIMPORT +#ifdef H5DEBUGIMPORT HDprintf("h5dump inputByteOrder %d\n", in->inputByteOrder); - #endif +#endif kindex = 4; } else if (!HDstrcmp(buffer, "H5T_STD_I32LE")) { - in->inputSize = 32; + in->inputSize = 32; in->configOptionVector[INPUT_SIZE] = 1; if ((kindex = OutputArchStrToInt("STD")) == -1) { - (void) HDfprintf(stderr, "%s", err2); + (void)HDfprintf(stderr, "%s", err2); return (-1); } in->outputArchitecture = kindex; if ((kindex = OutputByteOrderStrToInt("LE")) == -1) { - (void) HDfprintf(stderr, "%s", err3); + (void)HDfprintf(stderr, "%s", err3); return (-1); } in->outputByteOrder = kindex; - #ifdef H5DEBUGIMPORT +#ifdef H5DEBUGIMPORT HDprintf("h5dump inputByteOrder %d\n", in->inputByteOrder); - #endif +#endif kindex = 4; } else if (!HDstrcmp(buffer, "H5T_STD_I64BE")) { - in->inputSize = 64; + in->inputSize = 64; in->configOptionVector[INPUT_SIZE] = 1; if ((kindex = OutputArchStrToInt("STD")) == -1) { - (void) HDfprintf(stderr, "%s", err2); + (void)HDfprintf(stderr, "%s", err2); return (-1); } in->outputArchitecture = kindex; if ((kindex = OutputByteOrderStrToInt("BE")) == -1) { - (void) HDfprintf(stderr, "%s", err3); + (void)HDfprintf(stderr, "%s", err3); return (-1); } in->outputByteOrder = kindex; - #ifdef H5DEBUGIMPORT +#ifdef H5DEBUGIMPORT HDprintf("h5dump inputByteOrder %d\n", in->inputByteOrder); - #endif +#endif kindex = 4; } else if (!HDstrcmp(buffer, "H5T_STD_I64LE")) { - in->inputSize = 64; + in->inputSize = 64; in->configOptionVector[INPUT_SIZE] = 1; if ((kindex = OutputArchStrToInt("STD")) == -1) { - (void) HDfprintf(stderr, "%s", err2); + (void)HDfprintf(stderr, "%s", err2); return (-1); } in->outputArchitecture = kindex; if ((kindex = OutputByteOrderStrToInt("LE")) == -1) { - (void) HDfprintf(stderr, "%s", err3); + (void)HDfprintf(stderr, "%s", err3); return (-1); } in->outputByteOrder = kindex; - #ifdef H5DEBUGIMPORT +#ifdef H5DEBUGIMPORT HDprintf("h5dump inputByteOrder %d\n", in->inputByteOrder); - #endif +#endif kindex = 4; } else if (!HDstrcmp(buffer, "H5T_STD_U8BE")) { - in->inputSize = 8; + in->inputSize = 8; in->configOptionVector[INPUT_SIZE] = 1; if ((kindex = OutputArchStrToInt("STD")) == -1) { - (void) HDfprintf(stderr, "%s", err2); + (void)HDfprintf(stderr, "%s", err2); return (-1); } in->outputArchitecture = kindex; if ((kindex = OutputByteOrderStrToInt("BE")) == -1) { - (void) HDfprintf(stderr, "%s", err3); + (void)HDfprintf(stderr, "%s", err3); return (-1); } in->outputByteOrder = kindex; - #ifdef H5DEBUGIMPORT +#ifdef H5DEBUGIMPORT HDprintf("h5dump inputByteOrder %d\n", in->inputByteOrder); - #endif +#endif kindex = 7; } else if (!HDstrcmp(buffer, "H5T_STD_U8LE")) { - in->inputSize = 8; + in->inputSize = 8; in->configOptionVector[INPUT_SIZE] = 1; if ((kindex = OutputArchStrToInt("STD")) == -1) { - (void) HDfprintf(stderr, "%s", err2); + (void)HDfprintf(stderr, "%s", err2); return (-1); } in->outputArchitecture = kindex; if ((kindex = OutputByteOrderStrToInt("LE")) == -1) { - (void) HDfprintf(stderr, "%s", err3); + (void)HDfprintf(stderr, "%s", err3); return (-1); } in->outputByteOrder = kindex; - #ifdef H5DEBUGIMPORT +#ifdef H5DEBUGIMPORT HDprintf("h5dump inputByteOrder %d\n", in->inputByteOrder); - #endif +#endif kindex = 7; } else if (!HDstrcmp(buffer, "H5T_STD_U16BE")) { - in->inputSize = 16; + in->inputSize = 16; in->configOptionVector[INPUT_SIZE] = 1; if ((kindex = OutputArchStrToInt("STD")) == -1) { - (void) HDfprintf(stderr, "%s", err2); + (void)HDfprintf(stderr, "%s", err2); return (-1); } in->outputArchitecture = kindex; if ((kindex = OutputByteOrderStrToInt("BE")) == -1) { - (void) HDfprintf(stderr, "%s", err3); + (void)HDfprintf(stderr, "%s", err3); return (-1); } in->outputByteOrder = kindex; - #ifdef H5DEBUGIMPORT +#ifdef H5DEBUGIMPORT HDprintf("h5dump inputByteOrder %d\n", in->inputByteOrder); - #endif +#endif kindex = 7; } else if (!HDstrcmp(buffer, "H5T_STD_U16LE")) { - in->inputSize = 16; + in->inputSize = 16; in->configOptionVector[INPUT_SIZE] = 1; if ((kindex = OutputArchStrToInt("STD")) == -1) { - (void) HDfprintf(stderr, "%s", err2); + (void)HDfprintf(stderr, "%s", err2); return (-1); } in->outputArchitecture = kindex; if ((kindex = OutputByteOrderStrToInt("LE")) == -1) { - (void) HDfprintf(stderr, "%s", err3); + (void)HDfprintf(stderr, "%s", err3); return (-1); } in->outputByteOrder = kindex; - #ifdef H5DEBUGIMPORT +#ifdef H5DEBUGIMPORT HDprintf("h5dump inputByteOrder %d\n", in->inputByteOrder); - #endif +#endif kindex = 7; } else if (!HDstrcmp(buffer, "H5T_STD_U32BE")) { - in->inputSize = 32; + in->inputSize = 32; in->configOptionVector[INPUT_SIZE] = 1; if ((kindex = OutputArchStrToInt("STD")) == -1) { - (void) HDfprintf(stderr, "%s", err2); + (void)HDfprintf(stderr, "%s", err2); return (-1); } in->outputArchitecture = kindex; if ((kindex = OutputByteOrderStrToInt("BE")) == -1) { - (void) HDfprintf(stderr, "%s", err3); + (void)HDfprintf(stderr, "%s", err3); return (-1); } in->outputByteOrder = kindex; - #ifdef H5DEBUGIMPORT +#ifdef H5DEBUGIMPORT HDprintf("h5dump inputByteOrder %d\n", in->inputByteOrder); - #endif +#endif kindex = 7; } else if (!HDstrcmp(buffer, "H5T_STD_U32LE")) { - in->inputSize = 32; + in->inputSize = 32; in->configOptionVector[INPUT_SIZE] = 1; if ((kindex = OutputArchStrToInt("STD")) == -1) { - (void) HDfprintf(stderr, "%s", err2); + (void)HDfprintf(stderr, "%s", err2); return (-1); } in->outputArchitecture = kindex; if ((kindex = OutputByteOrderStrToInt("LE")) == -1) { - (void) HDfprintf(stderr, "%s", err3); + (void)HDfprintf(stderr, "%s", err3); return (-1); } in->outputByteOrder = kindex; - #ifdef H5DEBUGIMPORT +#ifdef H5DEBUGIMPORT HDprintf("h5dump inputByteOrder %d\n", in->inputByteOrder); - #endif +#endif kindex = 7; } else if (!HDstrcmp(buffer, "H5T_STD_U64BE")) { - in->inputSize = 64; + in->inputSize = 64; in->configOptionVector[INPUT_SIZE] = 1; if ((kindex = OutputArchStrToInt("STD")) == -1) { - (void) HDfprintf(stderr, "%s", err2); + (void)HDfprintf(stderr, "%s", err2); return (-1); } in->outputArchitecture = kindex; if ((kindex = OutputByteOrderStrToInt("BE")) == -1) { - (void) HDfprintf(stderr, "%s", err3); + (void)HDfprintf(stderr, "%s", err3); return (-1); } in->outputByteOrder = kindex; - #ifdef H5DEBUGIMPORT +#ifdef H5DEBUGIMPORT HDprintf("h5dump inputByteOrder %d\n", in->inputByteOrder); - #endif +#endif kindex = 7; } else if (!HDstrcmp(buffer, "H5T_STD_U64LE")) { - in->inputSize = 64; + in->inputSize = 64; in->configOptionVector[INPUT_SIZE] = 1; if ((kindex = OutputArchStrToInt("STD")) == -1) { - (void) HDfprintf(stderr, "%s", err2); + (void)HDfprintf(stderr, "%s", err2); return (-1); } in->outputArchitecture = kindex; if ((kindex = OutputByteOrderStrToInt("LE")) == -1) { - (void) HDfprintf(stderr, "%s", err3); + (void)HDfprintf(stderr, "%s", err3); return (-1); } in->outputByteOrder = kindex; - #ifdef H5DEBUGIMPORT +#ifdef H5DEBUGIMPORT HDprintf("h5dump inputByteOrder %d\n", in->inputByteOrder); - #endif +#endif kindex = 7; } else if (!HDstrcmp(buffer, "H5T_NATIVE_SCHAR")) { - in->inputSize = 8; + in->inputSize = 8; in->configOptionVector[INPUT_SIZE] = 1; if ((kindex = OutputArchStrToInt("NATIVE")) == -1) { - (void) HDfprintf(stderr, "%s", err2); + (void)HDfprintf(stderr, "%s", err2); return (-1); } in->outputArchitecture = kindex; @@ -2996,11 +3023,11 @@ static int getInputClassType(struct Input *in, char * buffer) kindex = 4; } else if (!HDstrcmp(buffer, "H5T_NATIVE_UCHAR")) { - in->inputSize = 8; + in->inputSize = 8; in->configOptionVector[INPUT_SIZE] = 1; if ((kindex = OutputArchStrToInt("NATIVE")) == -1) { - (void) HDfprintf(stderr, "%s", err2); + (void)HDfprintf(stderr, "%s", err2); return (-1); } in->outputArchitecture = kindex; @@ -3008,11 +3035,11 @@ static int getInputClassType(struct Input *in, char * buffer) kindex = 7; } else if (!HDstrcmp(buffer, "H5T_NATIVE_SHORT")) { - in->inputSize = 16; + in->inputSize = 16; in->configOptionVector[INPUT_SIZE] = 1; if ((kindex = OutputArchStrToInt("NATIVE")) == -1) { - (void) HDfprintf(stderr, "%s", err2); + (void)HDfprintf(stderr, "%s", err2); return (-1); } in->outputArchitecture = kindex; @@ -3020,11 +3047,11 @@ static int getInputClassType(struct Input *in, char * buffer) kindex = 4; } else if (!HDstrcmp(buffer, "H5T_NATIVE_USHORT")) { - in->inputSize = 16; + in->inputSize = 16; in->configOptionVector[INPUT_SIZE] = 1; if ((kindex = OutputArchStrToInt("NATIVE")) == -1) { - (void) HDfprintf(stderr, "%s", err2); + (void)HDfprintf(stderr, "%s", err2); return (-1); } in->outputArchitecture = kindex; @@ -3032,11 +3059,11 @@ static int getInputClassType(struct Input *in, char * buffer) kindex = 7; } else if (!HDstrcmp(buffer, "H5T_NATIVE_INT")) { - in->inputSize = 32; + in->inputSize = 32; in->configOptionVector[INPUT_SIZE] = 1; if ((kindex = OutputArchStrToInt("NATIVE")) == -1) { - (void) HDfprintf(stderr, "%s", err2); + (void)HDfprintf(stderr, "%s", err2); return (-1); } in->outputArchitecture = kindex; @@ -3044,11 +3071,11 @@ static int getInputClassType(struct Input *in, char * buffer) kindex = 4; } else if (!HDstrcmp(buffer, "H5T_NATIVE_UINT")) { - in->inputSize = 32; + in->inputSize = 32; in->configOptionVector[INPUT_SIZE] = 1; if ((kindex = OutputArchStrToInt("NATIVE")) == -1) { - (void) HDfprintf(stderr, "%s", err2); + (void)HDfprintf(stderr, "%s", err2); return (-1); } in->outputArchitecture = kindex; @@ -3056,11 +3083,11 @@ static int getInputClassType(struct Input *in, char * buffer) kindex = 7; } else if (!HDstrcmp(buffer, "H5T_NATIVE_LONG")) { - in->inputSize = 32; + in->inputSize = 32; in->configOptionVector[INPUT_SIZE] = 1; if ((kindex = OutputArchStrToInt("NATIVE")) == -1) { - (void) HDfprintf(stderr, "%s", err2); + (void)HDfprintf(stderr, "%s", err2); return (-1); } in->outputArchitecture = kindex; @@ -3068,11 +3095,11 @@ static int getInputClassType(struct Input *in, char * buffer) kindex = 4; } else if (!HDstrcmp(buffer, "H5T_NATIVE_ULONG")) { - in->inputSize = 32; + in->inputSize = 32; in->configOptionVector[INPUT_SIZE] = 1; if ((kindex = OutputArchStrToInt("NATIVE")) == -1) { - (void) HDfprintf(stderr, "%s", err2); + (void)HDfprintf(stderr, "%s", err2); return (-1); } in->outputArchitecture = kindex; @@ -3080,11 +3107,11 @@ static int getInputClassType(struct Input *in, char * buffer) kindex = 7; } else if (!HDstrcmp(buffer, "H5T_NATIVE_LLONG")) { - in->inputSize = 64; + in->inputSize = 64; in->configOptionVector[INPUT_SIZE] = 1; if ((kindex = OutputArchStrToInt("NATIVE")) == -1) { - (void) HDfprintf(stderr, "%s", err2); + (void)HDfprintf(stderr, "%s", err2); return (-1); } in->outputArchitecture = kindex; @@ -3092,11 +3119,11 @@ static int getInputClassType(struct Input *in, char * buffer) kindex = 4; } else if (!HDstrcmp(buffer, "H5T_NATIVE_ULLONG")) { - in->inputSize = 64; + in->inputSize = 64; in->configOptionVector[INPUT_SIZE] = 1; if ((kindex = OutputArchStrToInt("NATIVE")) == -1) { - (void) HDfprintf(stderr, "%s", err2); + (void)HDfprintf(stderr, "%s", err2); return (-1); } in->outputArchitecture = kindex; @@ -3104,107 +3131,107 @@ static int getInputClassType(struct Input *in, char * buffer) kindex = 7; } else if (!HDstrcmp(buffer, "H5T_IEEE_F32BE")) { - in->inputSize = 32; + in->inputSize = 32; in->configOptionVector[INPUT_SIZE] = 1; if ((kindex = OutputArchStrToInt("IEEE")) == -1) { - (void) HDfprintf(stderr, "%s", err2); + (void)HDfprintf(stderr, "%s", err2); return (-1); } in->outputArchitecture = kindex; if ((kindex = OutputByteOrderStrToInt("BE")) == -1) { - (void) HDfprintf(stderr, "%s", err3); + (void)HDfprintf(stderr, "%s", err3); return (-1); } in->outputByteOrder = kindex; - #ifdef H5DEBUGIMPORT +#ifdef H5DEBUGIMPORT HDprintf("h5dump inputByteOrder %d\n", in->inputByteOrder); - #endif +#endif kindex = 3; } else if (!HDstrcmp(buffer, "H5T_IEEE_F32LE")) { - in->inputSize = 32; + in->inputSize = 32; in->configOptionVector[INPUT_SIZE] = 1; if ((kindex = OutputArchStrToInt("IEEE")) == -1) { - (void) HDfprintf(stderr, "%s", err2); + (void)HDfprintf(stderr, "%s", err2); return (-1); } in->outputArchitecture = kindex; if ((kindex = OutputByteOrderStrToInt("LE")) == -1) { - (void) HDfprintf(stderr, "%s", err3); + (void)HDfprintf(stderr, "%s", err3); return (-1); } in->outputByteOrder = kindex; - #ifdef H5DEBUGIMPORT +#ifdef H5DEBUGIMPORT HDprintf("h5dump inputByteOrder %d\n", in->inputByteOrder); - #endif +#endif kindex = 3; } else if (!HDstrcmp(buffer, "H5T_IEEE_F64BE")) { - in->inputSize = 64; + in->inputSize = 64; in->configOptionVector[INPUT_SIZE] = 1; if ((kindex = OutputArchStrToInt("IEEE")) == -1) { - (void) HDfprintf(stderr, "%s", err2); + (void)HDfprintf(stderr, "%s", err2); return (-1); } in->outputArchitecture = kindex; if ((kindex = OutputByteOrderStrToInt("BE")) == -1) { - (void) HDfprintf(stderr, "%s", err3); + (void)HDfprintf(stderr, "%s", err3); return (-1); } in->outputByteOrder = kindex; - #ifdef H5DEBUGIMPORT +#ifdef H5DEBUGIMPORT HDprintf("h5dump inputByteOrder %d\n", in->inputByteOrder); - #endif +#endif kindex = 3; } else if (!HDstrcmp(buffer, "H5T_IEEE_F64LE")) { - in->inputSize = 64; + in->inputSize = 64; in->configOptionVector[INPUT_SIZE] = 1; if ((kindex = OutputArchStrToInt("IEEE")) == -1) { - (void) HDfprintf(stderr, "%s", err2); + (void)HDfprintf(stderr, "%s", err2); return (-1); } in->outputArchitecture = kindex; if ((kindex = OutputByteOrderStrToInt("LE")) == -1) { - (void) HDfprintf(stderr, "%s", err3); + (void)HDfprintf(stderr, "%s", err3); return (-1); } in->outputByteOrder = kindex; - #ifdef H5DEBUGIMPORT +#ifdef H5DEBUGIMPORT HDprintf("h5dump inputByteOrder %d\n", in->inputByteOrder); - #endif +#endif kindex = 3; } else if (!HDstrcmp(buffer, "H5T_VAX_F32")) { - in->inputSize = 32; + in->inputSize = 32; in->configOptionVector[INPUT_SIZE] = 1; kindex = 3; } else if (!HDstrcmp(buffer, "H5T_VAX_F64")) { - in->inputSize = 64; + in->inputSize = 64; in->configOptionVector[INPUT_SIZE] = 1; kindex = 3; } else if (!HDstrcmp(buffer, "H5T_NATIVE_FLOAT")) { - in->inputSize = 32; + in->inputSize = 32; in->configOptionVector[INPUT_SIZE] = 1; if ((kindex = OutputArchStrToInt("NATIVE")) == -1) { - (void) HDfprintf(stderr, "%s", err2); + (void)HDfprintf(stderr, "%s", err2); return (-1); } in->outputArchitecture = kindex; @@ -3212,24 +3239,24 @@ static int getInputClassType(struct Input *in, char * buffer) kindex = 3; } else if (!HDstrcmp(buffer, "H5T_NATIVE_DOUBLE")) { - in->inputSize = 64; + in->inputSize = 64; in->configOptionVector[INPUT_SIZE] = 1; if ((kindex = OutputArchStrToInt("NATIVE")) == -1) { - (void) HDfprintf(stderr, "%s", err2); + (void)HDfprintf(stderr, "%s", err2); return (-1); } in->outputArchitecture = kindex; kindex = 3; } -#if H5_SIZEOF_LONG_DOUBLE !=0 +#if H5_SIZEOF_LONG_DOUBLE != 0 else if (!HDstrcmp(buffer, "H5T_NATIVE_LDOUBLE")) { - in->inputSize = H5_SIZEOF_LONG_DOUBLE; + in->inputSize = H5_SIZEOF_LONG_DOUBLE; in->configOptionVector[INPUT_SIZE] = 1; if ((kindex = OutputArchStrToInt("NATIVE")) == -1) { - (void) HDfprintf(stderr, "%s", err2); + (void)HDfprintf(stderr, "%s", err2); return (-1); } in->outputArchitecture = kindex; @@ -3237,192 +3264,192 @@ static int getInputClassType(struct Input *in, char * buffer) kindex = 3; } #endif - else if(!HDstrcmp(buffer, "H5T_TIME: not yet implemented")) { + else if (!HDstrcmp(buffer, "H5T_TIME: not yet implemented")) { kindex = -1; } - else if(!HDstrcmp(buffer, "H5T_STRING")) { + 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); + (void)HDfprintf(stderr, "%s", err2); return (-1); } in->outputArchitecture = kindex; if ((kindex = OutputByteOrderStrToInt("BE")) == -1) { - (void) HDfprintf(stderr, "%s", err3); + (void)HDfprintf(stderr, "%s", err3); return (-1); } in->outputByteOrder = kindex; - #ifdef H5DEBUGIMPORT +#ifdef H5DEBUGIMPORT HDprintf("h5dump inputByteOrder %d\n", in->inputByteOrder); - #endif +#endif kindex = -1; } else if (!HDstrcmp(buffer, "H5T_STD_B8LE")) { if ((kindex = OutputArchStrToInt("STD")) == -1) { - (void) HDfprintf(stderr, "%s", err2); + (void)HDfprintf(stderr, "%s", err2); return (-1); } in->outputArchitecture = kindex; if ((kindex = OutputByteOrderStrToInt("LE")) == -1) { - (void) HDfprintf(stderr, "%s", err3); + (void)HDfprintf(stderr, "%s", err3); return (-1); } in->outputByteOrder = kindex; - #ifdef H5DEBUGIMPORT +#ifdef H5DEBUGIMPORT HDprintf("h5dump inputByteOrder %d\n", in->inputByteOrder); - #endif +#endif kindex = -1; } else if (!HDstrcmp(buffer, "H5T_STD_B16BE")) { if ((kindex = OutputArchStrToInt("STD")) == -1) { - (void) HDfprintf(stderr, "%s", err2); + (void)HDfprintf(stderr, "%s", err2); return (-1); } in->outputArchitecture = kindex; if ((kindex = OutputByteOrderStrToInt("BE")) == -1) { - (void) HDfprintf(stderr, "%s", err3); + (void)HDfprintf(stderr, "%s", err3); return (-1); } in->outputByteOrder = kindex; - #ifdef H5DEBUGIMPORT +#ifdef H5DEBUGIMPORT HDprintf("h5dump inputByteOrder %d\n", in->inputByteOrder); - #endif +#endif kindex = -1; } else if (!HDstrcmp(buffer, "H5T_STD_B16LE")) { if ((kindex = OutputArchStrToInt("STD")) == -1) { - (void) HDfprintf(stderr, "%s", err2); + (void)HDfprintf(stderr, "%s", err2); return (-1); } in->outputArchitecture = kindex; if ((kindex = OutputByteOrderStrToInt("LE")) == -1) { - (void) HDfprintf(stderr, "%s", err3); + (void)HDfprintf(stderr, "%s", err3); return (-1); } in->outputByteOrder = kindex; - #ifdef H5DEBUGIMPORT +#ifdef H5DEBUGIMPORT HDprintf("h5dump inputByteOrder %d\n", in->inputByteOrder); - #endif +#endif kindex = -1; } else if (!HDstrcmp(buffer, "H5T_STD_B32BE")) { if ((kindex = OutputArchStrToInt("STD")) == -1) { - (void) HDfprintf(stderr, "%s", err2); + (void)HDfprintf(stderr, "%s", err2); return (-1); } in->outputArchitecture = kindex; if ((kindex = OutputByteOrderStrToInt("BE")) == -1) { - (void) HDfprintf(stderr, "%s", err3); + (void)HDfprintf(stderr, "%s", err3); return (-1); } in->outputByteOrder = kindex; - #ifdef H5DEBUGIMPORT +#ifdef H5DEBUGIMPORT HDprintf("h5dump inputByteOrder %d\n", in->inputByteOrder); - #endif +#endif kindex = -1; } else if (!HDstrcmp(buffer, "H5T_STD_B32LE")) { if ((kindex = OutputArchStrToInt("STD")) == -1) { - (void) HDfprintf(stderr, "%s", err2); + (void)HDfprintf(stderr, "%s", err2); return (-1); } in->outputArchitecture = kindex; if ((kindex = OutputByteOrderStrToInt("LE")) == -1) { - (void) HDfprintf(stderr, "%s", err3); + (void)HDfprintf(stderr, "%s", err3); return (-1); } in->outputByteOrder = kindex; - #ifdef H5DEBUGIMPORT +#ifdef H5DEBUGIMPORT HDprintf("h5dump inputByteOrder %d\n", in->inputByteOrder); - #endif +#endif kindex = -1; } else if (!HDstrcmp(buffer, "H5T_STD_B64BE")) { if ((kindex = OutputArchStrToInt("STD")) == -1) { - (void) HDfprintf(stderr, "%s", err2); + (void)HDfprintf(stderr, "%s", err2); return (-1); } in->outputArchitecture = kindex; if ((kindex = OutputByteOrderStrToInt("BE")) == -1) { - (void) HDfprintf(stderr, "%s", err3); + (void)HDfprintf(stderr, "%s", err3); return (-1); } in->outputByteOrder = kindex; - #ifdef H5DEBUGIMPORT +#ifdef H5DEBUGIMPORT HDprintf("h5dump inputByteOrder %d\n", in->inputByteOrder); - #endif +#endif kindex = -1; } else if (!HDstrcmp(buffer, "H5T_STD_B64LE")) { if ((kindex = OutputArchStrToInt("STD")) == -1) { - (void) HDfprintf(stderr, "%s", err2); + (void)HDfprintf(stderr, "%s", err2); return (-1); } in->outputArchitecture = kindex; if ((kindex = OutputByteOrderStrToInt("LE")) == -1) { - (void) HDfprintf(stderr, "%s", err3); + (void)HDfprintf(stderr, "%s", err3); return (-1); } in->outputByteOrder = kindex; - #ifdef H5DEBUGIMPORT +#ifdef H5DEBUGIMPORT HDprintf("h5dump inputByteOrder %d\n", in->inputByteOrder); - #endif +#endif kindex = -1; } /* case H5T_OPAQUE: */ - else if(!HDstrcmp(buffer, "H5T_OPAQUE")) { + else if (!HDstrcmp(buffer, "H5T_OPAQUE")) { kindex = -1; } /* case H5T_COMPOUND: */ - else if(!HDstrcmp(buffer, "H5T_COMPOUND")) { + else if (!HDstrcmp(buffer, "H5T_COMPOUND")) { kindex = -1; } /* case H5T_REFERENCE: */ - else if(!HDstrcmp(buffer, "H5T_REFERENCE")) { + else if (!HDstrcmp(buffer, "H5T_REFERENCE")) { kindex = -1; } /* case H5T_ENUM: */ - else if(!HDstrcmp(buffer, "H5T_ENUM")) { + else if (!HDstrcmp(buffer, "H5T_ENUM")) { kindex = -1; } /* case H5T_VLEN: */ - else if(!HDstrcmp(buffer, "H5T_VLEN")) { + else if (!HDstrcmp(buffer, "H5T_VLEN")) { kindex = -1; } /* case H5T_ARRAY: */ - else if(!HDstrcmp(buffer, "H5T_ARRAY")) { + else if (!HDstrcmp(buffer, "H5T_ARRAY")) { kindex = -1; } if (kindex == -1) { - (void) HDfprintf(stderr, "%s", err1); + (void)HDfprintf(stderr, "%s", err1); return (-1); } @@ -3439,10 +3466,11 @@ static int getInputClassType(struct Input *in, char * buffer) return (0); } -static int InputClassStrToInt(char *temp) +static int +InputClassStrToInt(char *temp) { - int i; - char classKeywordTable[8][15] = { "TEXTIN", "TEXTFP", "TEXTFPE", "FP", "IN", "STR", "TEXTUIN", "UIN" }; + 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; @@ -3450,22 +3478,24 @@ static int InputClassStrToInt(char *temp) } /* same as getOutputSize. But defined separately for extensibility */ -static int getInputSize(struct Input *in, int ival) +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"; + 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); + (void)HDfprintf(stderr, "%s", err1); return (-1); } -static int getInputByteOrder(struct Input *in, FILE *strm) +static int +getInputByteOrder(struct Input *in, FILE *strm) { char temp[255]; int kindex; @@ -3473,12 +3503,12 @@ static int getInputByteOrder(struct Input *in, FILE *strm) const char *err2 = "Invalid value for input byte-order.\n"; if (fscanf(strm, "%254s", temp) != 1) { - (void) HDfprintf(stderr, "%s", err1); + (void)HDfprintf(stderr, "%s", err1); return (-1); } if ((kindex = OutputByteOrderStrToInt(temp)) == -1) { - (void) HDfprintf(stderr, "%s", err2); + (void)HDfprintf(stderr, "%s", err2); return (-1); } @@ -3486,15 +3516,16 @@ static int getInputByteOrder(struct Input *in, FILE *strm) return (0); } -static int getRank(struct Input *in, FILE *strm) +static int +getRank(struct Input *in, FILE *strm) { - int ival; + 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); + (void)HDfprintf(stderr, "%s", err1); return (-1); } if (ival >= MIN_NUM_DIMENSION && ival <= MAX_NUM_DIMENSION) { @@ -3502,21 +3533,23 @@ static int getRank(struct Input *in, FILE *strm) return (0); } - (void) HDfprintf(stderr, "%s", err2); + (void)HDfprintf(stderr, "%s", err2); return (-1); } /* same as getChunkedDimensionSizes. But defined separately for extensibility */ -static int getDimensionSizes(struct Input *in, FILE *strm) +static int +getDimensionSizes(struct Input *in, FILE *strm) { unsigned long long ullval; - int i = 0; + 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"; + 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); + if ((in->sizeOfDimension = (hsize_t *)HDmalloc((size_t)in->rank * sizeof(hsize_t))) == NULL) { + (void)HDfprintf(stderr, "%s", err1); return (-1); } @@ -3524,23 +3557,25 @@ static int getDimensionSizes(struct Input *in, FILE *strm) in->sizeOfDimension[i++] = ullval; if (in->rank != i) { - (void) HDfprintf(stderr, "%s", err2); + (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) +static int +getChunkedDimensionSizes(struct Input *in, FILE *strm) { unsigned long long ullval; - int i = 0; + 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 *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); + if ((in->sizeOfChunk = (hsize_t *)HDmalloc((size_t)in->rank * sizeof(hsize_t))) == NULL) { + (void)HDfprintf(stderr, "%s", err1); return (-1); } @@ -3548,29 +3583,32 @@ static int getChunkedDimensionSizes(struct Input *in, FILE *strm) in->sizeOfChunk[i++] = ullval; if (in->rank != i) { - (void) HDfprintf(stderr, "%s", err2); + (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); + (void)HDfprintf(stderr, "%s", err3); return (-1); } return (0); } -static int getMaximumDimensionSizes(struct Input *in, FILE *strm) +static int +getMaximumDimensionSizes(struct Input *in, FILE *strm) { long long llval; - int i = 0; + 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"; + 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); + if ((in->maxsizeOfDimension = (hsize_t *)HDmalloc((size_t)in->rank * sizeof(hsize_t))) == NULL) { + (void)HDfprintf(stderr, "%s", err1); return (-1); } @@ -3582,21 +3620,22 @@ static int getMaximumDimensionSizes(struct Input *in, FILE *strm) } if (in->rank != i) { - (void) HDfprintf(stderr, "%s", err2); + (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); + (void)HDfprintf(stderr, "%s", err3); return (-1); } } return (0); } -static int getOutputArchitecture(struct Input *in, FILE *strm) +static int +getOutputArchitecture(struct Input *in, FILE *strm) { char temp[255]; int kindex; @@ -3604,12 +3643,12 @@ static int getOutputArchitecture(struct Input *in, FILE *strm) const char *err2 = "Invalid value for output architecture.\n"; if (fscanf(strm, "%254s", temp) != 1) { - (void) HDfprintf(stderr, "%s", err1); + (void)HDfprintf(stderr, "%s", err1); return (-1); } if ((kindex = OutputArchStrToInt(temp)) == -1) { - (void) HDfprintf(stderr, "%s", err2); + (void)HDfprintf(stderr, "%s", err2); return (-1); } @@ -3617,18 +3656,19 @@ static int getOutputArchitecture(struct Input *in, FILE *strm) return (0); } -static int OutputArchStrToInt(const char *temp) +static int +OutputArchStrToInt(const char *temp) { - int i; - char outputArchKeywordTable[8][15] = { "NATIVE", "STD", "IEEE", "INTEL", - "CRAY", "MIPS", "ALPHA", "UNIX" }; + 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) +static int +getOutputByteOrder(struct Input *in, FILE *strm) { char temp[255]; int kindex; @@ -3636,12 +3676,12 @@ static int getOutputByteOrder(struct Input *in, FILE *strm) const char *err2 = "Invalid value for output byte-order.\n"; if (fscanf(strm, "%254s", temp) != 1) { - (void) HDfprintf(stderr, "%s", err1); + (void)HDfprintf(stderr, "%s", err1); return (-1); } if ((kindex = OutputByteOrderStrToInt(temp)) == -1) { - (void) HDfprintf(stderr, "%s", err2); + (void)HDfprintf(stderr, "%s", err2); return (-1); } @@ -3649,17 +3689,19 @@ static int getOutputByteOrder(struct Input *in, FILE *strm) return (0); } -static int OutputByteOrderStrToInt(const char *temp) +static int +OutputByteOrderStrToInt(const char *temp) { - int i; - char outputByteOrderKeywordTable[2][15] = { "BE", "LE" }; + 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) +static int +getCompressionType(struct Input *in, FILE *strm) { char temp[255]; int kindex; @@ -3667,34 +3709,35 @@ static int getCompressionType(struct Input *in, FILE *strm) const char *err2 = "Invalid value for compression.\n"; if (fscanf(strm, "%254s", temp) != 1) { - (void) HDfprintf(stderr, "%s", err1); + (void)HDfprintf(stderr, "%s", err1); return (-1); } if ((kindex = CompressionTypeStrToInt(temp)) == -1) { - (void) HDfprintf(stderr, "%s", err2); + (void)HDfprintf(stderr, "%s", err2); return (-1); } in->compressionType = kindex; return (0); - } -static int CompressionTypeStrToInt(char *temp) +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" }; + 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) +static int +getCompressionParameter(struct Input *in, FILE *strm) { /* currently supports only GZIP */ /* can be extended by adding more values to COMPRESSION-TYPE and */ @@ -3706,883 +3749,889 @@ static int getCompressionParameter(struct Input *in, FILE *strm) 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); - } + 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); + 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); + default: + (void)HDfprintf(stderr, "%s", err3); + return (-1); } } -static int getExternalFilename(struct Input *in, FILE *strm) +static int +getExternalFilename(struct Input *in, FILE *strm) { char temp[255]; const char *err1 = "Unable to get 'string' value.\n"; if (fscanf(strm, "%254s", temp) != 1) { - (void) HDfprintf(stderr, "%s", err1); + (void)HDfprintf(stderr, "%s", err1); return (-1); } - in->externFilename = (char *) HDmalloc ((size_t) (HDstrlen(temp) + 1) * sizeof(char)); - (void) HDstrncpy(in->externFilename, temp, HDstrlen(temp) + 1); + in->externFilename = (char *)HDmalloc((size_t)(HDstrlen(temp) + 1) * sizeof(char)); + (void)HDstrncpy(in->externFilename, temp, HDstrlen(temp) + 1); return (0); } -void setDefaultValues(struct Input *in, int count) +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; + 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->inputByteOrder = -1; /* use default */ - in->rank = 0; - in->path.count = 1; + in->rank = 0; + in->path.count = 1; HDstrcpy(temp, "dataset"); HDsprintf(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 */ + 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 +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"; + 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 0: + switch (in->outputArchitecture) { + case 0: /* NATIVE */ + switch (in->outputSize) { + case 8: + new_type = H5Tcopy(H5T_NATIVE_CHAR); + break; - case 32: - new_type = H5Tcopy(H5T_NATIVE_INT); - break; + case 16: + new_type = H5Tcopy(H5T_NATIVE_SHORT); + break; - case 64: - new_type = H5Tcopy(H5T_NATIVE_LLONG); - break; + case 32: + new_type = H5Tcopy(H5T_NATIVE_INT); + 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 64: + new_type = H5Tcopy(H5T_NATIVE_LLONG); + break; - case 1: - H5Tset_order(new_type, H5T_ORDER_LE); - 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; - default: - (void) HDfprintf(stderr, "%s", err3); - return (-1); - } - break; + case 1: + H5Tset_order(new_type, H5T_ORDER_LE); + break; - case 1: /* STD */ - switch (in->outputSize) { - case 8: - switch (in->outputByteOrder) { - case -1: - case 0: - new_type = H5Tcopy(H5T_STD_I8BE); + default: + (void)HDfprintf(stderr, "%s", err3); + return (-1); + } break; - case 1: - new_type = H5Tcopy(H5T_STD_I8LE); - 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; - 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 16: - switch (in->outputByteOrder) { - case -1: - case 0: - new_type = H5Tcopy(H5T_STD_I16BE); - break; + case 1: + new_type = H5Tcopy(H5T_STD_I16LE); + break; - case 1: - new_type = H5Tcopy(H5T_STD_I16LE); - break; + default: + (void)HDfprintf(stderr, "%s", err3); + return (-1); + } + 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 32: - switch (in->outputByteOrder) { - case -1: - case 0: - new_type = H5Tcopy(H5T_STD_I32BE); - break; + case 1: + new_type = H5Tcopy(H5T_STD_I32LE); + break; - case 1: - new_type = H5Tcopy(H5T_STD_I32LE); - break; + default: + (void)HDfprintf(stderr, "%s", err3); + return (-1); + } + 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 64: - switch (in->outputByteOrder) { - case -1: - case 0: - new_type = H5Tcopy(H5T_STD_I64BE); - break; + case 1: + new_type = H5Tcopy(H5T_STD_I64LE); + break; - case 1: - new_type = H5Tcopy(H5T_STD_I64LE); + default: + (void)HDfprintf(stderr, "%s", err3); + return (-1); + } + break; + + default: + (void)HDfprintf(stderr, "%s", err2); + return (-1); + } break; default: - (void) HDfprintf(stderr, "%s", err3); + (void)HDfprintf(stderr, "%s", err4); 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: + switch (in->outputArchitecture) { + case 0: + switch (in->outputSize) { + case 32: + new_type = H5Tcopy(H5T_NATIVE_FLOAT); + break; - case 1: - H5Tset_order(new_type, H5T_ORDER_LE); - break; + case 64: + new_type = H5Tcopy(H5T_NATIVE_DOUBLE); + break; - default: - (void) HDfprintf(stderr, "%s", err3); - return (-1); - } - 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: - (void) HDfprintf(stderr, "%s", err5); - return (-1); + case 1: + H5Tset_order(new_type, H5T_ORDER_LE); + break; - case 2: - switch (in->outputSize) { - case 32: - switch (in->outputByteOrder) { - case -1: - case 0: - new_type = H5Tcopy(H5T_IEEE_F32BE); + default: + (void)HDfprintf(stderr, "%s", err3); + return (-1); + } break; case 1: - new_type = H5Tcopy(H5T_IEEE_F32LE); - break; - - default: - (void) HDfprintf(stderr, "%s", err3); + (void)HDfprintf(stderr, "%s", err5); return (-1); - } - break; - case 64: - switch (in->outputByteOrder) { - case -1: - case 0: - new_type = H5Tcopy(H5T_IEEE_F64BE); - break; + 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 1: - new_type = H5Tcopy(H5T_IEEE_F64LE); + 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", err3); + (void)HDfprintf(stderr, "%s", err4); 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 2: + switch (in->outputArchitecture) { + case 0: + switch (in->outputSize) { + case 8: + new_type = H5Tcopy(H5T_NATIVE_UCHAR); + break; - case 32: - new_type = H5Tcopy(H5T_NATIVE_UINT); - break; + case 16: + new_type = H5Tcopy(H5T_NATIVE_USHORT); + break; - case 64: - new_type = H5Tcopy(H5T_NATIVE_ULLONG); - break; + case 32: + new_type = H5Tcopy(H5T_NATIVE_UINT); + 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 64: + new_type = H5Tcopy(H5T_NATIVE_ULLONG); + break; - case 1: - H5Tset_order(new_type, H5T_ORDER_LE); - 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; - default: - (void) HDfprintf(stderr, "%s", err3); - return (-1); - } - break; + case 1: + H5Tset_order(new_type, H5T_ORDER_LE); + break; - case 1: - switch (in->outputSize) { - case 8: - switch (in->outputByteOrder) { - case -1: - case 0: - new_type = H5Tcopy(H5T_STD_U8BE); + default: + (void)HDfprintf(stderr, "%s", err3); + return (-1); + } break; case 1: - new_type = H5Tcopy(H5T_STD_U8LE); - break; + 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; - 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 16: - switch (in->outputByteOrder) { - case -1: - case 0: - new_type = H5Tcopy(H5T_STD_U16BE); - break; + case 1: + new_type = H5Tcopy(H5T_STD_U16LE); + break; - case 1: - new_type = H5Tcopy(H5T_STD_U16LE); - break; + default: + (void)HDfprintf(stderr, "%s", err3); + return (-1); + } + 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 32: - switch (in->outputByteOrder) { - case -1: - case 0: - new_type = H5Tcopy(H5T_STD_U32BE); - break; + case 1: + new_type = H5Tcopy(H5T_STD_U32LE); + break; - case 1: - new_type = H5Tcopy(H5T_STD_U32LE); - break; + default: + (void)HDfprintf(stderr, "%s", err3); + return (-1); + } + 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 64: - switch (in->outputByteOrder) { - case -1: - case 0: - new_type = H5Tcopy(H5T_STD_U64BE); - break; + case 1: + new_type = H5Tcopy(H5T_STD_U64LE); + break; - case 1: - new_type = H5Tcopy(H5T_STD_U64LE); + default: + (void)HDfprintf(stderr, "%s", err3); + return (-1); + } + break; + + default: + (void)HDfprintf(stderr, "%s", err2); + return (-1); + } break; - default: - (void) HDfprintf(stderr, "%s", err3); + case 2: + (void)HDfprintf(stderr, "%s", err6); return (-1); - } - break; - default: - (void) HDfprintf(stderr, "%s", err2); - return (-1); + default: + (void)HDfprintf(stderr, "%s", err4); + return (-1); } break; - case 2: - (void) HDfprintf(stderr, "%s", err6); - return (-1); - default: - (void) HDfprintf(stderr, "%s", err4); + (void)HDfprintf(stderr, "%s", err1); return (-1); - } - break; - - default: - (void) HDfprintf(stderr, "%s", err1); - return (-1); } return new_type; } -hid_t createInputDataType(struct Input *in) +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 input size.\n"; - const char *err3 = "Invalid value for input 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"; + const char *err1 = "Invalid value for input class.\n"; + const char *err2 = "Invalid value for input size.\n"; + const char *err3 = "Invalid value for input 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"; if (in->h5dumpInput) { switch (in->inputClass) { - case 4: - switch (in->inputArchitecture) { - case 0: /*NATIVE*/ - 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; + case 4: + switch (in->inputArchitecture) { + case 0: /*NATIVE*/ + 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); + } + switch (in->inputByteOrder) { + 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; - default: - (void) HDfprintf(stderr, "%s", err2); - return (-1); - } - switch (in->inputByteOrder) { - case -1: /* default */ - break; - case 0: - H5Tset_order(new_type, H5T_ORDER_BE); - break; + case 1: /*STD*/ + switch (in->inputSize) { + case 8: + switch (in->inputByteOrder) { + 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->inputByteOrder) { + 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->inputByteOrder) { + 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->inputByteOrder) { + 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; - case 1: - H5Tset_order(new_type, H5T_ORDER_LE); - break; + default: + (void)HDfprintf(stderr, "%s", err2); + return (-1); + } + break; - default: - (void) HDfprintf(stderr, "%s", err3); - return (-1); + default: + (void)HDfprintf(stderr, "%s", err4); + return (-1); } break; - case 1: /*STD*/ - switch (in->inputSize) { - case 8: - switch (in->inputByteOrder) { - case -1: + case 3: + switch (in->inputArchitecture) { case 0: - new_type = H5Tcopy(H5T_STD_I8BE); + 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); + } + switch (in->inputByteOrder) { + 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: - new_type = H5Tcopy(H5T_STD_I8LE); - break; - - default: - (void) HDfprintf(stderr, "%s", err3); + (void)HDfprintf(stderr, "%s", err5); return (-1); - } - break; - case 16: - switch (in->inputByteOrder) { - case -1: - case 0: - new_type = H5Tcopy(H5T_STD_I16BE); - break; + case 2: + switch (in->inputSize) { + case 32: + switch (in->inputByteOrder) { + 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->inputByteOrder) { + 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; - case 1: - new_type = H5Tcopy(H5T_STD_I16LE); + default: + (void)HDfprintf(stderr, "%s", err2); + return (-1); + } break; default: - (void) HDfprintf(stderr, "%s", err3); + (void)HDfprintf(stderr, "%s", err4); return (-1); - } - break; + } + break; - case 32: - switch (in->inputByteOrder) { - case -1: + case 7: + switch (in->inputArchitecture) { case 0: - new_type = H5Tcopy(H5T_STD_I32BE); + 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); + } + switch (in->inputByteOrder) { + 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: - new_type = H5Tcopy(H5T_STD_I32LE); - break; - - default: - (void) HDfprintf(stderr, "%s", err3); - return (-1); - } - break; + switch (in->inputSize) { + case 8: + switch (in->inputByteOrder) { + 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->inputByteOrder) { + 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->inputByteOrder) { + 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->inputByteOrder) { + 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; - case 64: - switch (in->inputByteOrder) { - case -1: - case 0: - new_type = H5Tcopy(H5T_STD_I64BE); + default: + (void)HDfprintf(stderr, "%s", err2); + return (-1); + } break; - case 1: - new_type = H5Tcopy(H5T_STD_I64LE); - break; + case 2: + (void)HDfprintf(stderr, "%s", err6); + return (-1); default: - (void) HDfprintf(stderr, "%s", err3); + (void)HDfprintf(stderr, "%s", err4); return (-1); - } - break; - - default: - (void) HDfprintf(stderr, "%s", err2); - return (-1); } break; default: - (void) HDfprintf(stderr, "%s", err4); + (void)HDfprintf(stderr, "%s", err1); return (-1); - } - break; - - case 3: - switch (in->inputArchitecture) { + } + } + else { + switch (in->inputClass) { case 0: + case 4: 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); - } - switch (in->inputByteOrder) { - 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->inputSize) { - case 32: - switch (in->inputByteOrder) { - case -1: - case 0: - new_type = H5Tcopy(H5T_IEEE_F32BE); + case 8: + new_type = H5Tcopy(H5T_NATIVE_CHAR); break; - case 1: - new_type = H5Tcopy(H5T_IEEE_F32LE); + case 16: + new_type = H5Tcopy(H5T_NATIVE_SHORT); break; - default: - (void) HDfprintf(stderr, "%s", err3); - return (-1); - } - break; - - case 64: - switch (in->inputByteOrder) { - case -1: - case 0: - new_type = H5Tcopy(H5T_IEEE_F64BE); + case 32: + new_type = H5Tcopy(H5T_NATIVE_INT); break; - case 1: - new_type = H5Tcopy(H5T_IEEE_F64LE); + case 64: + new_type = H5Tcopy(H5T_NATIVE_LLONG); break; default: - (void) HDfprintf(stderr, "%s", err3); + (void)HDfprintf(stderr, "%s", err2); return (-1); - } - break; - - default: - (void) HDfprintf(stderr, "%s", err2); - return (-1); - } - break; - - default: - (void) HDfprintf(stderr, "%s", err4); - return (-1); - } - break; - - case 7: - switch (in->inputArchitecture) { - case 0: - 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); - } - switch (in->inputByteOrder) { - 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: + case 2: + case 3: switch (in->inputSize) { - case 8: - switch (in->inputByteOrder) { - case -1: - case 0: - new_type = H5Tcopy(H5T_STD_U8BE); + case 32: + new_type = H5Tcopy(H5T_NATIVE_FLOAT); break; - case 1: - new_type = H5Tcopy(H5T_STD_U8LE); + case 64: + new_type = H5Tcopy(H5T_NATIVE_DOUBLE); break; default: - (void) HDfprintf(stderr, "%s", err3); + (void)HDfprintf(stderr, "%s", err2); return (-1); - } - break; - - case 16: - switch (in->inputByteOrder) { - case -1: - case 0: - new_type = H5Tcopy(H5T_STD_U16BE); - break; - - case 1: - new_type = H5Tcopy(H5T_STD_U16LE); - break; + } + break; - default: - (void) HDfprintf(stderr, "%s", err3); - return (-1); - } - break; + case 5: + (void)HDfprintf(stderr, "%s", err1); + return (-1); + break; - case 32: - switch (in->inputByteOrder) { - case -1: - case 0: - new_type = H5Tcopy(H5T_STD_U32BE); + case 6: + case 7: + switch (in->inputSize) { + case 8: + new_type = H5Tcopy(H5T_NATIVE_UCHAR); break; - case 1: - new_type = H5Tcopy(H5T_STD_U32LE); + case 16: + new_type = H5Tcopy(H5T_NATIVE_USHORT); break; - default: - (void) HDfprintf(stderr, "%s", err3); - return (-1); - } - break; - - case 64: - switch (in->inputByteOrder) { - case -1: - case 0: - new_type = H5Tcopy(H5T_STD_U64BE); + case 32: + new_type = H5Tcopy(H5T_NATIVE_UINT); break; - case 1: - new_type = H5Tcopy(H5T_STD_U64LE); + case 64: + new_type = H5Tcopy(H5T_NATIVE_ULLONG); break; default: - (void) HDfprintf(stderr, "%s", err3); + (void)HDfprintf(stderr, "%s", err2); 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); + (void)HDfprintf(stderr, "%s", err1); return (-1); - } - break; - - default: - (void) HDfprintf(stderr, "%s", err1); - return (-1); - } - } - else { - 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) +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; + 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 *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); + (void)HDfprintf(stderr, err1, opt->outfile); return (-1); } } @@ -4593,13 +4642,13 @@ static int process(struct Options *opt) 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); + (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); + (void)HDfprintf(stderr, err3, opt->infiles[k].datafile); return (-1); } @@ -4612,13 +4661,15 @@ static int process(struct Options *opt) { /* create parent groups */ if (in->path.count > 1) { - j = 0; + 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); + 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); + group_id = H5Gcreate2(group_id, in->path.group[j], H5P_DEFAULT, H5P_DEFAULT, + H5P_DEFAULT); handle = group_id; break; } @@ -4628,7 +4679,7 @@ static int process(struct Options *opt) } else { handle = file_id; - j = 0; + j = 0; } /*enable error reporting */ @@ -4636,7 +4687,7 @@ static int process(struct Options *opt) H5E_END_TRY; /*create data type */ - intype = createInputDataType(in); + intype = createInputDataType(in); outtype = createOutputDataType(in); #ifdef H5DEBUGIMPORT HDprintf("process intype %ld outtype %ld\n", intype, outtype); @@ -4651,20 +4702,21 @@ static int process(struct Options *opt) } if (in->configOptionVector[COMPRESS] == 1) { - H5Pset_deflate(proplist, (unsigned) in->compressionParam); + 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); + (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 * (hsize_t)in->inputSize / 8); + H5Pset_external(proplist, in->externFilename, (off_t)0, + numOfElements * (hsize_t)in->inputSize / 8); } /* create dataspace */ @@ -4677,8 +4729,9 @@ static int process(struct Options *opt) 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); + 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); @@ -4690,8 +4743,8 @@ static int process(struct Options *opt) H5E_END_TRY; /* write dataset */ - if (H5Dwrite(dataset, intype, H5S_ALL, H5S_ALL, H5P_DEFAULT, (VOIDP) in->data) < 0) { - (void) HDfprintf(stderr, "%s", err6); + 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); @@ -4710,36 +4763,44 @@ static int process(struct Options *opt) return (0); } -uint16_t swap_uint16(uint16_t val) +uint16_t +swap_uint16(uint16_t val) { return (uint16_t)((val << 8) | (val >> 8)); } -int16_t swap_int16(int16_t val) +int16_t +swap_int16(int16_t val) { return (int16_t)((val << 8) | ((val >> 8) & 0xFF)); } -uint32_t swap_uint32(uint32_t val) +uint32_t +swap_uint32(uint32_t val) { val = ((val << 8) & 0xFF00FF00) | ((val >> 8) & 0xFF00FF); return (val << 16) | (val >> 16); } -int32_t swap_int32(int32_t val) +int32_t +swap_int32(int32_t val) { val = (int32_t)(((uint32_t)(val << 8) & 0xFF00FF00) | ((val >> 8) & 0xFF00FF)); return (val << 16) | ((val >> 16) & 0xFFFF); } -int64_t swap_int64(int64_t val) +int64_t +swap_int64(int64_t val) { - val = (int64_t)(((uint64_t)(val << 8) & 0xFF00FF00FF00FF00ULL) | ((uint64_t)(val >> 8) & 0x00FF00FF00FF00FFULL)); - val = (int64_t)(((uint64_t)(val << 16) & 0xFFFF0000FFFF0000ULL) | ((uint64_t)(val >> 16) & 0x0000FFFF0000FFFFULL)); + val = (int64_t)(((uint64_t)(val << 8) & 0xFF00FF00FF00FF00ULL) | + ((uint64_t)(val >> 8) & 0x00FF00FF00FF00FFULL)); + val = (int64_t)(((uint64_t)(val << 16) & 0xFFFF0000FFFF0000ULL) | + ((uint64_t)(val >> 16) & 0x0000FFFF0000FFFFULL)); return (int64_t)((uint64_t)(val << 32) | ((uint64_t)(val >> 32) & 0xFFFFFFFFULL)); } -uint64_t swap_uint64(uint64_t val) +uint64_t +swap_uint64(uint64_t val) { val = ((val << 8) & 0xFF00FF00FF00FF00ULL) | ((val >> 8) & 0x00FF00FF00FF00FFULL); val = ((val << 16) & 0xFFFF0000FFFF0000ULL) | ((val >> 16) & 0x0000FFFF0000FFFFULL); @@ -4754,414 +4815,297 @@ uint64_t swap_uint64(uint64_t val) * Print a helpful summary of command usage and features. */ -void help(char *name) +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> \ + (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 INPUT-BYTE-ORDER\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"); + (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 INPUT-BYTE-ORDER\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 +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); + (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; } - diff --git a/tools/src/h5import/h5import.h b/tools/src/h5import/h5import.h index 00c41f6..405d953 100644 --- a/tools/src/h5import/h5import.h +++ b/tools/src/h5import/h5import.h @@ -25,116 +25,109 @@ */ #define FILNAME 0 /* filename */ -#define OPT_o 1 +#define OPT_o 1 /* output filename */ -#define OPT_c 2 /* configuration filename */ -#define OPT_h 3 /* request for explanation */ -#define OPT_d 4 /* dimensions */ -#define OPT_p 5 /* pathname */ -#define OPT_t 6 /* data type */ -#define OPT_s 7 /* data size */ -#define ERR 20 /* invalid token */ - -#define MAX_GROUPS_IN_PATH 20 +#define OPT_c 2 /* configuration filename */ +#define OPT_h 3 /* request for explanation */ +#define OPT_d 4 /* dimensions */ +#define OPT_p 5 /* pathname */ +#define OPT_t 6 /* data type */ +#define OPT_s 7 /* data size */ +#define ERR 20 /* invalid token */ + +#define MAX_GROUPS_IN_PATH 20 #define MAX_PATH_NAME_LENGTH 255 -#define NUM_KEYS 15 -#define MIN_NUM_DIMENSION 1 -#define MAX_NUM_DIMENSION 32 -#define BASE_10 10 - -#define PATH 0 -#define INPUT_CLASS 1 -#define INPUT_SIZE 2 -#define RANK 3 -#define DIM 4 -#define OUTPUT_CLASS 5 -#define OUTPUT_SIZE 6 -#define OUTPUT_ARCH 7 -#define OUTPUT_B_ORDER 8 -#define CHUNK 9 -#define COMPRESS 10 -#define COMPRESS_PARAM 11 -#define EXTERNALSTORE 12 -#define EXTEND 13 -#define INPUT_B_ORDER 14 +#define NUM_KEYS 15 +#define MIN_NUM_DIMENSION 1 +#define MAX_NUM_DIMENSION 32 +#define BASE_10 10 + +#define PATH 0 +#define INPUT_CLASS 1 +#define INPUT_SIZE 2 +#define RANK 3 +#define DIM 4 +#define OUTPUT_CLASS 5 +#define OUTPUT_SIZE 6 +#define OUTPUT_ARCH 7 +#define OUTPUT_B_ORDER 8 +#define CHUNK 9 +#define COMPRESS 10 +#define COMPRESS_PARAM 11 +#define EXTERNALSTORE 12 +#define EXTEND 13 +#define INPUT_B_ORDER 14 /* data types */ -#define H5DT_INT8 signed char -#define H5DT_INT16 short -#define H5DT_INT32 int -#define H5DT_FLOAT32 float -#define H5DT_FLOAT64 double -#define VOIDP void* -#define H5DT_UINT8 unsigned char -#define H5DT_UINT16 unsigned short -#define H5DT_UINT32 unsigned int -#define H5DT_INT64 long long -#define H5DT_UINT64 unsigned H5DT_INT64 - -struct path_info -{ +#define H5DT_INT8 signed char +#define H5DT_INT16 short +#define H5DT_INT32 int +#define H5DT_FLOAT32 float +#define H5DT_FLOAT64 double +#define VOIDP void * +#define H5DT_UINT8 unsigned char +#define H5DT_UINT16 unsigned short +#define H5DT_UINT32 unsigned int +#define H5DT_INT64 long long +#define H5DT_UINT64 unsigned H5DT_INT64 + +struct path_info { char group[MAX_GROUPS_IN_PATH][MAX_PATH_NAME_LENGTH]; - int count; + int count; }; -struct Input -{ - int h5dumpInput; +struct Input { + int h5dumpInput; struct path_info path; - int inputClass; - int inputSize; - int inputArchitecture; - int inputByteOrder; - int rank; - hsize_t* sizeOfDimension; - int outputClass; - int outputSize; - int outputArchitecture; - int outputByteOrder; - hsize_t* sizeOfChunk; - hsize_t* maxsizeOfDimension; - int compressionType; - int compressionParam; - char *externFilename; - VOIDP data; - int configOptionVector[NUM_KEYS]; + int inputClass; + int inputSize; + int inputArchitecture; + int inputByteOrder; + int rank; + hsize_t * sizeOfDimension; + int outputClass; + int outputSize; + int outputArchitecture; + int outputByteOrder; + hsize_t * sizeOfChunk; + hsize_t * maxsizeOfDimension; + int compressionType; + int compressionParam; + char * externFilename; + VOIDP data; + int configOptionVector[NUM_KEYS]; }; -struct infilesformat -{ - char datafile[MAX_PATH_NAME_LENGTH]; - char configfile[MAX_PATH_NAME_LENGTH]; +struct infilesformat { + char datafile[MAX_PATH_NAME_LENGTH]; + char configfile[MAX_PATH_NAME_LENGTH]; struct Input in; - int config; /* Configfile present? No - 0. Yes - 1 */ + int config; /* Configfile present? No - 0. Yes - 1 */ }; -struct Options -{ - struct infilesformat infiles[30]; /* structure to hold the list of input file names. Limited to 30*/ - char outfile[256]; /* output file name */ - int fcount; /* number of input files */ +struct Options { + struct infilesformat infiles[30]; /* structure to hold the list of input file names. Limited to 30*/ + char outfile[256]; /* output file name */ + int fcount; /* number of input files */ }; -char keytable[NUM_KEYS][30] = { - "PATH", - "INPUT-CLASS", - "INPUT-SIZE", - "RANK", - "DIMENSION-SIZES", - "OUTPUT-CLASS", - "OUTPUT-SIZE", - "OUTPUT-ARCHITECTURE", - "OUTPUT-BYTE-ORDER", - "CHUNKED-DIMENSION-SIZES", - "COMPRESSION-TYPE", - "COMPRESSION-PARAM", - "EXTERNAL-STORAGE", - "MAXIMUM-DIMENSIONS", - "INPUT-BYTE-ORDER" -}; - -static int state_table[15][8] = -{ +char keytable[NUM_KEYS][30] = {"PATH", + "INPUT-CLASS", + "INPUT-SIZE", + "RANK", + "DIMENSION-SIZES", + "OUTPUT-CLASS", + "OUTPUT-SIZE", + "OUTPUT-ARCHITECTURE", + "OUTPUT-BYTE-ORDER", + "CHUNKED-DIMENSION-SIZES", + "COMPRESSION-TYPE", + "COMPRESSION-PARAM", + "EXTERNAL-STORAGE", + "MAXIMUM-DIMENSIONS", + "INPUT-BYTE-ORDER"}; + +static int state_table[15][8] = { /* token ordering: FILNAME OPT_o OPT_c OPT_h OPT_d OPT_p OPT_t OPT_s */ /* state 0: start */ @@ -189,12 +182,11 @@ static int state_table[15][8] = * Function declarations for h5import * */ -void usage(char *); -void setDefaultValues(struct Input *in, int count); -void help(char *); - -hid_t createOutputDataType(struct Input *in); -hid_t createInputDataType(struct Input *in); +void usage(char *); +void setDefaultValues(struct Input *in, int count); +void help(char *); -#endif /* H5IMPORT_H__ */ +hid_t createOutputDataType(struct Input *in); +hid_t createInputDataType(struct Input *in); +#endif /* H5IMPORT_H__ */ |