Merge pull request #162 from swig-fortran/fortrilinos-fixes

Fixes for updating ForTrilinos

Author: sethrj

Examples/test-suite/fortran/Makefile.in

@@ -26,6 +26,7 @@ CPP_TEST_CASES = \
 	fortran_naming \
 	fortran_onlywrapped \
 	fortran_overloads \
+	fortran_std_span \
 	fortran_subroutine \
 	li_std_set \
 	complextest \

Examples/test-suite/fortran/string_constants_runme.F90

@@ -8,8 +8,8 @@ program string_constants_runme
   implicit none
   type(things) :: foo
   ! note: Z'deadbeef' and O'777' are used to generate hex and oct constants
-  character(C_CHAR), parameter :: CR = char(Z'0D', C_CHAR)
-  character(C_CHAR), parameter :: LF = char(O'12', C_CHAR)
+  character(C_CHAR), parameter :: CR = char(int(Z'0D'), C_CHAR)
+  character(C_CHAR), parameter :: LF = char(int(O'12'), C_CHAR)
   character(kind=C_CHAR, len=*), parameter :: &
     expected_aa3 = "A" // CR // "B" // LF // "C"
   character(kind=C_CHAR, len=:), allocatable :: actual_aa3

Examples/test-suite/fortran_global_const.i

@@ -50,3 +50,18 @@ typedef enum {
 
 %}
 
+/* Test wrapping everything */
+%fortranconst;
+%nofortranconst NFCEnum;
+
+%inline %{
+typedef enum {
+  FCSierra = 1,
+  FCJuliet
+} FCEnum;
+
+typedef enum {
+  NFCWhiskey = 0x123
+} NFCEnum;
+
+%}

Examples/test-suite/fortran_std_span.i

@@ -11,16 +11,16 @@ class span
   typedef int index_type;
   typedef _Tp* pointer;
 
-  span() : d_ptr(NULL), d_size(0) {}
-  span(pointer d, index_type s) : d_ptr(d), d_size(s) {}
-  span(pointer first, pointer last) : d_ptr(first), d_size(last - first) {}
+  span() : ptr_(NULL), size_(0) {}
+  span(pointer d, index_type s) : ptr_(d), size_(s) {}
+  span(pointer first, pointer last) : ptr_(first), size_(last - first) {}
 
-  pointer data() const { return d_ptr; }
-  index_type size() const { return d_size; }
+  pointer data() const { return ptr_; }
+  index_type size() const { return size_; }
 
  private:
-  pointer d_ptr;
-  index_type d_size;
+  pointer ptr_;
+  index_type size_;
 };
 } // namespace std
 
@@ -30,6 +30,8 @@ class span
 
 %template() std::span<int>;
 %template() std::span<const int>;
+%template() std::span<unsigned int>;
+%template() std::span<const unsigned int>;
 
 %inline %{
 std::span<int> get_by_value() {

Lib/fortran/fortranarray.swg

@@ -97,7 +97,8 @@ end subroutine}
   %typemap(imtype) CPPTYPE& = CPPTYPE;
   %typemap(ctype) CPPTYPE& = CPPTYPE;
 
-  // Update the resulting Fortran pointer.
-  //%typemap(fargout, match="argout", noblock=1) CPPTYPE& = VTYPE[]&;
+  // Update the resulting Fortran pointer, but only by reference (not const ref)
+  %typemap(fargout, match="fin", noblock=1) CPPTYPE& = VTYPE ARRAY[];
+  %typemap(fargout, noblock=1) const CPPTYPE& {};
 %enddef
 

Lib/fortran/fundamental.swg

@@ -203,7 +203,10 @@ end subroutine}
 
   // Define proxy code typemaps for an array of this type
   %fortran_typemap_finout(CTYPE[], CTYPE ARRAY[])
-
+  %typemap(fargout, fragment="SWIG_fout"{CTYPE[]}, noblock=1) CTYPE ARRAY[] {
+  call %fortrantm(fout, CTYPE[])($1, $input)
+  }
+  %typemap(fargout) CTYPE const ARRAY[] = CTYPE ARRAY[];
 %enddef
 
 /*!
@@ -225,6 +228,8 @@ end subroutine}
 
   %typemap(fin) DSTTYPE ARRAY[] = SRCTYPE ARRAY[];
   %typemap(fout) DSTTYPE ARRAY[] = SRCTYPE ARRAY[];
+  %typemap(fargout) DSTTYPE ARRAY[] = SRCTYPE ARRAY[];
+  %typemap(fargout) DSTTYPE const ARRAY[] = SRCTYPE const ARRAY[];
 %enddef
 
 /* -------------------------------------------------------------------------

Lib/fortran/std_container.i

@@ -167,9 +167,9 @@ int fix_fortran_dims(Node *n, const char *tmap_name, String *typemap) {
 }
 
 /* -------------------------------------------------------------------------
- * \brief Determine whether to wrap an enum as a value.
+ * \brief Determine whether to wrap an enum as a fortran parameter.
  */
-bool is_native_enum(Node *n) {
+bool is_native_enum_decl(Node *n) {
   String *enum_feature = Getattr(n, "feature:fortran:const");
   if (!enum_feature) {
     // Determine from enum values
@@ -2897,7 +2897,7 @@ int FORTRAN::enumDeclaration(Node *n) {
 
   // Determine whether to add enum as a native fortran enumeration. If false,
   // the values are all wrapped as constants. Only create the list if values are defined.
-  bool is_native = is_native_enum(n) && firstChild(n);
+  bool is_native = is_native_enum_decl(n) && firstChild(n);
 
   // Check all enum values and update their names
   for (Node *c = firstChild(n); c; c = nextSibling(c)) {
@@ -3021,25 +3021,25 @@ int FORTRAN::callbackfunctionHandler(Node *n) {
  * and enum values.
  *
  * - Native enum values will become enumerators
- * - Constants marked with `%fortranconst` will be rendered as *named constants*
  * - Non-native enum values become C-bound external constants
+ * - Constants marked with `%fortranconst` will be rendered as *named constants*
  * - Constants marked with `%fortranbindc` also become C-bound external constants
  * - All other types will generate `getter` functions that return native fortran types.
  */
 int FORTRAN::constantWrapper(Node *n) {
   enum {
     NATIVE_ENUM,
-    NATIVE_CONSTANT,
     EXTERN_ENUM,
+    NATIVE_CONSTANT,
     EXTERN_CONSTANT
   } constant_type;
 
   if (d_enum_public) {
     constant_type = NATIVE_ENUM;
-  } else if (GetFlag(n, "feature:fortran:const") || Getattr(n, "feature:fortran:constvalue")) {
-    constant_type = NATIVE_CONSTANT;
   } else if (Cmp(nodeType(n), "enumitem") == 0) {
     constant_type = EXTERN_ENUM;
+  } else if (GetFlag(n, "feature:fortran:const") || Getattr(n, "feature:fortran:constvalue")) {
+    constant_type = NATIVE_CONSTANT;
   } else if (GetFlag(n, "feature:fortran:bindc") && has_constant_storage(n)) {
     constant_type = EXTERN_CONSTANT;
   } else {