[svn-r6583]

Purpose: New tool

Description: Pankaj created h5import tool long time ago. I am finally checking
             the source code in for the 1.6 release.
             Known problems: h5import test will crash if srcdir option
                             is used; will be fixed before the release.

Solution:

Platforms tested: vebena, arabica, modi4 were tested. h5import tests passed
                  I also tested on arabica with srcdir option to make sure that
                  there is a problem when srcdir is used. After that I disabled
                  h5import tests. Daily tests will build h5import, but will not run
                  h5import tests.

Misc. update:

37 files changed, 3511 insertions, 12 deletions

diff --git a/tools/Makefile.in b/tools/Makefile.in
index 156d78f..fb0147a 100644
--- a/tools/Makefile.in
+++ b/tools/Makefile.in
@@ -1,16 +1,8 @@
 ## Tools HDF5 Makefile(.in)
 ##
-## Copyright by the Board of Trustees of the University of Illinois.
-## All rights reserved.
-##
-## This file is part of HDF5.  The full HDF5 copyright notice, including
-## terms governing use, modification, and redistribution, is contained in
-## the files COPYING and Copyright.html.  COPYING can be found at the root
-## of the source code distribution tree; Copyright.html can be found at the
-## root level of an installed copy of the electronic HDF5 document set and
-## is linked from the top-level documents page.  It can also be found at
-## http://hdf.ncsa.uiuc.edu/HDF5/doc/Copyright.html.  If you do not have
-## access to either file, you may request a copy from hdfhelp@ncsa.uiuc.edu.
+## Copyright (C) 2001, 2002
+##     National Center for Supercomputing Applications.
+##     All rights reserved.
 ##
 top_srcdir=@top_srcdir@
 top_builddir=..
@@ -18,7 +10,7 @@ srcdir=@srcdir@
 
 ## All subdirectories except for the ``lib'' subdirectory.
 ##
-SUBDIRS=h5dump h5diff h5ls misc gifconv
+SUBDIRS=h5dump h5diff h5ls misc gifconv h5import
 
 @COMMENCE@
 
