Source Code and Kind Mapping

Oct 13, 2025 by recoveryshake.com 112 views

Understanding the Issue

When working with module parameters used as kind expressions for procedure arguments, it's essential to ensure that the parameters are properly imported and mapped. In this article, we'll delve into the issue of module parameters not being imported for argument kind, exploring the source code, kind mapping, and the generated wrapper code.

Source Code and Kind Mapping

Let's start with the source code, test.F90, which defines a module test with a function a_times_b:

module test
  implicit none

  integer, parameter :: jprb = 8

contains

  function a_times_b(a, b)
    real(kind=jprb) :: a_times_b
    real(kind=jprb), intent(in) :: a, b
    a_times_b = a * b
  end function a_times_b

end module test

The kind mapping, kind_map, is defined as follows:

{
  'real': {
    'jprb': 'double',
  },
}

This mapping associates the parameter jprb with the kind double.

Compilation and Error

When running the following commands:

f90wrap -m test -k kind_map test.F90

f2py-f90wrap -c --f77exec=gfortran --f90exec=gfortran --backend=meson -m _test f90wrap_test.f90 ./test.F90

We encounter compiler errors with gfortran:

../_test-f2pywrappers2.f90:7:16:
       real(kind=jprb) a                1
Error: Parameter ‘jprb’ at (1) has not been declared or is a variable, which does not reduce to a constant expression
...

Generated Wrapper Code

Inspecting the generated _test-f2pywrappers2.f90 file, we can see that the constructor imports jprb from the compiled module, but the wrapper for a_times_b does not:

module _test_f2pywrappers
  use _test
  implicit none

  ! _test_a_times_b wrapper
  interface
    function _test_a_times_b(a, b) result(a_times_b)
      use _test, only: jprb
      real(kind=jprb) :: a_times_b
      real(kind=jprb), intent(in) :: a, b
    end function _test_a_times_b
  end interface
end module _test_f2pywrappers

As we can see, the wrapper for a_times_b does not import jprb from the compiled module.

Conclusion

In conclusion, the issue of module parameters not being imported for argument kind is a result of the generated wrapper code not properly importing the parameter from the compiled module. This is a bug in the f2py-f90wrap tool, and it's essential to report this issue to the developers.

Workaround

As a workaround, we can manually import the parameter jprb in the wrapper code:

module _test_f2pywrappers
  use _test
  implicit none

  ! _test_a_times_b wrapper
  interface
    function _test_a_times_b(a, b) result(a_times_b)
      use _test, only: jprb
      real(kind=jprb) :: a_times_b
      real(kind=jprb), intent(in) :: a, b
    end function _test_a_times_b
  end interface
  use _test, only: jprb
end module _test_f2pywrappers

This workaround ensures that the parameter jprb is properly imported and used in the wrapper code.

Future Development

To resolve this issue, the f2py-f90wrap tool should be updated to properly import module parameters used as kind expressions for procedure arguments. This will ensure that the generated wrapper code accurately reflects the original source code and kind mapping.

Recommendations

When working with module parameters used as kind expressions for procedure arguments, it's essential to:

Ensure that the kind mapping is accurate and complete.
Verify that the generated wrapper code properly imports the parameter from the compiled module.
Report any issues or bugs to the f2py-f90wrap developers.

Q: What is the issue with module parameters not being imported for argument kind?

A: The issue arises when the f2py-f90wrap tool fails to properly import module parameters used as kind expressions for procedure arguments. This results in compiler errors and incorrect wrapper code.

Q: What is the source code and kind mapping that demonstrates the issue?

A: The source code, test.F90, is as follows:

module test
  implicit none

  integer, parameter :: jprb = 8

contains

  function a_times_b(a, b)
    real(kind=jprb) :: a_times_b
    real(kind=jprb), intent(in) :: a, b
    a_times_b = a * b
  end function a_times_b

end module test

The kind mapping, kind_map, is defined as:

{
  'real': {
    'jprb': 'double',
  },
}

Q: What are the compilation and error commands that demonstrate the issue?

A: The compilation and error commands are as follows:

f90wrap -m test -k kind_map test.F90

f2py-f90wrap -c --f77exec=gfortran --f90exec=gfortran --backend=meson -m _test f90wrap_test.f90 ./test.F90

This results in the following compiler error:

../_test-f2pywrappers2.f90:7:16:
       real(kind=jprb) a                1
Error: Parameter ‘jprb’ at (1) has not been declared or is a variable, which does not reduce to a constant expression
...

Q: What is the generated wrapper code that demonstrates the issue?

A: The generated wrapper code, _test-f2pywrappers2.f90, is as follows:

module _test_f2pywrappers
  use _test
  implicit none

  ! _test_a_times_b wrapper
  interface
    function _test_a_times_b(a, b) result(a_times_b)
      use _test, only: jprb
      real(kind=jprb) :: a_times_b
      real(kind=jprb), intent(in) :: a, b
    end function _test_a_times_b
  end interface
end module _test_f2pywrappers

As we can see, the wrapper for a_times_b does not import jprb from the compiled module.

Q: What is the workaround for this issue?

A: The workaround is to manually import the parameter jprb in the wrapper code:

module _test_f2pywrappers
  use _test
  implicit none

  ! _test_a_times_b wrapper
  interface
    function _test_a_times_b(a, b) result(a_times_b)
      use _test, only: jprb
      real(kind=jprb) :: a_times_b
      real(kind=jprb), intent(in) :: a, b
    end function _test_a_times_b
  end interface
  use _test, only: jprb
end module _test_f2pywrappers

This ensures that the parameter jprb is properly imported and used in the wrapper code.

Q: What are the recommendations for working with module parameters used as kind expressions for procedure arguments?

A: When working with module parameters used as kind expressions for procedure arguments, it's essential to:

Ensure that the kind mapping is accurate and complete.
Verify that the generated wrapper code properly imports the parameter from the compiled module.
Report any issues or bugs to the f2py-f90wrap developers.

By following these recommendations, you can ensure that your code is accurate, efficient, and easy to maintain.

Q: What is the future development plan for resolving this issue?

A: The f2py-f90wrap tool should be updated to properly import module parameters used as kind expressions for procedure arguments. This will ensure that the generated wrapper code accurately reflects the original source code and kind mapping.

Q: How can I contribute to the development of f2py-f90wrap?

A: You can contribute to the development of f2py-f90wrap by reporting issues, providing feedback, and submitting patches. You can also participate in the f2py-f90wrap community by joining the mailing list or contributing to the documentation.