HDFFV-10219 and HDFFV-10256 merge from develop

2 files changed, 881 insertions, 109 deletions

diff --git a/tools/src/h5import/h5import.c b/tools/src/h5import/h5import.c
index c71aeef..36a8c21 100644
--- a/tools/src/h5import/h5import.c
+++ b/tools/src/h5import/h5import.c
@@ -13,10 +13,6 @@
 
 #include "hdf5.h"
 #include "H5private.h"
-#include <stdio.h>
-#include <math.h>
-#include <string.h>
-#include <ctype.h>
 #include "h5import.h"
 #include "h5tools.h"
 #include "h5tools_utils.h"
@@ -40,6 +36,7 @@ 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);
@@ -66,6 +63,12 @@ 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[])
 {
@@ -226,7 +229,7 @@ int main(int argc, char *argv[])
 
     if (process(&opt) == -1)
         goto err;
-    
+
     for (i = 0; i < opt.fcount; i++) {
         in = &(opt.infiles[i].in);
         if (in->sizeOfDimension)
@@ -242,7 +245,7 @@ int main(int argc, char *argv[])
     }
 
     return (EXIT_SUCCESS);
-err: 
+err:
     (void) HDfprintf(stderr, "%s", err4);
     for (i = 0; i < opt.fcount; i++) {
         in = &(opt.infiles[i].in);
@@ -450,10 +453,12 @@ static int readIntegerData(FILE *strm, struct Input *in)
 {
     H5DT_INT8  *in08;
     H5DT_INT16 *in16;
-    H5DT_INT16  temp;
+    H5DT_INT16  temp16;
     H5DT_INT32 *in32;
+    H5DT_INT32  temp32;
 #ifdef H5_SIZEOF_LONG_LONG
     H5DT_INT64 *in64;
+    H5DT_INT64  temp64;
     char        buffer[256];
 #endif
     hsize_t     len = 1;
@@ -473,11 +478,11 @@ static int readIntegerData(FILE *strm, struct Input *in)
         case 0: /* TEXTIN */
             in08 = (H5DT_INT8 *) in->data;
             for (i = 0; i < len; i++, in08++) {
-                if (fscanf(strm, "%hd", &temp) != 1) {
+                if (fscanf(strm, "%hd", &temp16) != 1) {
                     (void) HDfprintf(stderr, "%s", err1);
                     return (-1);
                 }
-                (*in08) = (H5DT_INT8) temp;
+                (*in08) = (H5DT_INT8) temp16;
             }
             break;
 
@@ -488,6 +493,9 @@ static int readIntegerData(FILE *strm, struct Input *in)
                     (void) HDfprintf(stderr, "%s", err1);
                     return (-1);
                 }
+#ifdef H5DEBUGIMPORT
+                printf("readIntegerData %d (0x%.8X)\n", *in08, *in08);
+#endif
             }
             break;
 
@@ -512,10 +520,19 @@ static int readIntegerData(FILE *strm, struct Input *in)
 
         case 4: /* IN */
             for (i = 0; i < len; i++, in16++) {
-                if (HDfread((char *) in16, sizeof(H5DT_INT16), 1, strm) != 1) {
+                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
+                printf("readIntegerData %d (0x%.8X)\n", *in16, temp16);
+#endif
             }
             break;
 
@@ -539,10 +556,19 @@ static int readIntegerData(FILE *strm, struct Input *in)
 
         case 4: /* IN */
             for (i = 0; i < len; i++, in32++) {
-                if (HDfread((char *) in32, sizeof(H5DT_INT32), 1, strm) != 1) {
+                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
+                printf("readIntegerData %d (0x%.8X = 0x%.8X)\n", *in32, *in32, temp32);
+#endif
             }
             break;
 
@@ -568,10 +594,19 @@ static int readIntegerData(FILE *strm, struct Input *in)
 
         case 4: /* IN */
             for (i = 0; i < len; i++, in64++) {
-                if (HDfread((char *) in64, sizeof(H5DT_INT64), 1, strm) != 1) {
+                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
+                printf("readIntegerData %d (0x%.8X)\n", *in64, temp64);
+#endif
             }
             break;
 
@@ -593,10 +628,12 @@ static int readUIntegerData(FILE *strm, struct Input *in)
 {
     H5DT_UINT8  *in08;
     H5DT_UINT16 *in16;
-    H5DT_UINT16  temp;
+    H5DT_UINT16  temp16;
     H5DT_UINT32 *in32;
+    H5DT_UINT32  temp32;
 #ifdef H5_SIZEOF_LONG_LONG
     H5DT_UINT64 *in64;
+    H5DT_UINT64  temp64;
     char        buffer[256];
 #endif
     hsize_t     len = 1;
@@ -615,11 +652,11 @@ static int readUIntegerData(FILE *strm, struct Input *in)
         case 6: /* TEXTUIN */
             in08 = (H5DT_UINT8 *) in->data;
             for (i = 0; i < len; i++, in08++) {
-                if (fscanf(strm, "%hu", &temp) != 1) {
+                if (fscanf(strm, "%hu", &temp16) != 1) {
                     (void) HDfprintf(stderr, "%s", err1);
                     return (-1);
                 }
-                (*in08) = (H5DT_UINT8) temp;
+                (*in08) = (H5DT_UINT8) temp16;
             }
             break;
 
@@ -653,10 +690,19 @@ static int readUIntegerData(FILE *strm, struct Input *in)
 
         case 7: /* UIN */
             for (i = 0; i < len; i++, in16++) {
-                if (HDfread((char *) in16, sizeof(H5DT_UINT16), 1, strm) != 1) {
+                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
+                printf("readUIntegerData %d (0x%.4X = 0x%.4X)\n", *in16, *in16, temp16);
+#endif
             }
             break;
 
@@ -680,10 +726,19 @@ static int readUIntegerData(FILE *strm, struct Input *in)
 
         case 7: /* UIN */
             for (i = 0; i < len; i++, in32++) {
-                if (HDfread((char *) in32, sizeof(H5DT_UINT32), 1, strm) != 1) {
+                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
+                printf("readUIntegerData %d (0x%.8X = 0x%.8X)\n", *in32, *in32, temp32);
+#endif
             }
             break;
 
@@ -709,10 +764,19 @@ static int readUIntegerData(FILE *strm, struct Input *in)
 
         case 7: /* UIN */
             for (i = 0; i < len; i++, in64++) {
-                if (HDfread((char *) in64, sizeof(H5DT_UINT64), 1, strm) != 1) {
+                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
+                printf("readUIntegerData %ld (0x%.8X = 0x%.8X)\n", *in64, *in64, temp64);
+#endif
             }
             break;
 
@@ -733,12 +797,16 @@ static int readUIntegerData(FILE *strm, struct Input *in)
 static int readFloatData(FILE *strm, struct Input *in)
 {
     H5DT_FLOAT32 *fp32;
+    uint32_t  *bfp32;
+    uint32_t  temp32;
     H5DT_FLOAT64 *fp64;
+    uint64_t  *bfp64;
+    uint64_t  temp64;
 
     hsize_t     len = 1;
     hsize_t     i;
     int         j;
-    const char *err1 = "Unable to get integer value from file.\n";
+    const char *err1 = "Unable to get float value from file.\n";
     const char *err2 = "Unrecognized input class type.\n";
     const char *err3 = "Invalid input size type.\n";
 
@@ -774,11 +842,21 @@ static int readFloatData(FILE *strm, struct Input *in)
             break;
 
         case 3: /* FP */
-            for (i = 0; i < len; i++, fp32++) {
-                if (HDfread((char *) fp32, sizeof(H5DT_FLOAT32), 1, strm) != 1) {
+            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
+                printf("readFloatData %ld (0x%.8X = 0x%.8X)\n", *bfp32, *bfp32, temp32);
+#endif
             }
             break;
 
@@ -816,11 +894,21 @@ static int readFloatData(FILE *strm, struct Input *in)
             break;
 
         case 3: /* FP */
-            for (i = 0; i < len; i++, fp64++) {
-                if (HDfread((char *) fp64, sizeof(H5DT_FLOAT64), 1, strm) != 1) {
+            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
+                printf("readFloatData %ld (0x%.16lX)\n", *bfp64, temp64);
+#endif
             }
             break;
 
@@ -897,7 +985,7 @@ static int processStrData(FILE *strm, struct Input *in, hid_t file_id)
         goto out;
 
     /* disable error reporting */
-    H5E_BEGIN_TRY 
+    H5E_BEGIN_TRY
     {
         /* create parent groups */
         if (in->path.count > 1) {
@@ -1286,7 +1374,7 @@ static int processConfigurationFile(char *infile, struct Input *in)
     int         retval = -1;
 
     const char *err1 = "Unable to open the configuration file:  %s for reading.\n";
-    const char *err2 = "Unknown keyword in configuration file: %s\n";
+    const char *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";
@@ -1306,6 +1394,9 @@ static int processConfigurationFile(char *infile, struct Input *in)
     const char *err10b = "Error in retrieving the output architecture from %s.\n";
     const char *err11a = "OUTPUT-BYTE-ORDER keyword appears twice in %s.\n";
     const char *err11b = "Error in retrieving the output byte order from %s.\n";
+    const char *err11c = "INPUT-BYTE-ORDER keyword appears twice in %s.\n";
+    const char *err11d = "Error in retrieving the input byte order from %s.\n";
+    const char *err11e = "Invalid value for output byte-order.\n";
     const char *err12a = "CHUNKED-DIMENSION-SIZES keyword appears twice in %s.\n";
     const char *err12b = "CHUNKED-DIMENSION-SIZES cannot appear before DIMENSION-SIZES are provided.\n";
     const char *err12c = "Error in retrieving the chunked dimension sizes from %s.\n";
@@ -1321,6 +1412,7 @@ static int processConfigurationFile(char *infile, struct Input *in)
     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
@@ -1328,6 +1420,27 @@ static int processConfigurationFile(char *infile, struct Input *in)
      process the output file according to the options
      */
 
+    /* Initialize machine endian */
+    volatile uint32_t ibyte=0x01234567;
+    /* 0 for big endian, 1 for little endian. */
+    if ((*((uint8_t*)(&ibyte))) == 0x67) {
+        if ((kindex = OutputByteOrderStrToInt("LE")) == -1) {
+            (void) HDfprintf(stderr, "%s", err11e);
+            return (-1);
+        }
+    }
+    else {
+        if ((kindex = OutputByteOrderStrToInt("BE")) == -1) {
+            (void) HDfprintf(stderr, "%s", err11e);
+            return (-1);
+        }
+    }
+    in->inputByteOrder = kindex;
+#ifdef H5DEBUGIMPORT
+    printf("h5dump inputByteOrder %d\n", in->inputByteOrder);
+#endif
+    in->inputArchitecture = 0; /* default to NATIVE */
+
     if ((strm = HDfopen(infile, "r")) == NULL) {
         (void) HDfprintf(stderr, err1, infile);
         goto error;
@@ -1563,15 +1676,15 @@ static int processConfigurationFile(char *infile, struct Input *in)
                             goto error;
                         }
 #ifdef H5DEBUGIMPORT
-                        printf("h5dump DATASPACE SIMPLE %d rank\n", in->rank);
+                        printf("h5dump DATASPACE SIMPLE %ld rank\n", in->rank);
 #endif
                         for (i = 0; i < in->rank; i++) {
                             in->sizeOfDimension[i] = temp_dims[i];
                         }
 #ifdef H5DEBUGIMPORT
-                        printf("h5dump DATASPACE SIMPLE dims:", in->rank);
+                        printf("h5dump DATASPACE SIMPLE dims[%ld]:", in->rank);
                         for (pndx = 0; pndx < in->rank; pndx++) {
-                            printf(" %d", in->sizeOfDimension[pndx]);
+                            printf(" %ld", in->sizeOfDimension[pndx]);
                         }
                         printf("\n");
 #endif
@@ -1644,9 +1757,9 @@ static int processConfigurationFile(char *infile, struct Input *in)
                                 }
                             } /* while (get_next_dim) */
 #ifdef H5DEBUGIMPORT
-                            printf("h5dump DATASPACE SIMPLE maxdims:", in->rank);
+                            printf("h5dump DATASPACE SIMPLE maxdims[%ld]:", in->rank);
                             for (pndx = 0; pndx < in->rank; pndx++) {
-                                printf(" %d", in->maxsizeOfDimension[pndx]);
+                                printf(" %ld", in->maxsizeOfDimension[pndx]);
                             }
                             printf("\n");
                             printf("h5dump DATASPACE SIMPLE get max dim finished\n");
@@ -1731,9 +1844,9 @@ static int processConfigurationFile(char *infile, struct Input *in)
                             }
                         } /* while (get_next_dim) */
 #ifdef H5DEBUGIMPORT
-                        printf("h5dump STORAGE_LAYOUT CHUNKED dims:", in->rank);
+                        printf("h5dump STORAGE_LAYOUT CHUNKED dims [%ld]:", in->rank);
                         for (pndx = 0; pndx < in->rank; pndx++) {
-                            printf(" %d", in->sizeOfChunk[pndx]);
+                            printf(" %ld", in->sizeOfChunk[pndx]);
                         }
                         printf("\n");
 #endif
@@ -1852,6 +1965,151 @@ static int processConfigurationFile(char *infile, struct Input *in)
                 printf("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;
+#ifdef H5DEBUGIMPORT
+                printf("h5dump SUBSET key\n");
+#endif
+                if (fscanf(strm, "%s", temp) != 1) { /* start bracket */
+                    (void) HDfprintf(stderr, err20, infile);
+                    goto error;
+                }
+#ifdef H5DEBUGIMPORT
+                printf("h5dump SUBSET %s found\n", temp);
+#endif
+                if (fscanf(strm, "%s", temp) != 1) { /* SUBSET keyword */
+                    (void) HDfprintf(stderr, "%s", err18);
+                    goto error;
+                }
+#ifdef H5DEBUGIMPORT
+                printf("h5dump SUBSET %s found\n", temp);
+#endif
+                while (get_next_prop) {
+                    if(!HDstrcmp("COUNT", temp)) { /* COUNT */
+                        int icount = 0;
+                        if (fscanf(strm, "%s", temp) != 1) { /* start paren */
+                            (void) HDfprintf(stderr, err6b, infile);
+                            goto error;
+                        }
+#ifdef H5DEBUGIMPORT
+                        printf("h5dump SUBSET %s found\n", temp);
+#endif
+                        if(!HDstrcmp("(", temp)) { /* start paren */
+                            int get_next_dim = 1;
+                            int i = 0;
+
+                            if (fscanf(strm, "%s", temp) != 1) { /* Dimension with optional comma */
+                                (void) HDfprintf(stderr, err16c, infile);
+                                goto error;
+                            }
+#ifdef H5DEBUGIMPORT
+                            printf("h5dump SUBSET COUNT [%s] found\n", temp);
+#endif
+                            while (get_next_dim) {
+                                char *more = temp;
+                                temp_dims[icount] = HDstrtoull(more, &more, 10);
+                                if (fscanf(strm, "%s", temp) != 1) { /* Dimension or end paren */
+                                    (void) HDfprintf(stderr, err6b, infile);
+                                    goto error;
+                                }
+#ifdef H5DEBUGIMPORT
+                                printf("h5dump SUBSET COUNT %s found\n", temp);
+#endif
+                                if(!HDstrcmp(");", temp)) { /* end paren */
+                                    in->rank = ++icount;
+                                    in->configOptionVector[RANK] = 1;
+                                    get_next_dim = 0;
+                                }
+                                else { /* Dimension */
+                                    icount++;
+                                    if (icount > MAX_NUM_DIMENSION) {
+                                        (void) HDfprintf(stderr, "Invalid value for rank.\n");
+                                        goto error;
+                                    }
+                                }
+                            } /* while (get_next_dim) */
+                            for (i = 0; i < in->rank; i++) {
+                                in->sizeOfDimension[i] = temp_dims[i];
+                            }
+#ifdef H5DEBUGIMPORT
+                            printf("h5dump SUBSET COUNT dims: [%d]", in->rank);
+                            for (pndx = 0; pndx < in->rank; pndx++) {
+                                printf(" %ld", in->sizeOfDimension[pndx]);
+                            }
+                            printf("\n");
+#endif
+                            in->configOptionVector[DIM] = 1;
+                        } /* if(!HDstrcmp("(", key))  start paren */
+                    } /* if(!HDstrcmp("COUNT", temp))  COUNT */
+                    if(!HDstrcmp("BLOCK", temp)) { /* BLOCK */
+                        int icount = 0;
+                        if (fscanf(strm, "%s", temp) != 1) { /* start paren */
+                            (void) HDfprintf(stderr, err6b, infile);
+                            goto error;
+                        }
+#ifdef H5DEBUGIMPORT
+                        printf("h5dump SUBSET %s found\n", temp);
+#endif
+                        if(!HDstrcmp("(", temp)) { /* start paren */
+                            int get_next_dim = 1;
+                            int i = 0;
+
+                            if (fscanf(strm, "%s", temp) != 1) { /* Dimension with optional comma */
+                                (void) HDfprintf(stderr, err16c, infile);
+                                goto error;
+                            }
+#ifdef H5DEBUGIMPORT
+                        printf("h5dump SUBSET BLOCK [%s] found\n", temp);
+#endif
+                            while (get_next_dim) {
+                                char *more = temp;
+                                temp_dims[icount] = HDstrtoull(more, &more, 10);
+                                if (fscanf(strm, "%s", temp) != 1) { /* Dimension or end paren */
+                                    (void) HDfprintf(stderr, err6b, infile);
+                                    goto error;
+                                }
+#ifdef H5DEBUGIMPORT
+                                printf("h5dump SUBSET BLOCK %s found\n", temp);
+#endif
+                                if(!HDstrcmp(");", temp)) { /* end paren */
+                                    in->rank = ++icount;
+                                    in->configOptionVector[RANK] = 1;
+                                    get_next_dim = 0;
+                                }
+                                else { /* Dimension */
+                                    icount++;
+                                    if (icount > MAX_NUM_DIMENSION) {
+                                        (void) HDfprintf(stderr, "Invalid value for rank.\n");
+                                        goto error;
+                                    }
+                                }
+                            } /* while (get_next_dim) */
+                            for (i = 0; i < in->rank; i++) {
+                                in->sizeOfDimension[i] = in->sizeOfDimension[i] * temp_dims[i];
+                            }
+#ifdef H5DEBUGIMPORT
+                            printf("h5dump SUBSET BLOCK dims: [%d]", in->rank);
+                            for (pndx = 0; pndx < in->rank; pndx++) {
+                                printf(" %ld", in->sizeOfDimension[pndx]);
+                            }
+                            printf("\n");
+#endif
+                            in->configOptionVector[DIM] = 1;
+                        } /* if(!HDstrcmp("(", key))  start paren */
+                    } /* if(!HDstrcmp("BLOCK", temp))  BLOCK */
+                    if (fscanf(strm, "%s", temp) != 1) {
+                        (void) HDfprintf(stderr, "%s", err18);
+                        goto error;
+                    }
+#ifdef H5DEBUGIMPORT
+                    printf("h5dump SUBSET %s found\n", temp);
+#endif
+                    if(!HDstrcmp("}", temp)) { /* end bracket */
+                        get_next_prop = 0;
+                    }
+                } /* while (get_next_prop) */
+            } /* else if(!HDstrcmp("SUBSET", key)) */
             else if(!HDstrcmp("DATA", key)) { /* FINSHED */
 #ifdef H5DEBUGIMPORT
                 printf("h5dump DATA key\n");
@@ -1869,6 +2127,8 @@ static int processConfigurationFile(char *infile, struct Input *in)
         printf("\n");
         printf("h5dump inputClass=%d\n", in->inputClass);
         printf("h5dump inputSize=%d\n", in->inputSize);
+        printf("h5dump inputArchitecture=%d\n", in->inputArchitecture);
+        printf("h5dump inputByteOrder=%d\n", in->inputByteOrder);
         printf("h5dump rank=%d\n", in->rank);
         printf("h5dump outputClass=%d\n", in->outputClass);
         printf("h5dump outputSize=%d\n", in->outputSize);
@@ -1877,16 +2137,19 @@ static int processConfigurationFile(char *infile, struct Input *in)
         printf("h5dump compressionType=%d\n", in->compressionType);
         printf("h5dump compressionParam=%d\n", in->compressionParam);
         printf("h5dump externFilename=%s\n", in->externFilename);
-        printf("h5dump configOptionVector:\n");
-        for (pndx = 0; pndx < NUM_KEYS; pndx++) {
-            printf("    %s=%d\n", keytable[pndx], in->configOptionVector[pndx]);
+        printf("h5dump sizeOfDimensions:\n");
+        for (pndx = 0; pndx < in->rank; pndx++) {
+            printf("  %ld\n", in->sizeOfDimension[pndx]);
         }
 #endif
     }
     else {
+#ifdef H5DEBUGIMPORT
+        printf("original option keyword parsing\n");
+#endif
         while (scanret == 1) {
             if ((kindex = mapKeywordToIndex(key)) == -1) {
-                (void) HDfprintf(stderr, err2, infile);
+                (void) HDfprintf(stderr, err2, key, infile);
                 goto error;
             }
             switch (kindex) {
@@ -2121,21 +2384,34 @@ static int processConfigurationFile(char *infile, struct Input *in)
                 in->configOptionVector[EXTEND] = 1;
                 break;
 
+            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;
+
             default:
                 break;
             }
             scanret = fscanf(strm, "%s", key);
         }
-    }
 
-    /*
-         check if keywords obtained are valid
-         if yes, return 0 else error
-     */
+        /*
+            check if keywords obtained are valid
+            if yes, return 0 else error
+        */
 
-    if (validateConfigurationParameters(in) == -1) {
-        (void) HDfprintf(stderr, err17, infile);
-        goto error;
+        if (validateConfigurationParameters(in) == -1) {
+            (void) HDfprintf(stderr, err17, infile);
+            goto error;
+        }
     }
 
     /* Set success return value */
@@ -2361,7 +2637,7 @@ static int getInputClassType(struct Input *in, char * buffer)
     int         kindex = -1;
     const char *err1 = "Invalid value for input class.\n";
     const char *err2 = "Invalid value for output architecture.\n";
-    const char *err3 = "Invalid value for output byte-order.\n";
+    const char *err3 = "Invalid value for input byte-order.\n";
 
     if (!HDstrcmp(buffer, "H5T_STD_I8BE")) {
         in->inputSize = 8;
@@ -2378,6 +2654,9 @@ static int getInputClassType(struct Input *in, char * buffer)
             return (-1);
         }
         in->outputByteOrder = kindex;
+    #ifdef H5DEBUGIMPORT
+        printf("h5dump inputByteOrder %d\n", in->inputByteOrder);
+    #endif
 
         kindex = 4;
     }
@@ -2396,6 +2675,9 @@ static int getInputClassType(struct Input *in, char * buffer)
             return (-1);
         }
         in->outputByteOrder = kindex;
+    #ifdef H5DEBUGIMPORT
+        printf("h5dump inputByteOrder %d\n", in->inputByteOrder);
+    #endif
 
         kindex = 4;
     }
@@ -2414,6 +2696,9 @@ static int getInputClassType(struct Input *in, char * buffer)
             return (-1);
         }
         in->outputByteOrder = kindex;
+    #ifdef H5DEBUGIMPORT
+        printf("h5dump inputByteOrder %d\n", in->inputByteOrder);
+    #endif
 
         kindex = 4;
     }
@@ -2432,6 +2717,9 @@ static int getInputClassType(struct Input *in, char * buffer)
             return (-1);
         }
         in->outputByteOrder = kindex;
+    #ifdef H5DEBUGIMPORT
+        printf("h5dump inputByteOrder %d\n", in->inputByteOrder);
+    #endif
 
         kindex = 4;
     }
@@ -2450,6 +2738,9 @@ static int getInputClassType(struct Input *in, char * buffer)
             return (-1);
         }
         in->outputByteOrder = kindex;
+    #ifdef H5DEBUGIMPORT
+        printf("h5dump inputByteOrder %d\n", in->inputByteOrder);
+    #endif
 
         kindex = 4;
     }
@@ -2468,6 +2759,9 @@ static int getInputClassType(struct Input *in, char * buffer)
             return (-1);
         }
         in->outputByteOrder = kindex;
+    #ifdef H5DEBUGIMPORT
+        printf("h5dump inputByteOrder %d\n", in->inputByteOrder);
+    #endif
 
         kindex = 4;
     }
@@ -2486,6 +2780,9 @@ static int getInputClassType(struct Input *in, char * buffer)
             return (-1);
         }
         in->outputByteOrder = kindex;
