Clean up, simplify, improve %constant usage

Make it more consistent with other swig languages

Author: sethrj

Doc/Manual/src/Fortran.md

@@ -656,6 +656,86 @@ end enum
 integer, parameter, public :: Cls_Foo = kind(Cls_Foo_Bar)
 ```
 
+## Constants
+
+A constant declaration can be wrapped as a Fortran *named constant*
+(a compile-time value defined by having the `parameter` attribute) or as
+an externally linked data object. Constants can be declared with:
+- the SWIG `%constant` directive,
+- simple `#define` macros,
+- enum values, and
+- `constexpr` global variables.
+The last item is a SWIG-Fortran extension. For an explanation of this behavior,
+see the "Compatibility note" under "A brief word about const" in the SWIG
+documentation. Note that this list does *not* include global `const` data,
+which is wrapped in the same way as mutable global data (though without the
+setter functions).
+
+ - Native enum values (enum is marked `%fortranconst` or was determined
+   automatically to be native compatible) 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 `%fortranbindc` also become C-bound external
+   constants.
+ - All other types will generate `getter` functions that return native Fortran
+   types.  
+
+Some compile-time constants can have definitions that are valid C but invalid
+Fortran.  A macro whose definition cannot be parsed by Fortran can have its
+value *replaced* with a simpler expression using the `%fortranconstvalue`
+directive.
+
+The following example shows the behavior of the various rules above:
+```swig
+%fortranconst fortranconst_int_global;
+%fortranconst fortranconst_float_global;
+%constant int fortranconst_int_global = 4;
+%constant float fortranconst_float_global = 1.23f;
+
+%fortranbindc constant_int_global;
+%constant int constant_int_global = 4;
+%constant float constant_float_global = 1.23f;
+
+%fortranconstvalue(4) MACRO_HEX_INT;
+
+%inline %{
+#define MACRO_INT 4
+const int extern_const_int = 4;
+#define MACRO_HEX_INT 0x4
+%}
+```
+will be translated to
+```fortran
+ integer(C_INT), parameter, public :: fortranconst_int_global = 4_C_INT
+ real(C_FLOAT), parameter, public :: fortranconst_float_global = 1.23_C_FLOAT
+ integer(C_INT), protected, public, &
+   bind(C, name="_wrap_constant_int_global") :: constant_int_global
+ real(C_FLOAT), protected, public, &
+   bind(C, name="_wrap_constant_float_global") :: constant_float_global
+ integer(C_INT), protected, public, &
+   bind(C, name="_wrap_MACRO_INT") :: MACRO_INT
+ public :: get_extern_const_int
+ integer(C_INT), parameter, public :: MACRO_HEX_INT = 4_C_INT
+```
+The symbols marked as `protected, public, bind(C)` have their values defined in
+the C wrapper code, where *any* valid expression can be parsed. The
+`get_extern_const_int` wrapper function is a SWIG-generated getter that returns
+the external value.
+
+String constants without special characters (a backslash or anything that must
+be escaped with a backslash) with a can generally be represented
+exactly in Fortran:
+```swig
+%fortranconst MSG_STRING;
+%inline %{
+#define MSG_STRING "This is a string"
+%}
+```
+will generate
+```fortran
+ character(kind=C_CHAR, len=*), parameter, public :: MSG_STRING = "This is a string"
+```
+
 ## Function pointers
 
 It is possible to pass function pointers between C and Fortran using SWIG. When
