1 files changed, 345 insertions, 232 deletions

diff --git a/fortran/src/H5match_types.c b/fortran/src/H5match_types.c
index 37509a0..c4b7f73 100644
--- a/fortran/src/H5match_types.c
+++ b/fortran/src/H5match_types.c
@@ -9,7 +9,7 @@
  * PURPOSE
  *  C Program to match C types to Fortran types.
  *  Creates the files H5f90i_gen.h for the C code and
- *  H5fortran_types.F90 for the Fortran code.
+ *  H5fortran_types.f90 for the Fortran code.
  *
  * COPYRIGHT
  * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
@@ -31,7 +31,6 @@
 */
 
 #include <stdio.h>
-#include <string.h>
 #include <assert.h>
 
 #include "H5public.h"
@@ -46,13 +45,12 @@ FILE * c_header;
 FILE * fort_header;
 
 #define CFILE "H5f90i_gen.h"
-#define FFILE "H5fortran_types.F90"
+#define FFILE "H5fortran_types.f90"
 
 /* Prototypes for the write routines */
-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);
+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);
 
 static void
 initCfile(void)
@@ -102,7 +100,6 @@ initFfile(void)
 !\n!\n\
 ! This file is automatically generated and contains HDF5 Fortran90 type definitions.\n!\n\
        MODULE H5FORTRAN_TYPES\n\
-         USE ISO_C_BINDING\n\
          !\n\
          !  HDF5 integers\n\
          !\n");
@@ -122,198 +119,253 @@ endFfile(void)
 }
 
 /* Define a c_int_x type in the C header */
-void writeTypedef(const char* c_typedef, const char* c_type, int size)
+void writeTypedef(const char* c_typedef, const char* c_type, unsigned 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, int size)
+void writeTypedefDefault(const char* c_typedef, unsigned 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);
+  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,  int kind)
+void writeToFiles(const char* c_typedef, const char* fortran_type, const char* c_type, int size, unsigned 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);
 }
-void writeToFilesChr(const char* c_typedef, const char* fortran_type, const char* c_type, int size, char* kind)
-{
-  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[10];
-  int FoundIntSizeKind[10];
-  int FoundRealSize[10];
-  int FoundRealSizeKind[10];
-  int i, j,flag;
-  char chrA[32],chrB[32];
-
-  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;
-  int found_long_double = 0;
+  int FoundIntSize[4];
+  unsigned FoundIntSizeKind[4];
+  int FoundRealSize[3];
+  unsigned FoundRealSizeKind[3];
+  int i,j,flag;
+  char chrA[20],chrB[20];
+  int H5_C_HAS_REAL_NATIVE_16;
 
   /* Open target files */
   c_header = fopen(CFILE, "w");
   fort_header = fopen(FFILE, "w");
 
+  /* Default is C has 16 byte float */
+  H5_C_HAS_REAL_NATIVE_16 = 1;
+
   /* Write copyright, boilerplate to both files */
   initCfile();
   initFfile();
 
-  /* (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++) {
-    if (sizeof(float) == RealKinds_SizeOf[i]) {
-      writeTypedef("float", "float", RealKinds[i]);
-      strcpy(Real_C_TYPES[i], "C_FLOAT");
-    }
-    else if(sizeof(double) == RealKinds_SizeOf[i]) {
-      writeTypedef("float", "double", RealKinds[i]);
-      strcpy(Real_C_TYPES[i], "C_DOUBLE"); 
-    }
-#if H5_FORTRAN_HAVE_C_LONG_DOUBLE!=0
-    else if(sizeof(long double) == RealKinds_SizeOf[i] && found_long_double == 0) {
-      writeTypedef("float", "long double", RealKinds[i]);
-      strcpy(Real_C_TYPES[i], "C_LONG_DOUBLE");
-      found_long_double = 1; 
-    }
-#  ifdef H5_HAVE_FLOAT128
-    /* Don't select a higher precision than Fortran can support */
-    else if(sizeof(__float128) == RealKinds_SizeOf[i] && found_long_double == 1 && H5_PAC_FC_MAX_REAL_PRECISION > 28) {
-      writeTypedef("float", "__float128", RealKinds[i]);
-      strcpy(Real_C_TYPES[i], "C_FLOAT128");
-    }
-#  else
-    else if(sizeof(long double) == RealKinds_SizeOf[i] && found_long_double == 1 && H5_PAC_FC_MAX_REAL_PRECISION > 28) {
-      writeTypedef("float", "long double", RealKinds[i]);
-      strcpy(Real_C_TYPES[i], "C_FLOAT128");
-    }
-#  endif
-#else /* There is no C_LONG_DOUBLE intrinsic */
-#  ifdef H5_HAVE_FLOAT128
-    /* Don't select a higher precision than Fortran can support */
-    else if(sizeof(__float128) == RealKinds_SizeOf[i] ) {
-      writeTypedef("float", "__float128", RealKinds[i]);
-      strcpy(Real_C_TYPES[i], "C_FLOAT128");
-    }
-#  else
-    else if(sizeof(long double) == RealKinds_SizeOf[i] ) {
-      writeTypedef("float", "long double", RealKinds[i]);
-      strcpy(Real_C_TYPES[i], "C_FLOAT128");
-    }
-#  endif
-#endif
-    else {
-      printf("\n                      **** HDF5 WARNING ****\n");
-      printf("Fortran REAL(KIND=%d) is %d Bytes, but no corresponding C float type exists of that size\n",RealKinds[i],RealKinds_SizeOf[i]);
-      printf("     !!! Fortran interfaces will not be generated for REAL(KIND=%d) !!!\n\n",RealKinds[i]);
-
-      RealKinds_SizeOf[i] = -1;
-      RealKinds[i] = -1;
-    }
-  }
+  /* 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*/
 
   /* Now begin defining fortran types. */
   fprintf(c_header, "\n");