+    #ifdef H5DEBUGIMPORT
+        printf("h5dump inputByteOrder %d\n", in->inputByteOrder);
+    #endif
 
         kindex = 4;
     }
@@ -2504,6 +2801,9 @@ static int getInputClassType(struct Input *in, char * buffer)
             return (-1);
         }
         in->outputByteOrder = kindex;
+    #ifdef H5DEBUGIMPORT
+        printf("h5dump inputByteOrder %d\n", in->inputByteOrder);
+    #endif
 
         kindex = 4;
     }
@@ -2522,6 +2822,9 @@ static int getInputClassType(struct Input *in, char * buffer)
             return (-1);
         }
         in->outputByteOrder = kindex;
+    #ifdef H5DEBUGIMPORT
+        printf("h5dump inputByteOrder %d\n", in->inputByteOrder);
+    #endif
 
         kindex = 7;
     }
@@ -2540,6 +2843,9 @@ static int getInputClassType(struct Input *in, char * buffer)
             return (-1);
         }
         in->outputByteOrder = kindex;
+    #ifdef H5DEBUGIMPORT
+        printf("h5dump inputByteOrder %d\n", in->inputByteOrder);
+    #endif
 
         kindex = 7;
     }
@@ -2558,6 +2864,9 @@ static int getInputClassType(struct Input *in, char * buffer)
             return (-1);
         }
         in->outputByteOrder = kindex;
