Added fortran wrappers for most of the table API routines.

git-svn-id: http://svn.cactuscode.org/flesh/trunk@3092 17b73243-c579-4c4c-a9d2-2d5706c11dac

1 files changed, 927 insertions, 7 deletions

diff --git a/src/util/Table.c b/src/util/Table.c
index 7f9f863f..d2285abe 100644
--- a/src/util/Table.c
+++ b/src/util/Table.c
@@ -278,13 +278,6 @@ void **ip_array = NULL;
 
 #define min(x,y)        ((x < y) ? (x) : (y))
 
-/******************************************************************************/
-/***** Prototypes for Fortran Wrappers ****************************************/
-/******************************************************************************/
-void CCTK_FCALL CCTK_FNAME (Util_TableCreateFromString)
-                           (int *retval, ONE_FORTSTRING_ARG);
-void CCTK_FCALL CCTK_FNAME (Util_TableDestroy)
-                           (int *retval, const int *handle);
 
 /******************************************************************************/
 /***** Prototypes for Functions Private to This File **************************/
@@ -541,6 +534,14 @@ int Util_TableCreate(int flags)
     }
 }
 
+void CCTK_FCALL CCTK_FNAME (Util_TableCreate)
+                           (int *retval, const int *flags);
+void CCTK_FCALL CCTK_FNAME (Util_TableCreate)
+                           (int *retval, const int *flags)
+{
+  *retval = Util_TableCreate (*flags);
+}
+
 /******************************************************************************/
 
 /*@@
@@ -613,6 +614,14 @@ int Util_TableClone(int handle)
     }
 }
 
+void CCTK_FCALL CCTK_FNAME (Util_TableClone)
+                           (int *retval, const int *handle);
+void CCTK_FCALL CCTK_FNAME (Util_TableClone)
+                           (int *retval, const int *handle)
+{
+  *retval = Util_TableClone (*handle);
+}
+
 /******************************************************************************/
 
 /*@@
@@ -660,6 +669,8 @@ int Util_TableDestroy(int handle)
 }
 
 void CCTK_FCALL CCTK_FNAME (Util_TableDestroy)
+                           (int *retval, const int *handle);
+void CCTK_FCALL CCTK_FNAME (Util_TableDestroy)
                            (int *retval, const int *handle)
 {
   *retval = Util_TableDestroy (*handle);
@@ -696,6 +707,14 @@ int Util_TableQueryFlags(int handle)
   return thp->flags;
 }
 
+void CCTK_FCALL CCTK_FNAME (Util_TableQueryFlags)
+                           (int *retval, const int *handle);
+void CCTK_FCALL CCTK_FNAME (Util_TableQueryFlags)
+                           (int *retval, const int *handle)
+{
+  *retval = Util_TableQueryFlags (*handle);
+}
+
 /******************************************************************************/
 
 /*@@
@@ -737,6 +756,14 @@ int Util_TableQueryNKeys(int handle)
     }
 }
 
+void CCTK_FCALL CCTK_FNAME (Util_TableQueryNKeys)
+                           (int *retval, const int *handle);
+void CCTK_FCALL CCTK_FNAME (Util_TableQueryNKeys)
+                           (int *retval, const int *handle)
+{
+  *retval = Util_TableQueryNKeys (*handle);
+}
+
 /******************************************************************************/
 
 /*@@
@@ -781,6 +808,14 @@ int Util_TableQueryMaxKeyLength(int handle)
     }
 }
 
+void CCTK_FCALL CCTK_FNAME (Util_TableQueryMaxKeyLength)
+                           (int *retval, const int *handle);
+void CCTK_FCALL CCTK_FNAME (Util_TableQueryMaxKeyLength)
+                           (int *retval, const int *handle)
+{
+  *retval = Util_TableQueryMaxKeyLength (*handle);
+}
+
 /******************************************************************************/
 
 /*@@
@@ -873,6 +908,20 @@ int Util_TableQueryValueInfo(int handle,
     }
 }
 
+void CCTK_FCALL CCTK_FNAME (Util_TableQueryValueInfo)
+                           (int *retval, const int *handle,
+                            CCTK_INT *type_code, CCTK_INT *N_elements,
+                            ONE_FORTSTRING_ARG);
+void CCTK_FCALL CCTK_FNAME (Util_TableQueryValueInfo)
+                           (int *retval, const int *handle,
+                            CCTK_INT *type_code, CCTK_INT *N_elements,
+                            ONE_FORTSTRING_ARG)
+{
+  ONE_FORTSTRING_CREATE (key)
+  *retval = Util_TableQueryValueInfo (*handle, type_code, N_elements, key);
+  free (key);
+}
+
 /******************************************************************************/
 
 /*@@
@@ -920,6 +969,16 @@ int Util_TableDeleteKey(int handle, const char *key)
   return delete_table_entry_by_key(thp, key);
 }
 
+void CCTK_FCALL CCTK_FNAME (Util_TableDeleteKey)
+                           (int *retval, const int *handle, ONE_FORTSTRING_ARG);
+void CCTK_FCALL CCTK_FNAME (Util_TableDeleteKey)
+                           (int *retval, const int *handle, ONE_FORTSTRING_ARG)
+{
+  ONE_FORTSTRING_CREATE (key)
+  *retval = Util_TableDeleteKey (*handle, key);
+  free (key);
+}
+
 /******************************************************************************/
 
 /*@@
@@ -974,6 +1033,8 @@ int Util_TableCreateFromString(const char string[])
 }
 
 void CCTK_FCALL CCTK_FNAME (Util_TableCreateFromString)
+                           (int *retval, ONE_FORTSTRING_ARG);
+void CCTK_FCALL CCTK_FNAME (Util_TableCreateFromString)
                            (int *retval, ONE_FORTSTRING_ARG)
 {
   ONE_FORTSTRING_CREATE (string)
@@ -1363,6 +1424,16 @@ int Util_TableSetFromString(int handle, const char string[])
     }
 }
 
+void CCTK_FCALL CCTK_FNAME (Util_TableSetFromString)
+                           (int *retval, const int *handle, ONE_FORTSTRING_ARG);
+void CCTK_FCALL CCTK_FNAME (Util_TableSetFromString)
+                           (int *retval, const int *handle, ONE_FORTSTRING_ARG)
+{
+  ONE_FORTSTRING_CREATE (string)
+  *retval = Util_TableSetFromString (*handle, string);
+  free (string);
+}
+
 /******************************************************************************/
 
 /*@@
@@ -1424,6 +1495,16 @@ int Util_TableSetString(int handle,
                       key);
 }
 
+void CCTK_FCALL CCTK_FNAME (Util_TableSetString)
+                           (int *retval, const int *handle, TWO_FORTSTRING_ARG);
+void CCTK_FCALL CCTK_FNAME (Util_TableSetString)
+                           (int *retval, const int *handle, TWO_FORTSTRING_ARG)
+{
+  TWO_FORTSTRING_CREATE (string, key)
+  *retval = Util_TableSetString (*handle, string, key);
+  free (string); free (key);
+}
+
 /******************************************************************************/
 
 /*@@
@@ -1524,6 +1605,7 @@ int Util_TableGetString(int handle,
          ? UTIL_ERROR_TABLE_STRING_TRUNCATED
          : string_length;
 }
+/*** FIXME: no fortran wrapper yet ***/
 
 /******************************************************************************/
 
@@ -1579,6 +1661,20 @@ int Util_TableSetGeneric(int handle,
   return Util_TableSetGenericArray(handle, type_code, 1, value_ptr, key);
 }
 