-
   /* haddr_t */
-  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;
-  }
+#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
 
   /* hsize_t */
-  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;
-  }
+#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
 
   /* hssize_t */
-  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;
-  }
+#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
 
   /* off_t */
-  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;
-  }
+#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
 
   /* size_t */
-  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;
-  }
+#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
 
   /* int */
-  writeToFiles("int","Fortran_INTEGER", "int_f", H5_FORTRAN_NATIVE_INTEGER_SIZEOF, H5_FORTRAN_NATIVE_INTEGER_KIND);
+#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
 
   /* int_1, int_2, int_4, int_8 */
 
@@ -322,20 +374,29 @@ 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;
 
-  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]); */
-  }
+#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
 
-  for(i=0;i<H5_FORTRAN_NUM_INTEGER_KINDS;i++) {
+    for(i=0;i<4;i++) {
       if( FoundIntSize[i] > 0) /* Found the integer type */
 	{
 	  sprintf(chrA, "Fortran_INTEGER_%d", FoundIntSize[i]);
@@ -382,77 +443,129 @@ 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] = -1;
-  FoundRealSize[1] = -1;
-  FoundRealSize[2] = -1;
-  FoundRealSize[3] = -1;
-  FoundRealSize[4] = -1;
-  
-  for(i=0;i<H5_FORTRAN_NUM_REAL_KINDS;i++) {
-    if (RealKinds[i] > 0) {
-      FoundRealSize[i] = (int)RealKinds[i];
-      FoundRealSizeKind[i] = (int)RealKinds_SizeOf[i];	
-      sprintf(chrA, "Fortran_REAL_%s", Real_C_TYPES[i]);
-      sprintf(chrB, "real_%s_f", Real_C_TYPES[i]);
-      writeToFiles("float",chrA, chrB, RealKinds[i], RealKinds_SizeOf[i]);
+    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
 
-  /* hid_t */
-  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;
+    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]); */
+/* 		  } */
+		  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;
+	}
     }
-    if(i == (H5_FORTRAN_NUM_INTEGER_KINDS-1) )
-      /* Error: couldn't find a size for hid_t */
-      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
 
   /* real_f */