+    #ifdef H5DEBUGIMPORT
+        printf("h5dump inputByteOrder %d\n", in->inputByteOrder);
+    #endif
 
         kindex = 7;
     }
@@ -2576,6 +2885,9 @@ static int getInputClassType(struct Input *in, char * buffer)
             return (-1);
         }
         in->outputByteOrder = kindex;
+    #ifdef H5DEBUGIMPORT
+        printf("h5dump inputByteOrder %d\n", in->inputByteOrder);
+    #endif
 
         kindex = 7;
     }
@@ -2594,6 +2906,9 @@ static int getInputClassType(struct Input *in, char * buffer)
             return (-1);
         }
         in->outputByteOrder = kindex;
+    #ifdef H5DEBUGIMPORT
+        printf("h5dump inputByteOrder %d\n", in->inputByteOrder);
+    #endif
 
         kindex = 7;
     }
@@ -2612,6 +2927,9 @@ static int getInputClassType(struct Input *in, char * buffer)
             return (-1);
         }
         in->outputByteOrder = kindex;
+    #ifdef H5DEBUGIMPORT
+        printf("h5dump inputByteOrder %d\n", in->inputByteOrder);
+    #endif
 
         kindex = 7;
     }
@@ -2630,6 +2948,9 @@ static int getInputClassType(struct Input *in, char * buffer)
             return (-1);
         }
         in->outputByteOrder = kindex;