diff --git a/tools/h5import/Dependencies b/tools/h5import/Dependencies
new file mode 100644
index 0000000..0519ecb
--- /dev/null
+++ b/tools/h5import/Dependencies
@@ -0,0 +1 @@
+ 
\ No newline at end of file
diff --git a/tools/h5import/Makefile.in b/tools/h5import/Makefile.in
new file mode 100755
index 0000000..12fd969
--- /dev/null
+++ b/tools/h5import/Makefile.in
@@ -0,0 +1,71 @@
+## HDF5 Library Makefile(.in)
+##
+## Copyright (C) 2001 National Center for Supercomputing Applications.
+##                    All rights reserved.
+##
+## 
+top_srcdir=@top_srcdir@
+top_builddir=../..
+srcdir=@srcdir@
+SUBDIRS=
+@COMMENCE@
+
+## Add include directory to the C preprocessor flags, add -lh5tools and
+## -lhdf5 to the list of libraries.
+##
+CPPFLAGS=-I. -I$(srcdir) -I$(top_builddir)/src -I$(top_srcdir)/src  \
+         -I$(top_srcdir)/tools/lib @CPPFLAGS@
+
+## Test programs and scripts.
+##
+#TEST_PROGS= h5importtest
+#TEST_SCRIPTS=$(srcdir)/h5importtestutil.sh
+TEST_PROGS= 
+TEST_SCRIPTS=
+
+## These are our main targets: library and tools.
+##
+LIBTOOLS=../lib/libh5tools.la
+LIBHDF5=$(top_builddir)/src/libhdf5.la
+
+PUB_PROGS=h5import
+PROGS=$(PUB_PROGS) $(TEST_PROGS) h5importtest
+
+## Source and object files for the library; do not install
+##
+LIB_SRC=
+LIB_OBJ=$(LIB_SRC:.c=.lo)
+PUB_LIB=
+
+## Source and object files for programs...
+##
+PROG_SRC=h5import.c h5importtest.c
+PROG_OBJ=$(PROG_SRC:.c=.lo)
+
+PRIVATE_HDR=
+
+## Source and object files for the tests
+##
+TEST_SRC=
+TEST_OBJ=$(TEST_SRC:.c=.lo)
+
+## Programs have to be built before they can be tested!
+##
+check test _test: $(PROGS)
+
+## How to build the programs...They all depend on the hdf5 library and
+## the tools library compiled in this directory.
+##
+$(PROGS): $(LIBTOOLS) $(LIBHDF5)
+
+h5import: h5import.lo
+	@$(LT_LINK_EXE) $(CFLAGS) -o $@ h5import.lo $(LIBTOOLS) $(LIBHDF5) $(LDFLAGS) $(LIBS)
+
+h5importtest: h5importtest.lo
+	@$(LT_LINK_EXE) $(CFLAGS) -o $@ h5importtest.lo $(LIBTOOLS) $(LIBHDF5) $(LDFLAGS) $(LIBS)
+@CONCLUDE@
+
+
+
+
+
diff --git a/tools/h5import/h5import.c b/tools/h5import/h5import.c
new file mode 100755
index 0000000..74ddeab
--- /dev/null
+++ b/tools/h5import/h5import.c
@@ -0,0 +1,2623 @@
+
+/*
+ *     Copyright (C) 2002
+ *     National Center for Supercomputing Applications
+ *     All rights reserved.
+ *
+ */
+#include <hdf5.h>
+#include <H5private.h>
+#include  <stdio.h>
+#ifndef  MIPSEL
+#include  <math.h>
+#endif  /* MIPSEL */
+#include  <string.h>
+#include  <ctype.h>
+#include  "h5import.h"
+
+int main(int argc, char *argv[]) 
+{
+  struct  Options opt;
+  int    outfile_named = FALSE;
+  int    token;
+  int    i;
+  int    state = 0;
+  struct Input *in;
+
+  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";
+  
+  (void) setvbuf(stderr, (char *) NULL, _IOLBF, 0);
+  (void) setvbuf(stdout, (char *) NULL, _IOLBF, 0);
+
+#if defined __MWERKS__
+    argc = ccommand(&argv);
+#endif
+
+ /*
+  * validate the number of command line arguments
+  */
+ 
+  if (argc < 2)
+  {
+    (void) fprintf(stderr, err1, argc);
+    usage(argv[0]);
+    goto err;
+  }
+
+  /* Initialize the file count to 0 */
+  opt.fcount = 0;
+
+ /*
+  * parse the command line
+  */
+
+  for (i = 1; i < argc; i++)
+  {
+    if ((token = gtoken(argv[i])) == ERR)
+    {
+      usage(argv[0]);
+      goto err;
+    }
+      
+    state = state_table[state][token];
+
+    switch (state)
+    {
+    
+      case 1: /* counting input files */                  
+        (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++;
+      break;
+
+      case 2: /* -c found; look for configfile */
+      break;
+
+      case 3: /* get configfile name */
+        (void) HDstrcpy(opt.infiles[opt.fcount-1].configfile, argv[i]);
+	opt.infiles[opt.fcount-1].config = 1;
+      break;
+
+      case 4: /* -o found; look for outfile */
+      break;
+
+      case 5: /* get outfile found */
+        (void) HDstrcpy(opt.outfile, argv[i]);
+        outfile_named = TRUE;
+      break;
+
+      case 6:    /* -h found; help, then exit */
+        help(argv[0]);
+        exit(0);
+      break;
+
+      case 7:    /* -d found; look for dimensions */
+      break;
+
+      case 8:    /* read dimensions */
+	if (parseDimensions(in, argv[i]) == -1)
+        {
+          (void) fprintf(stderr, err6, argv[i]);
+          return (-1);        
+        }
+      break;
+
+      case 9:    /* -p found; look for path name */
+      break;
+
+      case 10:    /* read path name */
+ 	if (parsePathInfo(&in->path, argv[i]) == -1)
+        {
+          (void) fprintf(stderr, err5, argv[i]);
+          return (-1);        
+        }
+      break;
+
+      case 11:    /* -t found; look for data type */
+      break;
+
+      case 12:    /* read data type */
+        if (getInputClass(in, argv[i]) == -1)
+        {
+          (void) fprintf(stderr, err7, argv[i]);
+          return (-1);      
+        }
+
+        if (in->inputClass == 0 || in->inputClass == 4)
+            in->outputClass = 0;
+        if (in->inputClass == 1 || in->inputClass == 2 || in->inputClass == 3)
+            in->outputClass = 1;
+        if (in->inputClass == 6 || in->inputClass == 7)
+            in->outputClass = 2;
+      break;
+
+      case 13:    /* -s found; look for data size */
+      break;
+
+      case 14:    /* read data size */
+        if (getInputSize(in, HDstrtol(argv[i], NULL, BASE_10)) == -1)
+        {
+          (void) fprintf(stderr, err8, argv[i]);
+          return (-1);      
+        }
+        /*set default value for output-size */          
+        in->outputSize = in->inputSize;
+      break;
+
+      case ERR:   /* command syntax error */
+      default:
+        (void) fprintf(stderr, err2);
+        usage(argv[0]);
+        goto err;
+    }
+  }
+
+  if (FALSE == outfile_named)
+  {
+    (void) fprintf(stderr, err3);
+    usage(argv[0]);
+    goto err;
+  }
+  
+  if (process(&opt) == -1)
+    goto err;
+
+  return(0);  
+  err:
+    (void) fprintf(stderr, err4);
+    return(1);
+}
+
+static int
+gtoken(char *s)
+{
+  size_t      len;
+  int         token;
+
+  const char *err1 = "Illegal argument: %s.\n";
+
+  /*
+   * identify the token type
+   */
+  if (s[0] == '-')
+  {     /* option name (or negative number) */
+    token = ERR;
+    len = HDstrlen(&s[1]);
+    switch (s[1])
+    {
+      case 'o':
+        if (!HDstrncmp("outfile", &s[1], len))
+          token = OPT_o;
+      break;
+       
+      case 'c':
+        if (!HDstrncmp("config", &s[1], len))
+          token = OPT_c;
+      break;
+    
+      case 'h':
+        if (!HDstrncmp("help", &s[1], len))
+          token = OPT_h;
+      break; 
+
+      case 'd':
+        if (!HDstrncmp("dims", &s[1], len))
+          token = OPT_d;
+      break; 
+
+      case 'p':
+        if (!HDstrncmp("path", &s[1], len))
+          token = OPT_p;
+      break; 
+
+      case 't':
+        if (!HDstrncmp("type", &s[1], len))
+          token = OPT_t;
+      break; 
+
+      case 's':
+        if (!HDstrncmp("size", &s[1], len))
+          token = OPT_s;
+      break; 
+    }
+    
+    if (token == ERR)
+      (void) fprintf(stderr, err1, s);
+  }
+  else    /* filename */
+  {
+    token = FILNAME;
+  }
+  return (token);
+}
+
+static int 
+processDataFile(char *infile, struct Input *in, FILE **strm)
+{
+  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";
+
+  if ((*strm = fopen(infile, "r")) == NULL)
+  {
+      (void) fprintf(stderr, err1, infile);
+      return(-1);
+  }
+
+  switch(in->inputClass)
+  {
+    case 0: /*  TEXTIN */
+    case 4: /*  IN  */
+      if (allocateIntegerStorage(in) == -1)
+      {
+        (void) fprintf(stderr, err2, infile);
+        return(-1);  
+      }
+
+      if (readIntegerData(strm, in) == -1)
+      {
+        (void) fprintf(stderr, err4, infile);
+        return(-1);        
+      }
+    break;
+
+    case 1: /*  TEXTFP */
+    case 2: /*  TEXTFPE  */
+    case 3: /*  FP  */    
+      if (allocateFloatStorage(in) == -1)
+      {
+        (void) fprintf(stderr, err3, infile);
+        return(-1);  
+
+      }
+    
+      if (readFloatData(strm, in) == -1)
+      {
+        (void) fprintf(stderr, err5, infile);
+          return(-1);        
+      }
+    break;
+          
+    case 5: /*  STR  */
+    break;
+
+    case 6: /* TEXTUIN */
+    case 7: /* UIN */
+      if (allocateUIntegerStorage(in) == -1)
+      {
+        (void) fprintf(stderr, err6, infile);
+          return(-1);  
+      }
+      if (readUIntegerData(strm, in) == -1)
+      {
+        (void) fprintf(stderr, err7, infile);
+         return(-1);        
+      }
+    break;
+        
+    default:
+        (void) fprintf(stderr, err10);
+        return(-1);
+  }
+  return (0);
+}
+
+static int 
+readIntegerData(FILE **strm, struct Input *in)
+{
+  H5DT_INT8 *in08;
+  H5DT_INT16 *in16, temp;
+  H5DT_INT32 *in32;
+#ifndef WIN32
+  H5DT_INT64 *in64;
+  char buffer[256];
+#endif
+  hsize_t len=1;
+  hsize_t i;
+  int j;
+
+  const char *err1 = "Unable to get integer value from file.\n";
+  const char *err2 = "Unrecongnized input class type.\n";
+  const char *err3 = "Invalid input size.\n";	
+
+  for (j=0; j<in->rank;j++)
+    len *= in->sizeOfDimension[j];
+
+  switch(in->inputSize)
+  {
+    case 8:
+      switch(in->inputClass)
+      {
+        case 0: /* TEXTIN */
+          in08 = (H5DT_INT8 *) in->data; 
+          for (i = 0; i < len; i++, in08++)
+          {        
+            if (fscanf(*strm, "%hd", &temp) != 1)
+            {
+              (void) fprintf(stderr, err1);
+              return (-1);
+            }
+            (*in08) = (H5DT_INT8)temp;
+          }      
+        break;
+
+        case 4: /* IN */
+          in08 = (H5DT_INT8 *) in->data;     
+          for (i = 0; i < len; i++, in08++)
+          {
+            if (fread((char *) in08, sizeof(H5DT_INT8), 1, *strm) != 1)
+            {  
+              (void) fprintf(stderr, err1);
+              return (-1);
+            }      
+          }
+        break;
+  
+        default:
+          (void) fprintf(stderr, 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) fprintf(stderr, err1);
+              return (-1);
+            }
+          }
+          in16 = (H5DT_INT16 *) in->data;
+        break;
+
+        case 4: /* IN */
+          for (i = 0; i < len; i++, in16++)
+          {
+            if (fread((char *) in16, sizeof(H5DT_INT16), 1, *strm) != 1)
+            {  
+              (void) fprintf(stderr, err1);
+              return (-1);
+            }          
+          }
+        break;
+  
+        default:
+          (void) fprintf(stderr, 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) fprintf(stderr, err1);
+              return (-1);
+            }
+          }
+        break;
+
+        case 4: /* IN */
+          for (i = 0; i < len; i++, in32++)
+          {
+            if (fread((char *) in32, sizeof(H5DT_INT32), 1, *strm) != 1)
+            {  
+              (void) fprintf(stderr, err1);
+              return (-1);
+            }          
+          }
+        break;
+  
+        default:
+          (void) fprintf(stderr, err2);
+          return (-1);
+        break;
+      }
+    break;
+
+#ifndef WIN32
+    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) fprintf(stderr, err1);
+              return (-1);
+            }   
+            *in64 = (H5DT_INT64) strtoll(buffer, NULL, 10);
+          }
+        break;
+
+        case 4: /* IN */
+          for (i = 0; i < len; i++, in64++)
+          {
+            if (fread((char *) in64, sizeof(H5DT_INT64), 1, *strm) != 1)
+            {  
+              (void) fprintf(stderr, err1);
+              return (-1);
+            }          
+          }
+        break;
+  
+        default:
+          (void) fprintf(stderr, err2);
+          return (-1);
+        break;
+      }
+  	  break;
+#endif /* ifndef WIN32 */ 
+	  
+    default:
+      (void) fprintf(stderr, err3);
+      break;
+  }
+  return(0);
+}
+
+static int 
+readUIntegerData(FILE **strm, struct Input *in)
+{
+  H5DT_UINT8 *in08;
+  H5DT_UINT16 *in16, temp;
+  H5DT_UINT32 *in32;
+#ifndef WIN32  
+  H5DT_UINT64 *in64;
+  char buffer[256];
+#endif
+  hsize_t len=1;
+  hsize_t i;
+  int j;
+  const char *err1 = "Unable to get unsigned integer value from file.\n";
+  const char *err2 = "Unrecongnized input class type.\n";
+  const char *err3 = "Invalid input size.\n";
+
+  for (j=0; j<in->rank;j++)
+    len *= in->sizeOfDimension[j];
+
+  switch(in->inputSize)
+  {
+    case 8:
+      switch(in->inputClass)
+      {
+        case 6: /* TEXTUIN */
+          in08 = (H5DT_UINT8 *) in->data; 
+          for (i = 0; i < len; i++, in08++)
+          {              
+            if (fscanf(*strm, "%hu", &temp) != 1)
+            {
+              (void) fprintf(stderr, err1);
+              return (-1);
+            }
+            (*in08) = (H5DT_UINT8)temp;
+          }      
+        break;
+
+        case 7: /* UIN */
+          in08 = (H5DT_UINT8 *) in->data;         
+          for (i = 0; i < len; i++, in08++)
+          {
+            if (fread((char *) in08, sizeof(H5DT_UINT8), 1, *strm) != 1)
+            {  
+              (void) fprintf(stderr, err1);
+              return (-1);
+            }          
+          }
+        break;
+  
+        default:
+          (void) fprintf(stderr, err2);
+          return (-1);
+        break;
+      }
+    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) fprintf(stderr, err1);
+              return (-1);
+            }
+          }
+        break;
+
+        case 7: /* UIN */
+          for (i = 0; i < len; i++, in16++)
+          {
+            if (fread((char *) in16, sizeof(H5DT_UINT16), 1, *strm) != 1)
+            {  
+              (void) fprintf(stderr, err1);
+              return (-1);
+            }          
+          }
+        break;
+  
+        default:
+          (void) fprintf(stderr, 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) fprintf(stderr, err1);
+              return (-1);
+            }
+          }
+        break;
+
+        case 7: /* UIN */
+          for (i = 0; i < len; i++, in32++)
+          {
+            if (fread((char *) in32, sizeof(H5DT_UINT32), 1, *strm) != 1)
+            {  
+              (void) fprintf(stderr, err1);
+              return (-1);
+            }          
+          }
+        break;
+  
+        default:
+          (void) fprintf(stderr, err2);
+          return (-1);
+        break;
+      }
+    break;
+
+#ifndef WIN32
+    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) fprintf(stderr, err1);
+              return (-1);
+            }   
+            *in64 = (H5DT_UINT64) strtoll(buffer, NULL, 10);
+          }
+        break;
+
+        case 7: /* UIN */
+          for (i = 0; i < len; i++, in64++)
+          {
+            if (fread((char *) in64, sizeof(H5DT_UINT64), 1, *strm) != 1)
+            {  
+              (void) fprintf(stderr, err1);
+              return (-1);
+            }          
+          }
+        break;
+  
+        default:
+          (void) fprintf(stderr, err2);
+          return (-1);
+        break;
+      }
+    break;
+#endif /* ifndef WIN32 */
+    
+    default:
+      (void) fprintf(stderr, err3);
+      break;
+  }
+  return(0);
+}
+
+static int 
+readFloatData(FILE **strm, struct Input *in)
+{
+  H5DT_FLOAT32 *fp32;
+  H5DT_FLOAT64 *fp64;
+
+  hsize_t len=1;
+  hsize_t i;
+  int j;
+  const char *err1 = "Unable to get integer value from file.\n";
+  const char *err2 = "Unrecongnized input class type.\n";
+  const char *err3 = "Invalid input size type.\n";
+
+  for (j=0; j<in->rank;j++)
+    len *= in->sizeOfDimension[j];
+
+  switch(in->inputSize)
+  {
+    case 32:
+      fp32 = (H5DT_FLOAT32 *) in->data; 
+      switch(in->inputClass)
+      {
+        case 1: /* TEXTFP */
+          for (i = 0; i < len; i++, fp32++)
+          {
+            if (fscanf(*strm, "%f", fp32) != 1)
+            {
+              (void) fprintf(stderr, err1);
+              return (-1);
+            }
+          }
+
+          fp32 = (H5DT_FLOAT32 *) in->data;
+        break;
+
+        case 2: /*TEXTFPE */
+        break;
+
+        case 3: /* FP */
+          for (i = 0; i < len; i++, fp32++)
+          {
+            if (fread((char *) fp32, sizeof(H5DT_FLOAT32), 1, *strm) != 1)
+            {  
+              (void) fprintf(stderr, err1);
+              return (-1);
+            }          
+          }
+        break;
+  
+        default:
+          (void) fprintf(stderr, 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) fprintf(stderr, err1);
+              return (-1);
+            }
+          }
+
+          fp64 = (H5DT_FLOAT64 *) in->data;
+        break;
+
+        case 2: /*TEXTFPE */
+        break;
+
+        case 3: /* FP */
+          for (i = 0; i < len; i++, fp64++)
+          {
+            if (fread((char *) fp64, sizeof(H5DT_FLOAT64), 1, *strm) != 1)
+            {  
+              (void) fprintf(stderr, err1);
+              return (-1);
+            }          
+          }
+        break;
+  
+        default:
+          (void) fprintf(stderr, err2);
+          return (-1);
+        break;
+      }
+    break;
+
+    default:
+      (void) fprintf(stderr, err3);
+      break;
+  }
+  return(0);
+}
+
+static int 
+allocateIntegerStorage(struct Input *in)
+{
+  hsize_t len=1;
+  int j;
+  const char *err1 = "Unable to allocate dynamic memory.\n";
+  const char *err2 = "Invalid storage size for integer input data.\n";
+
+  for (j=0; j<in->rank;j++)
+    len *= in->sizeOfDimension[j];
+
+  switch(in->inputSize)
+  {
+    case 8:
+      if ((in->data = (VOIDP) HDmalloc((size_t) len * sizeof(H5DT_INT8))) == NULL)
+      {
+        (void) fprintf(stderr, err1);
+        return (-1);
+      }
+    break;
+  
+    case 16:
+      if ((in->data = (VOIDP) HDmalloc((size_t) len * sizeof(H5DT_INT16))) == NULL)
+      {
+        (void) fprintf(stderr, err1);
+        return (-1);
+      }
+    break;
+  
+    case 32:
+      if ((in->data = (VOIDP) HDmalloc((size_t) len * sizeof(H5DT_INT32))) == NULL)
+      {
+        (void) fprintf(stderr, err1);
+        return (-1);
+      }        
+    break;
+
+    case 64:
+      if ((in->data = (VOIDP) HDmalloc((size_t) len * sizeof(H5DT_INT64))) == NULL)
+      {
+        (void) fprintf(stderr, err1);
+        return (-1);
+      }                
+    break;
+    
+    default:
+      (void) fprintf(stderr, err2);
+    break;
+  }
+  return(0);
+}
+
+static int allocateUIntegerStorage(struct Input *in)
+{
+  hsize_t len=1;
+  const char *err1 = "Unable to allocate dynamic memory.\n";
+  const char *err2 = "Invalid storage size for unsigned integer input data.\n";
+  int j;
+
+  for (j=0; j<in->rank;j++)
+    len *= in->sizeOfDimension[j];
+
+  switch(in->inputSize)
+  {
+    case 8:
+      if ((in->data = (VOIDP) HDmalloc((size_t) len * sizeof(H5DT_UINT8))) == NULL)
+      {
+        (void) fprintf(stderr, err1);
+        return (-1);
+      }
+      break;
+  
+    case 16:
+      if ((in->data = (VOIDP) HDmalloc((size_t) len * sizeof(H5DT_UINT16))) == NULL)
+      {
+        (void) fprintf(stderr, err1);
+        return (-1);
+      }
+      break;
+  
+    case 32:
+      if ((in->data = (VOIDP) HDmalloc((size_t) len * sizeof(H5DT_UINT32))) == NULL)
+      {
+        (void) fprintf(stderr, err1);
+        return (-1);
+      }        
+      break;
+
+    case 64:
+      if ((in->data = (VOIDP) HDmalloc((size_t) len * sizeof(H5DT_UINT64))) == NULL)
+      {
+        (void) fprintf(stderr, err1);
+        return (-1);
+      }                
+      break;
+    
+    default:
+      (void) fprintf(stderr, err2);
+      break;
+  }
+  return(0); 
+}
+
+static int 
+allocateFloatStorage(struct Input *in)
+{
+  hsize_t len = 1;
+  int j;
+  const char *err1 = "Unable to allocate dynamic memory.\n";
+  const char *err2 = "Invalid storage size for float input data.\n";
+  
+  for (j=0; j<in->rank;j++)
+    len *= in->sizeOfDimension[j];
+
+  switch(in->inputSize)
+  {
+    case 32:
+      if ((in->data = (VOIDP) HDmalloc((size_t) len * sizeof(H5DT_FLOAT32))) == NULL)
+      {
+        (void) fprintf(stderr, err1);
+        return (-1);
+      }        
+    break;
+
+    case 64:
+      if ((in->data = (VOIDP) HDmalloc((size_t) len * sizeof(H5DT_FLOAT64))) == NULL)
+      {
+        (void) fprintf(stderr, err1);
+        return (-1);
+      }                
+    break;
+    
+    default:
+      (void) fprintf(stderr, err2);
+    break;
+  }
+  return(0);
+}
+
+static int 
+processConfigurationFile(char *infile, struct Input *in, FILE **strm)
+{
+  char key[255];
+  int kindex;
+  char temp[255];
+  int ival;
+  
+  const char *err1 = "Unable to open the configuration file:  %s for reading.\n";
+  const char *err2 = "Unknown keyword in configuration file: %s\n";
+  const char *err3a = "PATH keyword appears twice in %s.\n";
+  const char *err3b = "Error in parsing the path information from %s.\n";
+  const char *err4a = "INPUT-CLASS keyword appears twice in %s.\n";  
+  const char *err4b = "Error in retrieving the input class from %s.\n";
+  const char *err5a = "INPUT-SIZE keyword appears twice in %s.\n";    
+  const char *err5b = "Error in retrieving the input size from %s.\n";
+  const char *err6a = "RANK keyword appears twice in %s.\n";    
+  const char *err6b = "Error in retrieving the rank from %s.\n";
+  const char *err7a = "DIMENSION-SIZES keyword appears twice in %s.\n";      
+  const char *err7b = "DIMENSION-SIZES cannot appear before RANK is provided.\n";  
+  const char *err7c = "Error in retrieving the dimension sizes from %s.\n";  
+  const char *err8a = "OUTPUT-CLASS keyword appears twice in %s.\n";        
+  const char *err8b = "Error in retrieving the output class from %s.\n";
+  const char *err9a = "OUTPUT-SIZE keyword appears twice in %s.\n";          
+  const char *err9b = "Error in retrieving the output size from %s.\n";
+  const char *err10a = "OUTPUT-ARCHITECTURE keyword appears twice in %s.\n";            
+  const char *err10b = "Error in retrieving the output architecture from %s.\n";
+  const char *err11a = "OUTPUT-BYTE-ORDER keyword appears twice in %s.\n";              
+  const char *err11b = "Error in retrieving the output byte order from %s.\n";
+  const char *err12a = "CHUNKED-DIMENSION-SIZES keyword appears twice in %s.\n";                
+  const char *err12b = "CHUNKED-DIMENSION-SIZES cannot appear before DIMENSION-SIZES are provided.\n";    
+  const char *err12c = "Error in retrieving the chunked dimension sizes from %s.\n";  
+  const char *err13a = "COMPRESSION-TYPE keyword appears twice in %s.\n";                
+  const char *err13b = "Error in retrieving the compression type from %s.\n";
+  const char *err14a = "COMPRESSION-PARAM keyword appears twice in %s.\n";                  
+  const char *err14b = "Error in retrieving the compression parameter from %s.\n";
+  const char *err15a = "EXTERNAL-STORAGE keyword appears twice in %s.\n";                  
+  const char *err15b = "Error in retrieving the external storage paramters from %s.\n";
+  const char *err16a = "MAXIMUM-DIMENSIONS keyword appears twice in %s.\n";
+  const char *err16b = "MAXIMUM-DIMENSIONS cannot appear before DIMENSION-SIZES are provided.\n";    
+  const char *err16c = "Error in retrieving the maximum dimension sizes from %s.\n";
+  const char *err17 =  "Configuration parameters are invalid in %s.\n";
+  const char *err18 =  "Unable to get string value.\n";
+  const char *err19 =  "Unable to get integer value.\n";
+
+  /* create vector to map which keywords have been found 
+  check vector after each keyword to check for violation
+  at the end check vector to see if required fields have been provided
+  process the output file according to the options
+  */
+
+  if ((*strm = fopen(infile, "r")) == NULL)
+  {
+    (void) fprintf(stderr, err1, infile);
+    return (-1);
+  }
+  
+  while (fscanf(*strm, "%s", key) == 1)
+  {
+    if ((kindex = mapKeywordToIndex(key)) == -1)
+    {
+      (void) fprintf(stderr, err2, infile);
+      return (-1);
+    }
+    switch (kindex)
+    {
+      case 0: /* PATH */
+        if (in->configOptionVector[PATH] == 1)
+        {
+          (void) fprintf(stderr, err3a, infile);
+          return (-1);                
+        }
+	if (fscanf(*strm, "%s", temp) != 1)
+	{
+	  (void) fprintf(stderr, err18);
+	  return (-1);  
+	}        
+        if (parsePathInfo(&in->path, temp) == -1)
+        {
+          (void) fprintf(stderr, err3b, infile);
+          return (-1);        
+        }
+        in->configOptionVector[PATH] = 1;
+      break;
+
+      case 1: /* INPUT-CLASS */
+        if (in->configOptionVector[INPUT_CLASS] == 1)
+        {
+          (void) fprintf(stderr, err4a, infile);
+          return (-1);                
+        }
+
+	if (fscanf(*strm, "%s", temp) != 1)
+	{
+	  (void) fprintf(stderr, err18);
+	  return (-1);
+	}
+        if (getInputClass(in, temp) == -1)
+        {
+          (void) fprintf(stderr, err4b, infile);
+          return (-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;
+
+      case 2: /* INPUT-SIZE */
+        if (in->configOptionVector[INPUT_SIZE] == 1)
+        {
+          (void) fprintf(stderr, err5a, infile);
+          return (-1);                
+        }
+	if (fscanf(*strm, "%d", (&ival)) != 1)
+	{
+	  (void) fprintf(stderr, err19);
+	  return (-1);
+	}
+        if (getInputSize(in, ival) == -1)
+        {
+          (void) fprintf(stderr, err5b, infile);
+          return (-1);      
+        }
+        in->configOptionVector[INPUT_SIZE] = 1;
+        
+        /*set default value for output-size */          
+        if (in->configOptionVector[OUTPUT_SIZE] == 0)
+          in->outputSize = in->inputSize;
+      break;
+
+      case 3: /* RANK */
+        if (in->configOptionVector[RANK] == 1)
+        {
+          (void) fprintf(stderr, err6a, infile);
+          return (-1);                
+        }
+
+        if (getRank(in, strm) == -1)
+        {
+          (void) fprintf(stderr, err6b, infile);
+          return (-1);      
+        }
+        in->configOptionVector[RANK] = 1;
+      break;
+
+      case 4: /* DIMENSION-SIZES */
+        if (in->configOptionVector[DIM] == 1)
+        {
+          (void) fprintf(stderr, err7a, infile);
+          return (-1);                
+        }
+
+        if (in->configOptionVector[RANK] == 0)
+        {
+          (void) fprintf(stderr, err7b, infile);
+          return (-1);              
+        }                    
+        if (getDimensionSizes(in, strm) == -1)
+        {
+          (void) fprintf(stderr, err7c, infile);
+          return (-1);      
+        }
+        in->configOptionVector[DIM] = 1;
+      break;
+
+      case 5: /* OUTPUT-CLASS */
+        if (in->configOptionVector[OUTPUT_CLASS] == 1)
+        {
+          (void) fprintf(stderr, err8a, infile);
+          return (-1);                
+        }
+
+        if (getOutputClass(in, strm) == -1)
+        {
+          (void) fprintf(stderr, err8b, infile);
+          return (-1);      
+        }
+        in->configOptionVector[OUTPUT_CLASS] = 1;
+      break;
+
+      case 6: /* OUTPUT-SIZE */
+        if (in->configOptionVector[OUTPUT_SIZE] == 1)
+        {
+          (void) fprintf(stderr, err9a, infile);
+          return (-1);                
+        }
+
+        if (getOutputSize(in, strm) == -1)
+        {
+          (void) fprintf(stderr, err9b, infile);
+          return (-1);      
+        }          
+        in->configOptionVector[OUTPUT_SIZE] = 1;
+      break;
+
+      case 7: /* OUTPUT-ARCHITECTURE */
+        if (in->configOptionVector[OUTPUT_ARCH] == 1)
+        {
+          (void) fprintf(stderr, err10a, infile);
+          return (-1);                
+        }
+
+        if (getOutputArchitecture(in, strm) == -1)
+        {
+          (void) fprintf(stderr, err10b, infile);
+          return (-1);      
+        }          
+        in->configOptionVector[OUTPUT_ARCH] = 1;
+      break;
+
+      case 8: /* OUTPUT-BYTE-ORDER */
+        if (in->configOptionVector[OUTPUT_B_ORDER] == 1)
+        {
+          (void) fprintf(stderr, err11a, infile);
+          return (-1);                
+        }
+
+        if (getOutputByteOrder(in, strm) == -1)
+        {
+          (void) fprintf(stderr, err11b, infile);
+          return (-1);      
+        }          
+        in->configOptionVector[OUTPUT_B_ORDER] = 1;
+      break;
+
+      case 9: /* CHUNKED-DIMENSION-SIZES */
+        if (in->configOptionVector[CHUNK] == 1)
+        {
+          (void) fprintf(stderr, err12a, infile);
+          return (-1);                
+        }
+        /* cant appear before dimension sizes have been provided */
+        if (in->configOptionVector[DIM] == 0)
+        {
+          (void) fprintf(stderr, err12b, infile);
+          return (-1);              
+        }
+
+        if (getChunkedDimensionSizes(in, strm) == -1)
+        {
+          (void) fprintf(stderr, err12c, infile);
+          return (-1);      
+        }          
+        in->configOptionVector[CHUNK] = 1;                    
+      break;
+
+      case 10: /* COMPRESSION-TYPE */
+        if (in->configOptionVector[COMPRESS] == 1)
+        {
+          (void) fprintf(stderr, err13a, infile);
+          return (-1);                
+        }
+
+        if (getCompressionType(in, strm) == -1)
+        {
+          (void) fprintf(stderr, err13b, infile);
+          return (-1);      
+        }
+        in->configOptionVector[COMPRESS] = 1;
+        
+        if (in->configOptionVector[COMPRESS_PARAM] == 0)
+        {
+          if (in->compressionType == 0)
+            in->compressionParam = 6; /* default value if compressionType is GZIP */
+        }
+      break;
+
+      case 11: /* COMPRESSION-PARAM */
+        if (in->configOptionVector[COMPRESS_PARAM] == 1)
+        {
+          (void) fprintf(stderr, err14a, infile);
+          return (-1);                
+        }
+
+        if (getCompressionParameter(in, strm) == -1)
+        {
+          (void) fprintf(stderr, err14b, infile);
+          return (-1);      
+        }
+        
+        in->configOptionVector[COMPRESS_PARAM] = 1;
+
+        if (in->configOptionVector[COMPRESS] == 0)
+          in->compressionType = 0;              
+        
+        in->configOptionVector[COMPRESS] = 1;
+      break;
+
+      case 12: /* EXTERNAL-STORAGE */
+        if (in->configOptionVector[EXTERNAL] == 1)
+        {
+          (void) fprintf(stderr, err15a, infile);
+          return (-1);                
+        }
+
+        if (getExternalFilename(in, strm) == -1)
+        {
+          (void) fprintf(stderr, err15b, infile);
+          return (-1);      
+        }          
+        in->configOptionVector[EXTERNAL] = 1;          
+      break;
+
+      case 13: /* MAXIMUM-DIMENSIONS */
+        if (in->configOptionVector[EXTEND] == 1)
+        {
+          (void) fprintf(stderr, err16a, infile);
+          return (-1);                
+        }
+        /* cant appear before dimension sizes have been provided */
+        if (in->configOptionVector[DIM] == 0)
+        {
+          (void) fprintf(stderr, err16b, infile);
+          return (-1);              
+        }          
+        if (getMaximumDimensionSizes(in, strm) == -1)
+        {
+          (void) fprintf(stderr, err16c, infile);
+          return (-1);      
+        }          
+        in->configOptionVector[EXTEND] = 1;                    
+      break;
+      
+      default: 
+        break;
+    }
+  }
+  /*
+    check if keywords obtained are valid
+    if yes, return 0 else error
+  */
+  
+  if (validateConfigurationParameters(in) == -1)
+  {
+    (void) fprintf(stderr, err17, infile);
+    return (-1);  
+  }  
+
+  return (0); 
+}
+
+static int 
+validateConfigurationParameters(struct Input * in)
+{
+  const char *err1 = "One or more of the required fields (RANK, DIMENSION-SIZES) missing.\n";  
+  const char *err2 = "Cannot specify chunking or compression or extendible data sets with the external file option.\n";
+  const char *err3 = "Cannot specify the compression or the extendible data sets without the chunking option.\n";
+  const char *err4a = "OUTPUT-ARCHITECTURE cannot be STD if OUTPUT-CLASS is floating point (FP).\n";
+  const char *err4b = "OUTPUT-ARCHITECTURE cannot be IEEE if OUTPUT-CLASS is integer (IN).\n";
+  const char *err5 = "For OUTPUT-CLASS FP, valid values for OUTPUT-SIZE are (32, 64) .\n";
+#ifdef WIN32
+  const char *err6 = "No support for reading 64-bit integer (INPUT-CLASS: IN, TEXTIN, UIN, TEXTUIN files\n";
+#endif
+
+  if (
+      (in->configOptionVector[DIM] != 1) || 
+      (in->configOptionVector[RANK] != 1))
+  {
+    (void) fprintf(stderr, err1);
+    return (-1);  
+  }
+
+  if (in->configOptionVector[EXTERNAL] == 1)
+  {
+    if ((in->configOptionVector[COMPRESS] == 1) || 
+        (in->configOptionVector[CHUNK] == 1) || 
+        (in->configOptionVector[EXTEND] == 1))
+    {
+      (void) fprintf(stderr, err2);
+      return (-1);            
+    }
+  }
+
+  if ((in->configOptionVector[COMPRESS] == 1) || 
+      (in->configOptionVector[EXTEND] == 1))
+  {
+    if (in->configOptionVector[CHUNK] != 1)
+    {
+      (void) fprintf(stderr, err3);
+      return (-1);
+    }
+  }
+  
+  /* Arch cant be STD if O/p class is FP */
+  if (in->outputArchitecture == 1)
+    if (in->outputClass == 1)
+    {
+      (void) fprintf(stderr, err4a);
+      return (-1);
+    }
+
+  /* Arch cant be IEEE if O/p class is IN */
+  if (in->outputArchitecture == 2)
+    if (in->outputClass == 0)
+    {
+      (void) fprintf(stderr, err4b);
+      return (-1);
+    }
+  
+  if (in->outputClass == 1)
+    if(in->outputSize != 32 &&
+       in->outputSize != 64 )
+    {
+      (void) fprintf(stderr, err5);
+      return (-1);
+    }
+
+#ifdef WIN32
+  if (in->inputSize == 64 && (in->inputClass == 0 || in->inputClass == 4 || in->inputClass == 6 || in->inputClass == 7) )
+	{
+	  (void) fprintf(stderr, err6);
+	  return -1;
+	}
+#endif
+  return (0); 
+}
+
+static int 
+mapKeywordToIndex(char *key)
+{
+  int i;
+
+  for (i=0; i<NUM_KEYS; i++)
+    if (!HDstrcmp(keytable[i], key)) return i;
+  return -1;
+}
+
+static int 
+parsePathInfo(struct path_info *path, char *temp)
+{
+  const char delimiter[] = "/";
+  char *token = (char*) malloc(255*sizeof(char));
+  int i=0;
+
+  HDstrcpy(path->group[i++],HDstrtok (temp, delimiter));
+
+  while (1)
+  {
+    token = HDstrtok (NULL, delimiter);
+    if (token == NULL)
+      break;
+    HDstrcpy(path->group[i++],token);
+  }
+  path->count = i;
+  return (0);
+}
+
+static int 
+parseDimensions(struct Input *in, char *strm)
+{
+  const char delimiter[] = ",";
+  char temp[255];
+  char *token = (char*) malloc(255*sizeof(char));
+  int i=0;
+  const char *err1 = "Unable to allocate dynamic memory.\n";
+
+  HDstrcpy(temp, strm);
+  HDstrtok (temp, delimiter);
+
+  while (1)
+  {
+    token = HDstrtok (NULL, delimiter);
+    if (token == NULL)
+      break;
+    i++;
+  }
+  in->rank = i+1;
+  if ((in->sizeOfDimension = 
+               (hsize_t *) HDmalloc ((size_t) in->rank * sizeof(hsize_t))) == NULL)
+  {
+    (void) fprintf(stderr, err1);
+    return (-1);
+  }
+
+  i=0;
+  HDstrcpy(temp, strm);
+  in->sizeOfDimension[i++] = HDstrtol(HDstrtok (temp, delimiter), NULL, BASE_10);
+
+  while (1)
+  {
+    token = HDstrtok (NULL, delimiter);
+    if (token == NULL)
+      break;
+    in->sizeOfDimension[i++] = HDstrtol(token, NULL, BASE_10);
+  }
+  return (0);
+}
+
+static int 
+getOutputClass(struct Input *in, FILE** strm)
+{
+  char temp[255];
+  int kindex;
+  const char *err1 = "Unable to get 'string' value.\n";
+  const char *err2 = "Invalid value for output class.\n";
+  
+  if (fscanf(*strm, "%s", temp) != 1)
+    {
+    (void) fprintf(stderr, err1);
+    return (-1);  
+  }
+
+  if ((kindex = OutputClassStrToInt(temp)) == -1)
+  {
+    (void) fprintf(stderr, err2);
+    return (-1);  
+  }
+  
+  in->outputClass = kindex;
+  return (0);
+}
+
+static int 
+OutputClassStrToInt(char *temp)
+{
+  int i;
+  char classKeywordTable[3][15] = {
+    "IN",
+    "FP",    
+    "UIN"
+  };
+  for  (i=0; i<3; i++)
+    if (!HDstrcmp(classKeywordTable[i], temp)) return i;
+
+  return -1;
+}
+ /* same as getInputSize. But defined separately for extensibility */
+static int 
+getOutputSize(struct Input *in, FILE** strm)
+{
+  int ival;
+  int i;
+  int outputSizeValidValues[4] = {8,16,32,64};
+  const char *err1 = "Unable to get integer value.\n";
+  const char *err2 = "Invalid value for output size.\n";
+  
+  if (fscanf(*strm, "%d", (&ival)) != 1)
+  {
+    (void) fprintf(stderr, err1);
+        return (-1);
+  }
+
+  for  (i=0; i<4; i++)
+    if (outputSizeValidValues[i] == ival) 
+    {
+      in->outputSize = ival;
+      return (0);          
+    }  
+  (void) fprintf(stderr, err2);       
+  return(-1);  
+}
+
+static int 
+getInputClass(struct Input *in, char * temp)
+{
+  int kindex;
+  const char *err1 = "Invalid value for input class.\n";
+  
+  if ((kindex = InputClassStrToInt(temp)) == -1)
+  {
+    (void) fprintf(stderr, err1);
+    return (-1);  
+  }
+  
+  in->inputClass = kindex;
+  return (0);
+}
+
+static int 
+InputClassStrToInt(char *temp)
+{
+  int i;
+  char classKeywordTable[8][15] = {
+    "TEXTIN",      
+    "TEXTFP",
+    "TEXTFPE",
+    "FP",
+    "IN",
+    "STR",
+    "TEXTUIN",
+    "UIN"
+  };
+  for  (i=0; i<8; i++)
+    if (!HDstrcmp(classKeywordTable[i], temp)) return i;
+  return -1;
+}
+
+ /* same as getOutputSize. But defined separately for extensibility */
+static int 
+getInputSize(struct Input *in, int ival)
+{
+  int i;
+  int inputSizeValidValues[4] = {8,16,32,64};
+  const char *err1 = "Invalid value for input size.\n";
+
+  for  (i=0; i<4; i++)
+    if (inputSizeValidValues[i] == ival) 
+    {
+      in->inputSize = ival;
+      return (0);          
+    }  
+  (void) fprintf(stderr, err1);       
+  return(-1);  
+}
+
+static int 
+getRank(struct Input *in, FILE** strm)
+{
+  int ival;
+
+  const char *err1 = "Unable to get integer value.\n";
+  const char *err2 = "Invalid value for rank.\n";
+  
+  if (fscanf(*strm, "%d", (&ival)) != 1)
+  {
+    (void) fprintf(stderr, err1);
+    return (-1);
+  }
+  if (ival >=MIN_NUM_DIMENSION && ival <=MAX_NUM_DIMENSION ) 
+  {
+    in->rank = ival;
+    return (0);
+  }
+
+  (void) fprintf(stderr, err2);    
+  return(-1);  
+}
+
+ /* same as getChunkedDimensionSizes. But defined separately for extensibility */
+static int 
+getDimensionSizes(struct Input *in, FILE **strm)
+{
+  int ival;
+  int i=0;
+
+  const char *err1 = "Unable to allocate dynamic memory.\n";
+  const char *err2 = "No. of dimensions for which dimension sizes provided is not equal to provided rank.\n";
+
+  if ((in->sizeOfDimension = 
+               (hsize_t *) HDmalloc ((size_t) in->rank * sizeof(hsize_t))) == NULL)
+  {
+    (void) fprintf(stderr, err1);
+    return (-1);
+  }
+  
+  while (fscanf(*strm, "%d", (&ival)) == 1)
+    in->sizeOfDimension[i++] = ival;
+	
+  if (in->rank != i)
+  {
+    (void) fprintf(stderr, err2);
+    return (-1);
+  }
+  return (0);
+}
+ /* same as getDimensionSizes. But defined separately for extensibility */
+static int 
+getChunkedDimensionSizes(struct Input *in, FILE **strm)
+{
+  int ival;
+  int i=0;
+
+  const char *err1 = "Unable to allocate dynamic memory.\n";
+  const char *err2 = "No. of dimensions for which chunked dimension sizes provided is not equal to provided rank.\n";
+  const char *err3 = "The CHUNKED-DIMENSION-SIZES cannot exceed the sizes of DIMENSION-SIZES\n";
+
+  if ((in->sizeOfChunk = 
+           (hsize_t *) HDmalloc ((size_t) in->rank * sizeof(hsize_t))) == NULL)
+  {
+    (void) fprintf(stderr, err1);
+    return (-1);
+  }
+  
+  while (fscanf(*strm, "%d", (&ival)) == 1)
+      in->sizeOfChunk[i++] = ival;
+  
+  if (in->rank != i)
+  {
+    (void) fprintf(stderr, err2);
+    return (-1);
+  }
+
+  for (i=0; i<in->rank; i++)
+    if (in->sizeOfChunk[i] > in->sizeOfDimension[i])
+    {
+      (void) fprintf(stderr, err3);
+      return (-1);
+    }
+  return (0);
+}
+
+static int 
+getMaximumDimensionSizes(struct Input *in, FILE **strm)
+{
+  int ival;
+  int i=0;
+
+  const char *err1 = "Unable to allocate dynamic memory.\n";
+  const char *err2 = "No. of dimensions for which maximum dimension sizes provided is not equal to provided rank.\n";
+  const char *err3 = "The MAXIMUM-DIMENSIONS cannot be less than the sizes of DIMENSION-SIZES. Exception: can be -1 to indicate unlimited size\n";
+
+  if ((in->maxsizeOfDimension = 
+                (hsize_t *) HDmalloc ((size_t) in->rank * sizeof(hsize_t))) == NULL)
+  {
+    (void) fprintf(stderr, err1);
+    return (-1);
+  }
+  
+  while (fscanf(*strm, "%d", (&ival)) == 1)
+  {
+    if (ival == -1)
+         in->maxsizeOfDimension[i++] = H5S_UNLIMITED;
+    else
+         in->maxsizeOfDimension[i++] = ival;
+  }
+  
+  if (in->rank != i)
+  {
+    (void) fprintf(stderr, err2);
+    return (-1);
+  }
+
+  for (i=0; i<in->rank; i++)
+  {
+    if (in->maxsizeOfDimension[i] != H5S_UNLIMITED)
+      if (in->maxsizeOfDimension[i] < in->sizeOfDimension[i])
+      {
+        (void) fprintf(stderr, err3);
+        return (-1);
+      }
+  }
+  return (0);
+}
+
+static int 
+getOutputArchitecture(struct Input *in, FILE** strm)
+{
+  char temp[255];
+  int kindex;
+  const char *err1 = "Unable to get 'string' value.\n";
+  const char *err2 = "Invalid value for output architecture.\n";
+  
+  if (fscanf(*strm, "%s", temp) != 1)
+  {
+    (void) fprintf(stderr, err1);
+    return (-1);  
+  }
+
+  if ((kindex = OutputArchStrToInt(temp)) == -1)
+  {
+    (void) fprintf(stderr, err2);
+    return (-1);  
+  }
+  
+  in->outputArchitecture = kindex;
+  return (0);
+}
+
+static int 
+OutputArchStrToInt(char *temp)
+{
+  int i;
+  char outputArchKeywordTable[8][15] = {
+    "NATIVE",
+    "STD",
+    "IEEE",
+    "INTEL",
+    "CRAY",
+    "MIPS",
+    "ALPHA",
+    "UNIX"
+  };
+  for  (i=0; i<8; i++)
+    if (!HDstrcmp(outputArchKeywordTable[i], temp)) return i;
+  return -1;
+}
+
+static int 
+getOutputByteOrder(struct Input *in, FILE** strm)
+{
+  char temp[255];
+  int kindex;
+  const char *err1 = "Unable to get 'string' value.\n";
+  const char *err2 = "Invalid value for output byte-order.\n";
+  
+  if (fscanf(*strm, "%s", temp) != 1)
+  {
+    (void) fprintf(stderr, err1);
+    return (-1);  
+  }
+
+  if ((kindex = OutputByteOrderStrToInt(temp)) == -1)
+  {
+    (void) fprintf(stderr, err2);
+    return (-1);  
+  }
+  
+  in->outputByteOrder = kindex;
+  return (0);
+}
+
+static int 
+OutputByteOrderStrToInt(char *temp)
+{
+  int i;
+  char outputByteOrderKeywordTable[2][15] = {
+    "BE",
+    "LE"
+  };
+  for  (i=0; i<2; i++)
+    if (!HDstrcmp(outputByteOrderKeywordTable[i], temp)) return i;
+  return -1;
+}
+
+static int 
+getCompressionType(struct Input *in, FILE** strm)
+{
+  char temp[255];
+  int kindex;
+  const char *err1 = "Unable to get 'string' value.\n";
+  const char *err2 = "Invalid value for compression.\n";
+  
+  if (fscanf(*strm, "%s", temp) != 1)
+  {
+    (void) fprintf(stderr, err1);
+    return (-1);  
+  }
+
+  if ((kindex = CompressionTypeStrToInt(temp)) == -1)
+  {
+    (void) fprintf(stderr, err2);
+    return (-1);  
+  }
+  
+  in->outputByteOrder = kindex;
+  return (0);
+
+}
+
+static int 
+CompressionTypeStrToInt(char *temp)
+{
+  /* currently supports only GZIP */
+  /* can be extended by adding fields to the table */
+
+  int i;
+  char CompressionTypeKeywordTable[1][15] = {
+    "GZIP"
+  };
+  for  (i=0; i<1; i++)
+    if (!HDstrcmp(CompressionTypeKeywordTable[i], temp)) return i;
+  return -1;
+}
+
+static int 
+getCompressionParameter(struct Input *in, FILE** strm)
+{
+  /*  currently supports only GZIP */
+  /*  can be extended by adding more values to COMPRESSION-TYPE and 
+    handling the paramters here by adding more cases  */
+
+  int ival;
+  const char *err1 = "Unable to get integer value.\n";
+  const char *err2 = "Invalid value for compression paramter.\n";
+  const char *err3 = "Unsupported Compression Type.\n";  
+
+  switch (in->compressionType)
+  {
+    case 0:    /* GZIP */
+      if (fscanf(*strm, "%d", (&ival)) != 1)
+      {
+        (void) fprintf(stderr, err1);
+        return (-1);
+      }
+
+      if (ival <0 || ival > 9)
+      {
+        (void) fprintf(stderr, err2);
+        return (-1);    
+      }
+      in->compressionParam = ival;
+      return (0);
+    break;
+
+    default:
+      (void) fprintf(stderr, err3);
+      return (-1);
+    break;      
+  }
+}
+
+static int 
+getExternalFilename(struct Input *in, FILE** strm)
+{
+  char temp[255];
+  const char *err1 = "Unable to get 'string' value.\n";
+  
+  if (fscanf(*strm, "%s", temp) != 1)
+  {
+    (void) fprintf(stderr, err1);
+    return (-1);  
+  }
+  
+  in->externFilename = (char *) HDmalloc ((size_t) (HDstrlen(temp)) * sizeof(char));
+  (void) HDstrcpy(in->externFilename, temp);
+  return (0);
+}
+
+void 
+setDefaultValues(struct Input *in, int count)
+{
+  int i;
+  char temp[255];
+  char num[255];  	
+
+  in->inputClass = 3; /* FP */
+  in->inputSize = 32;
+  in->outputClass = 1; /* FP */
+  in->outputSize = 32; 
+  in->rank = 0;
+  in->path.count = 1;
+
+  HDstrcpy(temp, "dataset");
+  sprintf(num, "%d", count);
+  HDstrcat(temp, num);
+  HDstrcpy(in->path.group[0], temp);
+
+  in->outputArchitecture = 0; /* NATIVE */
+  in->outputByteOrder = 0;  /* BE    */
+  in->compressionType = 0;  /* GZIP   */
+  for (i=0; i<NUM_KEYS; i++)
+    in->configOptionVector[i] = 0;
+}
+
+hid_t 
+createOutputDataType(struct Input in)
+{
+  hid_t new_type;
+  const char *err1 = "Invalid value for output class.\n";
+  
+  switch (in.outputClass)
+  {
+    case 0: 
+      switch (in.outputArchitecture)
+      {
+        case 0: /* NATIVE */
+          switch(in.outputSize)
+          {
+            case 8:
+              new_type = H5Tcopy (H5T_NATIVE_CHAR);
+            break;
+
+            case 16:
+              new_type = H5Tcopy (H5T_NATIVE_SHORT);                
+            break;
+
+            case 32:
+              new_type = H5Tcopy (H5T_NATIVE_INT);                                
+            break;
+
+            case 64:
+              new_type = H5Tcopy (H5T_NATIVE_LLONG);
+            break;
+          }
+        break;
+          
+        case 1: /* STD */
+          switch(in.outputSize)
+          {
+            case 8:
+              switch(in.outputByteOrder)
+              {
+                case 0:
+                  new_type = H5Tcopy (H5T_STD_I8BE);
+                break;
+
+                case 1:
+                  new_type = H5Tcopy (H5T_STD_I8LE);
+                break;
+              }                  
+            break;
+
+            case 16:
+              switch(in.outputByteOrder)
+              {
+                case 0:
+                  new_type = H5Tcopy (H5T_STD_I16BE);
+                break;
+
+                case 1:
+                  new_type = H5Tcopy (H5T_STD_I16LE);
+                break;
+              }                  
+            break;
+
+            case 32:
+              switch(in.outputByteOrder)
+              {
+                case 0:
+                  new_type = H5Tcopy (H5T_STD_I32BE);
+                break;
+
+                case 1:
+                  new_type = H5Tcopy (H5T_STD_I32LE);
+                break;
+              }                  
+            break;
+
+            case 64:
+              switch(in.outputByteOrder)
+              {
+                case 0:
+                  new_type = H5Tcopy (H5T_STD_I64BE);
+                break;
+
+                case 1:
+                  new_type = H5Tcopy (H5T_STD_I64LE);
+                break;
+              }                  
+            break;              
+          }
+          break;
+            
+        }
+        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;
+          }
+        break;
+  
+        case 1:
+          /* STD not supported for float */
+        break;
+
+        case 2:
+          switch(in.outputSize)
+          {
+            case 32:
+              switch(in.outputByteOrder)
+              {
+                case 0:
+                  new_type = H5Tcopy (H5T_IEEE_F32BE);
+                break;
+
+                case 1:
+                  new_type = H5Tcopy (H5T_IEEE_F32LE);
+                break;
+              }                  
+            break;
+
+            case 64:
+              switch(in.outputByteOrder)
+              {
+                case 0:
+                  new_type = H5Tcopy (H5T_IEEE_F64BE);
+                break;
+
+                case 1:
+                  new_type = H5Tcopy (H5T_IEEE_F64LE);
+                break;
+              }                  
+            break;              
+          }
+        break;
+  
+      }
+      break;
+
+    case 2:
+        switch (in.outputArchitecture)
+        {
+          case 0:
+            switch(in.outputSize)
+            {
+              case 8:
+                new_type = H5Tcopy (H5T_NATIVE_UCHAR);
+              break;
+
+              case 16:
+                new_type = H5Tcopy (H5T_NATIVE_USHORT);                
+              break;
+
+              case 32:
+                new_type = H5Tcopy (H5T_NATIVE_UINT);                                
+              break;
+
+              case 64:
+                new_type = H5Tcopy (H5T_NATIVE_ULLONG);
+              break;
+            }
+            break;
+          
+          case 1:
+            switch(in.outputSize)
+            {
+              case 8:
+                switch(in.outputByteOrder)
+                {
+                  case 0:
+                    new_type = H5Tcopy (H5T_STD_U8BE);
+                  break;
+
+                  case 1:
+                    new_type = H5Tcopy (H5T_STD_U8LE);
+                  break;
+                }                  
+                break;
+
+              case 16:
+                switch(in.outputByteOrder)
+                {
+                  case 0:
+                    new_type = H5Tcopy (H5T_STD_U16BE);
+                  break;
+
+                  case 1:
+                    new_type = H5Tcopy (H5T_STD_U16LE);
+                  break;
+                }                  
+                break;
+
+              case 32:
+                switch(in.outputByteOrder)
+                {
+                  case 0:
+                    new_type = H5Tcopy (H5T_STD_U32BE);
+                  break;
+
+                  case 1:
+                    new_type = H5Tcopy (H5T_STD_U32LE);
+                  break;
+                }                  
+                break;
+
+              case 64:
+                switch(in.outputByteOrder)
+                {
+                  case 0:
+                    new_type = H5Tcopy (H5T_STD_U64BE);
+                  break;
+
+                  case 1:
+                    new_type = H5Tcopy (H5T_STD_U64LE);
+                  break;
+                }                  
+                break;              
+            }
+            break;
+            
+          case 2:
+            /* IEEE not supported for INT */
+          break;
+  
+        }
+
+        break;
+
+    default:
+        (void) fprintf(stderr, err1);
+        return (-1);
+    }
+    return new_type;
+}
+
+hid_t 
+createInputDataType(struct Input in)
+{
+  hid_t new_type;
+  const char *err1 = "Invalid value for input class.\n";
+
+  switch (in.inputClass)
+  {
+    case 0:
+    case 4:
+        switch(in.inputSize)
+        {
+          case 8:
+              new_type = H5Tcopy (H5T_NATIVE_CHAR);
+              break;
+
+          case 16:
+              new_type = H5Tcopy (H5T_NATIVE_SHORT);                
+              break;
+
+          case 32:
+              new_type = H5Tcopy (H5T_NATIVE_INT);                                
+              break;
+
+          case 64:
+              new_type = H5Tcopy (H5T_NATIVE_LLONG);
+              break;
+        }
+        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;            
+        }
+        break;
+
+    case 5:
+        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;
+        }
+        break;
+
+    default:
+        (void) fprintf(stderr, err1);
+        return (-1);
+    }
+  return new_type; 
+}
+
+static int 
+process(struct Options *opt)
+{
+  struct  Input *in;
+  hid_t   file_id, group_id, handle;  
+  hid_t   dataset, dataspace;   
+  FILE *strm, *extfile;
+  hid_t intype, outtype;
+  hid_t proplist;  
+  hsize_t numOfElements = 1; 
+  H5E_auto_t func;
+  void *client_data;
+  int j,k;
+
+  const char *err1 = "Error creating HDF output file: %s.\n";
+  const char *err2 = "Error in processing the configuration file: %s.\n";
+  const char *err3 = "Error in reading the input file: %s.\n";
+  const char *err4 = "Error in creating or opening external file.\n";  
+  const char *err5 = "Error in creating the output data set. Dataset with the same name may exist at the specified path\n";
+  const char *err6 = "Error in writing the output data set.\n";
+  H5Eget_auto(&func, &client_data);
+    
+    /* disable error reporting */
+    H5Eset_auto(NULL, NULL);
+  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) fprintf(stderr, err1, opt->outfile);
+    return (-1);
+  }
+    /*enable error reporting */
+    H5Eset_auto(func, client_data);
+    
+  for (k = 0; k < opt->fcount; k++)
+  {
+    in = &(opt->infiles[k].in);
+    if (opt->infiles[k].config == 1)
+    {	
+    	if (processConfigurationFile(opt->infiles[k].configfile, in, &strm) == -1)
+        {
+          (void) fprintf(stderr, err2, opt->infiles[k].configfile);
+          return (-1);
+        }
+    }
+
+    if (processDataFile(opt->infiles[k].datafile, in, &strm) == -1)
+    {
+      (void) fprintf(stderr, err3, opt->infiles[k].datafile);
+      return (-1);
+    }  
+    
+    for (j=0; j<in->rank;j++)
+      numOfElements *= in->sizeOfDimension[j];
+
+  /* store error reporting parameters */
+    H5Eget_auto(&func, &client_data);
+    
+    /* disable error reporting */
+    H5Eset_auto(NULL, NULL);
+    
+    /* create parent groups */
+    if (in->path.count > 1)
+    {
+      j = 0;
+      handle = file_id;
+      while (j<in->path.count-1)
+      {
+        if ((group_id = H5Gopen(handle, in->path.group[j])) < 0)
+        {
+          group_id = H5Gcreate(handle, in->path.group[j++], 0);
+          for (; j<in->path.count-1; j++)
+            group_id = H5Gcreate(group_id, in->path.group[j], 0);      
+          handle = group_id;
+          break;
+        }        
+        handle = group_id;
+        j++;
+      }
+    }
+    else 
+    {
+      handle = file_id;
+      j=0;
+    }
+
+    /*enable error reporting */
+    H5Eset_auto(func, client_data);
+    
+    /*create data type */
+    intype = createInputDataType(*in);
+    outtype = createOutputDataType(*in);    
+    
+    /* create property list */
+    proplist = H5Pcreate (H5P_DATASET_CREATE);      
+    if (in->configOptionVector[CHUNK] == 1)
+    {
+      H5Pset_layout (proplist, H5D_CHUNKED); 
+      /* not reqd chunking is implied if set_chunk is used  */
+      H5Pset_chunk (proplist, in->rank, in->sizeOfChunk);
+    }
+    
+    if (in->configOptionVector[COMPRESS] == 1)
+    {
+      H5Pset_deflate (proplist, (unsigned) in->compressionParam);
+    }
+    
+    if (in->configOptionVector[EXTERNAL] == 1)
+    {
+      /* creating the external file if it doesnt exist */
+      if ((extfile = HDfopen(in->externFilename, "ab")) == NULL)
+      {
+        (void) fprintf(stderr, err4);
+        H5Pclose(proplist);
+        H5Sclose(dataspace);
+        H5Fclose(file_id);        
+        return (-1);    
+      }
+      HDfclose(extfile);
+      H5Pset_external (proplist, in->externFilename, 0, numOfElements * in->inputSize / 8);
+    }
+    
+    /* create dataspace */
+    if (in->configOptionVector[EXTEND] == 1)
+    {
+      dataspace = H5Screate_simple(in->rank, in->sizeOfDimension, in->maxsizeOfDimension);
+    }
+    else
+    {
+      dataspace = H5Screate_simple(in->rank, in->sizeOfDimension, NULL);
+    }
+    H5Eget_auto(&func, &client_data);
+    
+    /* disable error reporting */
+    H5Eset_auto(NULL, NULL); 
+    /* create data set */
+    if ((dataset = H5Dcreate(handle, in->path.group[j], outtype, dataspace, proplist)) < 0) 
+    {
+      (void) fprintf(stderr, err5);
+      H5Pclose(proplist);
+      H5Sclose(dataspace);
+      H5Fclose(file_id);  
+      return (-1);  
+    }
+ 
+    /*enable error reporting */
+    H5Eset_auto(func, client_data);
+
+     /* write dataset */
+    if (H5Dwrite(dataset, intype, H5S_ALL, H5S_ALL, H5P_DEFAULT, (VOIDP)in->data) < 0) 
+    {
+      (void) fprintf(stderr, err6);
+      H5Dclose(dataset);
+      H5Pclose(proplist);
+      H5Sclose(dataspace);
+      H5Fclose(file_id);  
+      return (-1);  
+    }    
+   
+    H5Dclose(dataset);
+    H5Pclose(proplist);      
+    H5Sclose(dataspace);  
+  }
+  H5Fclose(file_id);  
+  return (0);
+}
+
+/*
+ * Name:
+ *      help
+ *
+ * Purpose:
+ *      Print a helpful summary of command usage and features.
+ */
+
+void
+help(char *name)
+{
+  (void) fprintf(stderr, "Name:\n\n");
+  (void) fprintf(stderr, "\t%s\n\n", name);
+  (void) fprintf(stderr, "\t  TOOL NAME:\n");
+  (void) fprintf(stderr, "\t   %s\n", name);
+  (void) fprintf(stderr, "\t   SYNTAX:\n");
+  (void) fprintf(stderr, "\t   %s -h[elp], OR\n", name);
+  (void) fprintf(stderr, "\t   %s <infile> -c[onfig] <configfile> [<infile> -c[config] <configfile>...]", name);
+  (void) fprintf(stderr, "\t\t\t\t      -o[utfile] <outfile>\n\n");
+  (void) fprintf(stderr, "\t   PURPOSE:\n");
+  (void) fprintf(stderr, "\t 	To convert data stored in one or more ASCII or binary files\n");
+  (void) fprintf(stderr, "\t	into one or more datasets (in accordance with the \n");
+  (void) fprintf(stderr, "\t	user-specified type and storage properties) in an existing \n");
+  (void) fprintf(stderr, "\t	or new HDF5 file.\n\n");
+  (void) fprintf(stderr, "\t   DESCRIPTION:\n");
+  (void) fprintf(stderr, "\t	The primary objective of the utility is to convert floating\n");
+  (void) fprintf(stderr, "\t	point or integer data stored in ASCII text or binary form \n");
+  (void) fprintf(stderr, "\t	into a data-set according to the type and storage properties\n");
+  (void) fprintf(stderr, "\t	specified by the user. The utility can also accept ASCII\n");
+  (void) fprintf(stderr, "\t	text files and store the contents in a compact form as an\n");
+  (void) fprintf(stderr, "\t	array of one-dimensional strings.\n\n");
+  (void) fprintf(stderr, "\t	The input data to be written as a data-set can be provided\n");
+  (void) fprintf(stderr, "\t	to the utility in one of the follwing forms:\n");
+  (void) fprintf(stderr, "\t	1. ASCII text file with numeric data (floating point or \n");
+  (void) fprintf(stderr, "\t	integer data). \n");
+  (void) fprintf(stderr, "\t	2. Binary file with native floating point data (32-bit or \n");
+  (void) fprintf(stderr, "\t	64-bit) \n");
+  (void) fprintf(stderr, "\t	3. Binary file with native integer (signed or unsigned)\n");
+  (void) fprintf(stderr, "\t	data (8-bit or 16-bit or 32-bit or 64-bit). \n");
+  (void) fprintf(stderr, "\t	4. ASCII text file containing strings (text data).\n");
+  (void) fprintf(stderr, "\t   (Not implemented)\n\n");
+  (void) fprintf(stderr, "\t	Every input file is associated with a configuration file \n");
+  (void) fprintf(stderr, "\t	also provided as an input to the utility. (See Section \n");
+  (void) fprintf(stderr, "\t	\"CONFIGURATION FILE\" to know how it is to be organised).\n");
+  (void) fprintf(stderr, "\t	The class, size and dimensions of the input data is \n");
+  (void) fprintf(stderr, "\t	specified in this configuration file. A point to note is\n");
+  (void) fprintf(stderr, "\t	that the floating point data in the ASCII text file may be\n");
+  (void) fprintf(stderr, "\t	organized in the fixed floating form (for example 323.56)\n");
+  (void) fprintf(stderr, "\t	or in a scientific notation (for example 3.23E+02). A \n");
+  (void) fprintf(stderr, "\t	different input-class specification is to be used for both\n");
+  (void) fprintf(stderr, "\t	forms.\n\n");
+  (void) fprintf(stderr, "\t	The utility extracts the input data from the input file \n");
+  (void) fprintf(stderr, "\t	according to the specified parameters and saves it into \n");
+  (void) fprintf(stderr, "\t	an H5 dataset. \n\n");
+  (void) fprintf(stderr, "\t	The user can specify output type and storage properties in \n");
+  (void) fprintf(stderr, "\t	the configuration file. The user is requited to specify the \n");
+  (void) fprintf(stderr, "\t	path of the dataset. If the groups in the path leading to \n");
+  (void) fprintf(stderr, "\t	the data-set do not exist, the groups will be created by the\n");
+  (void) fprintf(stderr, "\t	utility. If no group is specified, the dataset will be\n");
+  (void) fprintf(stderr, "\t	created under the root group.\n\n");
+  (void) fprintf(stderr, "\t	In addition to the name, the user is also required to \n");
+  (void) fprintf(stderr, "\t	provide the class and size of output data to be written to \n");
+  (void) fprintf(stderr, "\t	the dataset and may optionally specify the output-architecure,\n");
+  (void) fprintf(stderr, "\t	and the output-byte-order. If output-architecture is not \n");
+  (void) fprintf(stderr, "\t	specified the default is NATIVE. Output-byte-orders are fixed\n");
+  (void) fprintf(stderr, "\t	for some architectures and may be specified only if output-\n");
+  (void) fprintf(stderr, "\t	architecture is IEEE, UNIX or STD.\n\n");
+  (void) fprintf(stderr, "\t 	Also, layout and other storage properties such as \n");
+  (void) fprintf(stderr, "\t	compression, external storage and extendible data-sets may be\n");
+  (void) fprintf(stderr, "\t	optionally specified.  The layout and storage properties \n");
+  (void) fprintf(stderr, "\t	denote how raw data is to be organized on the disk. If these \n");
+  (void) fprintf(stderr, "\t	options are not specified the default is Contiguous layout \n");
+  (void) fprintf(stderr, "\t	and storage.\n\n");
+  (void) fprintf(stderr, "\t	The dataset can be organized in any of the following ways:\n");
+  (void) fprintf(stderr, "\t	1. Contiguous.\n");
+  (void) fprintf(stderr, "\t	2. Chunked.\n");
+  (void) fprintf(stderr, "\t	3. External Storage File    (has to be contiguous)\n");
+  (void) fprintf(stderr, "\t	4. Extendible data sets     (has to be chunked)\n");
+  (void) fprintf(stderr, "\t	5. Compressed.		    (has to be chunked)\n");
+  (void) fprintf(stderr, "\t	6. Compressed & Extendible  (has to be chunked)\n\n");
+  (void) fprintf(stderr, "\t	If the user wants to store raw data in a non-HDF file then \n");
+  (void) fprintf(stderr, "\t	the external storage file option is to be used and the name \n");
+  (void) fprintf(stderr, "\t	of the file is to be specified. \n\n");
+  (void) fprintf(stderr, "\t	If the user wants the dimensions of the data-set to be\n");
+  (void) fprintf(stderr, "\t	unlimited, the extendible data set option can be chosen. \n\n");
+  (void) fprintf(stderr, "\t	The user may also specify the type of compression and the \n");
+  (void) fprintf(stderr, "\t	level to which the data set must be compresses by setting \n");
+  (void) fprintf(stderr, "\t	the compressed option.\n\n");
+  (void) fprintf(stderr, "\t   SYNOPSIS:\n");
+  (void) fprintf(stderr, "\t  h5import -h[elp], OR\n");
+  (void) fprintf(stderr, "\t  h5import <infile> -c[onfig] <configfile> \
+                    [<infile> -c[config] <confile2>...] -o[utfile] <outfile>\n\n");
+  (void) fprintf(stderr, "\t   -h[elp]:\n");
+  (void) fprintf(stderr, "\t           Prints this summary of usage, and exits.\n\n");
+  (void) fprintf(stderr, "\t   <infile(s)>:\n");
+  (void) fprintf(stderr, "\t           Name of the Input file(s), containing a \n");
+  (void) fprintf(stderr, "\t		single n-dimensional floating point or integer array \n");
+  (void) fprintf(stderr, "\t		in either ASCII text, native floating point(32-bit \n");
+  (void) fprintf(stderr, "\t		or 64-bit) or native integer(8-bit or 16-bit or \n");
+  (void) fprintf(stderr, "\t		32-bit or 64-bit). Data to be specified in the order\n");
+  (void) fprintf(stderr, "\t		of fastest changing dimensions first.\n\n");
+  (void) fprintf(stderr, "\t	-c[config] <configfile>:\n");
+  (void) fprintf(stderr, "\t		Every input file should be associated with a \n");
+  (void) fprintf(stderr, "\t		configuration file and this is done by the -c option.\n");
+  (void) fprintf(stderr, "\t		<configfile> is the name of the configuration file.\n");
+  (void) fprintf(stderr, "\t		(See Section \"CONFIGURATION FILE\")\n\n");
+  (void) fprintf(stderr, "\t   -o[utfile] <outfile>:\n");
+  (void) fprintf(stderr, "\t           Name of the HDF 5 output file. Data from one or more \n");
+  (void) fprintf(stderr, "\t		input files are stored as one or more data sets in \n");
+  (void) fprintf(stderr, "\t		<outfile>. The output file may be an existing file or \n");
+  (void) fprintf(stderr, "\t		it maybe new in which case it will be created.\n\n\n");
+  (void) fprintf(stderr, "\t   CONFIGURATION FILE:\n");
+  (void) fprintf(stderr, "\t	The configuration file is an ASCII text file and must be \n");
+  (void) fprintf(stderr, "\t	organized as \"CONFIG-KEYWORD VALUE\" pairs, one pair on each \n");
+  (void) fprintf(stderr, "\t	line.\n\n");
+  (void) fprintf(stderr, "\t   The configuration file may have the following keywords each \n");
+  (void) fprintf(stderr, "\t   followed by an acceptable value.\n\n");
+  (void) fprintf(stderr, "\t	Required KEYWORDS:\n");
+  (void) fprintf(stderr, "\t		PATH\n");
+  (void) fprintf(stderr, "\t		INPUT-CLASS\n");
+  (void) fprintf(stderr, "\t		INPUT-SIZE\n");
+  (void) fprintf(stderr, "\t		RANK\n");
+  (void) fprintf(stderr, "\t		DIMENSION-SIZES\n");
+  (void) fprintf(stderr, "\t		OUTPUT-CLASS\n");
+  (void) fprintf(stderr, "\t		OUTPUT-SIZE\n\n");
+  (void) fprintf(stderr, "\t	Optional KEYWORDS:\n");
+  (void) fprintf(stderr, "\t		OUTPUT-ARCHITECTURE\n");
+  (void) fprintf(stderr, "\t		OUTPUT-BYTE-ORDER\n");
+  (void) fprintf(stderr, "\t  		CHUNKED-DIMENSION-SIZES\n");
+  (void) fprintf(stderr, "\t		COMPRESSION-TYPE\n");
+  (void) fprintf(stderr, "\t		COMPRESSION-PARAM\n");
+  (void) fprintf(stderr, "\t		EXTERNAL-STORAGE\n");
+  (void) fprintf(stderr, "\t		MAXIMUM-DIMENSIONS\n\n\n");
+  (void) fprintf(stderr, "\t  	Values for keywords:\n");
+  (void) fprintf(stderr, "\t		PATH:\n");
+  (void) fprintf(stderr, "\t			Strings separated by spaces to represent\n");
+  (void) fprintf(stderr, "\t			the path of the data-set. If the groups in\n");
+  (void) fprintf(stderr, "\t			the path do no exist, they will be created. \n");
+  (void) fprintf(stderr, "\t			For example,\n");
+  (void) fprintf(stderr, "\t				PATH grp1/grp2/dataset1\n");
+  (void) fprintf(stderr, "\t				PATH: keyword\n");
+  (void) fprintf(stderr, "\t				grp1: group under the root. If\n");
+  (void) fprintf(stderr, "\t				      non-existent will be created.\n");
+  (void) fprintf(stderr, "\t				grp2: group under grp1. If \n");
+  (void) fprintf(stderr, "\t				      non-existent will be created \n");
+  (void) fprintf(stderr, "\t				      under grp1.\n");
+  (void) fprintf(stderr, "\t				dataset1: the name of the data-set \n");
+  (void) fprintf(stderr, "\t					  to be created.\n\n");
+  (void) fprintf(stderr, "\t               INPUT-CLASS:\n");
+  (void) fprintf(stderr, "\t			String denoting the type of input data.\n");
+  (void) fprintf(stderr, "\t			(\"TEXTIN\", \"TEXTFP\", \"TEXTFPE\", \"FP\", \"IN\", \n");
+  (void) fprintf(stderr, "\t			\"STR\", \"TEXTUIN\", \"UIN\"). \n");
+  (void) fprintf(stderr, "\t			INPUT-CLASS \"TEXTIN\" denotes an ASCII text \n");
+  (void) fprintf(stderr, "\t			file with signed integer data in ASCII form,\n");
+  (void) fprintf(stderr, "\t			INPUT-CLASS \"TEXTIN\" denotes an ASCII text \n");
+  (void) fprintf(stderr, "\t			file with unsigned integer data in ASCII form,\n");
+  (void) fprintf(stderr, "\t			\"TEXTFP\" denotes an ASCII text file containing\n");
+  (void) fprintf(stderr, "\t			floating point data in the fixed notation\n");
+  (void) fprintf(stderr, "\t			(325.34),\n");
+  (void) fprintf(stderr, "\t			\"TEXTFPE\" denotes an ASCII text file containing\n");
+  (void) fprintf(stderr, "\t			floating point data in the scientific notation\n");
+  (void) fprintf(stderr, "\t			(3.2534E+02),\n");
+  (void) fprintf(stderr, "\t			\"FP\" denotes a floating point binary file,\n");
+  (void) fprintf(stderr, "\t			\"IN\" denotes a signed integer binary file,\n");
+  (void) fprintf(stderr, "\t			\"UIN\" denotes an unsigned integer binary file,\n");
+  (void) fprintf(stderr, "\t			 & \"STR\" denotes an ASCII text file the \n");
+  (void) fprintf(stderr, "\t			contents of which should be stored as an 1-D \n");
+  (void) fprintf(stderr, "\t			array of strings.\n");
+  (void) fprintf(stderr, "\t			If INPUT-CLASS is \"STR\", then RANK, \n");
+  (void) fprintf(stderr, "\t			DIMENSION-SIZES, OUTPUT-CLASS, OUTPUT-SIZE, \n");
+  (void) fprintf(stderr, "\t			OUTPUT-ARCHITECTURE and OUTPUT-BYTE-ORDER \n");
+  (void) fprintf(stderr, "\t			will be ignored.\n\n\n");
+  (void) fprintf(stderr, "\t		INPUT-SIZE:\n");
+  (void) fprintf(stderr, "\t			Integer denoting the size of the input data \n");
+  (void) fprintf(stderr, "\t			(8, 16, 32, 64). \n\n");
+  (void) fprintf(stderr, "\t			For floating point,\n");
+  (void) fprintf(stderr, "\t			INPUT-SIZE can be 32 or 64.\n");
+  (void) fprintf(stderr, "\t			For integers (signed and unsigned)\n");
+  (void) fprintf(stderr, "\t			INPUT-SIZE can be 8, 16, 32 or 64.\n\n");
+  (void) fprintf(stderr, "\t		RANK:\n");
+  (void) fprintf(stderr, "\t			Integer denoting the number of dimensions.\n\n");
+  (void) fprintf(stderr, "\t		DIMENSION-SIZES:\n");
+  (void) fprintf(stderr, "\t		        Integers separated by spaces to denote the \n");
+  (void) fprintf(stderr, "\t			dimension sizes for the no. of dimensions \n");
+  (void) fprintf(stderr, "\t			determined by rank.\n\n");
+  (void) fprintf(stderr, "\t		OUTPUT-CLASS:\n");
+  (void) fprintf(stderr, "\t			String dentoting data type of the dataset to \n");
+  (void) fprintf(stderr, "\t			be written (\"IN\",\"FP\", \"UIN\")\n\n");
+  (void) fprintf(stderr, "\t		OUTPUT-SIZE:\n");
+  (void) fprintf(stderr, "\t			Integer denoting the size of the data in the \n");
+  (void) fprintf(stderr, "\t			output dataset to be written.\n");
+  (void) fprintf(stderr, "\t			If OUTPUT-CLASS is \"FP\", OUTPUT-SIZE can be \n");
+  (void) fprintf(stderr, "\t			32 or 64.\n");
+  (void) fprintf(stderr, "\t			If OUTPUT-CLASS is \"IN\" or \"UIN\", OUTPUT-SIZE\n");
+  (void) fprintf(stderr, "\t			can be 8, 16, 32 or 64.\n\n");
+  (void) fprintf(stderr, "\t		OUTPUT-ARCHITECTURE:\n");
+  (void) fprintf(stderr, "\t			STRING denoting the type of output \n");
+  (void) fprintf(stderr, "\t			architecture. Can accept the following values\n");
+  (void) fprintf(stderr, "\t			STD\n");
+  (void) fprintf(stderr, "\t			IEEE\n");
+  (void) fprintf(stderr, "\t			INTEL\n");
+  (void) fprintf(stderr, "\t			CRAY\n");
+  (void) fprintf(stderr, "\t			MIPS\n");
+  (void) fprintf(stderr, "\t			ALPHA\n");
+  (void) fprintf(stderr, "\t			NATIVE (default)\n");
+  (void) fprintf(stderr, "\t			UNIX\n\n");
+  (void) fprintf(stderr, "\t		OUTPUT-BYTE-ORDER:\n");
+  (void) fprintf(stderr, "\t			String denoting the output-byte-order. Ignored\n");
+  (void) fprintf(stderr, "\t			if the OUTPUT-ARCHITECTURE is not specified or\n");
+  (void) fprintf(stderr, "\t			if it is IEEE, UNIX or STD. Can accept the \n");
+  (void) fprintf(stderr, "\t			following values.\n");
+  (void) fprintf(stderr, "\t			BE (default)\n");
+  (void) fprintf(stderr, "\t			LE\n\n");
+  (void) fprintf(stderr, "\t		CHUNKED-DIMENSION:\n");
+  (void) fprintf(stderr, "\t			Integers separated by spaces to denote the \n");
+  (void) fprintf(stderr, "\t			dimension sizes of the chunk for the no. of \n");
+  (void) fprintf(stderr, "\t			dimensions determined by rank. Required field\n");
+  (void) fprintf(stderr, "\t			to denote that the dataset will be stored with\n");
+  (void) fprintf(stderr, "\t			chunked storage. If this field is absent the\n");
+  (void) fprintf(stderr, "\t			dataset will be stored with contiguous storage.\n\n");
+  (void) fprintf(stderr, "\t		COMPRESSION-TYPE:\n");
+  (void) fprintf(stderr, "\t			String denoting the type of compression to be\n");
+  (void) fprintf(stderr, "\t			used with the chunked storage. Requires the\n");
+  (void) fprintf(stderr, "\t			CHUNKED-DIMENSION to be specified. The only \n");
+  (void) fprintf(stderr, "\t			currently supported compression method is GZIP. \n");
+  (void) fprintf(stderr, "\t			Will accept the following value\n");
+  (void) fprintf(stderr, "\t			GZIP\n\n");
+  (void) fprintf(stderr, "\t		COMPRESSION-PARAM:\n");
+  (void) fprintf(stderr, "\t			Integer used to denote compression level and \n");
+  (void) fprintf(stderr, "\t			this option is to be always specified when \n");
+  (void) fprintf(stderr, "\t			the COMPRESSION-TYPE option is specified. The\n");
+  (void) fprintf(stderr, "\t			values are applicable only to GZIP \n");
+  (void) fprintf(stderr, "\t			compression.\n");
+  (void) fprintf(stderr, "\t			Value 1-9: The level of Compression. \n");
+  (void) fprintf(stderr, "\t				1 will result in the fastest \n");
+  (void) fprintf(stderr, "\t				compression while 9 will result in \n");
+  (void) fprintf(stderr, "\t				the best compression ratio. The default\n");
+  (void) fprintf(stderr, "\t				level of compression is 6.\n\n");
+  (void) fprintf(stderr, "\t		EXTERNAL-STORAGE:\n");
+  (void) fprintf(stderr, "\t			String to denote the name of the non-HDF5 file \n");
+  (void) fprintf(stderr, "\t			to store data to. Cannot be used if CHUNKED-\n");
+  (void) fprintf(stderr, "\t			DIMENSIONS or COMPRESSION-TYPE or EXTENDIBLE-\n");
+  (void) fprintf(stderr, "\t			DATASET is specified.\n");
+  (void) fprintf(stderr, "\t			Value <external-filename>: the name of the \n");
+  (void) fprintf(stderr, "\t			external file as a string to be used.\n\n");
+  (void) fprintf(stderr, "\t		MAXIMUM-DIMENSIONS:\n");
+  (void) fprintf(stderr, "\t			Integers separated by spaces to denote the \n");
+  (void) fprintf(stderr, "\t			maximum dimension sizes of all the \n");
+  (void) fprintf(stderr, "\t			dimensions determined by rank. Requires the\n");
+  (void) fprintf(stderr, "\t			CHUNKED-DIMENSION to be specified. A value of \n");
+  (void) fprintf(stderr, "\t			-1 for any dimension implies UNLIMITED \n");
+  (void) fprintf(stderr, "\t			DIMENSION size for that particular dimension.\n\n");
+  (void) fprintf(stderr, "\t   EXAMPLES:\n");
+  (void) fprintf(stderr, "\t	1. Configuration File may look like:\n\n");
+  (void) fprintf(stderr, "\t		PATH work h5 pkamat First-set\n");
+  (void) fprintf(stderr, "\t		INPUT-CLASS TEXTFP\n");
+  (void) fprintf(stderr, "\t		RANK 3\n");
+  (void) fprintf(stderr, "\t		DIMENSION-SIZES 5 2 4\n");
+  (void) fprintf(stderr, "\t		OUTPUT-CLASS FP\n");
+  (void) fprintf(stderr, "\t		OUTPUT-SIZE 64\n");
+  (void) fprintf(stderr, "\t		OUTPUT-ARCHITECTURE IEEE\n");
+  (void) fprintf(stderr, "\t		OUTPUT-BYTE-ORDER LE\n");
+  (void) fprintf(stderr, "\t  		CHUNKED-DIMENSION 2 2 2 \n\n");
+  (void) fprintf(stderr, "\t	The above configuration will accept a floating point array \n");
+  (void) fprintf(stderr, "\t	(5 x 2 x 4)  in an ASCII file with the rank and dimension sizes \n");
+  (void) fprintf(stderr, "\t	specified and will save it in a chunked data-set (of pattern \n");
+  (void) fprintf(stderr, "\t	2 X 2 X 2) of 64-bit floating point in the little-endian order \n");
+  (void) fprintf(stderr, "\t	and IEEE architecture. The dataset will be stored at\n");
+  (void) fprintf(stderr, "\t	\"/work/h5/pkamat/First-set\"\n\n");
+  (void) fprintf(stderr, "\t	2. Another configuration could be:\n\n");
+  (void) fprintf(stderr, "\t		PATH Second-set\n");
+  (void) fprintf(stderr, "\t		INPUT-CLASS IN	\n");
+  (void) fprintf(stderr, "\t		RANK 5\n");
+  (void) fprintf(stderr, "\t		DIMENSION-SIZES 6 3 5 2 4\n");
+  (void) fprintf(stderr, "\t		OUTPUT-CLASS IN\n");
+  (void) fprintf(stderr, "\t		OUTPUT-SIZE 32\n");
+  (void) fprintf(stderr, "\t  		CHUNKED-DIMENSION 2 2 2 2 2\n");
+  (void) fprintf(stderr, "\t		EXTENDIBLE-DATASET 1 3 \n");
+  (void) fprintf(stderr, "\t		COMPRESSION-TYPE GZIP\n");
+  (void) fprintf(stderr, "\t		COMPRESSION-PARAM 7\n\n\n");
+  (void) fprintf(stderr, "\t	The above configuration will accept an integer array \n");
+  (void) fprintf(stderr, "\t	(6 X 3 X 5 x 2 x 4)  in a binary file with the rank and \n");
+  (void) fprintf(stderr, "\t	dimension sizes specified and will save it in a chunked data-set\n");
+  (void) fprintf(stderr, "\t	(of pattern 2 X 2 X 2 X 2 X 2) of 32-bit floating point in \n");
+  (void) fprintf(stderr, "\t	native format (as output-architecure is not specified). The \n");
+  (void) fprintf(stderr, "\t	first and the third dimension will be defined as unlimited. The \n");
+  (void) fprintf(stderr, "\t	data-set will be compressed using GZIP and a compression level \n");
+  (void) fprintf(stderr, "\t	of 7.\n");
+  (void) fprintf(stderr, "\t	The dataset will be stored at \"/Second-set\"\n\n");
+  return;
+}
+
+
+void
+usage(char *name)
+{
+  (void) fprintf(stderr, "\nUsage:\t%s -h[elp], OR\n", name);
+  (void) fprintf(stderr, "\t%s <infile> -c[onfig] <configfile> \
+  [<infile> -c[config] <configfile>...] -o[utfile] <outfile> \n\n", name);
+  return;
+}
+
diff --git a/tools/h5import/h5import.h b/tools/h5import/h5import.h
new file mode 100755
index 0000000..164173b
--- /dev/null
+++ b/tools/h5import/h5import.h
@@ -0,0 +1,215 @@
+/*
+ * Copyright (C) 2002
+ *     National Center for Supercomputing Applications
+ *     All rights reserved.
+ *
+ */
+
+/*
+ * 
+ * Data and structure definitions for h5import 
+ * 
+ */
+
+/*
+ * state table tokens
+ */
+#define FILNAME 0
+/* filename */
+#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 NUM_KEYS 14
+#define MIN_NUM_DIMENSION  1
+#define MAX_NUM_DIMENSION  32
+#define BASE_10 10
+
+#define CHUNK            0 
+#define COMPRESS         1
+#define EXTEND           2
+#define EXTERNAL         3
+#define DIM              4
+#define RANK             5
+#define PATH             6
+#define INPUT_CLASS      7
+#define INPUT_SIZE       8
+#define OUTPUT_CLASS     9
+#define OUTPUT_SIZE     10
+#define OUTPUT_ARCH     11
+#define OUTPUT_B_ORDER  12    
+#define COMPRESS_PARAM  13    
+
+/* 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
+{
+  char group[MAX_GROUPS_IN_PATH][255];
+  int count;
+};
+
+struct Input
+{
+  struct path_info path; 
+  int inputClass;
+  int inputSize;
+  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[255];
+  char configfile[255];
+  struct Input in;
+  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 */      
+};
+
+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"
+};
+
+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 */
+  {1, ERR, ERR, 6, ERR, ERR, ERR, ERR},
+
+  /* state 1: input files */
+  {ERR, ERR, 2, ERR, 7, ERR, ERR, ERR},
+
+  /* state 2: -c[onfigfile] */
+  {3, ERR, ERR, ERR, ERR, ERR, ERR, ERR},
+
+  /* state 3: configfile */
+  {1, 4, ERR, ERR, ERR, ERR, ERR, ERR},
+
+  /* state 4: -o[utfile] */
+  {5, ERR, ERR, ERR, ERR, ERR, ERR, ERR},
+
+  /* state 5: outfile */
+  {ERR, ERR, ERR, ERR, ERR, ERR, ERR, ERR},
+   
+  /* state 6: -h[elp] */
+  {ERR, ERR, ERR, ERR, ERR, ERR, ERR, ERR},
+
+  /* state 7: -d[ims] */
+  {8, ERR, ERR, ERR, ERR, ERR, ERR, ERR},
+
+  /* state 8: dimensions */
+  {1, 4, ERR, ERR, ERR, 9, 11, 13},
+
+  /* state 9: -p[ath] */
+  {10, ERR, ERR, ERR, ERR, ERR, ERR, ERR},
+
+  /* state 10: path name */
+  {1, 4, ERR, ERR, ERR, ERR, 11, 13},
+
+  /* state 11: -t[ype] */
+  {12, ERR, ERR, ERR, ERR, ERR, ERR, ERR},
+
+  /* state 12: data type */
+  {1, 4, ERR, ERR, ERR, ERR, ERR, 13},
+
+  /* state 13: -s[ize] */
+  {14, ERR, ERR, ERR, ERR, ERR, ERR, ERR},
+
+  /* state 14: data size */
+  {1, 4, ERR, ERR, ERR, ERR, ERR, ERR}
+
+};
+
+/* 
+ *
+ *  Function declarations for h5import 
+ *
+ */
+void  usage(char *);
+void  setDefaultValues(struct Input *in, int count);
+void  help(char *);
+
+static int  gtoken(char *s);
+static int  process(struct Options *opt);
+static int  processConfigurationFile(char *infile, struct Input *in, FILE **strm);
+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  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(char *temp);
+static int  getOutputByteOrder(struct Input *in, FILE** strm);
+static int  OutputByteOrderStrToInt(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, FILE **strm);
+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);
+hid_t       createOutputDataType(struct Input in);
+hid_t       createInputDataType(struct Input in);
+static int  readUIntegerData(FILE **strm, struct Input *in);
+static int  allocateUIntegerStorage(struct Input *in);
+static int  validateConfigurationParameters(struct Input * in);
diff --git a/tools/h5import/h5importtest.c b/tools/h5import/h5importtest.c
new file mode 100755
index 0000000..b27d67d
--- /dev/null
+++ b/tools/h5import/h5importtest.c
@@ -0,0 +1,278 @@
+/*
+ * Copyright (C) 2002
+ *     National Center for Supercomputing Applications
+ *     All rights reserved.
+ *
+ */
+#include <stdio.h>
+#include <H5private.h>
+/*
+ * Name:
+ *      h5importtest
+ *
+ * Description:
+ *      This program creates that can be
+ *      used to test the h5import program.  
+ *
+ */
+int
+main(void)
+{
+    int         nrow = 3, ncol = 4, npln = 5;
+    int         i, j, k;
+    FILE       *sp;
+
+    float     b32r2[3][4], b32r3[5][3][4];
+    float     row4[3], col4[4], pln4[5];
+    float     rowo4 = (float)11.0e0, colo4 = (float)21.0e0, plno4 = (float)51.0e0;
+    float     rowi4 = (float)1.0e0, coli4 = (float)2.0e0, plni4 = (float)5.0e0;
+
+    int     b32i2[3][4], b32i3[5][3][4];          
+    int     row4i[3], col4i[4], pln4i[5];
+    int     rowo4i = (int)11 , colo4i = (int)21 , plno4i = (int)51 ;
+    int     rowi4i = (int)1 , coli4i = (int)2 , plni4i = (int)5 ;
+
+#ifndef WIN32
+    long_long     b64i2[3][4], b64i3[5][3][4];          
+    long_long     row4i64[3], col4i64[4], pln4i64[5];
+    long_long     rowo4i64 = (long_long)11 , colo4i64 = (long_long)21 , plno4i64 = (long_long)51 ;
+    long_long     rowi4i64 = (long_long)1 , coli4i64 = (long_long)2 , plni4i64 = (long_long)5 ;
+#endif
+
+    short     b16i2[3][4], b16i3[5][3][4];          
+    short     row4i16[3], col4i16[4], pln4i16[5];
+    short     rowo4i16 = (short)11 , colo4i16 = (short)21 , plno4i16 = (short)51 ;
+    short     rowi4i16 = (short)1 , coli4i16 = (short)2 , plni4i16 = (short)5 ;
+
+    char     b8i2[3][4], b8i3[5][3][4];          
+    char     row4i8[3], col4i8[4], pln4i8[5];
+    char     rowo4i8 = (char)11 , colo4i8 = (char)21 , plno4i8 = (char)51 ;
+    char     rowi4i8 = (char)1 , coli4i8 = (char)2 , plni4i8 = (char)5 ;
+
+    double     b64r2[3][4], b64r3[5][3][4];
+    double     row8[3], col8[4], pln8[5];
+    double     rowo8 = 11.0e0, colo8 = 21.0e0, plno8 = 51.0e0;
+	double     rowi8 = 1.0e0, coli8 = 2.0e0, plni8 = 5.0e0;
+    
+    /*
+     * initialize the row, column, and plane vectors
+     *
+     * row values start at 11 and increment by 1 => 11, 12, 13
+     * column values start at 21 and increment by 2 => 21, 23, 25, 27
+     * plane values start at 51 and increment by 5 => 51, 56, 61, 66, 71
+     */
+
+    
+    /*
+     * build array elements - rank 2
+     *
+     * element value = sum of row value and col values
+     */
+
+    row4[0] = rowo4;
+    col4[0] = colo4;
+    pln4[0] = plno4;
+    
+    row8[0] = rowo8;
+    col8[0] = colo8;
+    pln8[0] = plno8;
+    
+    row4i[0] = rowo4i;
+    col4i[0] = colo4i;
+    pln4i[0] = plno4i;
+
+#ifndef WIN32 
+    row4i64[0] = rowo4i64;
+    col4i64[0] = colo4i64;
+    pln4i64[0] = plno4i64;
+#endif
+
+    row4i16[0] = rowo4i16;
+    col4i16[0] = colo4i16;
+    pln4i16[0] = plno4i16;
+    
+    row4i8[0] = rowo4i8;
+    col4i8[0] = colo4i8;
+    pln4i8[0] = plno4i8;
+    
+    for (i = 1; i < nrow; i++)
+    {
+        row4[i] = row4[i - 1] + rowi4;
+        row8[i] = row8[i - 1] + rowi8;
+        row4i[i] = row4i[i - 1] + rowi4i;
+#ifndef WIN32
+	row4i64[i] = row4i64[i - 1] + rowi4i64;
+#endif
+	row4i16[i] = row4i16[i - 1] + rowi4i16;
+	row4i8[i] = row4i8[i - 1] + rowi4i8;      
+    }
+	    
+    for (j = 1; j < ncol; j++)
+    {
+          col4[j] = col4[j - 1] + coli4;
+          col8[j] = col8[j - 1] + coli8;
+	  col4i[j] = col4i[j - 1] + coli4i;
+#ifndef WIN32
+          col4i64[j] = col4i64[j - 1] + coli4i64;             
+#endif
+	  col4i16[j] = col4i16[j - 1] + coli4i16;	    
+	  col4i8[j] = col4i8[j - 1] + coli4i8;
+    }
+    for (k = 1; k < npln; k++)
+    {
+          pln4[k] = pln4[k - 1] + plni4;
+          pln8[k] = pln8[k - 1] + plni8;
+	  pln4i[k] = pln4i[k - 1] + plni4i;
+#ifndef WIN32
+    	  pln4i64[k] = pln4i64[k - 1] + plni4i64;
+#endif
+	  pln4i16[k] = pln4i16[k - 1] + plni4i16;	    
+	  pln4i8[k] = pln4i8[k - 1] + plni4i8;
+   }
+
+   for (i = 0; i < nrow; i++)
+   {
+     for (j = 0; j < ncol; j++)
+     {
+        b32r2[i][j] = row4[i] + col4[j];
+        b64r2[i][j] = row8[i] + col8[j];
+	b32i2[i][j] = row4i[i] + col4i[j];  
+#ifndef WIN32
+  	b64i2[i][j] = row4i64[i] + col4i64[j];  
+#endif
+	b16i2[i][j] = row4i16[i] + col4i16[j]; 
+	b8i2[i][j] = row4i8[i] + col4i8[j]; 
+     }
+   }
+
+    /*
+     * build array elements - rank 3
+     *
+     * element value = sum of row value, col, and plane values
+     */
+
+    for (i = 0; i < nrow; i++)
+      {
+          for (j = 0; j < ncol; j++)
+            {
+                for (k = 0; k < npln; k++)
+                  {
+                      b32r3[k][i][j] = row4[i] + col4[j] + pln4[k];
+                      b64r3[k][i][j] = row8[i] + col8[j] + pln8[k];
+	              b32i3[k][i][j] = row4i[i] + col4i[j] + pln4i[k];
+#ifndef WIN32
+	     	      b64i3[k][i][j] = row4i64[i] + col4i64[j] + pln4i64[k];
+#endif
+		      b16i3[k][i][j] = row4i16[i] + col4i16[j] + pln4i16[k];
+		      b8i3[k][i][j] = row4i8[i] + col4i8[j] + pln4i8[k];
+                  }
+            }
+      }
+    
+    /*
+     * binary 32-bit file - rank 2 & 3
+     */
+
+#ifndef UNICOS
+    
+    	sp = fopen("testfiles/txtin16", "w");
+	for (k = 0; k < npln; k++)
+    	for (i = 0; i < nrow; i++)
+        {
+          for (j = 0; j < ncol; j++)
+              (void) fprintf(sp, "%10u", b16i3[k][i][j]);
+          (void) fprintf(sp, "\n");
+        }
+    (void) fclose(sp);
+
+      sp = fopen("testfiles/txtin32", "w");
+      for (k = 0; k < npln; k++)
+    	for (i = 0; i < nrow; i++)
+        {
+          for (j = 0; j < ncol; j++)
+              (void) fprintf(sp, "%10d", b32i3[k][i][j]);
+          (void) fprintf(sp, "\n");
+        }
+      (void) fclose(sp);
+
+    sp = fopen("testfiles/bin32", "w");
+    for (k = 0; k < npln; k++) 
+    for (i = 0; i < nrow; i++)
+        for (j = 0; j < ncol; j++)
+            (void) fwrite((char *) &b32i3[k][i][j], sizeof(int), 1, sp);
+    (void) fclose(sp);
+
+  sp = fopen("testfiles/buin32", "w");
+    for (k = 0; k < npln; k++) 
+    for (i = 0; i < nrow; i++)
+        for (j = 0; j < ncol; j++)
+            (void) fwrite((char *) &b32i3[k][i][j], sizeof(unsigned int), 1, sp);
+    (void) fclose(sp);
+
+#ifndef WIN32
+   sp = fopen("testfiles/bin64-2", "w");
+    for (i = 0; i < nrow; i++)
+        for (j = 0; j < ncol; j++)
+            (void) fwrite((char *) &b64i2[i][j], sizeof(long_long), 1, sp);
+    (void) fclose(sp);
+#endif
+
+    sp = fopen("testfiles/bfp32", "w");
+    for (k = 0; k < npln; k++)
+        for (i = 0; i < nrow; i++)
+            for (j = 0; j < ncol; j++)
+                (void) fwrite((char *) &b32r3[k][i][j],
+                              sizeof(float), 1, sp);
+    (void) fclose(sp);
+ 
+    sp = fopen("testfiles/bin16", "w");
+	for (k = 0; k < npln; k++)
+    	for (i = 0; i < nrow; i++)
+        for (j = 0; j < ncol; j++)
+            (void) fwrite((char *) &b16i3[k][i][j], sizeof(short), 1,
+                          sp);
+    (void) fclose(sp);
+
+    sp = fopen("testfiles/buin16", "w");
+	for (k = 0; k < npln; k++)
+    	for (i = 0; i < nrow; i++)
+        for (j = 0; j < ncol; j++)
+            (void) fwrite((char *) &b16i3[k][i][j], sizeof(unsigned short), 1,
+                          sp);
+    (void) fclose(sp);
+
+#ifndef WIN32
+   sp = fopen("testfiles/bin64-3", "w");
+	for (k = 0; k < npln; k++)
+    	for (i = 0; i < nrow; i++)
+        for (j = 0; j < ncol; j++)
+            (void) fwrite((char *) &b64i3[k][i][j], sizeof(long_long), 1,
+                          sp);
+    (void) fclose(sp);
+#endif
+    
+    sp = fopen("testfiles/bin8", "w");
+    for (k = 0; k < npln; k++)
+    	for (i = 0; i < nrow; i++)
+        for (j = 0; j < ncol; j++)
+            (void) fwrite((char *) &b8i3[k][i][j], sizeof(char), 1,
+                          sp);
+    (void) fclose(sp);
+  
+#endif
+
+    /*
+     * binary 64-bit file - rank 2 & 3
+     */
+    
+    sp = fopen("testfiles/bfp64", "w");
+    for (k = 0; k < npln; k++)
+        for (i = 0; i < nrow; i++)
+            for (j = 0; j < ncol; j++)
+                (void) fwrite((char *) &b64r3[k][i][j],
+                              sizeof(double), 1, sp);
+    (void) fclose(sp);
+    return (0);
+}
+
+
diff --git a/tools/h5import/h5importtestutil.sh b/tools/h5import/h5importtestutil.sh
new file mode 100755
index 0000000..40ce7f5
--- /dev/null
+++ b/tools/h5import/h5importtestutil.sh
@@ -0,0 +1,102 @@
+#!rbin/sh 
+# HDF Utilities Test script
+# Usage: h5importtestutil.sh [machine-type]
+
+# initialize errors variable
+errors=0
+
+TESTING() {
+   SPACES="                                                               "
+   echo "Testing $* $SPACES" | cut -c1-70 | tr -d '\012'
+}
+
+TOOLTEST()
+{
+err=0
+./h5import $*
+../h5dump/h5dump $5 >log2
+
+cd testfiles
+../../h5dump/h5dump $5 >log1
+cd ..
+
+cmp -s testfiles/log1 log2 || err=1
+rm -f log2 testfiles/log1
+if [ $err -eq 1 ]; then
+errors="` expr $errors + 1 `";
+  echo "*FAILED*"
+else
+  echo " PASSED"
+fi
+}
+
+echo "" 
+echo "=============================="
+echo "H5IMPORT tests started"
+echo "=============================="
+
+if [ -f h5import -a -f h5importtest ]; then
+#echo "** Testing h5import  ***"
+
+rm -f  output.h5 log1 testfiles/tx* testfiles/b* *.dat
+
+./h5importtest
+
+TESTING "ASCII I32 rank 3 - Output BE " ;
+TOOLTEST testfiles/txtin32 -c testfiles/textin32 -o test1.h5
+
+TESTING "ASCII I16 rank 3 - Output LE - CHUNKED - extended" 
+TOOLTEST testfiles/txtin16 -c testfiles/textin16 -o test2.h5
+
+TESTING "ASCII I8 - rank 3 - Output I16 LE-Chunked+Extended+Compressed " 
+TOOLTEST testfiles/txtin16 -c testfiles/textin8  -o test3.h5
+
+TESTING "ASCII UI32 - rank 3 - Output BE" 
+TOOLTEST testfiles/in1 -c testfiles/textuin32 -o test4.h5
+
+TESTING "ASCII UI16 - rank 2 - Output LE+Chunked+Compressed " 
+TOOLTEST testfiles/in1 -c testfiles/textuin16 -o test5.h5
+
+TESTING "ASCII F32 - rank 3 - Output LE " 
+TOOLTEST testfiles/fp1 -c testfiles/textfp32 -o test6.h5
+
+TESTING "ASCII F64 - rank 3 - Output BE + CHUNKED+Extended+Compressed " 
+TOOLTEST testfiles/fp2 -c testfiles/textfp64 -o test7.h5
+
+TESTING "BINARY F64 - rank 3 - Output LE+CHUNKED+Extended+Compressed " 
+TOOLTEST testfiles/bfp64 -c testfiles/conbfp64 -o test8.h5
+
+TESTING "BINARY I16 - rank 3 - Output order LE + CHUNKED + extended " 
+TOOLTEST testfiles/bin16 -c testfiles/conbin16 -o test9.h5
+
+TESTING "BINARY I8 - rank 3 - Output I16LE + Chunked+Extended+Compressed " 
+TOOLTEST testfiles/bin8 -c testfiles/conbin8  -o test10.h5
+
+TESTING "BINARY I32 - rank 3 - Output BE + CHUNKED " 
+TOOLTEST testfiles/bin32 -c testfiles/conbin32 -o test11.h5
+
+TESTING "BINARY UI16 - rank 3 - Output byte BE + CHUNKED " 
+TOOLTEST testfiles/buin16 -c testfiles/conbuin16 -o test12.h5
+
+TESTING "BINARY UI32 - rank 3 - Output LE + CHUNKED " 
+TOOLTEST testfiles/buin32 -c testfiles/conbuin32 -o test13.h5
+
+rm -f  testfiles/tx* testfiles/b* *.dat
+rm -f  test*.h5 testfiles/test*.log
+else
+	echo "** h5import or h5importtest not available ***"
+	errors="` expr $errors + 1 `";
+fi
+
+#
+# Check errors result
+if [ $errors -eq 0 ]; then
+    echo "======================================"
+    echo " H5IMPORT Utilities tests have passed."
+    echo "======================================"    
+else
+    echo "*********************************************"
+    echo " H5IMPORT Utilities tests encountered errors"
+    echo "*********************************************"
+fi
+exit $errors
diff --git a/tools/h5import/testfiles/conbfp32 b/tools/h5import/testfiles/conbfp32
new file mode 100755
index 0000000..66e6b35
--- /dev/null
+++ b/tools/h5import/testfiles/conbfp32
@@ -0,0 +1,12 @@
+PATH /fpbin/32-bit
+INPUT-CLASS FP
+INPUT-SIZE	32
+RANK 3
+DIMENSION-SIZES 5 3 4
+OUTPUT-ARCHITECTURE IEEE
+OUTPUT-BYTE-ORDER BE
+CHUNKED-DIMENSION-SIZES 2 2 2 
+COMPRESSION-PARAM 2
+
+
+
diff --git a/tools/h5import/testfiles/conbfp64 b/tools/h5import/testfiles/conbfp64
new file mode 100755
index 0000000..6b4c361
--- /dev/null
+++ b/tools/h5import/testfiles/conbfp64
@@ -0,0 +1,13 @@
+PATH /fp/bin/64-bit
+INPUT-CLASS FP
+INPUT-SIZE	64
+RANK 3
+DIMENSION-SIZES 5 3 4
+OUTPUT-ARCHITECTURE IEEE
+OUTPUT-BYTE-ORDER LE
+CHUNKED-DIMENSION-SIZES 2 2 2
+COMPRESSION-PARAM 8
+MAXIMUM-DIMENSIONS -1 6 7
+
+
+
diff --git a/tools/h5import/testfiles/conbin16 b/tools/h5import/testfiles/conbin16
new file mode 100755
index 0000000..06869cb
--- /dev/null
+++ b/tools/h5import/testfiles/conbin16
@@ -0,0 +1,12 @@
+PATH /int/bin/16-bit
+INPUT-CLASS IN
+INPUT-SIZE	16
+RANK 3
+DIMENSION-SIZES 2 3 4
+CHUNKED-DIMENSION-SIZES 2 2 2
+MAXIMUM-DIMENSIONS -1 -1 8
+OUTPUT-ARCHITECTURE STD
+OUTPUT-BYTE-ORDER LE
+
+
+
diff --git a/tools/h5import/testfiles/conbin32 b/tools/h5import/testfiles/conbin32
new file mode 100755
index 0000000..11996ef
--- /dev/null
+++ b/tools/h5import/testfiles/conbin32
@@ -0,0 +1,12 @@
+PATH /int/bin/32-bit
+INPUT-CLASS IN
+INPUT-SIZE	32
+RANK 3
+DIMENSION-SIZES 5 3 4
+OUTPUT-ARCHITECTURE STD
+OUTPUT-BYTE-ORDER BE
+CHUNKED-DIMENSION-SIZES 1 2 1
+
+
+
+
diff --git a/tools/h5import/testfiles/conbin8 b/tools/h5import/testfiles/conbin8
new file mode 100755
index 0000000..1edd80a
--- /dev/null
+++ b/tools/h5import/testfiles/conbin8
@@ -0,0 +1,16 @@
+PATH /int/bin/8-bit
+INPUT-CLASS IN
+INPUT-SIZE	8
+OUTPUT-CLASS IN
+OUTPUT-SIZE 16
+RANK 3
+OUTPUT-ARCHITECTURE STD
+OUTPUT-BYTE-ORDER LE
+DIMENSION-SIZES 5 3 4
+CHUNKED-DIMENSION-SIZES 2 2 2
+MAXIMUM-DIMENSIONS -1 -1 -1
+COMPRESSION-PARAM 3
+
+
+
+
diff --git a/tools/h5import/testfiles/conbuin16 b/tools/h5import/testfiles/conbuin16
new file mode 100755
index 0000000..a4603df
--- /dev/null
+++ b/tools/h5import/testfiles/conbuin16
@@ -0,0 +1,12 @@
+PATH /int/buin/16-bit
+INPUT-CLASS UIN
+INPUT-SIZE	16
+RANK 3
+DIMENSION-SIZES 2 3 4
+CHUNKED-DIMENSION-SIZES 2 2 2
+MAXIMUM-DIMENSIONS -1 -1 8
+OUTPUT-ARCHITECTURE STD
+OUTPUT-BYTE-ORDER BE
+
+
+
diff --git a/tools/h5import/testfiles/conbuin32 b/tools/h5import/testfiles/conbuin32
new file mode 100755
index 0000000..a649e97
--- /dev/null
+++ b/tools/h5import/testfiles/conbuin32
@@ -0,0 +1,12 @@
+PATH /int/buin/32-bit
+INPUT-CLASS UIN
+INPUT-SIZE	32
+RANK 3
+DIMENSION-SIZES 5 3 4
+OUTPUT-ARCHITECTURE STD
+OUTPUT-BYTE-ORDER LE
+
+
+
+
+
diff --git a/tools/h5import/testfiles/fp1 b/tools/h5import/testfiles/fp1
new file mode 100755
index 0000000..142c94f
--- /dev/null
+++ b/tools/h5import/testfiles/fp1
@@ -0,0 +1,9 @@
+12.3 14.2 15.56
+26.782 27.22 28.44
+29.33 20.11 11.45
+22.31 23.3332 24.343
+
+16.134 19.34 0.17
+4.5 8.9 91.8
+34.7 0.32 0.076
+22.2 88.31 77.83
\ No newline at end of file
diff --git a/tools/h5import/testfiles/fp2 b/tools/h5import/testfiles/fp2
new file mode 100755
index 0000000..6c83dc3
--- /dev/null
+++ b/tools/h5import/testfiles/fp2
@@ -0,0 +1,19 @@
+12.3 14.2 15.56
+26.782 27.22 28.44
+29.33 20.11 11.45
+22.31 23.3332 24.343
+
+16.134 19.34 0.17
+4.5 8.9 91.8
+34.7 0.32 0.076
+22.2 88.31 77.83
+
+216.134 139.34 101.17
+24.5 82.9 291.8  
+334.7 0.232 10.076 
+222.2 88.31 77.83
+
+122.3 114.2 125.56
+226.782 27.222 128.44
+341.7 30.132 0.1076
+4.51 181.9 911.8
diff --git a/tools/h5import/testfiles/in1 b/tools/h5import/testfiles/in1
new file mode 100755
index 0000000..0688e9b
--- /dev/null
+++ b/tools/h5import/testfiles/in1
@@ -0,0 +1,15 @@
+        83        85        87        89
+        84        86        88        90
+        85        87        89        91
+        88        90        92        94
+        89        91        93        95
+        90        92        94        96
+        93        95        97        99
+        94        96        98       100
+        95        97        99       101
+        98       100       102       104
+        99       101       103       105
+       100       102       104       106
+       103       105       107       109
+       104       106       108       110
+       105       107       109       111
diff --git a/tools/h5import/testfiles/test1.h5 b/tools/h5import/testfiles/test1.h5
new file mode 100644
index 0000000..350333c
--- /dev/null
+++ b/tools/h5import/testfiles/test1.h5
diff --git a/tools/h5import/testfiles/test10.h5 b/tools/h5import/testfiles/test10.h5
new file mode 100644
index 0000000..a1d1a37
--- /dev/null
+++ b/tools/h5import/testfiles/test10.h5
diff --git a/tools/h5import/testfiles/test11.h5 b/tools/h5import/testfiles/test11.h5
new file mode 100644
index 0000000..fd8faa9
--- /dev/null
+++ b/tools/h5import/testfiles/test11.h5
diff --git a/tools/h5import/testfiles/test12.h5 b/tools/h5import/testfiles/test12.h5
new file mode 100644
index 0000000..c486c89
--- /dev/null
+++ b/tools/h5import/testfiles/test12.h5
diff --git a/tools/h5import/testfiles/test13.h5 b/tools/h5import/testfiles/test13.h5
new file mode 100644
index 0000000..41699d7
--- /dev/null
+++ b/tools/h5import/testfiles/test13.h5
diff --git a/tools/h5import/testfiles/test2.h5 b/tools/h5import/testfiles/test2.h5
new file mode 100644
index 0000000..dc6c1ea
--- /dev/null
+++ b/tools/h5import/testfiles/test2.h5
diff --git a/tools/h5import/testfiles/test3.h5 b/tools/h5import/testfiles/test3.h5
new file mode 100644
index 0000000..42e7727
--- /dev/null
+++ b/tools/h5import/testfiles/test3.h5
diff --git a/tools/h5import/testfiles/test4.h5 b/tools/h5import/testfiles/test4.h5
new file mode 100644
index 0000000..1a4dda5
--- /dev/null
+++ b/tools/h5import/testfiles/test4.h5
diff --git a/tools/h5import/testfiles/test5.h5 b/tools/h5import/testfiles/test5.h5
new file mode 100644
index 0000000..9ee166a
--- /dev/null
+++ b/tools/h5import/testfiles/test5.h5
diff --git a/tools/h5import/testfiles/test6.h5 b/tools/h5import/testfiles/test6.h5
new file mode 100644
index 0000000..f74e003
--- /dev/null
+++ b/tools/h5import/testfiles/test6.h5
diff --git a/tools/h5import/testfiles/test7.h5 b/tools/h5import/testfiles/test7.h5
new file mode 100644
index 0000000..b6ba4f5
--- /dev/null
+++ b/tools/h5import/testfiles/test7.h5
diff --git a/tools/h5import/testfiles/test8.h5 b/tools/h5import/testfiles/test8.h5
new file mode 100644
index 0000000..80e3a8a
--- /dev/null
+++ b/tools/h5import/testfiles/test8.h5
diff --git a/tools/h5import/testfiles/test9.h5 b/tools/h5import/testfiles/test9.h5
new file mode 100644
index 0000000..0825bbc
--- /dev/null
+++ b/tools/h5import/testfiles/test9.h5
diff --git a/tools/h5import/testfiles/textfp32 b/tools/h5import/testfiles/textfp32
new file mode 100755
index 0000000..9696a7f
--- /dev/null
+++ b/tools/h5import/testfiles/textfp32
@@ -0,0 +1,10 @@
+PATH /fp/32-bit
+INPUT-CLASS TEXTFP
+INPUT-SIZE	32
+RANK 3
+DIMENSION-SIZES 2 4 3
+OUTPUT-ARCHITECTURE IEEE
+OUTPUT-BYTE-ORDER LE
+
+
+
diff --git a/tools/h5import/testfiles/textfp64 b/tools/h5import/testfiles/textfp64
new file mode 100755
index 0000000..fbab6a6
--- /dev/null
+++ b/tools/h5import/testfiles/textfp64
@@ -0,0 +1,13 @@
+PATH /fp/64-bit
+INPUT-CLASS TEXTFP
+INPUT-SIZE	64
+RANK 3
+DIMENSION-SIZES 4 4 3
+OUTPUT-ARCHITECTURE IEEE
+OUTPUT-BYTE-ORDER BE
+CHUNKED-DIMENSION-SIZES 2 2 2
+COMPRESSION-PARAM 8
+MAXIMUM-DIMENSIONS -1 6 7
+
+
+
diff --git a/tools/h5import/testfiles/textin16 b/tools/h5import/testfiles/textin16
new file mode 100755
index 0000000..d2d11c3
--- /dev/null
+++ b/tools/h5import/testfiles/textin16
@@ -0,0 +1,12 @@
+PATH /int/16-bit
+INPUT-CLASS TEXTIN
+INPUT-SIZE	16
+RANK 3
+DIMENSION-SIZES 2 4 3
+OUTPUT-BYTE-ORDER LE
+CHUNKED-DIMENSION-SIZES 2 2 2
+MAXIMUM-DIMENSIONS -1 -1 8
+OUTPUT-ARCHITECTURE STD
+
+
+
diff --git a/tools/h5import/testfiles/textin32 b/tools/h5import/testfiles/textin32
new file mode 100755
index 0000000..ca4802a
--- /dev/null
+++ b/tools/h5import/testfiles/textin32
@@ -0,0 +1,11 @@
+PATH /int/32-bit
+INPUT-CLASS TEXTIN
+INPUT-SIZE 32
+RANK 3
+DIMENSION-SIZES 2 4 3
+OUTPUT-ARCHITECTURE STD
+OUTPUT-BYTE-ORDER BE
+
+
+
+
diff --git a/tools/h5import/testfiles/textin8 b/tools/h5import/testfiles/textin8
new file mode 100755
index 0000000..4405338
--- /dev/null
+++ b/tools/h5import/testfiles/textin8
@@ -0,0 +1,16 @@
+PATH /int/8-bit
+INPUT-CLASS TEXTIN
+INPUT-SIZE	8
+OUTPUT-CLASS IN
+OUTPUT-SIZE 8
+OUTPUT-BYTE-ORDER LE
+OUTPUT-ARCHITECTURE STD
+RANK 3
+DIMENSION-SIZES 2 4 3
+CHUNKED-DIMENSION-SIZES 2 2 2
+MAXIMUM-DIMENSIONS -1 -1 -1
+COMPRESSION-PARAM 3
+
+
+
+
diff --git a/tools/h5import/testfiles/textuin16 b/tools/h5import/testfiles/textuin16
new file mode 100755
index 0000000..753e6e8
--- /dev/null
+++ b/tools/h5import/testfiles/textuin16
@@ -0,0 +1,12 @@
+PATH /int/uint/16-bit
+INPUT-CLASS TEXTUIN
+INPUT-SIZE	16
+RANK 2
+DIMENSION-SIZES 4 3
+COMPRESSION-PARAM 2
+CHUNKED-DIMENSION-SIZES 2 2
+OUTPUT-ARCHITECTURE STD
+OUTPUT-BYTE-ORDER LE
+
+
+
diff --git a/tools/h5import/testfiles/textuin32 b/tools/h5import/testfiles/textuin32
new file mode 100755
index 0000000..d61e1a1
--- /dev/null
+++ b/tools/h5import/testfiles/textuin32
@@ -0,0 +1,11 @@
+PATH /int/uint/32-bit
+INPUT-CLASS TEXTUIN
+INPUT-SIZE	32
+RANK 3
+DIMENSION-SIZES 2 4 3
+OUTPUT-ARCHITECTURE STD
+OUTPUT-BYTE-ORDER BE
+
+
+
+