Define 'index_int' type parameter for Fortran

Author: sethrj

doc/modules/algorithm.rst

@@ -53,18 +53,18 @@ A routine that provides the indices that correspond to a sorted array, like
 Numpy's argsort_ ,
 takes an array to analyze and an empty array of integers to fill::
 
-  use flc_algorithm, only : argsort
+  use flc_algorithm, only : argsort, INDEX_INT
   implicit none
   integer, dimension(5) :: iarr = [ 2, 5, -2, 3, -10000]
-  integer(C_INT), dimension(5) :: idx
+  integer(INDEX_INT), dimension(5) :: idx
 
   call argsort(iarr, idx)
   ! This line prints a sorted array:
   write(*,*) iarr(idx)
 
-Note that the index array is always a ``C_INT``. On some compilers and
-platforms, this may be the same as native Fortran integer, but it's not
-guaranteed.
+Note that the index array is always a ``INDEX_INT``, which is an alias to
+``C_INT``. On some compilers and platforms, this may be the same as native
+Fortran integer, but it's not guaranteed.
 
 The ``data`` and ``idx`` arguments to ``argsort`` *must* be the same size. If
 the index array is larger than the data, invalid entries will be filled with
@@ -86,9 +86,9 @@ The input array **must** be sorted.
 
 Example::
 
-  use flc_algorithm, only : binary_search
+  use flc_algorithm, only : binary_search, INDEX_INT
   implicit none
-  integer :: idx
+  integer(INDEX_INT) :: idx
   integer, dimension(6) :: iarr = [ -5, 1, 1, 2, 4, 9]
 
   idx = binary_search(iarr, -100) ! returns 0

src/flc_algorithm.i

@@ -35,11 +35,25 @@ static RETURN_TYPE FUNCNAME ## _cmp(ARGS, bool (*cmp)(T, T)) {
 
 %enddef
 
+/******************************
+ * Types
+ ******************************/
+
+%inline %{
+typedef int index_int;
+%}
+%insert("fdecl") %{integer, parameter, public :: INDEX_INT = C_INT
+%}
+
+%apply int { index_int };
+%typemap(ftype, in={integer(INDEX_INT), intent(in)}) index_int
+   %{integer(INDEX_INT)%}
+
 /******************************
  * Sorting
  ******************************/
 
