Add Fortran back-end

Author: znicholls

meson.build

@@ -54,6 +54,9 @@ if pyprojectwheelbuild_enabled
   # Specify all the other source Fortran files (original files and managers)
   # Injected with `script/inject-srcs-into-meson-build.py`
   srcs_ancillary_lib = files(
+    'src/example_fgen_basic/error_v/creation.f90',
+    'src/example_fgen_basic/error_v/error_v.f90',
+    'src/example_fgen_basic/fpyfgen/base_finalisable.f90',
     'src/example_fgen_basic/get_wavelength.f90',
     'src/example_fgen_basic/kind_parameters.f90',
   )

src/example_fgen_basic/error_v/creation.f90

@@ -0,0 +1,44 @@
+!> Error creation
+!>
+!> A very basic demo to get the idea.
+!
+! TODO: discuss - we should probably have some convention for module names.
+! The hard part is avoiding them becoming too long...
+module m_error_v_creation
+
+    use m_error_v, only: ErrorV, NO_ERROR_CODE
+
+    implicit none
+    private
+
+    public :: create_error
+
+contains
+
+    function create_error(inv) result(err)
+        !! Create an error
+        !!
+        !! If an odd number is supplied, the error code is no error (TODO: cross-ref).
+        !! If an even number is supplied, the error code is 1.
+        !! If a negative number is supplied, the error code is 2.
+
+        integer, intent(in) :: inv
+        !! Value to use to create the error
+
+        type(ErrorV) :: err
+        !! Created error
+
+        if (inv < 0) then
+            err = ErrorV(code=2, message="Negative number supplied")
+            return
+        end if
+
+        if (mod(inv, 2) .eq. 0) then
+            err = ErrorV(code=1, message="Even number supplied")
+        else
+            err = ErrorV(code=0)
+        end if
+
+    end function create_error
+
+end module m_error_v_creation

src/example_fgen_basic/error_v/error_v.f90

@@ -0,0 +1,98 @@
+!> Error value
+!>
+!> Inspired by the excellent, MIT licensed
+!> https://github.com/samharrison7/fortran-error-handler
+!>
+!> Fortran doesn't have a null value.
+!> As a result, we introduce this derived type
+!> with the convention that a code of 0 indicates no error.
+module m_error_v
+
+    ! TODO: switch `m_` prefix to project name prefix
+    ! (e.g. fpyfgen, "Fortran-code for Python-Fortran wrapper Generator")
+    ! (same idea as `tomlf_` prefix)
+    ! TODO: move this to standalone repo (eventually)
+    use fpyfgen_base_finalisable, only: BaseFinalisable
+
+    implicit none
+    private
+
+    integer, parameter, public :: NO_ERROR_CODE = 0
+    !! Code that indicates no error
+
+    type, extends(BaseFinalisable), public :: ErrorV
+    !! Error value
+
+        integer :: code = 1
+        !! Error code
+
+        character(len=128) :: message = ""
+        ! TODO: think about making the message allocatable to handle long messages
+
+        ! TODO: think about adding idea of critical
+        ! (means you can stop but also unwind errors and traceback along the way)
+
+        ! TODO: think about adding trace (might be simpler than compiling with traceback)
+
+    contains
+
+        private
+
+        procedure, public:: build, finalise
+        ! get_res sort of not needed (?)
+        ! get_err sort of not needed (?)
+
+    end type ErrorV
+
+    interface ErrorV
+    !! Constructor interface - see build (TODO: figure out cross-ref syntax) for details
+    ! This is what allows us to do ErrorV(...) when using this class
+        module procedure :: constructor
+    end interface ErrorV
+
+contains
+
+    function constructor(code, message) result(self)
+        !! Constructor - see build (TODO: figure out cross-ref syntax) for details
+
+        integer, intent(in) :: code
+        character(len=*), optional, intent(in) :: message
+
+        type(ErrorV) :: self
+
+        call self % build(code, message)
+
+    end function constructor
+
+    subroutine build(self, code, message)
+        !! Build instance
+
+        class(ErrorV), intent(inout) :: self
+        ! Hopefully can leave without docstring (like Python)
+
+        integer, intent(in) :: code
+        !! Error code
+        !!
+        !! Use [TODO: figure out xref] `NO_ERROR_CODE` if there is no error
+
+        character(len=*), optional, intent(in) :: message
+        !! Error message
+
+        self % code = code
+        if (present(message)) then
+            self % message = message
+        end if
+
+    end subroutine build
+
+    subroutine finalise(self)
+        !! Finalise the instance (i.e. free/deallocate)
+
+        class(ErrorV), intent(inout) :: self
+        ! Hopefully can leave without docstring (like Python)
+
+        ! If we make message allocatable, deallocate here
+
+    end subroutine finalise
+
+end module m_error_v

src/example_fgen_basic/fpyfgen/base_finalisable.f90

@@ -0,0 +1,46 @@
+!> Base class for classes that can be wrapped with pyfgen.
+!>
+!> Such classes must always be finalisable, to help with memory management
+!> across the Python-Fortran interface.
+module fpyfgen_base_finalisable
+
+    implicit none
+    private
+
+    integer, parameter, public :: INVALID_INSTANCE_INDEX = -1
+    !! Value that denotes an invalid model index
+
+    public :: BaseFinalisable
+
+    type, abstract :: BaseFinalisable
+
+        integer :: instance_index = INVALID_INSTANCE_INDEX
+        !! Unique identifier for the instance.
+        !!
+        !! Set to a value > 0 when the instance is in use,
+        !! set to `INVALID_INSTANCE_INDEX` (TODO xref) otherwise.
+        !! The value is linked to the position in a manager array stored elsewhere.
+        !! This value shouldn't be modified from outside the manager
+        !! unless you really know what you're doing.
+
+    contains
+
+        private
+
+        procedure(derived_type_finalise), public, deferred :: finalise
+
+    end type BaseFinalisable
+
+    interface
+
+        subroutine derived_type_finalise(self)
+            !! Finalise the instance (i.e. free/deallocate)
+
+            import :: BaseFinalisable
+            class(BaseFinalisable), intent(inout) :: self
+
+        end subroutine derived_type_finalise
+
+    end interface
+
+end module fpyfgen_base_finalisable