-  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 */
-      printf("Error: couldn't find a size for real_f \n");
-      return -1;
+#if defined H5_FORTRAN_HAS_REAL_NATIVE_16_KIND
+    if(H5_C_HAS_REAL_NATIVE_16 != 0) {
+      writeToFiles("float","Fortran_REAL", "real_f", 16, H5_FORTRAN_HAS_REAL_NATIVE_16_KIND);
     }
-  }
+#elif defined H5_FORTRAN_HAS_REAL_NATIVE_8_KIND
+    writeToFiles("float", "Fortran_REAL", "real_f", 8, H5_FORTRAN_HAS_REAL_NATIVE_8_KIND);
+#elif defined H5_FORTRAN_HAS_REAL_NATIVE_4_KIND
+    writeToFiles("float", "Fortran_REAL", "real_f", 4, H5_FORTRAN_HAS_REAL_NATIVE_4_KIND);
+#else
+    /* Error: couldn't find a size for real_f */
+    return -1;
+#endif
 
   /* double_f */
-  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");
-#ifdef H5_HAVE_FLOAT128
-    /* Don't select a higher precision than Fortran can support */
-  else if(sizeof(__float128) == H5_FORTRAN_NATIVE_DOUBLE_SIZEOF && H5_PAC_FC_MAX_REAL_PRECISION > 28) {
-      writeToFilesChr("float","Fortran_DOUBLE", "double_f", H5_FORTRAN_NATIVE_DOUBLE_KIND, "C_FLOAT128");
+#if defined H5_FORTRAN_HAS_DOUBLE_NATIVE_16_KIND
+    if(H5_C_HAS_REAL_NATIVE_16 != 0) { /* Check if C has 16 byte floats */
+      writeToFiles("float", "Fortran_DOUBLE", "double_f", 16, H5_FORTRAN_HAS_DOUBLE_NATIVE_16_KIND);
+    } else {
+#if defined H5_FORTRAN_HAS_REAL_NATIVE_8_KIND /* Fall back to 8 byte floats */
+    writeToFiles("float", "Fortran_DOUBLE", "double_f", 8, H5_FORTRAN_HAS_REAL_NATIVE_8_KIND);
+    }
+#elif defined H5_FORTRAN_HAS_REAL_NATIVE_4_KIND  /* Fall back to 4 byte floats */
+    writeToFiles("float", "Fortran_DOUBLE", "double_f", 4, H5_FORTRAN_HAS_REAL_NATIVE_4_KIND);
     }
 #else
-  else if(sizeof(long double) == H5_FORTRAN_NATIVE_DOUBLE_SIZEOF && H5_PAC_FC_MAX_REAL_PRECISION > 28) {
-      writeToFilesChr("float","Fortran_DOUBLE", "double_f", H5_FORTRAN_NATIVE_DOUBLE_KIND, "C_FLOAT128");
+    /* Error: couldn't find a size for double_f when fortran has 16 byte reals */
+    return -1;
     }
 #endif
-  else {
-    /* Error: couldn't find a size for double_f */
-    printf("Error: couldn't find a size for double_f \n");
+
+#elif defined H5_FORTRAN_HAS_DOUBLE_NATIVE_8_KIND
+    writeToFiles("float", "Fortran_DOUBLE", "double_f", 8, H5_FORTRAN_HAS_DOUBLE_NATIVE_8_KIND);
+#else
+    /* Error: couldn't find a size for real_f */
     return -1;
-  }
+#endif
 
   /* Need the buffer size for the fortran derive type 'hdset_reg_ref_t_f03'
    * in order to be interoperable with C's structure, the C buffer size
@@ -461,12 +574,12 @@ int main(void)
     
     fprintf(fort_header, "        INTEGER, PARAMETER :: H5R_DSET_REG_REF_BUF_SIZE_F = %u\n", H5_SIZEOF_HADDR_T + 4 );
 
+
   /* Close files */
   endCfile();
   endFfile();
   fclose(c_header);
   fclose(fort_header);
-
   return 0;
 }