+void CCTK_FCALL CCTK_FNAME (Util_TableSetGeneric)
+                           (int *retval, const int *handle,
+                            const int *type_code, const CCTK_POINTER *value,
+                            ONE_FORTSTRING_ARG);
+void CCTK_FCALL CCTK_FNAME (Util_TableSetGeneric)
+                           (int *retval, const int *handle,
+                            const int *type_code, const CCTK_POINTER *value,
+                            ONE_FORTSTRING_ARG)
+{
+  ONE_FORTSTRING_CREATE (key)
+  *retval = Util_TableSetGeneric (*handle, *type_code, value, key);
+  free (key);
+}
+
 /******************************************************************************/
 
 /*@@
@@ -1642,6 +1738,21 @@ int Util_TableSetGenericArray(int handle,
                       key);
 }
 
+void CCTK_FCALL CCTK_FNAME (Util_TableSetGenericArray)
+                           (int *retval, const int *handle,
+                            const int *type_code, const int *N_elements,
+                            const CCTK_POINTER array[], ONE_FORTSTRING_ARG);
+void CCTK_FCALL CCTK_FNAME (Util_TableSetGenericArray)
+                           (int *retval, const int *handle,
+                            const int *type_code, const int *N_elements,
+                            const CCTK_POINTER array[], ONE_FORTSTRING_ARG)
+{
+  ONE_FORTSTRING_CREATE (key)
+  *retval = Util_TableSetGenericArray (*handle, *type_code, *N_elements,
+                                       array, key);
+  free (key);
+}
+
 /******************************************************************************/
 
 /*@@
@@ -1716,6 +1827,20 @@ int Util_TableGetGeneric(int handle,
          : status;
 }
 
+void CCTK_FCALL CCTK_FNAME (Util_TableGetGeneric)
+                           (int *retval, const int *handle,
+                            const int *type_code, CCTK_POINTER *value,
+                            ONE_FORTSTRING_ARG);
+void CCTK_FCALL CCTK_FNAME (Util_TableGetGeneric)
+                           (int *retval, const int *handle,
+                            const int *type_code, CCTK_POINTER *value,
+                            ONE_FORTSTRING_ARG)
+{
+  ONE_FORTSTRING_CREATE (key)
+  *retval = Util_TableGetGeneric (*handle, *type_code, value, key);
+  free (key);
+}
+
 /******************************************************************************/
 
 /*@@
@@ -1798,6 +1923,21 @@ int Util_TableGetGenericArray(int handle,
                       key);
 }
 
+void CCTK_FCALL CCTK_FNAME (Util_TableGetGenericArray)
+                           (int *retval, const int *handle,
+                            const int *type_code, const int *N_elements,
+                            CCTK_POINTER array[], ONE_FORTSTRING_ARG);
+void CCTK_FCALL CCTK_FNAME (Util_TableGetGenericArray)
+                           (int *retval, const int *handle,
+                            const int *type_code, const int *N_elements,
+                            CCTK_POINTER array[], ONE_FORTSTRING_ARG)
+{
+  ONE_FORTSTRING_CREATE (key)
+  *retval = Util_TableGetGenericArray (*handle, *type_code, *N_elements,
+                                       array, key);
+  free (key);
+}
+
 /******************************************************************************/
 
 /*@@
@@ -1857,11 +1997,35 @@ int Util_TableSetPointer(int handle, CCTK_POINTER value, const char *key)
   return Util_TableSetPointerArray(handle, 1, &value, key);
 }
 
+void CCTK_FCALL CCTK_FNAME (Util_TableSetPointer)
+                           (int *retval, const int *handle,
+                            const CCTK_POINTER *value, ONE_FORTSTRING_ARG);
+void CCTK_FCALL CCTK_FNAME (Util_TableSetPointer)
+                           (int *retval, const int *handle, const CCTK_POINTER *value,
+                            ONE_FORTSTRING_ARG)
+{
+  ONE_FORTSTRING_CREATE (key)
+  *retval = Util_TableSetPointer (*handle, *value, key);
+  free (key);
+}
+
 int Util_TableSetFnPointer(int handle, CCTK_FPOINTER value, const char *key)
 {
   return Util_TableSetFnPointerArray(handle, 1, &value, key);
 }
 
+void CCTK_FCALL CCTK_FNAME (Util_TableSetFnPointer)
+                           (int *retval, const int *handle,
+                            const CCTK_FPOINTER *value, ONE_FORTSTRING_ARG);
+void CCTK_FCALL CCTK_FNAME (Util_TableSetFnPointer)
+                           (int *retval, const int *handle,
+                            const CCTK_FPOINTER *value, ONE_FORTSTRING_ARG)
+{
+  ONE_FORTSTRING_CREATE (key)
+  *retval = Util_TableSetFnPointer (*handle, *value, key);
+  free (key);
+}
+
 /**************************************/
 
 /*
@@ -1873,6 +2037,18 @@ int Util_TableSetChar(int handle, CCTK_CHAR value, const char *key)
   return Util_TableSetCharArray(handle, 1, &value, key);
 }
 
+void CCTK_FCALL CCTK_FNAME (Util_TableSetChar)
+                           (int *retval, const int *handle,
+                            const CCTK_CHAR *value, ONE_FORTSTRING_ARG);
+void CCTK_FCALL CCTK_FNAME (Util_TableSetChar)
+                           (int *retval, const int *handle,
+                            const CCTK_CHAR *value, ONE_FORTSTRING_ARG)
+{
+  ONE_FORTSTRING_CREATE (key)
+  *retval = Util_TableSetChar (*handle, *value, key);
+  free (key);
+}
+
 /**************************************/
 
 /*
@@ -1884,11 +2060,35 @@ int Util_TableSetInt(int handle, CCTK_INT value, const char *key)
   return Util_TableSetIntArray(handle, 1, &value, key);
 }
 
+void CCTK_FCALL CCTK_FNAME (Util_TableSetInt)
+                           (int *retval, const int *handle,
+                            const CCTK_INT *value, ONE_FORTSTRING_ARG);
+void CCTK_FCALL CCTK_FNAME (Util_TableSetInt)
+                           (int *retval, const int *handle,
+                            const CCTK_INT *value, ONE_FORTSTRING_ARG)
+{
+  ONE_FORTSTRING_CREATE (key)
+  *retval = Util_TableSetInt (*handle, *value, key);
+  free (key);
+}
+
 #ifdef CCTK_INTEGER_PRECISION_2
 int Util_TableSetInt2(int handle, CCTK_INT2 value, const char *key)
 {
   return Util_TableSetInt2Array(handle, 1, &value, key);
 }
+
+void CCTK_FCALL CCTK_FNAME (Util_TableSetInt2)
+                           (int *retval, const int *handle,
+                            const CCTK_INT2 *value, ONE_FORTSTRING_ARG);
+void CCTK_FCALL CCTK_FNAME (Util_TableSetInt2)
+                           (int *retval, const int *handle,
+                            const CCTK_INT2 *value, ONE_FORTSTRING_ARG)
+{
+  ONE_FORTSTRING_CREATE (key)
+  *retval = Util_TableSetInt2 (*handle, *value, key);
+  free (key);
+}
 #endif
 
 #ifdef CCTK_INTEGER_PRECISION_4
@@ -1896,6 +2096,18 @@ int Util_TableSetInt4(int handle, CCTK_INT4 value, const char *key)
 {
   return Util_TableSetInt4Array(handle, 1, &value, key);
 }
+
+void CCTK_FCALL CCTK_FNAME (Util_TableSetInt4)
+                           (int *retval, const int *handle,
+                            const CCTK_INT4 *value, ONE_FORTSTRING_ARG);
+void CCTK_FCALL CCTK_FNAME (Util_TableSetInt4)
+                           (int *retval, const int *handle,
+                            const CCTK_INT4 *value, ONE_FORTSTRING_ARG)
+{
+  ONE_FORTSTRING_CREATE (key)
+  *retval = Util_TableSetInt4 (*handle, *value, key);
+  free (key);
+}
 #endif
 
 #ifdef CCTK_INTEGER_PRECISION_8
@@ -1903,6 +2115,18 @@ int Util_TableSetInt8(int handle, CCTK_INT8 value, const char *key)
 {
   return Util_TableSetInt8Array(handle, 1, &value, key);
 }
+
+void CCTK_FCALL CCTK_FNAME (Util_TableSetInt8)
+                           (int *retval, const int *handle,
+                            const CCTK_INT8 *value, ONE_FORTSTRING_ARG);
+void CCTK_FCALL CCTK_FNAME (Util_TableSetInt8)
+                           (int *retval, const int *handle,
+                            const CCTK_INT8 *value, ONE_FORTSTRING_ARG)
+{
+  ONE_FORTSTRING_CREATE (key)
+  *retval = Util_TableSetInt8 (*handle, *value, key);
+  free (key);
+}
 #endif
 
 /**************************************/