+    #ifdef H5DEBUGIMPORT
+        printf("h5dump inputByteOrder %d\n", in->inputByteOrder);
+    #endif
 
         kindex = 7;
     }
@@ -2648,6 +2969,9 @@ static int getInputClassType(struct Input *in, char * buffer)
             return (-1);
         }
         in->outputByteOrder = kindex;
+    #ifdef H5DEBUGIMPORT
+        printf("h5dump inputByteOrder %d\n", in->inputByteOrder);
+    #endif
 
         kindex = 7;
     }
@@ -2786,6 +3110,9 @@ static int getInputClassType(struct Input *in, char * buffer)
             return (-1);
         }
         in->outputByteOrder = kindex;
+    #ifdef H5DEBUGIMPORT
+        printf("h5dump inputByteOrder %d\n", in->inputByteOrder);
+    #endif
 
         kindex = 3;
     }
@@ -2804,6 +3131,9 @@ static int getInputClassType(struct Input *in, char * buffer)
             return (-1);
         }
         in->outputByteOrder = kindex;
+    #ifdef H5DEBUGIMPORT
+        printf("h5dump inputByteOrder %d\n", in->inputByteOrder);
+    #endif
 
         kindex = 3;
     }
@@ -2822,6 +3152,9 @@ static int getInputClassType(struct Input *in, char * buffer)
             return (-1);
         }
         in->outputByteOrder = kindex;
