[svn-r27115] Moved testing KINDs and SIZEOFs to configure.

1 files changed, 266 insertions, 341 deletions

diff --git a/fortran/src/H5match_types.c b/fortran/src/H5match_types.c
index ae4ef40..ef0a1f3 100644
--- a/fortran/src/H5match_types.c
+++ b/fortran/src/H5match_types.c
@@ -31,6 +31,7 @@
 */
 
 #include <stdio.h>
+#include <string.h>
 #include <assert.h>
 
 #include "H5public.h"
@@ -48,9 +49,9 @@ FILE * fort_header;
 #define FFILE "H5fortran_types.F90"
 
 /* Prototypes for the write routines */
-void writeTypedef(const char* c_typedef, const char* c_type, unsigned int size);
-void writeTypedefDefault(const char* c_typedef, unsigned int size);
-void writeToFiles(const char* c_typedef, const char* fortran_type, const char* c_type, int size, unsigned int kind);
+void writeTypedef(const char* c_typedef, const char* c_type, int size);
+void writeTypedefDefault(const char* c_typedef, int size);
+void writeToFiles(const char* c_typedef, const char* fortran_type, const char* c_type, int size, int kind);
 void writeToFilesChr(const char* c_typedef, const char* fortran_type, const char* c_type, int size, char* kind);
 
 static void
@@ -121,20 +122,20 @@ endFfile(void)
 }
 
 /* Define a c_int_x type in the C header */
-void writeTypedef(const char* c_typedef, const char* c_type, unsigned int size)
+void writeTypedef(const char* c_typedef, const char* c_type, int size)
 {
   fprintf(c_header, "#define c_%s_%u %s\n", c_typedef, size, c_type);
 }
 
 /* Call this function if there is no matching C type for sizes > 1 */
-void writeTypedefDefault(const char* c_typedef, unsigned int size)
+void writeTypedefDefault(const char* c_typedef, int size)
 {
   assert(size %2 == 0);
   fprintf(c_header, "typedef struct {c_%s_%u a; c_%s_%u b;} c_%s_%u\n", c_typedef, size / 2, c_typedef, size / 2, c_typedef, size);
 }
 
 /* Create matching Fortran and C types by writing to both files */
