summaryrefslogtreecommitdiffstats
path: root/fortran/src/H5match_types.c
diff options
context:
space:
mode:
Diffstat (limited to 'fortran/src/H5match_types.c')
-rw-r--r--fortran/src/H5match_types.c202
1 files changed, 103 insertions, 99 deletions
diff --git a/fortran/src/H5match_types.c b/fortran/src/H5match_types.c
index 3fa0efc..c4b7f73 100644
--- a/fortran/src/H5match_types.c
+++ b/fortran/src/H5match_types.c
@@ -48,11 +48,9 @@ FILE * fort_header;
#define FFILE "H5fortran_types.f90"
/* Prototypes for the write routines */
-void writeTypedef(const char* c_type, unsigned int size);
-void writeFloatTypedef(const char* c_type, unsigned int size);
-void writeTypedefDefault(unsigned int size);
-void writeToFiles(const char* fortran_type, const char* c_type, int size, unsigned int kind);
-void writeFloatToFiles(const char* fortran_type, const char* c_type, int size, unsigned int 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)
@@ -121,38 +119,23 @@ endFfile(void)
}
/* Define a c_int_x type in the C header */
-void writeTypedef(const char* c_type, unsigned int size)
+void writeTypedef(const char* c_typedef, const char* c_type, unsigned int size)
{
- fprintf(c_header, "#define c_int_%u %s\n", size, c_type);
-}
-
-/* Define a c_float_x type in the C header */
-void writeFloatTypedef(const char* c_type, unsigned int size)
-{
- fprintf(c_header, "#define c_float_%u %s\n", size, c_type);
+ 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(unsigned int size)
+void writeTypedefDefault(const char* c_typedef, unsigned int size)
{
assert(size %2 == 0);
-
- fprintf(c_header, "typedef struct {c_int_%u a; c_int_%u b;} c_int_%u\n", size / 2, size / 2, 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* 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_int_%d %s;\n", size, c_type);
-}
-
-/* Create matching Fortran and C floating types by writing to both files */
-void writeFloatToFiles(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, unsigned int kind)
{
fprintf(fort_header, " INTEGER, PARAMETER :: %s = %u\n", fortran_type, kind);
-
- fprintf(c_header, "typedef c_float_%d %s;\n", size, c_type);
+ fprintf(c_header, "typedef c_%s_%d %s;\n", c_typedef, size, c_type);
}
int main(void)
@@ -180,68 +163,89 @@ int main(void)
#if defined H5_FORTRAN_HAS_INTEGER_1_KIND
if(sizeof(long long) == 1)
- writeTypedef("long long", 1);
+ writeTypedef("int", "long long", 1);
else if(sizeof(long) == 1)
- writeTypedef("long", 1);
+ writeTypedef("int", "long", 1);
else if(sizeof(int) == 1)
- writeTypedef("int", 1);
+ writeTypedef("int", "int", 1);
else if(sizeof(short) == 1)
- writeTypedef("short", 1);
+ writeTypedef("int", "short", 1);
else
- writeTypedef("char", 1);
+ 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("long long", 2);
+ writeTypedef("int", "long long", 2);
else if(sizeof(long) == 2)
- writeTypedef("long", 2);
+ writeTypedef("int", "long", 2);
else if(sizeof(int) == 2)
- writeTypedef("int", 2);
+ writeTypedef("int", "int", 2);
else if(sizeof(short) == 2)
- writeTypedef("short", 2);
+ writeTypedef("int", "short", 2);
else
- writeTypedefDefault(2);
+ 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("long long", 4);
+ writeTypedef("int", "long long", 4);
else if(sizeof(long) == 4)
- writeTypedef("long", 4);
+ writeTypedef("int", "long", 4);
else if(sizeof(int) == 4)
- writeTypedef("int", 4);
+ writeTypedef("int", "int", 4);
else if(sizeof(short) == 4)
- writeTypedef("short", 4);
+ writeTypedef("int", "short", 4);
else
- writeTypedefDefault(4);
+ 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("long long", 8);
+ writeTypedef("int", "long long", 8);
else if(sizeof(long) == 8)
- writeTypedef("long", 8);
+ writeTypedef("int", "long", 8);
else if(sizeof(int) == 8)
- writeTypedef("int", 8);
+ writeTypedef("int", "int", 8);
else if(sizeof(short) == 8)
- writeTypedef("short", 8);
+ writeTypedef("int", "short", 8);
else
- writeTypedefDefault(8);
+ 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)
- writeFloatTypedef("long double", 4);
+ writeTypedef("float", "long double", 4);
else if(sizeof(double) == 4)
- writeFloatTypedef("double", 4);
+ writeTypedef("float", "double", 4);
else if(sizeof(float) == 4)
- writeFloatTypedef("float", 4);
+ writeTypedef("float", "float", 4);
else
{ printf("Fortran REAL is 4 bytes, no corresponding C floating type\n");
printf("Quitting....\n");
@@ -251,11 +255,11 @@ int main(void)
#if defined H5_FORTRAN_HAS_REAL_NATIVE_8_KIND || defined H5_FORTRAN_HAS_REAL_8_KIND
if(sizeof(long double) == 8)
- writeFloatTypedef("long double", 8);
+ writeTypedef("float", "long double", 8);
else if(sizeof(double) == 8)
- writeFloatTypedef("double", 8);
+ writeTypedef("float", "double", 8);
else if(sizeof(float) == 8)
- writeFloatTypedef("float", 8);
+ writeTypedef("float", "float", 8);
else
{ printf("Fortran REAL is 16 bytes, no corresponding C floating type\n");
printf("Quitting....\n");
@@ -265,11 +269,11 @@ int main(void)
#if defined H5_FORTRAN_HAS_REAL_NATIVE_16_KIND || defined H5_FORTRAN_HAS_REAL_16_KIND
if(sizeof(long double) == 16)
- writeFloatTypedef("long double", 16);
+ writeTypedef("float", "long double", 16);
else if(sizeof(double) == 16)
- writeFloatTypedef("double", 16);
+ writeTypedef("float", "double", 16);
else if(sizeof(float) == 16)
- writeFloatTypedef("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");
@@ -281,13 +285,13 @@ int main(void)
fprintf(c_header, "\n");
/* haddr_t */
#if defined H5_FORTRAN_HAS_INTEGER_8_KIND && H5_SIZEOF_HADDR_T >= 8
- writeToFiles("HADDR_T", "haddr_t_f", 8, H5_FORTRAN_HAS_INTEGER_8_KIND);
+ 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("HADDR_T", "haddr_t_f", 4, H5_FORTRAN_HAS_INTEGER_4_KIND);
+ 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("HADDR_T", "haddr_t_f", 2, H5_FORTRAN_HAS_INTEGER_2_KIND);
+ 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("HADDR_T", "haddr_t_f", 1, H5_FORTRAN_HAS_INTEGER_1_KIND);
+ 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;
@@ -295,13 +299,13 @@ int main(void)
/* hsize_t */
#if defined H5_FORTRAN_HAS_INTEGER_8_KIND && H5_SIZEOF_HSIZE_T >= 8
- writeToFiles("HSIZE_T", "hsize_t_f", 8, H5_FORTRAN_HAS_INTEGER_8_KIND);
+ 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_f", 4, H5_FORTRAN_HAS_INTEGER_4_KIND);
+ 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_f", 2, H5_FORTRAN_HAS_INTEGER_2_KIND);
+ 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_f", 1, H5_FORTRAN_HAS_INTEGER_1_KIND);
+ 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;
@@ -309,13 +313,13 @@ int main(void)
/* hssize_t */
#if defined H5_FORTRAN_HAS_INTEGER_8_KIND && H5_SIZEOF_HSSIZE_T >= 8
- writeToFiles("HSSIZE_T", "hssize_t_f", 8, H5_FORTRAN_HAS_INTEGER_8_KIND);
+ 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("HSSIZE_T", "hssize_t_f", 4, H5_FORTRAN_HAS_INTEGER_4_KIND);
+ 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("HSSIZE_T", "hssize_t_f", 2, H5_FORTRAN_HAS_INTEGER_2_KIND);
+ 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("HSSIZE_T", "hssize_t_f", 1, H5_FORTRAN_HAS_INTEGER_1_KIND);
+ 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;
@@ -323,13 +327,13 @@ int main(void)
/* off_t */
#if defined H5_FORTRAN_HAS_INTEGER_8_KIND && H5_SIZEOF_OFF_T >= 8
- writeToFiles("OFF_T", "off_t_f", 8, H5_FORTRAN_HAS_INTEGER_8_KIND);
+ 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("OFF_T", "off_t_f", 4, H5_FORTRAN_HAS_INTEGER_4_KIND);
+ 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("OFF_T", "off_t_f", 2, H5_FORTRAN_HAS_INTEGER_2_KIND);
+ 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("OFF_T", "off_t_f", 1, H5_FORTRAN_HAS_INTEGER_1_KIND);
+ 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;
@@ -337,13 +341,13 @@ int main(void)
/* size_t */
#if defined H5_FORTRAN_HAS_INTEGER_8_KIND && H5_SIZEOF_SIZE_T >= 8
- writeToFiles("SIZE_T", "size_t_f", 8, H5_FORTRAN_HAS_INTEGER_8_KIND);
+ 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_f", 4, H5_FORTRAN_HAS_INTEGER_4_KIND);
+ 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_f", 2, H5_FORTRAN_HAS_INTEGER_2_KIND);
+ 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_f", 1, H5_FORTRAN_HAS_INTEGER_1_KIND);
+ 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;
@@ -351,13 +355,13 @@ int main(void)
/* int */
#if defined H5_FORTRAN_HAS_NATIVE_8_KIND
- writeToFiles("Fortran_INTEGER", "int_f", 8, 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("Fortran_INTEGER", "int_f", 4, 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("Fortran_INTEGER", "int_f", 2, 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("Fortran_INTEGER", "int_f", 1, 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;
@@ -397,7 +401,7 @@ int main(void)
{
sprintf(chrA, "Fortran_INTEGER_%d", FoundIntSize[i]);
sprintf(chrB, "int_%d_f", FoundIntSize[i]);
- writeToFiles(chrA, chrB, FoundIntSize[i], FoundIntSizeKind[i]);
+ writeToFiles("int",chrA, chrB, FoundIntSize[i], FoundIntSizeKind[i]);
}
else /* Did not find the integer type */
{
@@ -408,7 +412,7 @@ int main(void)
{
sprintf(chrA, "Fortran_INTEGER_%d", (-1)*FoundIntSize[i]);
sprintf(chrB, "int_%d_f", (-1)*FoundIntSize[i]);
- writeToFiles(chrA, chrB, FoundIntSize[j], FoundIntSizeKind[j]);
+ writeToFiles("int",chrA, chrB, FoundIntSize[j], FoundIntSizeKind[j]);
flag = 1;
break;
}
@@ -421,7 +425,7 @@ int main(void)
{
sprintf(chrA, "Fortran_INTEGER_%d", (-1)*FoundIntSize[i]);
sprintf(chrB, "int_%d_f", (-1)*FoundIntSize[i]);
- writeToFiles(chrA, chrB, FoundIntSize[j], FoundIntSizeKind[j]);
+ writeToFiles("int",chrA, chrB, FoundIntSize[j], FoundIntSizeKind[j]);
flag = 1;
break;
}
@@ -464,7 +468,7 @@ int main(void)
{
sprintf(chrA, "Fortran_REAL_%d", FoundRealSize[i]);
sprintf(chrB, "real_%d_f", FoundRealSize[i]);
- writeFloatToFiles(chrA, chrB, FoundRealSize[i], FoundRealSizeKind[i]);
+ writeToFiles("float",chrA, chrB, FoundRealSize[i], FoundRealSizeKind[i]);
}
else /* Did not find the real type */
{
@@ -476,11 +480,11 @@ int main(void)
sprintf(chrA, "Fortran_REAL_%d", (-1)*FoundRealSize[i]);
sprintf(chrB, "real_%d_f", (-1)*FoundRealSize[i]);
if(FoundRealSize[j]>4) {
- writeFloatToFiles(chrA, chrB, FoundRealSize[j], FoundRealSizeKind[j]);
+ writeToFiles("float",chrA, chrB, FoundRealSize[j], FoundRealSizeKind[j]);
flag = 1;
}
/* else { */
-/* writeFloatToFiles(chrA, chrB, FoundRealSize[j]); */
+/* writeToFiles("float", chrA, chrB, FoundRealSize[j]); */
/* } */
flag = 1;
break;
@@ -495,9 +499,9 @@ int main(void)
sprintf(chrA, "Fortran_REAL_%d", (-1)*FoundRealSize[i]);
sprintf(chrB, "real_%d_f", (-1)*FoundRealSize[i]);
if(FoundRealSize[j]>4)
- writeFloatToFiles(chrA, chrB, FoundRealSize[j], FoundRealSizeKind[j]);
+ writeToFiles("float",chrA, chrB, FoundRealSize[j], FoundRealSizeKind[j]);
/* else { */
-/* writeFloatToFiles(chrA, chrB, FoundRealSize[j]); */
+/* writeToFiles("float", chrA, chrB, FoundRealSize[j]); */
/* } */
flag = 1;
break;
@@ -511,15 +515,15 @@ int main(void)
/* hid_t */
#if defined H5_FORTRAN_HAS_INTEGER_8_KIND && H5_SIZEOF_HID_T >= 8
- writeToFiles("HID_T", "hid_t_f", 8, H5_FORTRAN_HAS_INTEGER_8_KIND);
+ 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("HID_T", "hid_t_f", 4, H5_FORTRAN_HAS_INTEGER_4_KIND);
+ 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("HID_T", "hid_t_f", 2, H5_FORTRAN_HAS_INTEGER_2_KIND);
+ 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("HID_T", "hid_t_f", 1, H5_FORTRAN_HAS_INTEGER_1_KIND);
+ 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("HID_T", "hid_t_f", 8, H5_FORTRAN_HAS_INTEGER_8_KIND);
+ 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;
@@ -528,12 +532,12 @@ int main(void)
/* real_f */
#if defined H5_FORTRAN_HAS_REAL_NATIVE_16_KIND
if(H5_C_HAS_REAL_NATIVE_16 != 0) {
- writeFloatToFiles("Fortran_REAL", "real_f", 16, H5_FORTRAN_HAS_REAL_NATIVE_16_KIND);
+ writeToFiles("float","Fortran_REAL", "real_f", 16, H5_FORTRAN_HAS_REAL_NATIVE_16_KIND);
}
#elif defined H5_FORTRAN_HAS_REAL_NATIVE_8_KIND
- writeFloatToFiles("Fortran_REAL", "real_f", 8, 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
- writeFloatToFiles("Fortran_REAL", "real_f", 4, 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;
@@ -542,13 +546,13 @@ int main(void)
/* 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 */
- writeFloatToFiles("Fortran_DOUBLE", "double_f", 16, H5_FORTRAN_HAS_DOUBLE_NATIVE_16_KIND);
+ 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 */
- writeFloatToFiles("Fortran_DOUBLE", "double_f", 8, H5_FORTRAN_HAS_REAL_NATIVE_8_KIND);
+ 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 */
- writeFloatToFiles("Fortran_DOUBLE", "double_f", 4, H5_FORTRAN_HAS_REAL_NATIVE_4_KIND);
+ writeToFiles("float", "Fortran_DOUBLE", "double_f", 4, H5_FORTRAN_HAS_REAL_NATIVE_4_KIND);
}
#else
/* Error: couldn't find a size for double_f when fortran has 16 byte reals */
@@ -557,7 +561,7 @@ int main(void)
#endif
#elif defined H5_FORTRAN_HAS_DOUBLE_NATIVE_8_KIND
- writeFloatToFiles("Fortran_DOUBLE", "double_f", 8, 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;
generated by cgit v0.12 at 2024-07-05 03:59:38 (GMT)