+    #ifdef H5DEBUGIMPORT
+        printf("h5dump inputByteOrder %d\n", in->inputByteOrder);
+    #endif
 
         kindex = 3;
     }
@@ -2840,6 +3173,9 @@ static int getInputClassType(struct Input *in, char * buffer)
             return (-1);
         }
         in->outputByteOrder = kindex;
+    #ifdef H5DEBUGIMPORT
+        printf("h5dump inputByteOrder %d\n", in->inputByteOrder);
+    #endif
 
         kindex = 3;
     }
@@ -2913,6 +3249,9 @@ static int getInputClassType(struct Input *in, char * buffer)
             return (-1);
         }
         in->outputByteOrder = kindex;
+    #ifdef H5DEBUGIMPORT
+        printf("h5dump inputByteOrder %d\n", in->inputByteOrder);
+    #endif
 
         kindex = -1;
     }
@@ -2929,6 +3268,9 @@ static int getInputClassType(struct Input *in, char * buffer)
             return (-1);
         }
         in->outputByteOrder = kindex;
+    #ifdef H5DEBUGIMPORT
+        printf("h5dump inputByteOrder %d\n", in->inputByteOrder);
+    #endif
 
         kindex = -1;
     }
@@ -2945,6 +3287,9 @@ static int getInputClassType(struct Input *in, char * buffer)
             return (-1);
         }
         in->outputByteOrder = kindex;