@@ -1916,11 +2140,35 @@ int Util_TableSetReal(int handle, CCTK_REAL value, const char *key)
   return Util_TableSetRealArray(handle, 1, &value, key);
 }
 
+void CCTK_FCALL CCTK_FNAME (Util_TableSetReal)
+                           (int *retval, const int *handle,
+                            const CCTK_REAL *value, ONE_FORTSTRING_ARG);
+void CCTK_FCALL CCTK_FNAME (Util_TableSetReal)
+                           (int *retval, const int *handle,
+                            const CCTK_REAL *value, ONE_FORTSTRING_ARG)
+{
+  ONE_FORTSTRING_CREATE (key)
+  *retval = Util_TableSetReal (*handle, *value, key);
+  free (key);
+}
+
 #ifdef CCTK_REAL_PRECISION_4
 int Util_TableSetReal4(int handle, CCTK_REAL4 value, const char *key)
 {
   return Util_TableSetReal4Array(handle, 1, &value, key);
 }
+
+void CCTK_FCALL CCTK_FNAME (Util_TableSetReal4)
+                           (int *retval, const int *handle,
+                            const CCTK_REAL4 *value, ONE_FORTSTRING_ARG);
+void CCTK_FCALL CCTK_FNAME (Util_TableSetReal4)
+                           (int *retval, const int *handle,
+                            const CCTK_REAL4 *value, ONE_FORTSTRING_ARG)
+{
+  ONE_FORTSTRING_CREATE (key)
+  *retval = Util_TableSetReal4 (*handle, *value, key);
+  free (key);
+}
 #endif
 
 #ifdef CCTK_REAL_PRECISION_8
@@ -1928,6 +2176,18 @@ int Util_TableSetReal8(int handle, CCTK_REAL8 value, const char *key)
 {
   return Util_TableSetReal8Array(handle, 1, &value, key);
 }
+
+void CCTK_FCALL CCTK_FNAME (Util_TableSetReal8)
+                           (int *retval, const int *handle,
+                            const CCTK_REAL8 *value, ONE_FORTSTRING_ARG);
+void CCTK_FCALL CCTK_FNAME (Util_TableSetReal8)
+                           (int *retval, const int *handle,
+                            const CCTK_REAL8 *value, ONE_FORTSTRING_ARG)
+{
+  ONE_FORTSTRING_CREATE (key)
+  *retval = Util_TableSetReal8 (*handle, *value, key);
+  free (key);
+}
 #endif
 
 #ifdef CCTK_REAL_PRECISION_16
@@ -1935,6 +2195,18 @@ int Util_TableSetReal16(int handle, CCTK_REAL16 value, const char *key)
 {
   return Util_TableSetReal16Array(handle, 1, &value, key);
 }
+
+void CCTK_FCALL CCTK_FNAME (Util_TableSetReal16)
+                           (int *retval, const int *handle,
+                            const CCTK_REAL16 *value, ONE_FORTSTRING_ARG);
+void CCTK_FCALL CCTK_FNAME (Util_TableSetReal16)
+                           (int *retval, const int *handle,
+                            const CCTK_REAL16 *value, ONE_FORTSTRING_ARG)
+{
+  ONE_FORTSTRING_CREATE (key)
+  *retval = Util_TableSetReal16 (*handle, *value, key);
+  free (key);
+}
 #endif
 
 /**************************************/
@@ -1948,11 +2220,35 @@ int Util_TableSetComplex(int handle, CCTK_COMPLEX value, const char *key)
   return Util_TableSetComplexArray(handle, 1, &value, key);
 }
 
+void CCTK_FCALL CCTK_FNAME (Util_TableSetComplex)
+                           (int *retval, const int *handle,
+                            const CCTK_COMPLEX *value, ONE_FORTSTRING_ARG);
+void CCTK_FCALL CCTK_FNAME (Util_TableSetComplex)
+                           (int *retval, const int *handle,
+                            const CCTK_COMPLEX *value, ONE_FORTSTRING_ARG)
+{
+  ONE_FORTSTRING_CREATE (key)
+  *retval = Util_TableSetComplex (*handle, *value, key);
+  free (key);
+}
+
 #ifdef CCTK_COMPLEX_PRECISION_8
 int Util_TableSetComplex8(int handle, CCTK_COMPLEX8 value, const char *key)
 {
   return Util_TableSetComplex8Array(handle, 1, &value, key);
 }
+
+void CCTK_FCALL CCTK_FNAME (Util_TableSetComplex8)
+                           (int *retval, const int *handle,
+                            const CCTK_COMPLEX8 *value, ONE_FORTSTRING_ARG);
+void CCTK_FCALL CCTK_FNAME (Util_TableSetComplex8)
+                           (int *retval, const int *handle,
+                            const CCTK_COMPLEX8 *value, ONE_FORTSTRING_ARG)
+{
+  ONE_FORTSTRING_CREATE (key)
+  *retval = Util_TableSetComplex8 (*handle, *value, key);
+  free (key);
+}
 #endif
 
 #ifdef CCTK_COMPLEX_PRECISION_16
@@ -1960,6 +2256,18 @@ int Util_TableSetComplex16(int handle, CCTK_COMPLEX16 value, const char *key)
 {
   return Util_TableSetComplex16Array(handle, 1, &value, key);
 }
+
+void CCTK_FCALL CCTK_FNAME (Util_TableSetComplex16)
+                           (int *retval, const int *handle,
+                            const CCTK_COMPLEX16 *value, ONE_FORTSTRING_ARG);
+void CCTK_FCALL CCTK_FNAME (Util_TableSetComplex16)
+                           (int *retval, const int *handle,
+                            const CCTK_COMPLEX16 *value, ONE_FORTSTRING_ARG)
+{
+  ONE_FORTSTRING_CREATE (key)
+  *retval = Util_TableSetComplex16 (*handle, *value, key);
+  free (key);
+}
 #endif
 
 #ifdef CCTK_COMPLEX_PRECISION_32
@@ -1967,6 +2275,18 @@ int Util_TableSetComplex32(int handle, CCTK_COMPLEX32 value, const char *key)
 {
   return Util_TableSetComplex32Array(handle, 1, &value, key);
 }
+
+void CCTK_FCALL CCTK_FNAME (Util_TableSetComplex32)
+                           (int *retval, const int *handle,
+                            const CCTK_COMPLEX32 *value, ONE_FORTSTRING_ARG);
+void CCTK_FCALL CCTK_FNAME (Util_TableSetComplex32)
+                           (int *retval, const int *handle,
+                            const CCTK_COMPLEX32 *value, ONE_FORTSTRING_ARG)
+{
+  ONE_FORTSTRING_CREATE (key)
+  *retval = Util_TableSetComplex32 (*handle, *value, key);
+  free (key);
+}
 #endif
 
 /******************************************************************************/
@@ -2039,6 +2359,20 @@ int Util_TableSetPointerArray(int handle,
                       key);
 }
 
+void CCTK_FCALL CCTK_FNAME (Util_TableSetPointerArray)
+                           (int *retval, const int *handle,
+                            const int *N_elements,
+                            const CCTK_POINTER array[], ONE_FORTSTRING_ARG);
+void CCTK_FCALL CCTK_FNAME (Util_TableSetPointerArray)
+                           (int *retval, const int *handle,
+                            const int *N_elements,
+                            const CCTK_POINTER array[], ONE_FORTSTRING_ARG)
+{
+  ONE_FORTSTRING_CREATE (key)
+  *retval = Util_TableSetPointerArray (*handle, *N_elements, array, key);
+  free (key);
+}
+
 int Util_TableSetFnPointerArray(int handle,
                                 int N_elements, const CCTK_FPOINTER array[],
                                 const char *key)