-void writeToFiles(const char* c_typedef, const char* fortran_type, const char* c_type, int size, unsigned int kind)
+void writeToFiles(const char* c_typedef, const char* fortran_type, const char* c_type, int size,  int kind)
 {
   fprintf(fort_header, "        INTEGER, PARAMETER :: %s = %u\n", fortran_type, kind);
   fprintf(c_header, "typedef c_%s_%d %s;\n", c_typedef, size, c_type);
@@ -144,17 +145,25 @@ void writeToFilesChr(const char* c_typedef, const char* fortran_type, const char
   fprintf(fort_header, "        INTEGER, PARAMETER :: %s = %s\n", fortran_type, kind);
   fprintf(c_header, "typedef c_%s_%d %s;\n", c_typedef, size, c_type);
 }
-
 int main(void)
 {
-  int FoundIntSize[4];
-  unsigned FoundIntSizeKind[4];
-  int FoundRealSize[3];
-  unsigned FoundRealSizeKind[3];
-  int i,j,flag;
+  int FoundIntSize[10];
+  int FoundIntSizeKind[10];
+  int FoundRealSize[10];
+  int FoundRealSizeKind[10];
+  int i, j,flag;
   char chrA[20],chrB[20];
   int H5_C_HAS_REAL_NATIVE_16;
 
+  int IntKinds[] = H5_FORTRAN_INTEGER_KINDS;
+  int IntKinds_SizeOf[] = H5_FORTRAN_INTEGER_KINDS_SIZEOF;
+  int RealKinds[] = H5_FORTRAN_REAL_KINDS;
+  int RealKinds_SizeOf[] = H5_FORTRAN_REAL_KINDS_SIZEOF;
+  char Real_C_TYPES[10][32];
+  
+  int H5_FORTRAN_NUM_INTEGER_KINDS;
+  int H5_FORTRAN_NUM_REAL_KINDS;
+
   /* Open target files */
   c_header = fopen(CFILE, "w");
   fort_header = fopen(FFILE, "w");
@@ -166,213 +175,123 @@ int main(void)
   initCfile();
   initFfile();
 
-  /* First, define c_int_x */
-
-#if defined H5_FORTRAN_HAS_INTEGER_1_KIND
-  if(sizeof(long long) == 1)
-    writeTypedef("int", "long long", 1);
-  else if(sizeof(long) == 1)
-    writeTypedef("int", "long", 1);
-  else if(sizeof(int) == 1)
-    writeTypedef("int", "int", 1);
-  else if(sizeof(short) == 1)
-    writeTypedef("int", "short", 1);
-  else
-    writeTypedef("int", "char", 1);
-  /* Actually, char is not necessarily one byte.
-   * But if char isn't, then nothing is, so this
-   * is as close as we can get. */
-  if(sizeof(size_t) == 1)
-    writeTypedef("size_t", "size_t", 1);
-  if(sizeof(hsize_t) == 1)
-    writeTypedef("hsize_t", "hsize_t", 1);
-#endif /*H5_FORTRAN_HAS_INTEGER_1_KIND*/
-
-#if defined H5_FORTRAN_HAS_INTEGER_2_KIND
-  if(sizeof(long long) == 2)
-    writeTypedef("int", "long long", 2);
-  else if(sizeof(long) == 2)
-    writeTypedef("int", "long", 2);
-  else if(sizeof(int) == 2)
-    writeTypedef("int", "int", 2);
-  else if(sizeof(short) == 2)
-    writeTypedef("int", "short", 2);
-  else
-    writeTypedefDefault("int",2);
-
-  if(sizeof(size_t) == 2)
-    writeTypedef("size_t", "size_t", 2);
-  if(sizeof(hsize_t) == 2)
-    writeTypedef("hsize_t", "hsize_t", 2);
-#endif /*H5_FORTRAN_HAS_INTEGER_2_KIND*/
-
-#if defined H5_FORTRAN_HAS_INTEGER_4_KIND
-  if(sizeof(long long) == 4)
-    writeTypedef("int", "long long", 4);
-  else if(sizeof(long) == 4)
-    writeTypedef("int", "long", 4);
-  else if(sizeof(int) == 4)
-    writeTypedef("int", "int", 4);
-  else if(sizeof(short) == 4)
-    writeTypedef("int", "short", 4);
-  else
-    writeTypedefDefault("int",4);
-
-  if(sizeof(size_t) == 4)
-    writeTypedef("size_t", "size_t", 4);
-  if(sizeof(hsize_t) == 4)
-    writeTypedef("hsize_t", "hsize_t", 4);
-    
-#endif /*H5_FORTRAN_HAS_INTEGER_4_KIND*/
-
-#if defined H5_FORTRAN_HAS_INTEGER_8_KIND
-  if(sizeof(long long) == 8)
-    writeTypedef("int", "long long", 8);
-  else if(sizeof(long) == 8)
-    writeTypedef("int", "long", 8);
-  else if(sizeof(int) == 8)
-    writeTypedef("int", "int", 8);
-  else if(sizeof(short) == 8)
-    writeTypedef("int", "short", 8);
-  else
-    writeTypedefDefault("int",8);
-
-  if(sizeof(size_t) == 8)
-    writeTypedef("size_t", "size_t",  8);
-  if(sizeof(hsize_t) == 8)
-    writeTypedef("hsize_t", "hsize_t", 8);
-
-#endif /*H5_FORTRAN_HAS_INTEGER_8_KIND*/
-
-  /* Define c_float_x */
-
-#if defined H5_FORTRAN_HAS_REAL_NATIVE_4_KIND || defined H5_FORTRAN_HAS_REAL_4_KIND
-  if(sizeof(long double) == 4)
-    writeTypedef("float", "long double", 4);
-  else if(sizeof(double) == 4)
-   writeTypedef("float", "double", 4);
-  else if(sizeof(float) == 4)
-   writeTypedef("float", "float", 4);
-  else
-   { printf("Fortran REAL is 4 bytes, no corresponding C floating type\n");
-     printf("Quitting....\n");
-     return -1;
-   }
-#endif /*H5_FORTRAN_HAS_REAL_NATIVE_4_KIND*/
-
-#if defined H5_FORTRAN_HAS_REAL_NATIVE_8_KIND || defined H5_FORTRAN_HAS_REAL_8_KIND
-  if(sizeof(long double) == 8)
-    writeTypedef("float", "long double", 8);
-  else if(sizeof(double) == 8)
-   writeTypedef("float", "double", 8);
-  else if(sizeof(float) == 8)
-   writeTypedef("float", "float", 8);
-  else
-   { printf("Fortran REAL is 16 bytes, no corresponding C floating type\n");
-     printf("Quitting....\n");
-     return -1;
-   }
-#endif /*H5_FORTRAN_HAS_REAL_NATIVE_8_KIND*/
-
-#if defined H5_FORTRAN_HAS_REAL_NATIVE_16_KIND || defined H5_FORTRAN_HAS_REAL_16_KIND
-  if(sizeof(long double) == 16)
-    writeTypedef("float", "long double", 16);
-  else if(sizeof(double) == 16)
-   writeTypedef("float", "double", 16);
-  else if(sizeof(float) == 16)
-   writeTypedef("float", "float", 16);
-  else /*C has no 16 byte float so disable it in Fortran*/
-   { printf("warning: Fortran REAL is 16 bytes, no corresponding C floating type\n");
-     printf("         Disabling Fortran 16 byte REALs\n");
-     H5_C_HAS_REAL_NATIVE_16 = 0;
-   }
-#endif /*H5_FORTRAN_HAS_REAL_NATIVE_16_KIND*/
+  /* (a) define c_int_x */
+
+  H5_FORTRAN_NUM_INTEGER_KINDS = (int)(sizeof(IntKinds)/sizeof(IntKinds[0]));
+  H5_FORTRAN_NUM_REAL_KINDS = (int)(sizeof(RealKinds)/sizeof(RealKinds[0]));
+
+  for(i=0;i< H5_FORTRAN_NUM_INTEGER_KINDS;i++) {
+    if(sizeof(long long) == IntKinds_SizeOf[i])
+      writeTypedef("int", "long long", IntKinds[i]);
+    else if(sizeof(long) == IntKinds[i])
+      writeTypedef("int", "long", IntKinds[i]);
+    else if(sizeof(int) == IntKinds_SizeOf[i])
+      writeTypedef("int", "int", IntKinds[i]);
+    else if(sizeof(short) == IntKinds_SizeOf[i])
+      writeTypedef("int", "short", IntKinds[i]);
+    else
+      if(IntKinds_SizeOf[i] == 1) {
+	writeTypedef("int", "char", IntKinds[i]);
+	/* Actually, char is not necessarily one byte.
+	 * But if char isn't, then nothing is, so this
+	 * is as close as we can get. */
+      } else {
+	writeTypedefDefault("int",IntKinds[i]);
+      }
+    if(sizeof(size_t) == IntKinds_SizeOf[i])
+      writeTypedef("size_t", "size_t", IntKinds[i]);
+    if(sizeof(hsize_t) == IntKinds_SizeOf[i])
+      writeTypedef("hsize_t", "hsize_t", IntKinds[i]);
+  }
+
+  /* (b) Define c_float_x */
+
+  for(i=0;i< H5_FORTRAN_NUM_REAL_KINDS;i++) {
+#ifdef HAVE_FLOAT128
+/* should fail */
+    if(sizeof(__float128) == RealKinds_SizeOf[i]) {
+      writeTypedef("float", "__float128", RealKinds[i]);
+      strcpy(Real_C_TYPES[i], "C_FLOAT128");
+    } else
+#endif
+    if(sizeof(long double) == RealKinds_SizeOf[i]) {
+      writeTypedef("float", "long double", RealKinds[i]);
+      strcpy(Real_C_TYPES[i], "C_LONG_DOUBLE");
+    } else if(sizeof(double) == RealKinds_SizeOf[i]) {
+      writeTypedef("float", "double", RealKinds[i]);
+      strcpy(Real_C_TYPES[i], "C_DOUBLE");
+    } else if(sizeof(float) == RealKinds_SizeOf[i]) {
+      writeTypedef("float", "float", RealKinds[i]);
+      strcpy(Real_C_TYPES[i], "C_FLOAT");
+    } else {
+      printf("                      **** HDF5 WARNING ****/n");
+      printf("Fortran REAL is %d bytes, but no corresponding C floating type exists\n",RealKinds_SizeOf[i]);
+      printf("Fortran Interfaces for Fortran REALs of %d bytes will not exist\n",RealKinds_SizeOf[i]);
+    }
+  }
 
   /* Now begin defining fortran types. */
   fprintf(c_header, "\n");
+
   /* haddr_t */
-#if defined H5_FORTRAN_HAS_INTEGER_8_KIND && H5_SIZEOF_HADDR_T >= 8
-  writeToFiles("int","HADDR_T", "haddr_t_f", 8, H5_FORTRAN_HAS_INTEGER_8_KIND);
-#elif defined H5_FORTRAN_HAS_INTEGER_4_KIND && H5_SIZEOF_HADDR_T >= 4
-  writeToFiles("int","HADDR_T", "haddr_t_f", 4, H5_FORTRAN_HAS_INTEGER_4_KIND);
-#elif defined H5_FORTRAN_HAS_INTEGER_2_KIND && H5_SIZEOF_HADDR_T >= 2
-  writeToFiles("int","HADDR_T", "haddr_t_f", 2, H5_FORTRAN_HAS_INTEGER_2_KIND);
-#elif defined H5_FORTRAN_HAS_INTEGER_1_KIND && H5_SIZEOF_HADDR_T >= 1
-  writeToFiles("int","HADDR_T", "haddr_t_f", 1, H5_FORTRAN_HAS_INTEGER_1_KIND);
-#else
-    /* Error: couldn't find a size for haddr_t */
-    return -1;
-#endif
+  for(i=0;i< H5_FORTRAN_NUM_INTEGER_KINDS;i++) {
+    if(IntKinds_SizeOf[i] == H5_SIZEOF_HADDR_T) {
+      writeToFiles("int","HADDR_T", "haddr_t_f", H5_SIZEOF_HADDR_T, IntKinds[i]);
+      break;
+    }
+    if(i == (H5_FORTRAN_NUM_INTEGER_KINDS-1) )
+      /* Error: couldn't find a size for haddr_t */
+      return -1;
+  }
 
   /* hsize_t */
-#if defined H5_FORTRAN_HAS_INTEGER_8_KIND && H5_SIZEOF_HSIZE_T >= 8
-    writeToFiles("hsize_t","HSIZE_T", "hsize_t_f", 8, H5_FORTRAN_HAS_INTEGER_8_KIND);
-#elif defined H5_FORTRAN_HAS_INTEGER_4_KIND && H5_SIZEOF_HSIZE_T >= 4
-    writeToFiles("hsize_t","HSIZE_T", "hsize_t_f", 4, H5_FORTRAN_HAS_INTEGER_4_KIND);
-#elif defined H5_FORTRAN_HAS_INTEGER_2_KIND && H5_SIZEOF_HSIZE_T >= 2
-    writeToFiles("hsize_t","HSIZE_T", "hsize_t_f", 2, H5_FORTRAN_HAS_INTEGER_2_KIND);
-#elif defined H5_FORTRAN_HAS_INTEGER_1_KIND && H5_SIZEOF_HSIZE_T >= 1
-    writeToFiles("hsize_t","HSIZE_T", "hsize_t_f", 1, H5_FORTRAN_HAS_INTEGER_1_KIND);
-#else
-    /* Error: couldn't find a size for hsize_t */
-    return -1;
-#endif
+  for(i=0;i< H5_FORTRAN_NUM_INTEGER_KINDS;i++) {
+    if(IntKinds_SizeOf[i] == H5_SIZEOF_HSIZE_T) {
+      writeToFiles("hsize_t","HSIZE_T", "hsize_t_f", H5_SIZEOF_HSIZE_T, IntKinds[i]);
+      break;
+    }
+    if(i == (H5_FORTRAN_NUM_INTEGER_KINDS-1) )
+      /* Error: couldn't find a size for hsize_t */
+      return -1;
+  }
 
   /* hssize_t */
-#if defined H5_FORTRAN_HAS_INTEGER_8_KIND && H5_SIZEOF_HSSIZE_T >= 8
-    writeToFiles("int","HSSIZE_T", "hssize_t_f", 8, H5_FORTRAN_HAS_INTEGER_8_KIND);
-#elif defined H5_FORTRAN_HAS_INTEGER_4_KIND && H5_SIZEOF_HSSIZE_T >= 4
-    writeToFiles("int","HSSIZE_T", "hssize_t_f", 4, H5_FORTRAN_HAS_INTEGER_4_KIND);
-#elif defined H5_FORTRAN_HAS_INTEGER_2_KIND && H5_SIZEOF_HSSIZE_T >= 2
-    writeToFiles("int","HSSIZE_T", "hssize_t_f", 2, H5_FORTRAN_HAS_INTEGER_2_KIND);
-#elif defined H5_FORTRAN_HAS_INTEGER_1_KIND && H5_SIZEOF_HSSIZE_T >= 1
-    writeToFiles("int","HSSIZE_T", "hssize_t_f", 1, H5_FORTRAN_HAS_INTEGER_1_KIND);
-#else
-    /* Error: couldn't find a size for hssize_t */
-    return -1;
-#endif
+  for(i=0;i< H5_FORTRAN_NUM_INTEGER_KINDS;i++) {
+    if(IntKinds_SizeOf[i] == H5_SIZEOF_HSSIZE_T) {
+      writeToFiles("int","HSSIZE_T", "hssize_t_f", H5_SIZEOF_HSSIZE_T, IntKinds[i]);
+      break;
+    }
+    if(i == (H5_FORTRAN_NUM_INTEGER_KINDS-1) )
+      /* Error: couldn't find a size for hssize_t */
+      return -1;
+  }
 
   /* off_t */
-#if defined H5_FORTRAN_HAS_INTEGER_8_KIND && H5_SIZEOF_OFF_T >= 8
-    writeToFiles("int","OFF_T", "off_t_f", 8, H5_FORTRAN_HAS_INTEGER_8_KIND);
-#elif defined H5_FORTRAN_HAS_INTEGER_4_KIND && H5_SIZEOF_OFF_T >= 4
-    writeToFiles("int","OFF_T", "off_t_f", 4, H5_FORTRAN_HAS_INTEGER_4_KIND);
-#elif defined H5_FORTRAN_HAS_INTEGER_2_KIND && H5_SIZEOF_OFF_T >= 2
-    writeToFiles("int","OFF_T", "off_t_f", 2, H5_FORTRAN_HAS_INTEGER_2_KIND);
-#elif defined H5_FORTRAN_HAS_INTEGER_1_KIND && H5_SIZEOF_OFF_T >= 1
-    writeToFiles("int","OFF_T", "off_t_f", 1, H5_FORTRAN_HAS_INTEGER_1_KIND);
-#else
-    /* Error: couldn't find a size for off_t */
-    return -1;
-#endif
+  for(i=0;i< H5_FORTRAN_NUM_INTEGER_KINDS;i++) {
+    if(IntKinds_SizeOf[i] == H5_SIZEOF_OFF_T) {
+      writeToFiles("int","OFF_T", "off_t_f", H5_SIZEOF_OFF_T, IntKinds[i]);
+      break;
+    }
+    if(i == (H5_FORTRAN_NUM_INTEGER_KINDS-1) )
+      /* Error: couldn't find a size for off_t */
+      return -1;
+  }
 
   /* size_t */
-#if defined H5_FORTRAN_HAS_INTEGER_8_KIND && H5_SIZEOF_SIZE_T >= 8
-    writeToFiles("size_t","SIZE_T", "size_t_f", 8, H5_FORTRAN_HAS_INTEGER_8_KIND);
-#elif defined H5_FORTRAN_HAS_INTEGER_4_KIND && H5_SIZEOF_SIZE_T >= 4
-    writeToFiles("size_t","SIZE_T", "size_t_f", 4, H5_FORTRAN_HAS_INTEGER_4_KIND);
-#elif defined H5_FORTRAN_HAS_INTEGER_2_KIND && H5_SIZEOF_SIZE_T >= 2
-    writeToFiles("size_t","SIZE_T", "size_t_f", 2, H5_FORTRAN_HAS_INTEGER_2_KIND);
-#elif defined H5_FORTRAN_HAS_INTEGER_1_KIND && H5_SIZEOF_SIZE_T >= 1
-    writeToFiles("size_t","SIZE_T", "size_t_f", 1, H5_FORTRAN_HAS_INTEGER_1_KIND);
-#else
-    /* Error: couldn't find a size for size_t */
-    return -1;
-#endif
+  for(i=0;i< H5_FORTRAN_NUM_INTEGER_KINDS;i++) {
+    if(IntKinds_SizeOf[i] == H5_SIZEOF_SIZE_T) {
+      writeToFiles("size_t","SIZE_T", "size_t_f", H5_SIZEOF_SIZE_T, IntKinds[i]);
+      break;
+    }
+    if(i == (H5_FORTRAN_NUM_INTEGER_KINDS-1) )
+      /* Error: couldn't find a size for size_t */
+      return -1;
+  }
 
   /* int */
-#if defined H5_FORTRAN_HAS_NATIVE_8_KIND
-    writeToFiles("int","Fortran_INTEGER", "int_f", 8, H5_FORTRAN_HAS_NATIVE_8_KIND);
-#elif defined H5_FORTRAN_HAS_NATIVE_4_KIND
-    writeToFiles("int","Fortran_INTEGER", "int_f", 4, H5_FORTRAN_HAS_NATIVE_4_KIND);
-#elif defined H5_FORTRAN_HAS_NATIVE_2_KIND
-    writeToFiles("int","Fortran_INTEGER", "int_f", 2, H5_FORTRAN_HAS_NATIVE_2_KIND);
-#elif defined H5_FORTRAN_HAS_NATIVE_1_KIND
-    writeToFiles("int","Fortran_INTEGER", "int_f", 1, H5_FORTRAN_HAS_NATIVE_1_KIND);
-#else
-    /* Error: couldn't find a size for int */
-    return -1;
-#endif
+  writeToFiles("int","Fortran_INTEGER", "int_f", H5_FORTRAN_NATIVE_INTEGER_SIZEOF, H5_FORTRAN_NATIVE_INTEGER_KIND);
+  
+
 
   /* int_1, int_2, int_4, int_8 */
 
@@ -381,29 +300,20 @@ int main(void)
 /* it a value of the next larger one, but if the next         */
 /* higher one is not available we assigned it the next lowest */
 
-    FoundIntSize[0] = -1;
-    FoundIntSize[1] = -2;
-    FoundIntSize[2] = -4;
-    FoundIntSize[3] = -8;
 
-#if defined H5_FORTRAN_HAS_INTEGER_1_KIND
-    FoundIntSize[0] = 1;
-    FoundIntSizeKind[0] = H5_FORTRAN_HAS_INTEGER_1_KIND;
-#endif
-#if defined H5_FORTRAN_HAS_INTEGER_2_KIND
-    FoundIntSize[1] = 2;
-    FoundIntSizeKind[1] = H5_FORTRAN_HAS_INTEGER_2_KIND;
-#endif
-#if defined H5_FORTRAN_HAS_INTEGER_4_KIND
-    FoundIntSize[2] = 4;
-    FoundIntSizeKind[2] = H5_FORTRAN_HAS_INTEGER_4_KIND;
-#endif
-#if defined H5_FORTRAN_HAS_INTEGER_8_KIND
-    FoundIntSize[3] = 8;
-    FoundIntSizeKind[3] = H5_FORTRAN_HAS_INTEGER_8_KIND ;
-#endif
+  FoundIntSize[0] = -1;
+  FoundIntSize[1] = -1;
+  FoundIntSize[2] = -1;
+  FoundIntSize[3] = -1;
+  FoundIntSize[4] = -1;
+  
+  for(i=0;i<H5_FORTRAN_NUM_INTEGER_KINDS;i++) {
+    FoundIntSize[i] = (int)IntKinds[i];
+    FoundIntSizeKind[i] = (int)IntKinds_SizeOf[i];
+/*     writeToFiles("int",chrA, chrB, FoundIntSize[i], FoundIntSizeKind[i]); */
+  }
 
-    for(i=0;i<4;i++) {
+  for(i=0;i<H5_FORTRAN_NUM_INTEGER_KINDS;i++) {
       if( FoundIntSize[i] > 0) /* Found the integer type */
 	{
 	  sprintf(chrA, "Fortran_INTEGER_%d", FoundIntSize[i]);
@@ -450,129 +360,144 @@ int main(void)
 /* it a value of the next larger one, but if the next         */
 /* higher one is not available we assigned it the next lowest */
 
-    FoundRealSize[0] = -4;
-    FoundRealSize[1] = -8;
-    FoundRealSize[2] = -16;
-
-#if defined H5_FORTRAN_HAS_REAL_4_KIND
-    FoundRealSize[0] = 4;
-    FoundRealSizeKind[0] = H5_FORTRAN_HAS_REAL_4_KIND;
-#endif
-#if defined H5_FORTRAN_HAS_REAL_8_KIND
-    FoundRealSize[1] = 8;
-    FoundRealSizeKind[1] = H5_FORTRAN_HAS_REAL_8_KIND;
-#endif
-
-#if defined H5_FORTRAN_HAS_REAL_16_KIND
-    if(H5_C_HAS_REAL_NATIVE_16 != 0) {
-      FoundRealSize[2] = 16;
-      FoundRealSizeKind[2] = H5_FORTRAN_HAS_REAL_16_KIND;
-    }
-#endif
-
-    for(i=0;i<3;i++) {
-      if( FoundRealSize[i] > 0) /* Found the real type */
-	{
-	  sprintf(chrA, "Fortran_REAL_%d", FoundRealSize[i]);
-	  sprintf(chrB, "real_%d_f", FoundRealSize[i]);
-	  writeToFiles("float",chrA, chrB, FoundRealSize[i], FoundRealSizeKind[i]);
-	}
-      else  /* Did not find the real type */
-	{
-	  flag = 0; /* flag indicating if found the next highest */
-	  for(j=i+1;j<3;j++)  /* search for next highest */
-	    {
-	      if( FoundRealSize[j] > 0) /* Found the next highest */
-		{
-		  sprintf(chrA, "Fortran_REAL_%d", (-1)*FoundRealSize[i]);
-		  sprintf(chrB, "real_%d_f", (-1)*FoundRealSize[i]);
-		  if(FoundRealSize[j]>4) {
-		    writeToFiles("float",chrA, chrB,  FoundRealSize[j], FoundRealSizeKind[j]);
-		    flag = 1;
-		  }
-		/*   else { */
-/* 		    writeToFiles("float", chrA, chrB, FoundRealSize[j]); */
+  FoundRealSize[0] = -1;
+  FoundRealSize[1] = -1;
+  FoundRealSize[2] = -1;
+  FoundRealSize[3] = -1;
+  FoundRealSize[4] = -1;
+  
+  for(i=0;i<H5_FORTRAN_NUM_REAL_KINDS;i++) {
+    FoundRealSize[i] = (int)RealKinds[i];
+    FoundRealSizeKind[i] = (int)RealKinds_SizeOf[i];	
+    sprintf(chrA, "Fortran_REAL_%s", Real_C_TYPES[i]);
+ /*    sprintf(chrB, "real_%d_f", FoundRealSize[i]); */
+    sprintf(chrB, "real_%s_f", Real_C_TYPES[i]);
+    writeToFiles("float",chrA, chrB, RealKinds[i], RealKinds_SizeOf[i]);
+  }
+
+/*   for(i=0;i<H5_FORTRAN_NUM_REAL_KINDS;i++) { */
+/*     if( FoundRealSize[i] > 0) /\* Found the real type *\/ */
+/* 	{ */
+/* 	  sprintf(chrA, "Fortran_REAL_%d", Real_C_TYPES[i]); */
+/* 	  sprintf(chrB, "real_%d_f", FoundRealSize[i]); */
+/* 	  writeToFiles("float",chrA, chrB, FoundRealSize[i], FoundRealSizeKind[i]); */
+/* 	} */
+/*       else  /\* Did not find the real type *\/ */
+/* 	{ */
+/* 	  flag = 0; /\* flag indicating if found the next highest *\/ */
+/* 	  for(j=i+1;j<3;j++)  /\* search for next highest *\/ */
+/* 	    { */
+/* 	      if( FoundRealSize[j] > 0) /\* Found the next highest *\/ */
+/* 		{ */
+/* 		  sprintf(chrA, "Fortran_REAL_%d", (-1)*FoundRealSize[i]); */
+/* 		  sprintf(chrB, "real_%d_f", (-1)*FoundRealSize[i]); */
+/* 		  if(FoundRealSize[j]>4) { */
+/* 		    writeToFiles("float",chrA, chrB,  FoundRealSize[j], FoundRealSizeKind[j]); */
+/* 		    flag = 1; */
 /* 		  } */
-		  flag = 1;
-		  break;
-		}
-	    }
-	  if(flag == 0) /* No higher one found, so find next lowest */
-	    {
-	      for(j=1;j>-1;j--)  /* Search for next lowest */
-		{
-		  if( FoundRealSize[j] > 0) /* Found the next lowest */
-		    {
-		      sprintf(chrA, "Fortran_REAL_%d", (-1)*FoundRealSize[i]);
-		      sprintf(chrB, "real_%d_f", (-1)*FoundRealSize[i]);
-		      if(FoundRealSize[j]>4)
-			writeToFiles("float",chrA, chrB,  FoundRealSize[j], FoundRealSizeKind[j]);
-		     /*  else { */
-/* 			writeToFiles("float", chrA, chrB, FoundRealSize[j]); */
-/* 		      } */
-		      flag = 1;
-		      break;
-		    }
-		}
-	    }
-	  if(flag == 0) /* No higher or lower one found, indicating an error */
-	     return -1;
-	}
-    }
+/* 		/\*   else { *\/ */
+/* /\* 		    writeToFiles("float", chrA, chrB, FoundRealSize[j]); *\/ */
+/* /\* 		  } *\/ */
+/* 		  flag = 1; */
+/* 		  break; */
+/* 		} */
+/* 	    } */
+/* 	  if(flag == 0) /\* No higher one found, so find next lowest *\/ */
+/* 	    { */
+/* 	      for(j=1;j>-1;j--)  /\* Search for next lowest *\/ */
+/* 		{ */
+/* 		  if( FoundRealSize[j] > 0) /\* Found the next lowest *\/ */
+/* 		    { */
+/* 		      sprintf(chrA, "Fortran_REAL_%d", (-1)*FoundRealSize[i]); */
+/* 		      sprintf(chrB, "real_%d_f", (-1)*FoundRealSize[i]); */
+/* 		      if(FoundRealSize[j]>4) */
+/* 			writeToFiles("float",chrA, chrB,  FoundRealSize[j], FoundRealSizeKind[j]); */
+/* 		     /\*  else { *\/ */
+/* /\* 			writeToFiles("float", chrA, chrB, FoundRealSize[j]); *\/ */
+/* /\* 		      } *\/ */
+/* 		      flag = 1; */
+/* 		      break; */
+/* 		    } */
+/* 		} */
+/* 	    } */
+/* 	  if(flag == 0) /\* No higher or lower one found, indicating an error *\/ */
+/* 	     return -1; */
+/* 	} */
+/*     } */
 
   /* hid_t */
-#if defined H5_FORTRAN_HAS_INTEGER_8_KIND && H5_SIZEOF_HID_T >= 8
-    writeToFiles("int","HID_T", "hid_t_f", 8, H5_FORTRAN_HAS_INTEGER_8_KIND);
-#elif defined H5_FORTRAN_HAS_INTEGER_4_KIND && H5_SIZEOF_HID_T >= 4
-    writeToFiles("int","HID_T", "hid_t_f", 4, H5_FORTRAN_HAS_INTEGER_4_KIND);
-#elif defined H5_FORTRAN_HAS_INTEGER_2_KIND && H5_SIZEOF_HID_T >= 2
-    writeToFiles("int","HID_T", "hid_t_f", 2, H5_FORTRAN_HAS_INTEGER_2_KIND);
-#elif defined H5_FORTRAN_HAS_INTEGER_1_KIND && H5_SIZEOF_HID_T >= 1
-    writeToFiles("int","HID_T", "hid_t_f", 1, H5_FORTRAN_HAS_INTEGER_1_KIND);
-#elif defined H5_FORTRAN_HAS_INTEGER_8_KIND && H5_SIZEOF_HID_T >= 4
-    writeToFiles("int","HID_T", "hid_t_f", 8, H5_FORTRAN_HAS_INTEGER_8_KIND);
-#else
-    /* Error: couldn't find a size for hid_t */
-    return -1;
-#endif
+  for(i=0;i< H5_FORTRAN_NUM_INTEGER_KINDS;i++) {
+    if(IntKinds_SizeOf[i] == H5_SIZEOF_HID_T) {
+      writeToFiles("int","HID_T", "hid_t_f", H5_SIZEOF_HID_T, IntKinds[i]);
+      break;
+    }
+    if(i == (H5_FORTRAN_NUM_INTEGER_KINDS-1) )
+      /* Error: couldn't find a size for hid_t */
+      return -1;
+  }
 
   /* real_f */
-#if defined H5_FORTRAN_HAS_REAL_NATIVE_16_KIND
-    if(H5_C_HAS_REAL_NATIVE_16 != 0) {
-	writeToFilesChr("float","Fortran_REAL", "real_f", 16, "C_LONG_DOUBLE");
-    }
-#elif defined H5_FORTRAN_HAS_REAL_NATIVE_8_KIND
-    writeToFilesChr("float", "Fortran_REAL", "real_f", 8, "C_DOUBLE");
-#elif defined H5_FORTRAN_HAS_REAL_NATIVE_4_KIND
-    writeToFilesChr("float", "Fortran_REAL", "real_f", 4, "C_FLOAT");
-#else
-    /* Error: couldn't find a size for real_f */
-    return -1;
-#endif
+  if(H5_FORTRAN_NATIVE_REAL_SIZEOF == sizeof(long double))
+    writeToFilesChr("float","Fortran_REAL", "real_f", H5_FORTRAN_NATIVE_REAL_KIND, "C_LONG_DOUBLE");
+  else if(H5_FORTRAN_NATIVE_REAL_SIZEOF == sizeof(double))
+    writeToFilesChr("float","Fortran_REAL", "real_f", H5_FORTRAN_NATIVE_REAL_KIND, "C_DOUBLE");
+  else if(H5_FORTRAN_NATIVE_REAL_SIZEOF == sizeof(float))
+    writeToFilesChr("float","Fortran_REAL", "real_f", H5_FORTRAN_NATIVE_REAL_KIND, "C_FLOAT");
+  else {
+    /* No exact match, choose the next highest */
+    if(H5_FORTRAN_NATIVE_REAL_SIZEOF > sizeof(long double))
+      writeToFilesChr("float","Fortran_REAL", "real_f", H5_FORTRAN_NATIVE_REAL_KIND, "C_LONG_DOUBLE");
+    else if(H5_FORTRAN_NATIVE_REAL_SIZEOF > sizeof(double))
+      writeToFilesChr("float","Fortran_REAL", "real_f", H5_FORTRAN_NATIVE_REAL_KIND, "C_DOUBLE");
+    else if(H5_FORTRAN_NATIVE_REAL_SIZEOF > sizeof(float))
+      writeToFilesChr("float","Fortran_REAL", "real_f", H5_FORTRAN_NATIVE_REAL_KIND, "C_FLOAT");
+    else
+      /* Error: couldn't find a size for real_f */
+      return -1;
+  }
 
   /* double_f */
-#if defined H5_FORTRAN_HAS_DOUBLE_NATIVE_16_KIND
-    if(H5_C_HAS_REAL_NATIVE_16 != 0) { /* Check if C has 16 byte floats */
-      writeToFilesChr("float", "Fortran_DOUBLE", "double_f", 16, "C_LONG_DOUBLE");
-    } else {
-#if defined H5_FORTRAN_HAS_REAL_NATIVE_8_KIND /* Fall back to 8 byte floats */
-    writeToFilesChr("float", "Fortran_DOUBLE", "double_f", 8, "C_DOUBLE");
-    }
-#elif defined H5_FORTRAN_HAS_REAL_NATIVE_4_KIND  /* Fall back to 4 byte floats */
-    writeToFilesChr("float", "Fortran_DOUBLE", "double_f", 4, "C_FLOAT");
-    }
-#else
-    /* Error: couldn't find a size for double_f when fortran has 16 byte reals */
-    return -1;
-    }
-#endif
+  if(H5_FORTRAN_NATIVE_DOUBLE_SIZEOF == sizeof(long double))
+    writeToFilesChr("float","Fortran_DOUBLE", "double_f", H5_FORTRAN_NATIVE_DOUBLE_KIND, "C_LONG_DOUBLE");
+  else if(H5_FORTRAN_NATIVE_DOUBLE_SIZEOF == sizeof(double))
+    writeToFilesChr("float","Fortran_DOUBLE", "double_f", H5_FORTRAN_NATIVE_DOUBLE_KIND, "C_DOUBLE");
+  else if(H5_FORTRAN_NATIVE_DOUBLE_SIZEOF == sizeof(float))
+    writeToFilesChr("float","Fortran_DOUBLE", "double_f", H5_FORTRAN_NATIVE_DOUBLE_KIND, "C_FLOAT");
+  else {
+/*     /\* No exact match, choose the next highest *\/ */
+/*     if(H5_FORTRAN_NATIVE_DOUBLE_SIZEOF > sizeof(long double)) */
+/*       writeToFilesChr("float","Fortran_DOUBLE", "double_f", H5_FORTRAN_NATIVE_DOUBLE_KIND, "C_LONG_DOUBLE"); */
+/*     else if(H5_FORTRAN_NATIVE_DOUBLE_SIZEOF > sizeof(double)) */
+/*       writeToFilesChr("float","Fortran_DOUBLE", "double_f", sizeof(double), "C_DOUBLE"); */
+/*     else if(H5_FORTRAN_NATIVE_DOUBLE_SIZEOF > sizeof(float)) */
+/*       writeToFilesChr("float","Fortran_DOUBLE", "double_f", sizeof(float), "C_FLOAT"); */
+/*     else */
+      /* Error: couldn't find a size for double_f */
+/*       printf("Error: couldn't find a size for double_f \n"); */
+/*       return -1; */
+  }
+
+
+
+/*   /\* double_f *\/ */
+/*   if(H5_FORTRAN_NATIVE_DOUBLE_SIZEOF == C_LONG_DOUBLE_SIZEOF) */
+/*     writeToFilesChr("float","Fortran_DOUBLE", "double_f", H5_FORTRAN_NATIVE_DOUBLE_SIZEOF, "C_LONG_DOUBLE"); */
+/*   else if(H5_FORTRAN_NATIVE_DOUBLE_SIZEOF == C_DOUBLE_SIZEOF) */
+/*     writeToFilesChr("float","Fortran_DOUBLE", "double_f", H5_FORTRAN_NATIVE_DOUBLE_SIZEOF, "C_DOUBLE"); */
+/*   else if(H5_FORTRAN_NATIVE_DOUBLE_SIZEOF == C_FLOAT_SIZEOF) */
+/*     writeToFilesChr("float","Fortran_DOUBLE", "double_f", H5_FORTRAN_NATIVE_DOUBLE_SIZEOF, "C_FLOAT"); */
+/*   else */
+/*     /\* Error: couldn't find a size for double_f *\/ */
+/*     return -1; */
 
-#elif defined H5_FORTRAN_HAS_DOUBLE_NATIVE_8_KIND
-    writeToFilesChr("float", "Fortran_DOUBLE", "double_f", 8, "C_DOUBLE");
-#else
-    /* Error: couldn't find a size for real_f */
-    return -1;
-#endif
+/*   writeToFiles("float","Fortran_DOUBLE", "double_f", H5_FORTRAN_NATIVE_DOUBLE_SIZEOF, H5_FORTRAN_NATIVE_DOUBLE_KIND); */
+
+/* #elif defined H5_FORTRAN_HAS_DOUBLE_NATIVE_8_KIND */
+/*     writeToFilesChr("float", "Fortran_DOUBLE", "double_f", 8, "C_DOUBLE"); */
+/* #else */
+/*     /\* Error: couldn't find a size for real_f *\/ */
+/*     return -1; */
+/* #endif */
 
 /*     /\* real_f *\/ */
 /*     if(sizeof(float) == C_LONG_DOUBLE_SIZEOF) { */