-%apply (SWIGTYPE *DATA, size_t SIZE) { (int *IDX, size_t IDXSIZE) };
+%apply (SWIGTYPE *DATA, size_t SIZE) { (index_int *IDX, size_t IDXSIZE) };
 
 %{
 template<class T, class Compare>
@@ -54,7 +68,7 @@ static bool is_sorted_impl(const T *data, size_t size, Compare cmp) {
 
 template<class T, class Compare>
 static void argsort_impl(const T *data, size_t size,
-                         int *index, size_t index_size,
+                         index_int *index, size_t index_size,
                          Compare cmp) {
   // Fill invalid indices with zero
   if (size < index_size) {
@@ -64,7 +78,7 @@ static void argsort_impl(const T *data, size_t size,
   // Fill the indices with 1 through size
   std::iota(index, index + size, 1);
   // Define a comparator that accesses the original data
-  auto int_sort_cmp = [cmp, data](int left, int right)
+  auto int_sort_cmp = [cmp, data](index_int left, index_int right)
   { return cmp(data[left - 1], data[right - 1]); };
   // Let the standard library do all the hard work!
   std::sort(index, index + size, int_sort_cmp);
@@ -77,7 +91,7 @@ static void argsort_impl(const T *data, size_t size,
 %flc_cmp_algorithm(bool, is_sorted, %arg(const T *DATA, size_t DATASIZE),
                    %arg(DATA, DATASIZE))
 %flc_cmp_algorithm(void, argsort, %arg(const T *DATA, size_t DATASIZE,
-                                       int *IDX, size_t IDXSIZE),
+                                       index_int *IDX, size_t IDXSIZE),
                    %arg(DATA, DATASIZE, IDX, IDXSIZE))
 
 /******************************
@@ -86,17 +100,17 @@ static void argsort_impl(const T *data, size_t size,
 
 %{
 template<class T, class Compare>
-static int binary_search_impl(const T *data, size_t size, T value, Compare cmp) {
+static index_int binary_search_impl(const T *data, size_t size, T value, Compare cmp) {
   const T *end = data + size;
   auto iter = std::lower_bound(data, end, value, cmp);
   if (iter == end || cmp(*iter, value) || cmp(value, *iter))
-      return 0;
+    return 0;
   // Index of the found item *IN FORTAN INDEXING*
   return (iter - data) + 1;
 }
 %}
 
-%flc_cmp_algorithm(int, binary_search, %arg(const T *DATA, size_t DATASIZE,
+%flc_cmp_algorithm(index_int, binary_search, %arg(const T *DATA, size_t DATASIZE,
                                             T value),
                    %arg(DATA, DATASIZE, value))
 

src/generated/flcFORTRAN_wrap.cxx

@@ -221,10 +221,6 @@ using std::size_t;
 
 #include <stdint.h>
 
-#ifdef __cplusplus
 extern "C" {
-#endif
-#ifdef __cplusplus
-}
-#endif
+} // extern
 

src/generated/flc_algorithm.f90

@@ -16,21 +16,19 @@ module flc_algorithm
  private
 
  ! DECLARATION CONSTRUCTS
+integer, parameter, public :: INDEX_INT = C_INT
+
  type, bind(C) :: SwigArrayWrapper
   type(C_PTR), public :: data = C_NULL_PTR
   integer(C_SIZE_T), public :: size = 0
  end type
- enum, bind(c)
-  enumerator :: SWIG_NULL
-  enumerator :: SWIG_OWN
-  enumerator :: SWIG_MOVE
-  enumerator :: SWIG_REF
-  enumerator :: SWIG_CREF
- end enum
- integer, parameter :: SwigMemState = kind(SWIG_NULL)
+
+ integer, parameter :: swig_cmem_own_bit = 0
+ integer, parameter :: swig_cmem_rvalue_bit = 1
+ integer, parameter :: swig_cmem_const_bit = 2
  type, bind(C) :: SwigClassWrapper
   type(C_PTR), public :: cptr = C_NULL_PTR
-  integer(C_INT), public :: mem = SWIG_NULL
+  integer(C_INT), public :: cmemflags = 0
  end type
  interface binary_search
   module procedure swigf_binary_search__SWIG_1, swigf_binary_search__SWIG_2, swigf_binary_search__SWIG_3, &
@@ -746,7 +744,7 @@ subroutine swigf_argsort__SWIG_6(data, idx, cmp)
 function swigf_binary_search__SWIG_1(data, value) &
 result(swig_result)
 use, intrinsic :: ISO_C_BINDING
-integer(C_INT) :: swig_result
+integer(INDEX_INT) :: swig_result
 integer(C_INT32_T), dimension(:), intent(in), target :: data
 integer(C_INT32_T), pointer :: farg1_view
 integer(C_INT32_T), intent(in) :: value
@@ -770,7 +768,7 @@ function swigf_binary_search__SWIG_1(data, value) &
 function swigf_binary_search__SWIG_2(data, value) &
 result(swig_result)
 use, intrinsic :: ISO_C_BINDING
-integer(C_INT) :: swig_result
+integer(INDEX_INT) :: swig_result
 integer(C_INT64_T), dimension(:), intent(in), target :: data
 integer(C_INT64_T), pointer :: farg1_view
 integer(C_INT64_T), intent(in) :: value
@@ -794,7 +792,7 @@ function swigf_binary_search__SWIG_2(data, value) &
 function swigf_binary_search__SWIG_3(data, value) &
 result(swig_result)
 use, intrinsic :: ISO_C_BINDING
-integer(C_INT) :: swig_result
+integer(INDEX_INT) :: swig_result
 real(C_DOUBLE), dimension(:), intent(in), target :: data
 real(C_DOUBLE), pointer :: farg1_view
 real(C_DOUBLE), intent(in) :: value
@@ -818,7 +816,7 @@ function swigf_binary_search__SWIG_3(data, value) &
 function swigf_binary_search__SWIG_4(data, value, cmp) &
 result(swig_result)
 use, intrinsic :: ISO_C_BINDING
-integer(C_INT) :: swig_result
+integer(INDEX_INT) :: swig_result
 integer(C_INT32_T), dimension(:), intent(in), target :: data
 integer(C_INT32_T), pointer :: farg1_view
 integer(C_INT32_T), intent(in) :: value
@@ -845,7 +843,7 @@ function swigf_binary_search__SWIG_4(data, value, cmp) &
 function swigf_binary_search__SWIG_5(data, value, cmp) &
 result(swig_result)
 use, intrinsic :: ISO_C_BINDING
-integer(C_INT) :: swig_result
+integer(INDEX_INT) :: swig_result
 integer(C_INT64_T), dimension(:), intent(in), target :: data
 integer(C_INT64_T), pointer :: farg1_view
 integer(C_INT64_T), intent(in) :: value
@@ -872,7 +870,7 @@ function swigf_binary_search__SWIG_5(data, value, cmp) &
 function swigf_binary_search__SWIG_6(data, value, cmp) &
 result(swig_result)
 use, intrinsic :: ISO_C_BINDING
-integer(C_INT) :: swig_result
+integer(INDEX_INT) :: swig_result
 real(C_DOUBLE), dimension(:), intent(in), target :: data
 real(C_DOUBLE), pointer :: farg1_view
 real(C_DOUBLE), intent(in) :: value