@@ -2049,6 +2383,20 @@ int Util_TableSetFnPointerArray(int handle,
                  key);
 }
 
+void CCTK_FCALL CCTK_FNAME (Util_TableSetFnPointerArray)
+                           (int *retval, const int *handle,
+                            const int *N_elements,
+                            const CCTK_FPOINTER array[], ONE_FORTSTRING_ARG);
+void CCTK_FCALL CCTK_FNAME (Util_TableSetFnPointerArray)
+                           (int *retval, const int *handle,
+                            const int *N_elements,
+                            const CCTK_FPOINTER array[], ONE_FORTSTRING_ARG)
+{
+  ONE_FORTSTRING_CREATE (key)
+  *retval = Util_TableSetFnPointerArray (*handle, *N_elements, array, key);
+  free (key);
+}
+
 /**************************************/
 
 /*
@@ -2064,6 +2412,20 @@ int Util_TableSetCharArray(int handle,
                       key);
 }
 
+void CCTK_FCALL CCTK_FNAME (Util_TableSetCharArray)
+                           (int *retval, const int *handle,
+                            const int *N_elements,
+                            const CCTK_CHAR array[], ONE_FORTSTRING_ARG);
+void CCTK_FCALL CCTK_FNAME (Util_TableSetCharArray)
+                           (int *retval, const int *handle,
+                            const int *N_elements,
+                            const CCTK_CHAR array[], ONE_FORTSTRING_ARG)
+{
+  ONE_FORTSTRING_CREATE (key)
+  *retval = Util_TableSetCharArray (*handle, *N_elements, array, key);
+  free (key);
+}
+
 /**************************************/
 
 /*
@@ -2079,6 +2441,20 @@ int Util_TableSetIntArray(int handle,
                       key);
 }
 
+void CCTK_FCALL CCTK_FNAME (Util_TableSetIntArray)
+                           (int *retval, const int *handle,
+                            const int *N_elements,
+                            const CCTK_INT array[], ONE_FORTSTRING_ARG);
+void CCTK_FCALL CCTK_FNAME (Util_TableSetIntArray)
+                           (int *retval, const int *handle,
+                            const int *N_elements,
+                            const CCTK_INT array[], ONE_FORTSTRING_ARG)
+{
+  ONE_FORTSTRING_CREATE (key)
+  *retval = Util_TableSetIntArray (*handle, *N_elements, array, key);
+  free (key);
+}
+
 #ifdef CCTK_INTEGER_PRECISION_2
 int Util_TableSetInt2Array(int handle,
                            int N_elements, const CCTK_INT2 array[],
@@ -2088,6 +2464,20 @@ int Util_TableSetInt2Array(int handle,
                       CCTK_VARIABLE_INT2, N_elements, (const void *) array,
                       key);
 }
+
+void CCTK_FCALL CCTK_FNAME (Util_TableSetInt2Array)
+                           (int *retval, const int *handle,
+                            const int *N_elements,
+                            const CCTK_INT2 array[], ONE_FORTSTRING_ARG);
+void CCTK_FCALL CCTK_FNAME (Util_TableSetInt2Array)
+                           (int *retval, const int *handle,
+                            const int *N_elements,
+                            const CCTK_INT2 array[], ONE_FORTSTRING_ARG)
+{
+  ONE_FORTSTRING_CREATE (key)
+  *retval = Util_TableSetInt2Array (*handle, *N_elements, array, key);
+  free (key);
+}
 #endif
 
 #ifdef CCTK_INTEGER_PRECISION_4
@@ -2099,6 +2489,20 @@ int Util_TableSetInt4Array(int handle,
                       CCTK_VARIABLE_INT4, N_elements, (const void *) array,
                       key);
 }
+
+void CCTK_FCALL CCTK_FNAME (Util_TableSetInt4Array)
+                           (int *retval, const int *handle,
+                            const int *N_elements,
+                            const CCTK_INT4 array[], ONE_FORTSTRING_ARG);
+void CCTK_FCALL CCTK_FNAME (Util_TableSetInt4Array)
+                           (int *retval, const int *handle,
+                            const int *N_elements,
+                            const CCTK_INT4 array[], ONE_FORTSTRING_ARG)
+{
+  ONE_FORTSTRING_CREATE (key)
+  *retval = Util_TableSetInt4Array (*handle, *N_elements, array, key);
+  free (key);
+}
 #endif
 
 #ifdef CCTK_INTEGER_PRECISION_8
@@ -2110,6 +2514,20 @@ int Util_TableSetInt8Array(int handle,
                       CCTK_VARIABLE_INT8, N_elements, (const void *) array,
                       key);
 }
+
+void CCTK_FCALL CCTK_FNAME (Util_TableSetInt8Array)
+                           (int *retval, const int *handle,
+                            const int *N_elements,
+                            const CCTK_INT8 array[], ONE_FORTSTRING_ARG);
+void CCTK_FCALL CCTK_FNAME (Util_TableSetInt8Array)
+                           (int *retval, const int *handle,
+                            const int *N_elements,
+                            const CCTK_INT8 array[], ONE_FORTSTRING_ARG)
+{
+  ONE_FORTSTRING_CREATE (key)
+  *retval = Util_TableSetInt8Array (*handle, *N_elements, array, key);
+  free (key);
+}
 #endif
 
 /**************************************/
@@ -2128,6 +2546,20 @@ int Util_TableSetRealArray(int handle,
                     key);
 }
 
+void CCTK_FCALL CCTK_FNAME (Util_TableSetRealArray)
+                           (int *retval, const int *handle,
+                            const int *N_elements,
+                            const CCTK_REAL array[], ONE_FORTSTRING_ARG);
+void CCTK_FCALL CCTK_FNAME (Util_TableSetRealArray)
+                           (int *retval, const int *handle,
+                            const int *N_elements,
+                            const CCTK_REAL array[], ONE_FORTSTRING_ARG)
+{
+  ONE_FORTSTRING_CREATE (key)
+  *retval = Util_TableSetRealArray (*handle, *N_elements, array, key);
+  free (key);
+}
+
 #ifdef CCTK_REAL_PRECISION_4
 int Util_TableSetReal4Array(int handle,
                             int N_elements, const CCTK_REAL4 array[],
@@ -2137,6 +2569,20 @@ int Util_TableSetReal4Array(int handle,
                       CCTK_VARIABLE_REAL4, N_elements, (const void *) array,
                       key);
 }
+
+void CCTK_FCALL CCTK_FNAME (Util_TableSetReal4Array)
+                           (int *retval, const int *handle,
+                            const int *N_elements,
+                            const CCTK_REAL4 array[], ONE_FORTSTRING_ARG);
+void CCTK_FCALL CCTK_FNAME (Util_TableSetReal4Array)
+                           (int *retval, const int *handle,
+                            const int *N_elements,
+                            const CCTK_REAL4 array[], ONE_FORTSTRING_ARG)
+{
+  ONE_FORTSTRING_CREATE (key)
+  *retval = Util_TableSetReal4Array (*handle, *N_elements, array, key);
+  free (key);
+}
 #endif
 
 #ifdef CCTK_REAL_PRECISION_8
@@ -2148,6 +2594,20 @@ int Util_TableSetReal8Array(int handle,
                       CCTK_VARIABLE_REAL8, N_elements, (const void *) array,
                       key);
 }