+    #ifdef H5DEBUGIMPORT
+        printf("h5dump inputByteOrder %d\n", in->inputByteOrder);
+    #endif
 
         kindex = -1;
     }
@@ -2961,6 +3306,9 @@ static int getInputClassType(struct Input *in, char * buffer)
             return (-1);
         }
         in->outputByteOrder = kindex;
+    #ifdef H5DEBUGIMPORT
+        printf("h5dump inputByteOrder %d\n", in->inputByteOrder);
+    #endif
 
         kindex = -1;
     }
@@ -2977,6 +3325,9 @@ static int getInputClassType(struct Input *in, char * buffer)
             return (-1);
         }
         in->outputByteOrder = kindex;
+    #ifdef H5DEBUGIMPORT
+        printf("h5dump inputByteOrder %d\n", in->inputByteOrder);
+    #endif
 
         kindex = -1;
     }
@@ -2993,6 +3344,9 @@ static int getInputClassType(struct Input *in, char * buffer)
             return (-1);
         }
         in->outputByteOrder = kindex;
+    #ifdef H5DEBUGIMPORT
+        printf("h5dump inputByteOrder %d\n", in->inputByteOrder);
+    #endif
 
         kindex = -1;
     }
@@ -3009,6 +3363,9 @@ static int getInputClassType(struct Input *in, char * buffer)
             return (-1);
         }
         in->outputByteOrder = kindex;
