API prefix is only prepended to function declarations not file names

.github/workflows/cmake.yml

@@ -30,6 +30,7 @@ jobs:
           - build_type: Debug
             build_shared_libs: OFF
             do_fortran: ON
+            api_prefix: gha
           - build_type: Release
             build_shared_libs: ON
             os: ubuntu-24.04
@@ -69,6 +70,7 @@ jobs:
         -D LIBINT2_ENABLE_FORTRAN=${{ matrix.do_fortran }}
         -D LIBINT2_ENABLE_PYTHON=ON
         -D LIBINT2_EXPORT_COMPRESSOR=${{ matrix.compressor }}
+        -D LIBINT2_API_PREFIX=${{ matrix.api_prefix }}
 
     outputs:
       should_skip: ${{ steps.skip_check.outputs.should_skip }}

CMakeLists.txt

@@ -272,8 +272,8 @@ option_with_print(LIBINT2_GENERATE_FMA
   "Generate FMA (fused multiply-add) instructions (to benefit must have FMA-capable hardware and compiler)" OFF)
 option_with_print(LIBINT2_ENABLE_GENERIC_CODE
   "Use manually-written generic code" OFF)
-option_with_print(LIBINT2_API_PREFIX
-  "Prepend this string to every name in the library API (except for the types)." OFF)
+option_with_default(LIBINT2_API_PREFIX
+  "Prepend this string to every name in the library API (except for the types)." "")
 option_with_print(LIBINT2_VECTOR_LENGTH
   "Compute integrals in vectors of length N." OFF)
 option_with_default(LIBINT2_VECTOR_METHOD

INSTALL.md

@@ -357,7 +357,7 @@ Note that options, docs, and CMake components are focused on the C++ interface,
 * `LIBINT_ALIGN_SIZE` - G - If posix_memalign is available, this will specify alignment of Libint data, in units of sizeof(LIBINT2_REALTYPE). Default is to use built-in heuristics: system-determined for vectorization off (default) or veclen * sizeof(LIBINT2_REALTYPE) for vectorization on. (experts only). [Default=0]
 * `LIBINT2_GENERATE_FMA` - G - Generate FMA (fused multiply-add) instructions (to benefit must have FMA-capable hardware and compiler). [Default=OFF]
 * `LIBINT2_ENABLE_GENERIC_CODE` - G - Use manually-written generic code. [Default=OFF]
-* `LIBINT2_API_PREFIX` - G - Prepend this string to every name in the library API (except for the types). [Default=OFF]
+* `LIBINT2_API_PREFIX` - G - Prepend this string to every name in the library API (except for the types). [Default=""]
 * `LIBINT2_VECTOR_LENGTH` - G - Compute integrals in vectors of length N. [Default=OFF]
 * `LIBINT2_VECTOR_METHOD` - G - Specifies how to vectorize integrals. Irrelevant when `LIBINT2_VECTOR_LENGTH=OFF. Allowed values are 'block' and 'line'.  [Default=block]
 * `LIBINT2_ACCUM_INTS` - G - Accumulate integrals to the buffer, rather than copy (OFF for copy, ON for accum). [Default=OFF]

cmake/modules/options.cmake

@@ -53,13 +53,13 @@ macro(option_with_default variable msge default)
     # TODO: need to namespace all Libint-specific cmake variables
     # disabled for now, pending discussion with @loriab
     if (TRUE OR ${variable} MATCHES "^LIBINT_")
-        print_option(${variable} ${default})
+        print_option(${variable} "${default}")
         if(NOT DEFINED ${variable} OR "${${variable}}" STREQUAL "")
             set(${variable} "${default}" CACHE STRING "${msge}" FORCE)
         endif()
     else ()
         set(_libint_var LIBINT_${variable})
-        print_option(${_libint_var} ${default})
+        print_option(${_libint_var} "${default}")
         if(NOT DEFINED ${_libint_var} OR "${${_libint_var}}" STREQUAL "")
             if(DEFINED ${variable} AND (NOT "${${variable}}" STREQUAL ""))
                 set(${_libint_var} "${variable}" CACHE STRING "${msge}" FORCE)

export/fortran/libint_f.F90

@@ -5,6 +5,15 @@ MODULE libint_f
 #include <libint2/util/generated/libint2_params.h>
 #include "fortran_incldefs.h"
 
+/* Macro to form BIND(C, NAME=...) with API prefix for Fortran.
+   Uses LIBINT_API_PREFIX from config.h (a string literal, e.g. "gha")
+   and Fortran's // string concatenation operator. */
+#ifdef LIBINT_API_PREFIX
+#define LIBINT2_FORTRAN_BIND(namestr) BIND(C, NAME=LIBINT_API_PREFIX // namestr)
+#else
+#define LIBINT2_FORTRAN_BIND(namestr) BIND(C)
+#endif
+
    IMPLICIT NONE
 
 #ifdef LIBINT2_MAX_AM
@@ -59,103 +68,103 @@ MODULE libint_f
 
 #ifdef LIBINT_INCLUDE_ERI
    TYPE(C_FUNPTR), DIMENSION(0:libint2_max_am_eri, 0:libint2_max_am_eri, 0:libint2_max_am_eri, 0:libint2_max_am_eri), &
-      BIND(C) :: libint2_build_eri
+      LIBINT2_FORTRAN_BIND("libint2_build_eri") :: libint2_build_eri
 #if LIBINT_INCLUDE_ERI >= 1
    TYPE(C_FUNPTR), DIMENSION(0:libint2_max_am_eri1, 0:libint2_max_am_eri1, 0:libint2_max_am_eri1, 0:libint2_max_am_eri1), &
-      BIND(C) :: libint2_build_eri1
+      LIBINT2_FORTRAN_BIND("libint2_build_eri1") :: libint2_build_eri1
 #endif
 #if LIBINT_INCLUDE_ERI >= 2
    TYPE(C_FUNPTR), DIMENSION(0:libint2_max_am_eri2, 0:libint2_max_am_eri2, 0:libint2_max_am_eri2, 0:libint2_max_am_eri2), &
-      BIND(C) :: libint2_build_eri2
+      LIBINT2_FORTRAN_BIND("libint2_build_eri2") :: libint2_build_eri2
 #endif
 #endif
 
 #ifdef LIBINT_INCLUDE_ERI2
    TYPE(C_FUNPTR), DIMENSION(0:libint2_max_am_2eri, 0:libint2_max_am_2eri), &
-      BIND(C) :: libint2_build_2eri
+      LIBINT2_FORTRAN_BIND("libint2_build_2eri") :: libint2_build_2eri
 #if LIBINT_INCLUDE_ERI2 >= 1
    TYPE(C_FUNPTR), DIMENSION(0:libint2_max_am_2eri1, 0:libint2_max_am_2eri1), &
-      BIND(C) :: libint2_build_2eri1
+      LIBINT2_FORTRAN_BIND("libint2_build_2eri1") :: libint2_build_2eri1
 #endif
 #if LIBINT_INCLUDE_ERI2 >= 2
    TYPE(C_FUNPTR), DIMENSION(0:libint2_max_am_2eri2, 0:libint2_max_am_2eri2), &
-      BIND(C) :: libint2_build_2eri2
+      LIBINT2_FORTRAN_BIND("libint2_build_2eri2") :: libint2_build_2eri2
 #endif
 #endif
 
 #ifdef LIBINT_INCLUDE_ERI3
    TYPE(C_FUNPTR), DIMENSION(0:libint2_max_am_default, 0:libint2_max_am_default, 0:libint2_max_am_3eri), &
-      BIND(C) :: libint2_build_3eri
+      LIBINT2_FORTRAN_BIND("libint2_build_3eri") :: libint2_build_3eri
 #if LIBINT_INCLUDE_ERI3 >= 1
    TYPE(C_FUNPTR), DIMENSION(0:libint2_max_am_default1, 0:libint2_max_am_default1, 0:libint2_max_am_3eri1), &
-      BIND(C) :: libint2_build_3eri1
+      LIBINT2_FORTRAN_BIND("libint2_build_3eri1") :: libint2_build_3eri1
 #endif
 #if LIBINT_INCLUDE_ERI3 >= 2
    TYPE(C_FUNPTR), DIMENSION(0:libint2_max_am_default2, 0:libint2_max_am_default2, 0:libint2_max_am_3eri2), &
-      BIND(C) :: libint2_build_3eri2
+      LIBINT2_FORTRAN_BIND("libint2_build_3eri2") :: libint2_build_3eri2
 #endif
 #endif
 
    INTERFACE
-      SUBROUTINE libint2_static_init() BIND(C)
+      SUBROUTINE libint2_static_init() LIBINT2_FORTRAN_BIND("libint2_static_init")
       END SUBROUTINE
 
-      SUBROUTINE libint2_static_cleanup() BIND(C)
+      SUBROUTINE libint2_static_cleanup() LIBINT2_FORTRAN_BIND("libint2_static_cleanup")
       END SUBROUTINE
 
 #ifdef LIBINT_INCLUDE_ERI
-      SUBROUTINE libint2_init_eri(libint, max_am, buf) BIND(C)
+      SUBROUTINE libint2_init_eri(libint, max_am, buf) LIBINT2_FORTRAN_BIND("libint2_init_eri")
          IMPORT
          TYPE(libint_t), DIMENSION(*) :: libint
          INTEGER(KIND=C_INT), VALUE :: max_am
          TYPE(C_PTR), VALUE :: buf
       END SUBROUTINE
 
-      SUBROUTINE libint2_cleanup_eri(libint) BIND(C)
+      SUBROUTINE libint2_cleanup_eri(libint) LIBINT2_FORTRAN_BIND("libint2_cleanup_eri")
          IMPORT
          TYPE(libint_t), DIMENSION(*) :: libint
       END SUBROUTINE
 
-      FUNCTION libint2_need_memory_eri(max_am) BIND(C)
+      FUNCTION libint2_need_memory_eri(max_am) LIBINT2_FORTRAN_BIND("libint2_need_memory_eri")
          IMPORT
          INTEGER(KIND=C_INT), VALUE :: max_am
          INTEGER(KIND=C_SIZE_T) :: libint2_need_memory_eri
       END FUNCTION
 
 #if LIBINT_INCLUDE_ERI >= 1
-      SUBROUTINE libint2_init_eri1(libint, max_am, buf) BIND(C)
+      SUBROUTINE libint2_init_eri1(libint, max_am, buf) LIBINT2_FORTRAN_BIND("libint2_init_eri1")
          IMPORT
          TYPE(libint_t), DIMENSION(*) :: libint
          INTEGER(KIND=C_INT), VALUE :: max_am
          TYPE(C_PTR), VALUE :: buf
       END SUBROUTINE
 
-      SUBROUTINE libint2_cleanup_eri1(libint) BIND(C)
+      SUBROUTINE libint2_cleanup_eri1(libint) LIBINT2_FORTRAN_BIND("libint2_cleanup_eri1")
          IMPORT
          TYPE(libint_t), DIMENSION(*) :: libint
       END SUBROUTINE
 
-      FUNCTION libint2_need_memory_eri1(max_am) BIND(C)
+      FUNCTION libint2_need_memory_eri1(max_am) LIBINT2_FORTRAN_BIND("libint2_need_memory_eri1")
          IMPORT
          INTEGER(KIND=C_INT), VALUE :: max_am
          INTEGER(KIND=C_SIZE_T) :: libint2_need_memory_eri1
       END FUNCTION
 #endif
 
 #if LIBINT_INCLUDE_ERI >= 2
-      SUBROUTINE libint2_init_eri2(libint, max_am, buf) BIND(C)
+      SUBROUTINE libint2_init_eri2(libint, max_am, buf) LIBINT2_FORTRAN_BIND("libint2_init_eri2")
          IMPORT
          TYPE(libint_t), DIMENSION(*) :: libint
          INTEGER(KIND=C_INT), VALUE :: max_am
          TYPE(C_PTR), VALUE :: buf
       END SUBROUTINE
 
-      SUBROUTINE libint2_cleanup_eri2(libint) BIND(C)
+      SUBROUTINE libint2_cleanup_eri2(libint) LIBINT2_FORTRAN_BIND("libint2_cleanup_eri2")
          IMPORT
          TYPE(libint_t), DIMENSION(*) :: libint
       END SUBROUTINE
 
-      FUNCTION libint2_need_memory_eri2(max_am) BIND(C)
+      FUNCTION libint2_need_memory_eri2(max_am) LIBINT2_FORTRAN_BIND("libint2_need_memory_eri2")
          IMPORT
          INTEGER(KIND=C_INT), VALUE :: max_am
          INTEGER(KIND=C_SIZE_T) :: libint2_need_memory_eri2
@@ -164,58 +173,58 @@ FUNCTION libint2_need_memory_eri2(max_am) BIND(C)
 #endif
 
 #ifdef LIBINT_INCLUDE_ERI2
-      SUBROUTINE libint2_init_2eri(libint, max_am, buf) BIND(C)
+      SUBROUTINE libint2_init_2eri(libint, max_am, buf) LIBINT2_FORTRAN_BIND("libint2_init_2eri")
          IMPORT
          TYPE(libint_t), DIMENSION(*) :: libint
          INTEGER(KIND=C_INT), VALUE :: max_am
          TYPE(C_PTR), VALUE :: buf
       END SUBROUTINE
 
-      SUBROUTINE libint2_cleanup_2eri(libint) BIND(C)
+      SUBROUTINE libint2_cleanup_2eri(libint) LIBINT2_FORTRAN_BIND("libint2_cleanup_2eri")
          IMPORT
          TYPE(libint_t), DIMENSION(*) :: libint
       END SUBROUTINE
 
-      FUNCTION libint2_need_memory_2eri(max_am) BIND(C)
+      FUNCTION libint2_need_memory_2eri(max_am) LIBINT2_FORTRAN_BIND("libint2_need_memory_2eri")
          IMPORT
          INTEGER(KIND=C_INT), VALUE :: max_am
          INTEGER(KIND=C_SIZE_T) :: libint2_need_memory_2eri
       END FUNCTION
 
 #if LIBINT_INCLUDE_ERI2 >= 1
-      SUBROUTINE libint2_init_2eri1(libint, max_am, buf) BIND(C)
+      SUBROUTINE libint2_init_2eri1(libint, max_am, buf) LIBINT2_FORTRAN_BIND("libint2_init_2eri1")
          IMPORT
          TYPE(libint_t), DIMENSION(*) :: libint
          INTEGER(KIND=C_INT), VALUE :: max_am
          TYPE(C_PTR), VALUE :: buf
       END SUBROUTINE
 
-      SUBROUTINE libint2_cleanup_2eri1(libint) BIND(C)
+      SUBROUTINE libint2_cleanup_2eri1(libint) LIBINT2_FORTRAN_BIND("libint2_cleanup_2eri1")
          IMPORT
          TYPE(libint_t), DIMENSION(*) :: libint
       END SUBROUTINE
 
-      FUNCTION libint2_need_memory_2eri1(max_am) BIND(C)
+      FUNCTION libint2_need_memory_2eri1(max_am) LIBINT2_FORTRAN_BIND("libint2_need_memory_2eri1")
          IMPORT
          INTEGER(KIND=C_INT), VALUE :: max_am
          INTEGER(KIND=C_SIZE_T) :: libint2_need_memory_2eri1
       END FUNCTION
 #endif
 
 #if LIBINT_INCLUDE_ERI2 >= 2
-      SUBROUTINE libint2_init_2eri2(libint, max_am, buf) BIND(C)
+      SUBROUTINE libint2_init_2eri2(libint, max_am, buf) LIBINT2_FORTRAN_BIND("libint2_init_2eri2")
          IMPORT
          TYPE(libint_t), DIMENSION(*) :: libint
          INTEGER(KIND=C_INT), VALUE :: max_am
          TYPE(C_PTR), VALUE :: buf
       END SUBROUTINE
 
-      SUBROUTINE libint2_cleanup_2eri2(libint) BIND(C)
+      SUBROUTINE libint2_cleanup_2eri2(libint) LIBINT2_FORTRAN_BIND("libint2_cleanup_2eri2")
          IMPORT
          TYPE(libint_t), DIMENSION(*) :: libint
       END SUBROUTINE
 
-      FUNCTION libint2_need_memory_2eri2(max_am) BIND(C)
+      FUNCTION libint2_need_memory_2eri2(max_am) LIBINT2_FORTRAN_BIND("libint2_need_memory_2eri2")
          IMPORT
          INTEGER(KIND=C_INT), VALUE :: max_am
          INTEGER(KIND=C_SIZE_T) :: libint2_need_memory_2eri2
@@ -224,58 +233,58 @@ FUNCTION libint2_need_memory_2eri2(max_am) BIND(C)
 #endif
 
 #ifdef LIBINT_INCLUDE_ERI3
-      SUBROUTINE libint2_init_3eri(libint, max_am, buf) BIND(C)
+      SUBROUTINE libint2_init_3eri(libint, max_am, buf) LIBINT2_FORTRAN_BIND("libint2_init_3eri")
          IMPORT
          TYPE(libint_t), DIMENSION(*) :: libint
          INTEGER(KIND=C_INT), VALUE :: max_am
          TYPE(C_PTR), VALUE :: buf
       END SUBROUTINE
 
-      SUBROUTINE libint2_cleanup_3eri(libint) BIND(C)
+      SUBROUTINE libint2_cleanup_3eri(libint) LIBINT2_FORTRAN_BIND("libint2_cleanup_3eri")
          IMPORT
          TYPE(libint_t), DIMENSION(*) :: libint
       END SUBROUTINE
 
-      FUNCTION libint2_need_memory_3eri(max_am) BIND(C)
+      FUNCTION libint2_need_memory_3eri(max_am) LIBINT2_FORTRAN_BIND("libint2_need_memory_3eri")
          IMPORT
          INTEGER(KIND=C_INT), VALUE :: max_am
          INTEGER(KIND=C_SIZE_T) :: libint2_need_memory_3eri
       END FUNCTION
 
 #if LIBINT_INCLUDE_ERI3 >= 1
-      SUBROUTINE libint2_init_3eri1(libint, max_am, buf) BIND(C)
+      SUBROUTINE libint2_init_3eri1(libint, max_am, buf) LIBINT2_FORTRAN_BIND("libint2_init_3eri1")
          IMPORT
          TYPE(libint_t), DIMENSION(*) :: libint
          INTEGER(KIND=C_INT), VALUE :: max_am
          TYPE(C_PTR), VALUE :: buf
       END SUBROUTINE
 
-      SUBROUTINE libint2_cleanup_3eri1(libint) BIND(C)
+      SUBROUTINE libint2_cleanup_3eri1(libint) LIBINT2_FORTRAN_BIND("libint2_cleanup_3eri1")
          IMPORT
          TYPE(libint_t), DIMENSION(*) :: libint
       END SUBROUTINE
 
-      FUNCTION libint2_need_memory_3eri1(max_am) BIND(C)
+      FUNCTION libint2_need_memory_3eri1(max_am) LIBINT2_FORTRAN_BIND("libint2_need_memory_3eri1")
          IMPORT
          INTEGER(KIND=C_INT), VALUE :: max_am
          INTEGER(KIND=C_SIZE_T) :: libint2_need_memory_3eri1
       END FUNCTION
 #endif
 
 #if LIBINT_INCLUDE_ERI3 >= 2
-      SUBROUTINE libint2_init_3eri2(libint, max_am, buf) BIND(C)
+      SUBROUTINE libint2_init_3eri2(libint, max_am, buf) LIBINT2_FORTRAN_BIND("libint2_init_3eri2")
          IMPORT
          TYPE(libint_t), DIMENSION(*) :: libint
          INTEGER(KIND=C_INT), VALUE :: max_am
          TYPE(C_PTR), VALUE :: buf
       END SUBROUTINE
 
-      SUBROUTINE libint2_cleanup_3eri2(libint) BIND(C)
+      SUBROUTINE libint2_cleanup_3eri2(libint) LIBINT2_FORTRAN_BIND("libint2_cleanup_3eri2")
          IMPORT
          TYPE(libint_t), DIMENSION(*) :: libint
       END SUBROUTINE
 
-      FUNCTION libint2_need_memory_3eri2(max_am) BIND(C)
+      FUNCTION libint2_need_memory_3eri2(max_am) LIBINT2_FORTRAN_BIND("libint2_need_memory_3eri2")
          IMPORT
          INTEGER(KIND=C_INT), VALUE :: max_am
          INTEGER(KIND=C_SIZE_T) :: libint2_need_memory_3eri2

export/fortran/test-eri.cc

@@ -394,12 +394,15 @@ void compute_eri_c(int &contrdepth, int &deriv_order, int &am1, double *c1,
   erieval[0].contrdepth = p0123;
 #endif
 
-  if (deriv_order == 0) libint2_build_eri[am1][am2][am3][am4](erieval);
+  if (deriv_order == 0)
+    LIBINT2_PREFIXED_NAME(libint2_build_eri)[am1][am2][am3][am4](erieval);
 #if LIBINT_INCLUDE_ERI >= 1
-  if (deriv_order == 1) libint2_build_eri1[am1][am2][am3][am4](erieval);
+  if (deriv_order == 1)
+    LIBINT2_PREFIXED_NAME(libint2_build_eri1)[am1][am2][am3][am4](erieval);
 #endif
 #if LIBINT_INCLUDE_ERI >= 2
-  if (deriv_order == 2) libint2_build_eri2[am1][am2][am3][am4](erieval);
+  if (deriv_order == 2)
+    LIBINT2_PREFIXED_NAME(libint2_build_eri2)[am1][am2][am3][am4](erieval);
 #endif
 }
 
@@ -421,19 +424,19 @@ bool test_eri_c_f(int &contrdepth, int &am1, double *c1, double *alpha1,
   const unsigned int max_am = std::max(std::max(am1, am2), std::max(am3, am4));
 
   if (deriv_order == 0) {
-    libint2_init_eri(erieval_c, max_am, 0);
-    libint2_init_eri(erieval_f, max_am, 0);
+    LIBINT2_PREFIXED_NAME(libint2_init_eri)(erieval_c, max_am, 0);
+    LIBINT2_PREFIXED_NAME(libint2_init_eri)(erieval_f, max_am, 0);
   }
 #if LIBINT_INCLUDE_ERI >= 1
   if (deriv_order == 1) {
-    libint2_init_eri1(erieval_c, max_am, 0);
-    libint2_init_eri1(erieval_f, max_am, 0);
+    LIBINT2_PREFIXED_NAME(libint2_init_eri1)(erieval_c, max_am, 0);
+    LIBINT2_PREFIXED_NAME(libint2_init_eri1)(erieval_f, max_am, 0);
   }
 #endif
 #if LIBINT_INCLUDE_ERI >= 2
   if (deriv_order == 2) {
-    libint2_init_eri2(erieval_c, max_am, 0);
-    libint2_init_eri2(erieval_f, max_am, 0);
+    LIBINT2_PREFIXED_NAME(libint2_init_eri2)(erieval_c, max_am, 0);
+    LIBINT2_PREFIXED_NAME(libint2_init_eri2)(erieval_f, max_am, 0);
   }
 #endif
 
@@ -519,19 +522,19 @@ bool test_eri_c_f(int &contrdepth, int &am1, double *c1, double *alpha1,
   }
 
   if (deriv_order == 0) {
-    libint2_cleanup_eri(erieval_c);
-    libint2_cleanup_eri(erieval_f);
+    LIBINT2_PREFIXED_NAME(libint2_cleanup_eri)(erieval_c);
+    LIBINT2_PREFIXED_NAME(libint2_cleanup_eri)(erieval_f);
   }
 #if LIBINT_INCLUDE_ERI >= 1
   if (deriv_order == 1) {
-    libint2_cleanup_eri1(erieval_c);
-    libint2_cleanup_eri1(erieval_f);
+    LIBINT2_PREFIXED_NAME(libint2_cleanup_eri1)(erieval_c);
+    LIBINT2_PREFIXED_NAME(libint2_cleanup_eri1)(erieval_f);
   }
 #endif
 #if LIBINT_INCLUDE_ERI >= 2
   if (deriv_order == 2) {
-    libint2_cleanup_eri2(erieval_c);
-    libint2_cleanup_eri2(erieval_f);
+    LIBINT2_PREFIXED_NAME(libint2_cleanup_eri2)(erieval_c);
+    LIBINT2_PREFIXED_NAME(libint2_cleanup_eri2)(erieval_f);
   }
 #endif