+
+void CCTK_FCALL CCTK_FNAME (Util_TableSetReal8Array)
+                           (int *retval, const int *handle,
+                            const int *N_elements,
+                            const CCTK_REAL8 array[], ONE_FORTSTRING_ARG);
+void CCTK_FCALL CCTK_FNAME (Util_TableSetReal8Array)
+                           (int *retval, const int *handle,
+                            const int *N_elements,
+                            const CCTK_REAL8 array[], ONE_FORTSTRING_ARG)
+{
+  ONE_FORTSTRING_CREATE (key)
+  *retval = Util_TableSetReal8Array (*handle, *N_elements, array, key);
+  free (key);
+}
 #endif
 
 #ifdef CCTK_REAL_PRECISION_16
@@ -2159,6 +2619,20 @@ int Util_TableSetReal16Array(int handle,
                       CCTK_VARIABLE_REAL16, N_elements, (const void *) array,
                       key);
 }
+
+void CCTK_FCALL CCTK_FNAME (Util_TableSetReal16Array)
+                           (int *retval, const int *handle,
+                            const int *N_elements,
+                            const CCTK_REAL16 array[], ONE_FORTSTRING_ARG);
+void CCTK_FCALL CCTK_FNAME (Util_TableSetReal16Array)
+                           (int *retval, const int *handle,
+                            const int *N_elements,
+                            const CCTK_REAL16 array[], ONE_FORTSTRING_ARG)
+{
+  ONE_FORTSTRING_CREATE (key)
+  *retval = Util_TableSetReal16Array (*handle, *N_elements, array, key);
+  free (key);
+}
 #endif
 
 /**************************************/
@@ -2176,6 +2650,20 @@ int Util_TableSetComplexArray(int handle,
                       key);
 }
 
+void CCTK_FCALL CCTK_FNAME (Util_TableSetComplexArray)
+                           (int *retval, const int *handle,
+                            const int *N_elements,
+                            const CCTK_COMPLEX array[], ONE_FORTSTRING_ARG);
+void CCTK_FCALL CCTK_FNAME (Util_TableSetComplexArray)
+                           (int *retval, const int *handle,
+                            const int *N_elements,
+                            const CCTK_COMPLEX array[], ONE_FORTSTRING_ARG)
+{
+  ONE_FORTSTRING_CREATE (key)
+  *retval = Util_TableSetComplexArray (*handle, *N_elements, array, key);
+  free (key);
+}
+
 #ifdef CCTK_COMPLEX_PRECISION_8
 int Util_TableSetComplex8Array(int handle,
                                int N_elements, const CCTK_COMPLEX8 array[],
@@ -2185,6 +2673,20 @@ int Util_TableSetComplex8Array(int handle,
                       CCTK_VARIABLE_COMPLEX8, N_elements, (const void *) array,
                       key);
 }
+
+void CCTK_FCALL CCTK_FNAME (Util_TableSetComplex8Array)
+                           (int *retval, const int *handle,
+                            const int *N_elements,
+                            const CCTK_COMPLEX8 array[], ONE_FORTSTRING_ARG);
+void CCTK_FCALL CCTK_FNAME (Util_TableSetComplex8Array)
+                           (int *retval, const int *handle,
+                            const int *N_elements,
+                            const CCTK_COMPLEX8 array[], ONE_FORTSTRING_ARG)
+{
+  ONE_FORTSTRING_CREATE (key)
+  *retval = Util_TableSetComplex8Array (*handle, *N_elements, array, key);
+  free (key);
+}
 #endif
 
 #ifdef CCTK_COMPLEX_PRECISION_16
@@ -2196,6 +2698,20 @@ int Util_TableSetComplex16Array(int handle,
                       CCTK_VARIABLE_COMPLEX16, N_elements, (const void *) array,
                       key);
 }
+
+void CCTK_FCALL CCTK_FNAME (Util_TableSetComplex16Array)
+                           (int *retval, const int *handle,
+                            const int *N_elements,
+                            const CCTK_COMPLEX16 array[], ONE_FORTSTRING_ARG);
+void CCTK_FCALL CCTK_FNAME (Util_TableSetComplex16Array)
+                           (int *retval, const int *handle,
+                            const int *N_elements,
+                            const CCTK_COMPLEX16 array[], ONE_FORTSTRING_ARG)
+{
+  ONE_FORTSTRING_CREATE (key)
+  *retval = Util_TableSetComplex16Array (*handle, *N_elements, array, key);
+  free (key);
+}
 #endif
 
 #ifdef CCTK_COMPLEX_PRECISION_32
@@ -2207,6 +2723,20 @@ int Util_TableSetComplex32Array(int handle,
                       CCTK_VARIABLE_COMPLEX32, N_elements, (const void *) array,
                       key);
 }
+
+void CCTK_FCALL CCTK_FNAME (Util_TableSetComplex32Array)
+                           (int *retval, const int *handle,
+                            const int *N_elements,
+                            const CCTK_COMPLEX32 array[], ONE_FORTSTRING_ARG);
+void CCTK_FCALL CCTK_FNAME (Util_TableSetComplex32Array)
+                           (int *retval, const int *handle,
+                            const int *N_elements,
+                            const CCTK_COMPLEX32 array[], ONE_FORTSTRING_ARG)
+{
+  ONE_FORTSTRING_CREATE (key)
+  *retval = Util_TableSetComplex32Array (*handle, *N_elements, array, key);
+  free (key);
+}
 #endif
 
 /******************************************************************************/
@@ -2283,6 +2813,18 @@ int Util_TableGetPointer(int handle, CCTK_POINTER *value, const char *key)
          : status;
 }
 
+void CCTK_FCALL CCTK_FNAME (Util_TableGetPointer)
+                           (int *retval, const int *handle,
+                            CCTK_POINTER *value, ONE_FORTSTRING_ARG);
+void CCTK_FCALL CCTK_FNAME (Util_TableGetPointer)
+                           (int *retval, const int *handle,
+                            CCTK_POINTER *value, ONE_FORTSTRING_ARG)
+{
+  ONE_FORTSTRING_CREATE (key)
+  *retval = Util_TableGetPointer (*handle, value, key);
+  free (key);
+}
+
 int Util_TableGetFnPointer(int handle, CCTK_FPOINTER *value, const char *key)
 {
   const int status = Util_TableGetFnPointerArray(handle, 1, value, key);
@@ -2291,6 +2833,18 @@ int Util_TableGetFnPointer(int handle, CCTK_FPOINTER *value, const char *key)
          : status;
 }
 
+void CCTK_FCALL CCTK_FNAME (Util_TableGetFnPointer)
+                           (int *retval, const int *handle,
+                            CCTK_FPOINTER *value, ONE_FORTSTRING_ARG);
+void CCTK_FCALL CCTK_FNAME (Util_TableGetFnPointer)
+                           (int *retval, const int *handle,
+                            CCTK_FPOINTER *value, ONE_FORTSTRING_ARG)
+{
+  ONE_FORTSTRING_CREATE (key)
+  *retval = Util_TableGetFnPointer (*handle, value, key);
+  free (key);
+}
+
 /**************************************/
 
 /* a single character */
@@ -2302,6 +2856,18 @@ int Util_TableGetChar(int handle, CCTK_CHAR *value, const char *key)
          : status;
 }
 
+void CCTK_FCALL CCTK_FNAME (Util_TableGetChar)
+                           (int *retval, const int *handle,
+                            CCTK_CHAR *value, ONE_FORTSTRING_ARG);
+void CCTK_FCALL CCTK_FNAME (Util_TableGetChar)
+                           (int *retval, const int *handle,
+                            CCTK_CHAR *value, ONE_FORTSTRING_ARG)
+{
+  ONE_FORTSTRING_CREATE (key)
+  *retval = Util_TableGetChar (*handle, value, key);
+  free (key);
+}
+
 /**************************************/
 
 /* integers */
@@ -2313,6 +2879,18 @@ int Util_TableGetInt(int handle, CCTK_INT *value, const char *key)
          : status;
 }
 
