Sloppy but working std::complex implementation

Only a few other languages implement it, and none of them tests the C implementation.

Author: sethrj

Examples/test-suite/fortran/Makefile.in

@@ -28,6 +28,7 @@ CPP_TEST_CASES = \
 	fortran_overloads \
 	fortran_subroutine \
 	li_std_set \
+	complextest \
 
 C_TEST_CASES = \
 	fortran_array_typemap \

Examples/test-suite/fortran/complextest_runme.F90

@@ -0,0 +1,28 @@
+! File : complextest_runme.F90
+
+#include "fassert.h"
+
+program complextest_runme
+  use complextest
+  use ISO_C_BINDING
+  implicit none
+  complex(C_FLOAT_COMPLEX) :: cflt
+  complex(C_DOUBLE_COMPLEX) :: cdbl 
+  type(VectorStdCplx) :: vec
+
+  cflt = (1, 3) ! 1 + 3i
+  cflt = Conjf(cflt)
+  ASSERT(cflt == (1, -3))
+  cdbl = (4.0000000001d0, 1d0)
+  ASSERT(Conj(cdbl) == (4.0000000001d0, -1d0))
+
+  cdbl = (4, 5)
+  cdbl = Conj2(cdbl)
+  ASSERT(cdbl == (4d0, -5d0))
+
+  vec = VectorStdCplx(10)
+  call vec%set(5, cmplx(4, -5, kind=C_DOUBLE_COMPLEX))
+  ASSERT(vec%get(5) == cdbl)
+end program
+
+

Lib/fortran/ccomplex.i

@@ -0,0 +1,15 @@
+/* -------------------------------------------------------------------------
+ * ccomplex.i
+ * ------------------------------------------------------------------------- */
+
+%{
+#include <complex.h>
+
+#define SWIG_ccomplex_construct(REAL, IMAG) ((REAL) + I * (IMAG))
+%}
+
+%define %fortran_typemap_ccomplex(CPLX_TYPE, CTYPE, FKIND)
+  %fortran_typemap_complex(CPLX_TYPE, SWIG_ccomplex_construct, CTYPE, FKIND)
+%enddef
+
+#error "C complex numbers are not currently supported"

Lib/fortran/complex.i

@@ -0,0 +1,62 @@
+%define %fortran_typemap_complex(CPPTYPE, CONSTRUCT_CPPTYPE, CTYPE, FKIND)
+
+%fragment("SWIG_complex_"{CTYPE}, "header", noblock=1) {
+extern "C" {
+typedef struct {
+  CTYPE real;
+  CTYPE imag;
+} SwigComplex_ ## CTYPE;
+}
+
+SWIGINTERN SwigComplex_ ## CTYPE SWIG_create_complex_ ## CTYPE(CTYPE real, CTYPE imag) {
+  SwigComplex_ ## CTYPE result;
+  result.real = real;
+  result.imag = imag;
+  return result;
+}
+}
+
+struct SwigComplex_ ## CTYPE;
+
+%naturalvar CPPTYPE;
+
+%fortran_intrinsic(SwigComplex_ ## CTYPE, complex, FKIND)
+%fortran_apply_typemaps(SwigComplex_ ## CTYPE, CPPTYPE)
+
+%apply SwigComplex_ ## CTYPE& { CPPTYPE*, CPPTYPE[], CPPTYPE[ANY] };
+
+%apply SwigComplex_ ## CTYPE { CPPTYPE };
+
+%typemap(ctype, in={SwigComplex_ ## CTYPE*}, null={SWIG_create_complex_ ## CTYPE(0, 0)}, fragment="SWIG_complex_"{CTYPE}, noblock=1) CPPTYPE {
+  SwigComplex_ ## CTYPE
+}
+%typemap(in, noblock=1) CPPTYPE {
+  $1 = CONSTRUCT_CPPTYPE($input->real, $input->imag);
+}
+%typemap(out, fragment="SWIG_complex_"{CTYPE}, noblock=1) CPPTYPE
+{$result = SWIG_create_complex_ ## CTYPE($1.real(), $1.imag());}
+
+%typemap(out, noblock=1) CPPTYPE&
+{$result = (SwigComplex_ ## CTYPE*)($1);}
+
+%apply CPPTYPE { const CPPTYPE& };
+%typemap(in, noblock=1) const CPPTYPE& ($*1_ltype temp) {
+  temp = CONSTRUCT_CPPTYPE($input->real, $input->imag);
+  $1 = &temp;
+}
+%typemap(out, noblock=1) const CPPTYPE&
+{$result = SWIG_create_complex_ ## CTYPE($1->real(), $1->imag());}
+
+%enddef // %fortran_typemap_complex
+
+#ifdef __cplusplus
+%include <std_complex.i>
+#else
+%{
+#ifdef __STDC_NO_COMPLEX__
+#error "This generated file requires C complex number support"
+#endif
+%}
+%include <ccomplex.i>
+#endif
+

Lib/fortran/fundamental.swg

@@ -44,12 +44,7 @@ subroutine %fortrantm(fout, bool)(imout, fout)
   use, intrinsic :: ISO_C_BINDING
   integer(kind=C_INT), intent(in) :: imout
   logical, intent(out) :: fout
-  ! TODO: fout = (imout /= 0) ???
-  if (imout /= 0) then
-    fout = .true.
-  else
-    fout = .false.
-  end if
+  fout = (imout /= 0)
 end subroutine
 }
 

Lib/fortran/std_complex.i

@@ -0,0 +1,20 @@
+/* -------------------------------------------------------------------------
+ * std_complex.i
+ * ------------------------------------------------------------------------- */
+
+%{
+#include <complex>
+%}
+
+namespace std {
+  %naturalvar complex;
+  template<typename T> class complex;
+}
+
+%define %fortran_typemap_std_complex(CTYPE, FKIND)
+  %template() std::complex<CTYPE>;
+  %fortran_typemap_complex(std::complex<CTYPE>, std::complex<CTYPE>, CTYPE, FKIND)
+%enddef
+
+%fortran_typemap_std_complex(float, C_FLOAT_COMPLEX)
+%fortran_typemap_std_complex(double, C_DOUBLE_COMPLEX)