+    #ifdef H5DEBUGIMPORT
+        printf("h5dump inputByteOrder %d\n", in->inputByteOrder);
+    #endif
 
         kindex = -1;
     }
@@ -3025,6 +3382,9 @@ static int getInputClassType(struct Input *in, char * buffer)
             return (-1);
         }
         in->outputByteOrder = kindex;
+    #ifdef H5DEBUGIMPORT
+        printf("h5dump inputByteOrder %d\n", in->inputByteOrder);
+    #endif
 
         kindex = -1;
     }
@@ -3062,8 +3422,9 @@ static int getInputClassType(struct Input *in, char * buffer)
     if (in->configOptionVector[OUTPUT_SIZE] == 0)
         in->outputSize = in->inputSize;
 #ifdef H5DEBUGIMPORT
-    printf("h5dump DATATYPE STRING %d inputSize\n", in->inputSize);
-    printf("h5dump DATATYPE STRING %d outputSize\n", in->outputSize);
+    printf("h5dump DATATYPE InClass %d inputSize\n", in->inputSize);
+    printf("h5dump DATATYPE InClass %d outputSize\n", in->outputSize);
+    printf("h5dump DATATYPE InClass %d outputArchitecture\n", in->outputArchitecture);
 #endif
 
     in->inputClass = kindex;
@@ -3096,6 +3457,27 @@ static int getInputSize(struct Input *in, int ival)
     return (-1);
 }
 
+static int getInputByteOrder(struct Input *in, FILE *strm)
+{
+    char        temp[255];
+    int         kindex;
+    const char *err1 = "Unable to get 'string' value.\n";
+    const char *err2 = "Invalid value for input byte-order.\n";
+
+    if (fscanf(strm, "%s", temp) != 1) {
+        (void) HDfprintf(stderr, "%s", err1);
+        return (-1);
+    }
+
+    if ((kindex = OutputByteOrderStrToInt(temp)) == -1) {
+        (void) HDfprintf(stderr, "%s", err2);
+        return (-1);
+    }
+
+    in->inputByteOrder = kindex;
+    return (0);
+}
+
 static int getRank(struct Input *in, FILE *strm)
 {
     int         ival;
@@ -3361,6 +3743,7 @@ void setDefaultValues(struct Input *in, int count)
     in->inputSize = 32;
     in->outputClass = 1; /* FP */
     in->outputSize = 32;
+    in->inputByteOrder = -1; /* use default    */
     in->rank = 0;
     in->path.count = 1;
 
@@ -3382,7 +3765,7 @@ hid_t createOutputDataType(struct Input *in)
     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 *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";
 
@@ -3504,9 +3887,9 @@ hid_t createOutputDataType(struct Input *in)
             }
             break;
 
-		default:
-			(void) HDfprintf(stderr, "%s", err4);
-			return (-1);
+        default:
+            (void) HDfprintf(stderr, "%s", err4);
+            return (-1);
         }
         break;
 
@@ -3589,9 +3972,9 @@ hid_t createOutputDataType(struct Input *in)
             }
             break;
 
-		default:
-			(void) HDfprintf(stderr, "%s", err4);
-			return (-1);
+        default:
+            (void) HDfprintf(stderr, "%s", err4);
+            return (-1);
         }
         break;
 
@@ -3733,85 +4116,433 @@ hid_t createInputDataType(struct Input *in)
 {
     hid_t       new_type = (-1);
     const char *err1 = "Invalid value for input class.\n";
-    const char *err2 = "Invalid value for output size.\n";
+    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";
 
-    switch (in->inputClass) {
-    case 0:
-    case 4:
-        switch (in->inputSize) {
-        case 8:
-            new_type = H5Tcopy(H5T_NATIVE_CHAR);
-            break;
+    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 16:
+                    new_type = H5Tcopy(H5T_NATIVE_SHORT);
+                    break;
 
-        case 32:
-            new_type = H5Tcopy(H5T_NATIVE_INT);
-            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;
+
+            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:
-            new_type = H5Tcopy(H5T_NATIVE_LLONG);
+                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;
+
+                default:
+                    (void) HDfprintf(stderr, "%s", err2);
+                    return (-1);
+                }
+                break;
+
+            default:
+                (void) HDfprintf(stderr, "%s", err4);
+                return (-1);
+            }
             break;
 
-        default:
-            (void) HDfprintf(stderr, "%s", err2);
-            return (-1);
-        }
-        break;
+        case 3:
+            switch (in->inputArchitecture) {
+            case 0:
+                switch (in->inputSize) {
+                case 32:
+                    new_type = H5Tcopy(H5T_NATIVE_FLOAT);
+                    break;
 
-    case 1:
-    case 2:
-    case 3:
-        switch (in->inputSize) {
-        case 32:
-            new_type = H5Tcopy(H5T_NATIVE_FLOAT);
+                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);
+                        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;
+
+                default:
+                    (void) HDfprintf(stderr, "%s", err2);
+                    return (-1);
+                }
+                break;
+
+            default:
+                (void) HDfprintf(stderr, "%s", err4);
+                return (-1);
+            }
             break;
 