+void CCTK_FCALL CCTK_FNAME (Util_TableGetInt)
+                           (int *retval, const int *handle,
+                            CCTK_INT *value, ONE_FORTSTRING_ARG);
+void CCTK_FCALL CCTK_FNAME (Util_TableGetInt)
+                           (int *retval, const int *handle,
+                            CCTK_INT *value, ONE_FORTSTRING_ARG)
+{
+  ONE_FORTSTRING_CREATE (key)
+  *retval = Util_TableGetInt (*handle, value, key);
+  free (key);
+}
+
 #ifdef CCTK_INTEGER_PRECISION_2
 int Util_TableGetInt2(int handle, CCTK_INT2 *value, const char *key)
 {
@@ -2321,6 +2899,18 @@ int Util_TableGetInt2(int handle, CCTK_INT2 *value, const char *key)
          ? UTIL_ERROR_TABLE_VALUE_IS_EMPTY
          : status;
 }
+
+void CCTK_FCALL CCTK_FNAME (Util_TableGetInt2)
+                           (int *retval, const int *handle,
+                            CCTK_INT2 *value, ONE_FORTSTRING_ARG);
+void CCTK_FCALL CCTK_FNAME (Util_TableGetInt2)
+                           (int *retval, const int *handle,
+                            CCTK_INT2 *value, ONE_FORTSTRING_ARG)
+{
+  ONE_FORTSTRING_CREATE (key)
+  *retval = Util_TableGetInt2 (*handle, value, key);
+  free (key);
+}
 #endif
 
 #ifdef CCTK_INTEGER_PRECISION_4
@@ -2331,6 +2921,18 @@ int Util_TableGetInt4(int handle, CCTK_INT4 *value, const char *key)
          ? UTIL_ERROR_TABLE_VALUE_IS_EMPTY
          : status;
 }
+
+void CCTK_FCALL CCTK_FNAME (Util_TableGetInt4)
+                           (int *retval, const int *handle,
+                            CCTK_INT4 *value, ONE_FORTSTRING_ARG);
+void CCTK_FCALL CCTK_FNAME (Util_TableGetInt4)
+                           (int *retval, const int *handle,
+                            CCTK_INT4 *value, ONE_FORTSTRING_ARG)
+{
+  ONE_FORTSTRING_CREATE (key)
+  *retval = Util_TableGetInt4 (*handle, value, key);
+  free (key);
+}
 #endif
 
 #ifdef CCTK_INTEGER_PRECISION_8
@@ -2341,6 +2943,18 @@ int Util_TableGetInt8(int handle, CCTK_INT8 *value, const char *key)
          ? UTIL_ERROR_TABLE_VALUE_IS_EMPTY
          : status;
 }
+
+void CCTK_FCALL CCTK_FNAME (Util_TableGetInt8)
+                           (int *retval, const int *handle,
+                            CCTK_INT8 *value, ONE_FORTSTRING_ARG);
+void CCTK_FCALL CCTK_FNAME (Util_TableGetInt8)
+                           (int *retval, const int *handle,
+                            CCTK_INT8 *value, ONE_FORTSTRING_ARG)
+{
+  ONE_FORTSTRING_CREATE (key)
+  *retval = Util_TableGetInt8 (*handle, value, key);
+  free (key);
+}
 #endif
 
 /**************************************/
@@ -2354,6 +2968,18 @@ int Util_TableGetReal(int handle, CCTK_REAL *value, const char *key)
          : status;
 }
 
+void CCTK_FCALL CCTK_FNAME (Util_TableGetReal)
+                           (int *retval, const int *handle,
+                            CCTK_REAL *value, ONE_FORTSTRING_ARG);
+void CCTK_FCALL CCTK_FNAME (Util_TableGetReal)
+                           (int *retval, const int *handle,
+                            CCTK_REAL *value, ONE_FORTSTRING_ARG)
+{
+  ONE_FORTSTRING_CREATE (key)
+  *retval = Util_TableGetReal (*handle, value, key);
+  free (key);
+}
+
 #ifdef CCTK_REAL_PRECISION_4
 int Util_TableGetReal4(int handle, CCTK_REAL4 *value, const char *key)
 {
@@ -2362,6 +2988,18 @@ int Util_TableGetReal4(int handle, CCTK_REAL4 *value, const char *key)
          ? UTIL_ERROR_TABLE_VALUE_IS_EMPTY
          : status;
 }
+
+void CCTK_FCALL CCTK_FNAME (Util_TableGetReal4)
+                           (int *retval, const int *handle,
+                            CCTK_REAL4 *value, ONE_FORTSTRING_ARG);
+void CCTK_FCALL CCTK_FNAME (Util_TableGetReal4)
+                           (int *retval, const int *handle,
+                            CCTK_REAL4 *value, ONE_FORTSTRING_ARG)
+{
+  ONE_FORTSTRING_CREATE (key)
+  *retval = Util_TableGetReal4 (*handle, value, key);
+  free (key);
+}
 #endif
 
 #ifdef CCTK_REAL_PRECISION_8
@@ -2372,6 +3010,18 @@ int Util_TableGetReal8(int handle, CCTK_REAL8 *value, const char *key)
          ? UTIL_ERROR_TABLE_VALUE_IS_EMPTY
          : status;
 }
+
+void CCTK_FCALL CCTK_FNAME (Util_TableGetReal8)
+                           (int *retval, const int *handle,
+                            CCTK_REAL8 *value, ONE_FORTSTRING_ARG);
+void CCTK_FCALL CCTK_FNAME (Util_TableGetReal8)
+                           (int *retval, const int *handle,
+                            CCTK_REAL8 *value, ONE_FORTSTRING_ARG)
+{
+  ONE_FORTSTRING_CREATE (key)
+  *retval = Util_TableGetReal8 (*handle, value, key);
+  free (key);
+}
 #endif
 
 #ifdef CCTK_REAL_PRECISION_16
@@ -2382,6 +3032,18 @@ int Util_TableGetReal16(int handle, CCTK_REAL16 *value, const char *key)
          ? UTIL_ERROR_TABLE_VALUE_IS_EMPTY
          : status;
 }
+
+void CCTK_FCALL CCTK_FNAME (Util_TableGetReal16)
+                           (int *retval, const int *handle,
+                            CCTK_REAL4 *value, ONE_FORTSTRING_ARG);
+void CCTK_FCALL CCTK_FNAME (Util_TableGetReal16)
+                           (int *retval, const int *handle,
+                            CCTK_REAL16 *value, ONE_FORTSTRING_ARG)
+{
+  ONE_FORTSTRING_CREATE (key)
+  *retval = Util_TableGetReal16 (*handle, value, key);
+  free (key);
+}
 #endif
 
 /**************************************/
@@ -2395,6 +3057,18 @@ int Util_TableGetComplex(int handle, CCTK_COMPLEX *value, const char *key)
          : status;
 }
 
+void CCTK_FCALL CCTK_FNAME (Util_TableGetComplex)
+                           (int *retval, const int *handle,
+                            CCTK_COMPLEX *value, ONE_FORTSTRING_ARG);
+void CCTK_FCALL CCTK_FNAME (Util_TableGetComplex)
+                           (int *retval, const int *handle,
+                            CCTK_COMPLEX *value, ONE_FORTSTRING_ARG)
+{
+  ONE_FORTSTRING_CREATE (key)
+  *retval = Util_TableGetComplex (*handle, value, key);
+  free (key);
+}
+
 #ifdef CCTK_COMPLEX_PRECISION_8
 int Util_TableGetComplex8(int handle, CCTK_COMPLEX8 *value, const char *key)
 {
@@ -2403,6 +3077,18 @@ int Util_TableGetComplex8(int handle, CCTK_COMPLEX8 *value, const char *key)
          ? UTIL_ERROR_TABLE_VALUE_IS_EMPTY
          : status;
 }