@@ -907,69 +987,6 @@ will generate a publicly accessible C-bound variable:
 integer(C_INT), public, bind(C, name="global_counter_c") :: global_counter_c
 ```
 
-### Constants
-
-A constant declaration can be wrapped as a Fortran *named constant*
-(a compile-time value defined by having the `parameter` attribute), as
-an externally linked data object, or as a wrapper function that returns the
-value as a native Fortran datatype. Constants can be declared with:
-- The SWIG `%constant` directive,
-- Simple `#define` macros, and
-- `constexpr` global variables.
-The last item is a SWIG-Fortran extension. For an explanation of this behavior,
-see the "Compatibility note" under "A brief word about const" in the SWIG
-documentation.
-
-All global `const` variables will be treated as regular global variables: they
-will be wrapped with getter functions. SWIG-declared `%constant`s whose
-data types cannot be [directly represented](#direct-c-binding) will be wrapped
-with getter functions. Constants marked with the `%fortranconst` directive are
-wrapped as Fortran module-level named constants. If declaring a C-linkage
-`%constant`, it is directly exposed to Fortran using `bind(C)`. Otherwise, a
-const global wrapper variable will be created in the C wrapper code and `bound`
-in the Fortran module.  
-
-Some compile-time constants can have definitions that are valid C but invalid
-Fortran.  A macro whose definition cannot be parsed by Fortran can have its
-value *replaced* with a simpler expression using the `%fortranconstvalue`
-directive.
-
-The following example shows the behavior of the various rules above:
-```swig
-%fortranconst fortranconst_int_global;
-%fortranconst fortranconst_float_global;
-%constant int fortranconst_int_global = 4;
-%constant float fortranconst_float_global = 1.23f;
-
-%constant int constant_int_global = 4;
-%constant float constant_float_global = 1.23f;
-
-%fortranconstvalue(4) MACRO_HEX_INT;
-
-%inline %{
-#define MACRO_INT 4
-const int extern_const_int = 4;
-#define MACRO_HEX_INT 0x4
-%}
-```
-will be translated to
-```fortran
- integer(C_INT), parameter, public :: fortranconst_int_global = 4_C_INT
- real(C_FLOAT), parameter, public :: fortranconst_float_global = 1.23_C_FLOAT
- integer(C_INT), protected, public, &
-   bind(C, name="_wrap_constant_int_global") :: constant_int_global
- real(C_FLOAT), protected, public, &
-   bind(C, name="_wrap_constant_float_global") :: constant_float_global
- integer(C_INT), protected, public, &
-   bind(C, name="_wrap_MACRO_INT") :: MACRO_INT
- public :: get_extern_const_int
- integer(C_INT), parameter, public :: MACRO_HEX_INT = 4_C_INT
-```
-The symbols marked as `protected, public, bind(C)` have their values defined in
-the C wrapper code, where *any* valid expression can be parsed. The
-`get_extern_const_int` wrapper function is a SWIG-generated getter that returns
-the external value.
-
 ## Classes
 
 C++ classes are transformed to Fortran *derived types*. These types have

Examples/fortran/bare/example.h

@@ -52,21 +52,28 @@ void print_cmyk(CmykEnum color);
 /* -------------------------------------------------------------------------
  * Global variables
  * ------------------------------------------------------------------------- */
+#if __cplusplus >= 201103
+#define CONSTEXPR constexpr
+#elif defined(SWIG)
+#define CONSTEXPR %constant
+#else
+#define CONSTEXPR const
+#endif
 
 //! An integer that is only known at link time
 extern const int linked_const_int;
 
 //! A simple integer
-const int simple_int = 4;
+CONSTEXPR int simple_int = 4;
 
 // A more complicated integer
-const int weird_int = (0x1337 | 0x10000);
+CONSTEXPR int weird_int = (0x1337 | 0x10000);
 
 //! A global constant wrapped as a native parameter
-const double approx_pi = 3.14160000001;
+CONSTEXPR double approx_pi = 3.14160000001;
 
 //! A global constant wrapped as a protected external variable
-const double approx_twopi = 2 * approx_pi;
+CONSTEXPR double approx_twopi = 2 * approx_pi;
 
 //! A global variable
 namespace foo {

Examples/fortran/bare/example.i

@@ -5,25 +5,29 @@
 #include "example.h"
 %}
 
-//! A const integer
-// const int param_int = 4;
-// const int wrapped_int = 0x1337;
+#ifdef SWIGFORTRAN
+// Force constants to be a compile-time native fortran parameter
+%fortranconst param_const;
+%fortranconst MY_SPECIAL_NUMBERS;
+%fortranconst approx_pi;
+%fortranconst so_excited;
+// Force constants to be defined in C++ but can be directly referenced in Fortran as link-time immutable variables
+%fortranbindc octal_const;
+%fortranbindc wrapped_const;
+%fortranbindc weird_int;
+#endif
 
+
+// Compile-time/link-time constants
 #define MY_SPECIAL_NUMBERS 5
 %constant int param_const = 911;
 %constant int octal_const = 0777;
 %constant int wrapped_const = 0xdeadbeef;
-
-// Force a constant to be a compile-time native fortran parameter
-%fortranconst approx_pi;
-
-#ifdef SWIGFORTRAN
+%constant so_excited = "wheee";
 
 // Ignore one of the functions that can't be overloaded correctly
 %ignore cannot_overload(int);
 
-#endif
-
 %include "example.h"
 
 

Examples/fortran/bare/runme.f90

@@ -53,6 +53,7 @@ subroutine test_consts()
   write(STDOUT, *) "pi is approximately ", approx_pi
   write(STDOUT, *) "2pi is approximately ", get_approx_twopi()
   write(STDOUT, *) "extern const int is ", get_linked_const_int()
+  write(STDOUT, *) so_excited
   ! Can't assign these
 !   wrapped_const = 2
 !   MY_SPECIAL_NUMBERS = 4

Examples/fortran/funcptr/runme.f90

@@ -31,11 +31,11 @@ program fortran_funptr_runme
   integer(C_INT) :: b = 3
   procedure(binary_op), pointer :: fptr => null()
 
-  call c_f_procpointer(add, fptr)
+  fptr => get_ADD()
   write(STDOUT,*) "SWIG-wrapped C function pointer:", do_op(a, b, fptr)
-  call c_f_procpointer(sub, fptr)                                 
+  fptr => get_SUB()
   write(STDOUT,*) "SWIG-wrapped C function pointer:", do_op(a, b, fptr)
-  call c_f_procpointer(mul, fptr)                                 
+  fptr => get_MUL()
   write(STDOUT,*) "SWIG-wrapped C function pointer:", do_op(a, b, fptr)
 
   ! Convert Fortran function to C function pointer

Examples/test-suite/fortran/fortran_callback_runme.F90

@@ -61,6 +61,10 @@ subroutine test_callback
   bin_op_ptr => get_a_callback("mul")
   ASSERT(associated(bin_op_ptr))
   ASSERT(bin_op_ptr(2, 5) == 10)
+  ! Get from the %callback-generated wrapper
+  bin_op_ptr => get_mul_cb()
+  ASSERT(associated(bin_op_ptr))
+  ASSERT(bin_op_ptr(2, 5) == 10)
 
   bin_op_ptr => get_a_callback("add")
   ASSERT(associated(bin_op_ptr))