-        case 64:
-            new_type = H5Tcopy(H5T_NATIVE_DOUBLE);
+        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:
+                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;
+
+                default:
+                    (void) HDfprintf(stderr, "%s", err2);
+                    return (-1);
+                }
+                break;
+
+            case 2:
+                (void) HDfprintf(stderr, "%s", err6);
+                return (-1);
+
+            default:
+                (void) HDfprintf(stderr, "%s", err4);
+                return (-1);
+            }
             break;
 
         default:
-            (void) HDfprintf(stderr, "%s", err2);
+            (void) HDfprintf(stderr, "%s", err1);
             return (-1);
         }
-        break;
+    }
+    else {
+        switch (in->inputClass) {
+        case 0:
+        case 4:
+            switch (in->inputSize) {
+            case 8:
+                new_type = H5Tcopy(H5T_NATIVE_CHAR);
+                break;
 
-    case 5:
-        (void) HDfprintf(stderr, "%s", err1);
-        return (-1);
-        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 6:
-    case 7:
-        switch (in->inputSize) {
-        case 8:
-            new_type = H5Tcopy(H5T_NATIVE_UCHAR);
+            default:
+                (void) HDfprintf(stderr, "%s", err2);
+                return (-1);
+            }
             break;
 
-        case 16:
-            new_type = H5Tcopy(H5T_NATIVE_USHORT);
+        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 32:
-            new_type = H5Tcopy(H5T_NATIVE_UINT);
+        case 5:
+            (void) HDfprintf(stderr, "%s", err1);
+            return (-1);
             break;
 
-        case 64:
-            new_type = H5Tcopy(H5T_NATIVE_ULLONG);
+        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", err2);
+            (void) HDfprintf(stderr, "%s", err1);
             return (-1);
         }
-        break;
-
-    default:
-        (void) HDfprintf(stderr, "%s", err1);
-        return (-1);
     }
     return new_type;
 }
@@ -3900,7 +4631,7 @@ static int process(struct Options *opt)
             intype = createInputDataType(in);
             outtype = createOutputDataType(in);
 #ifdef H5DEBUGIMPORT
-            printf("process intype %d outtype %d\n", intype, outtype);
+            printf("process intype %ld outtype %ld\n", intype, outtype);
 #endif
 
             /* create property list */
@@ -3971,6 +4702,42 @@ static int process(struct Options *opt)
     return (0);
 }
 
+uint16_t swap_uint16( uint16_t val)
+{
+    return (val << 8) | (val >> 8);
+}
+
+int16_t swap_int16(int16_t val)
+{
+    return (val << 8) | ((val >> 8) & 0xFF);
+}
+
+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)
+{
+    val = ((val << 8) & 0xFF00FF00) | ((val >> 8) & 0xFF00FF);
+    return (val << 16) | ((val >> 16) & 0xFFFF);
+}
+
+int64_t swap_int64(int64_t val)
+{
+    val = ((val << 8) & 0xFF00FF00FF00FF00ULL) | ((val >> 8) & 0x00FF00FF00FF00FFULL);
+    val = ((val << 16) & 0xFFFF0000FFFF0000ULL) | ((val >> 16) & 0x0000FFFF0000FFFFULL);
+    return (val << 32) | ((val >> 32) & 0xFFFFFFFFULL);
+}
+
+uint64_t swap_uint64(uint64_t val)
+{
+    val = ((val << 8) & 0xFF00FF00FF00FF00ULL) | ((val >> 8) & 0x00FF00FF00FF00FFULL);
+    val = ((val << 16) & 0xFFFF0000FFFF0000ULL) | ((val >> 16) & 0x0000FFFF0000FFFFULL);
+    return (val << 32) | (val >> 32);
+}
+
 /*
  * Name:
  *      help
@@ -4163,6 +4930,7 @@ void help(char *name)
     (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");
diff --git a/tools/src/h5import/h5import.h b/tools/src/h5import/h5import.h
index c69a542..c55717d 100644
--- a/tools/src/h5import/h5import.h
+++ b/tools/src/h5import/h5import.h
@@ -37,7 +37,7 @@
 
 #define MAX_GROUPS_IN_PATH  20
 #define MAX_PATH_NAME_LENGTH 255
-#define NUM_KEYS 14
+#define NUM_KEYS 15
 #define MIN_NUM_DIMENSION  1
 #define MAX_NUM_DIMENSION  32
 #define BASE_10 10
@@ -56,6 +56,7 @@
 #define COMPRESS_PARAM   11
 #define EXTERNALSTORE    12
 #define EXTEND           13
+#define INPUT_B_ORDER    14
 
 /* data types */
 #define H5DT_INT8      signed char
@@ -82,6 +83,8 @@ struct Input
     struct path_info path;
     int inputClass;
     int inputSize;
+    int inputArchitecture;
+    int inputByteOrder;
     int rank;
     hsize_t* sizeOfDimension;
     int outputClass;
@@ -126,7 +129,8 @@ char keytable[NUM_KEYS][30] = {
         "COMPRESSION-TYPE",
         "COMPRESSION-PARAM",
         "EXTERNAL-STORAGE",
-        "MAXIMUM-DIMENSIONS"
+        "MAXIMUM-DIMENSIONS",
+        "INPUT-BYTE-ORDER"
 };
 
 static int  state_table[15][8] =