+
+void CCTK_FCALL CCTK_FNAME (Util_TableGetComplex8)
+                           (int *retval, const int *handle,
+                            CCTK_COMPLEX8 *value, ONE_FORTSTRING_ARG);
+void CCTK_FCALL CCTK_FNAME (Util_TableGetComplex8)
+                           (int *retval, const int *handle,
+                            CCTK_COMPLEX8 *value, ONE_FORTSTRING_ARG)
+{
+  ONE_FORTSTRING_CREATE (key)
+  *retval = Util_TableGetComplex8 (*handle, value, key);
+  free (key);
+}
 #endif
 
 #ifdef CCTK_COMPLEX_PRECISION_16
@@ -2413,6 +3099,18 @@ int Util_TableGetComplex16(int handle, CCTK_COMPLEX16 *value, const char *key)
          ? UTIL_ERROR_TABLE_VALUE_IS_EMPTY
          : status;
 }
+
+void CCTK_FCALL CCTK_FNAME (Util_TableGetComplex16)
+                           (int *retval, const int *handle,
+                            CCTK_COMPLEX16 *value, ONE_FORTSTRING_ARG);
+void CCTK_FCALL CCTK_FNAME (Util_TableGetComplex16)
+                           (int *retval, const int *handle,
+                            CCTK_COMPLEX16 *value, ONE_FORTSTRING_ARG)
+{
+  ONE_FORTSTRING_CREATE (key)
+  *retval = Util_TableGetComplex16 (*handle, value, key);
+  free (key);
+}
 #endif
 
 #ifdef CCTK_COMPLEX_PRECISION_32
@@ -2423,6 +3121,18 @@ int Util_TableGetComplex32(int handle, CCTK_COMPLEX32 *value, const char *key)
          ? UTIL_ERROR_TABLE_VALUE_IS_EMPTY
          : status;
 }
+
+void CCTK_FCALL CCTK_FNAME (Util_TableGetComplex32)
+                           (int *retval, const int *handle,
+                            CCTK_COMPLEX32 *value, ONE_FORTSTRING_ARG);
+void CCTK_FCALL CCTK_FNAME (Util_TableGetComplex32)
+                           (int *retval, const int *handle,
+                            CCTK_COMPLEX32 *value, ONE_FORTSTRING_ARG)
+{
+  ONE_FORTSTRING_CREATE (key)
+  *retval = Util_TableGetComplex32 (*handle, value, key);
+  free (key);
+}
 #endif
 
 /******************************************************************************/
@@ -2510,6 +3220,20 @@ int Util_TableGetPointerArray(int handle,
                       key);
 }
 
+void CCTK_FCALL CCTK_FNAME (Util_TableGetPointerArray)
+                           (int *retval, const int *handle,
+                            const int *N_elements, CCTK_POINTER array[],
+                            ONE_FORTSTRING_ARG);
+void CCTK_FCALL CCTK_FNAME (Util_TableGetPointerArray)
+                           (int *retval, const int *handle,
+                            const int *N_elements, CCTK_POINTER array[],
+                            ONE_FORTSTRING_ARG)
+{
+  ONE_FORTSTRING_CREATE (key)
+  *retval = Util_TableGetPointerArray (*handle, *N_elements, array, key);
+  free (key);
+}
+
 int Util_TableGetFnPointerArray(int handle,
                                 int N_elements, CCTK_FPOINTER array[],
                                 const char *key)
@@ -2519,6 +3243,20 @@ int Util_TableGetFnPointerArray(int handle,
                       key);
 }
 
+void CCTK_FCALL CCTK_FNAME (Util_TableGetFnPointerArray)
+                           (int *retval, const int *handle,
+                            const int *N_elements, CCTK_FPOINTER array[],
+                            ONE_FORTSTRING_ARG);
+void CCTK_FCALL CCTK_FNAME (Util_TableGetFnPointerArray)
+                           (int *retval, const int *handle,
+                            const int *N_elements, CCTK_FPOINTER array[],
+                            ONE_FORTSTRING_ARG)
+{
+  ONE_FORTSTRING_CREATE (key)
+  *retval = Util_TableGetFnPointerArray (*handle, *N_elements, array, key);
+  free (key);
+}
+
 /**************************************/
 
 /* arrays of characters (i.e. character strings) */
@@ -2531,6 +3269,20 @@ int Util_TableGetCharArray(int handle,
                       key);
 }
 
+void CCTK_FCALL CCTK_FNAME (Util_TableGetCharArray)
+                           (int *retval, const int *handle,
+                            const int *N_elements, CCTK_CHAR array[],
+                            ONE_FORTSTRING_ARG);
+void CCTK_FCALL CCTK_FNAME (Util_TableGetCharArray)
+                           (int *retval, const int *handle,
+                            const int *N_elements, CCTK_CHAR array[],
+                            ONE_FORTSTRING_ARG)
+{
+  ONE_FORTSTRING_CREATE (key)
+  *retval = Util_TableGetCharArray (*handle, *N_elements, array, key);
+  free (key);
+}
+
 /**************************************/
 
 /* integers */
@@ -2543,6 +3295,20 @@ int Util_TableGetIntArray(int handle,
                       key);
 }
 
+void CCTK_FCALL CCTK_FNAME (Util_TableGetIntArray)
+                           (int *retval, const int *handle,
+                            const int *N_elements, CCTK_INT array[],
+                            ONE_FORTSTRING_ARG);
+void CCTK_FCALL CCTK_FNAME (Util_TableGetIntArray)
+                           (int *retval, const int *handle,
+                            const int *N_elements, CCTK_INT array[],
+                            ONE_FORTSTRING_ARG)
+{
+  ONE_FORTSTRING_CREATE (key)
+  *retval = Util_TableGetIntArray (*handle, *N_elements, array, key);
+  free (key);
+}
+
 #ifdef CCTK_INTEGER_PRECISION_2
 int Util_TableGetInt2Array(int handle,
                            int N_elements, CCTK_INT2 array[],
@@ -2552,6 +3318,20 @@ int Util_TableGetInt2Array(int handle,
                       CCTK_VARIABLE_INT2, N_elements, (void *) array,
                       key);
 }
+
+void CCTK_FCALL CCTK_FNAME (Util_TableGetInt2Array)
+                           (int *retval, const int *handle,
+                            const int *N_elements, CCTK_INT2 array[],
+                            ONE_FORTSTRING_ARG);
+void CCTK_FCALL CCTK_FNAME (Util_TableGetInt2Array)
+                           (int *retval, const int *handle,
+                            const int *N_elements, CCTK_INT2 array[],
+                            ONE_FORTSTRING_ARG)
+{
+  ONE_FORTSTRING_CREATE (key)
+  *retval = Util_TableGetInt2Array (*handle, *N_elements, array, key);
+  free (key);
+}
 #endif
 
 #ifdef CCTK_INTEGER_PRECISION_4
@@ -2563,6 +3343,20 @@ int Util_TableGetInt4Array(int handle,
                       CCTK_VARIABLE_INT4, N_elements, (void *) array,
                       key);
 }
+
+void CCTK_FCALL CCTK_FNAME (Util_TableGetInt4Array)
+                           (int *retval, const int *handle,
+                            const int *N_elements, CCTK_INT4 array[],
+                            ONE_FORTSTRING_ARG);
+void CCTK_FCALL CCTK_FNAME (Util_TableGetInt4Array)
+                           (int *retval, const int *handle,
+                            const int *N_elements, CCTK_INT4 array[],
+                            ONE_FORTSTRING_ARG)
+{
+  ONE_FORTSTRING_CREATE (key)
+  *retval = Util_TableGetInt4Array (*handle, *N_elements, array, key);
+  free (key);
+}
 #endif
 
 #ifdef CCTK_INTEGER_PRECISION_8
@@ -2574,6 +3368,20 @@ int Util_TableGetInt8Array(int handle,
                       CCTK_VARIABLE_INT8, N_elements, (void *) array,
                       key);
 }
+
+void CCTK_FCALL CCTK_FNAME (Util_TableGetInt8Array)
+                           (int *retval, const int *handle,
+                            const int *N_elements, CCTK_INT8 array[],
+                            ONE_FORTSTRING_ARG);
+void CCTK_FCALL CCTK_FNAME (Util_TableGetInt8Array)
+                           (int *retval, const int *handle,
+                            const int *N_elements, CCTK_INT8 array[],
+                            ONE_FORTSTRING_ARG)
+{
+  ONE_FORTSTRING_CREATE (key)
+  *retval = Util_TableGetInt8Array (*handle, *N_elements, array, key);
+  free (key);
+}
 #endif
 
 /**************************************/
@@ -2587,6 +3395,20 @@ int Util_TableGetRealArray(int handle,
                       CCTK_VARIABLE_REAL, N_elements, (void *) array,
                       key);
 }
+
+void CCTK_FCALL CCTK_FNAME (Util_TableGetRealArray)
+                           (int *retval, const int *handle,
+                            const int *N_elements, CCTK_REAL array[],
+                            ONE_FORTSTRING_ARG);
+void CCTK_FCALL CCTK_FNAME (Util_TableGetRealArray)
+                           (int *retval, const int *handle,
+                            const int *N_elements, CCTK_REAL array[],
+                            ONE_FORTSTRING_ARG)
+{
+  ONE_FORTSTRING_CREATE (key)
+  *retval = Util_TableGetRealArray (*handle, *N_elements, array, key);
+  free (key);
+}
 #ifdef CCTK_REAL_PRECISION_4
 
 int Util_TableGetReal4Array(int handle,
@@ -2597,6 +3419,20 @@ int Util_TableGetReal4Array(int handle,
                       CCTK_VARIABLE_REAL4, N_elements, (void *) array,
                       key);
 }
+
+void CCTK_FCALL CCTK_FNAME (Util_TableGetReal4Array)
+                           (int *retval, const int *handle,
+                            const int *N_elements, CCTK_REAL4 array[],
+                            ONE_FORTSTRING_ARG);
+void CCTK_FCALL CCTK_FNAME (Util_TableGetReal4Array)
+                           (int *retval, const int *handle,
+                            const int *N_elements, CCTK_REAL4 array[],
+                            ONE_FORTSTRING_ARG)
+{
+  ONE_FORTSTRING_CREATE (key)
+  *retval = Util_TableGetReal4Array (*handle, *N_elements, array, key);
+  free (key);
+}
 #endif
 
 #ifdef CCTK_REAL_PRECISION_8
@@ -2608,6 +3444,20 @@ int Util_TableGetReal8Array(int handle,
                       CCTK_VARIABLE_REAL8, N_elements, (void *) array,
                       key);
 }
+
+void CCTK_FCALL CCTK_FNAME (Util_TableGetReal8Array)
+                           (int *retval, const int *handle,
+                            const int *N_elements, CCTK_REAL8 array[],
+                            ONE_FORTSTRING_ARG);
+void CCTK_FCALL CCTK_FNAME (Util_TableGetReal8Array)
+                           (int *retval, const int *handle,
+                            const int *N_elements, CCTK_REAL8 array[],
+                            ONE_FORTSTRING_ARG)
+{
+  ONE_FORTSTRING_CREATE (key)
+  *retval = Util_TableGetReal8Array (*handle, *N_elements, array, key);
+  free (key);
+}
 #endif
 
 #ifdef CCTK_REAL_PRECISION_16
@@ -2619,6 +3469,20 @@ int Util_TableGetReal16Array(int handle,
                       CCTK_VARIABLE_REAL16, N_elements, (void *) array,
                       key);
 }
+
+void CCTK_FCALL CCTK_FNAME (Util_TableGetReal16Array)
+                           (int *retval, const int *handle,
+                            const int *N_elements, CCTK_REAL16 array[],
+                            ONE_FORTSTRING_ARG);
+void CCTK_FCALL CCTK_FNAME (Util_TableGetReal16Array)
+                           (int *retval, const int *handle,
+                            const int *N_elements, CCTK_REAL16 array[],
+                            ONE_FORTSTRING_ARG)
+{
+  ONE_FORTSTRING_CREATE (key)
+  *retval = Util_TableGetReal16Array (*handle, *N_elements, array, key);
+  free (key);
+}
 #endif
 
 /**************************************/
@@ -2632,6 +3496,20 @@ int Util_TableGetComplexArray(int handle,
                       CCTK_VARIABLE_COMPLEX, N_elements, (void *) array,
                       key);
 }
+
+void CCTK_FCALL CCTK_FNAME (Util_TableGetComplexArray)
+                           (int *retval, const int *handle,
+                            const int *N_elements, CCTK_COMPLEX array[],
+                            ONE_FORTSTRING_ARG);
+void CCTK_FCALL CCTK_FNAME (Util_TableGetComplexArray)
+                           (int *retval, const int *handle,
+                            const int *N_elements, CCTK_COMPLEX array[],
+                            ONE_FORTSTRING_ARG)
+{
+  ONE_FORTSTRING_CREATE (key)
+  *retval = Util_TableGetComplexArray (*handle, *N_elements, array, key);
+  free (key);
+}
 #ifdef CCTK_COMPLEX_PRECISION_8
 
 int Util_TableGetComplex8Array(int handle,
@@ -2642,6 +3520,20 @@ int Util_TableGetComplex8Array(int handle,
                       CCTK_VARIABLE_COMPLEX8, N_elements, (void *) array,
                       key);
 }
+
+void CCTK_FCALL CCTK_FNAME (Util_TableGetComplex8Array)
+                           (int *retval, const int *handle,
+                            const int *N_elements, CCTK_COMPLEX8 array[],
+                            ONE_FORTSTRING_ARG);
+void CCTK_FCALL CCTK_FNAME (Util_TableGetComplex8Array)
+                           (int *retval, const int *handle,
+                            const int *N_elements, CCTK_COMPLEX8 array[],
+                            ONE_FORTSTRING_ARG)
+{
+  ONE_FORTSTRING_CREATE (key)
+  *retval = Util_TableGetComplex8Array (*handle, *N_elements, array, key);
+  free (key);
+}
 #endif
 
 #ifdef CCTK_COMPLEX_PRECISION_16
@@ -2653,6 +3545,20 @@ int Util_TableGetComplex16Array(int handle,
                       CCTK_VARIABLE_COMPLEX16, N_elements, (void *) array,
                       key);
 }
+
+void CCTK_FCALL CCTK_FNAME (Util_TableGetComplex16Array)
+                           (int *retval, const int *handle,
+                            const int *N_elements, CCTK_COMPLEX16 array[],
+                            ONE_FORTSTRING_ARG);
+void CCTK_FCALL CCTK_FNAME (Util_TableGetComplex16Array)
+                           (int *retval, const int *handle,
+                            const int *N_elements, CCTK_COMPLEX16 array[],
+                            ONE_FORTSTRING_ARG)
+{
+  ONE_FORTSTRING_CREATE (key)
+  *retval = Util_TableGetComplex16Array (*handle, *N_elements, array, key);
+  free (key);
+}
 #endif
 
 #ifdef CCTK_COMPLEX_PRECISION_32
@@ -2664,6 +3570,20 @@ int Util_TableGetComplex32Array(int handle,
                       CCTK_VARIABLE_COMPLEX16, N_elements, (void *) array,
                       key);
 }
+
+void CCTK_FCALL CCTK_FNAME (Util_TableGetComplex32Array)
+                           (int *retval, const int *handle,
+                            const int *N_elements, CCTK_COMPLEX32 array[],
+                            ONE_FORTSTRING_ARG);
+void CCTK_FCALL CCTK_FNAME (Util_TableGetComplex32Array)
+                           (int *retval, const int *handle,
+                            const int *N_elements, CCTK_COMPLEX32 array[],
+                            ONE_FORTSTRING_ARG)
+{
+  ONE_FORTSTRING_CREATE (key)
+  *retval = Util_TableGetComplex32Array (*handle, *N_elements, array, key);
+  free (key);
+}
 #endif
 
 /******************************************************************************/