Fortran DLL in Delphi - delphi

Question

I am trying to compile some very old Fortran procedures in a DLL, so that to be able to use them with Delphi. Although the Fortran code is not very large (750-800 lines), its structure is very complicated with dozens of GOTO commands and the translation is not easy (I tried to make some useful code of it, but I failed).
Although I am new in Fortran, and not very experienced in calling DLLs, I gradually managed to overcome all the difficulties but for one, that is to be able to call the Fortran Subroutine with multiple dynamic arrays. Here’s a simple example that I created:
SUBROUTINE MYSUB1( NoEquations, INTARR1 )
!DEC$ ATTRIBUTES DLLEXPORT::MYSUB1
!DEC$ ATTRIBUTES C, REFERENCE, ALIAS:'MYSUB1' :: MYSUB1
C
C***************************************************************
C
INTEGER NoEquations, I
INTEGER INTARR1(*)
C
C***************************************************************
C
DO 100, I=1,NoEquations
INTARR1(I) = I
100 CONTINUE
RETURN
C
END
SUBROUTINE MYSUB2( NoEquations, INTARR1, INTARR2 )
!DEC$ ATTRIBUTES DLLEXPORT::MYSUB2
!DEC$ ATTRIBUTES C, REFERENCE, ALIAS:'MYSUB2' :: MYSUB2
C
C***************************************************************
C
INTEGER NoEquations, I
INTEGER INTARR1(*)
INTEGER INTARR2(*)
C
C***************************************************************
C
DO 100, I=1,NoEquations
INTARR2(I) = INTARR1(I)
100 CONTINUE
RETURN
C
END
I compile the Fortran code with mingw-w64 with the following command:
gfortran -shared -mrtd -fno-underscoring -o simple.dll simple.f
And I declare the procedure from within Delphi with:
procedure mysub1(var NoEquations: integer; var INTARR1 : array of integer); stdcall; external 'simple.dll';
procedure mysub2(var NoEquations: integer; var INTARR1,INTARR2: array of integer); stdcall; external 'simple.dll';
The Delphi proram compiles correctly, but when I run it, mysub1 works correctly and updates INTARR1, but mysub2 gives me an Access Violation. Obviously, the second dynamic array confuses the compiler, but I do not know how to make it understand.
Thanks in advance

Answer 1

I do not know Delphi, but here is what you can do to create a DLL accessible from the C language. I hope you find it helpful. Here is your F77 code modified to make it interoperable via iso_c_binding module features of Fortran:
SUBROUTINE MYSUB1(NoEquations,INTARR1) bind(C,name="MYSUB1")
!DEC$ ATTRIBUTES DLLEXPORT :: MYSUB1
use, intrinsic :: iso_c_binding, only: IK => c_int32_t
integer(IK), intent(in), value :: NoEquations
integer(IK), intent(out) :: INTARR1(NoEquations)
integer :: I
DO 100, I=1,NoEquations
INTARR1(I) = I
100 CONTINUE
RETURN
END SUBROUTINE MYSUB1
C***************************************************************
C***************************************************************
SUBROUTINE MYSUB2(NoEquations,INTARR1,INTARR2)
+bind(C,name="MYSUB2")
!DEC$ ATTRIBUTES DLLEXPORT :: MYSUB2
use, intrinsic :: iso_c_binding, only: IK => c_int32_t
integer(IK), intent(in), value :: NoEquations
integer(IK), intent(in) :: INTARR1(NoEquations)
integer(IK), intent(out) :: INTARR2(NoEquations)
integer :: I
DO 100, I=1,NoEquations
INTARR2(I) = INTARR1(I)
100 CONTINUE
RETURN
END SUBROUTINE MYSUB2
Note the many subtle but important changes that I have made to your code to make it interoperable with C:
The bind(C,name="MYSUB1") fixes the subroutine's name so you do not need the extra second compiler directives (which I have now removed from your code).
Also, note the value attribute which tells the compiler to pass by value as is done in C.
Also, note that I define the kinds of integers in the interfaces of the subroutine as c_int32_t to be compatible with the C processor's integer kinds.
Also, note that I have converted your assumed-size INTARR1 and INTARR2 arrays to explicit-shape arrays INTARR1(NoEquations), INTARR1(NoEquations).
Since you have the Intel !DEC$ compiler directives in your code, I assume that you are using the Intel Fortran compiler on Windows. Note that I removed your second lines of directives in both Fortran subroutines.
Now, assuming that you store the above code in a file named mysubs.F, then compiling this file via the Intel Fortran compiler ifort on the Intel-Windows command prompt as in the following command,
ifort mysubs.F /dll /out:libsubs
will generate a DLL named mysubs.dll in the current folder and print the following message on the screen,
Intel(R) Visual Fortran Intel(R) 64 Compiler for applications running on Intel(R) 64, Version 19.1.1.216 Build 20200306
Copyright (C) 1985-2020 Intel Corporation. All rights reserved.
Microsoft (R) Incremental Linker Version 14.16.27027.1
Copyright (C) Microsoft Corporation. All rights reserved.
-out:mysubs.dll
-dll
-implib:mysubs.lib
mysubs.obj
Creating library mysubs.lib and object mysubs.exp
To test this DLL, you can try the following C code stored in main.c,
#include <stdio.h>
#include <stdint.h>
#include <string.h>
void MYSUB1(int32_t, int32_t []);
void MYSUB2(int32_t, int32_t [], int32_t []);
int main(int argc, char *argv[])
{
const int32_t NoEquations = 5;
int32_t INTARR1[NoEquations];
int32_t INTARR2[NoEquations];
int loop;
// C rules for argument passing apply here
MYSUB1(NoEquations,INTARR1);
printf("\nINTARR1:\n"); for(loop = 0; loop < NoEquations; loop++) printf("%d ", INTARR1[loop]);
MYSUB2(NoEquations,INTARR1,INTARR2);
printf("\nINTARR2:\n"); for(loop = 0; loop < NoEquations; loop++) printf("%d ", INTARR2[loop]);
return 0;
}
Compiling this C code with the Intel C compiler,
icl main.c -c
prints the following on screen,
Intel(R) C++ Intel(R) 64 Compiler for applications running on Intel(R) 64, Version 19.1.1.216 Build 20200306
Copyright (C) 1985-2020 Intel Corporation. All rights reserved.
main.c
and generates the C main object file. Finally, link the C object file with the Fortran DLL library to generate the executable via the following command,
icl main.obj mysubs.lib -o main.exe
which prints the following on screen,
Intel(R) C++ Intel(R) 64 Compiler for applications running on Intel(R) 64, Version 19.1.1.216 Build 20200306
Copyright (C) 1985-2020 Intel Corporation. All rights reserved.
Microsoft (R) Incremental Linker Version 14.16.27027.1
Copyright (C) Microsoft Corporation. All rights reserved.
-out:main.exe
main.obj
mysubs.lib
Testing the DLL call. Simply call the generated executable main.exe,
main.exe
which prints on screen,
INTARR1:
1 2 3 4 5
INTARR2:
1 2 3 4 5
Now, to call this DLL from Delphi, simply assume that you are calling the C functions with the prototypes specified in the C main code. That's all. No further dealing with Fortran from inside Delphi.
Final advice:
Fortran has powerful standard interoperability features, like the ones I have added to your F77 code, that can easily connect almost any Fortran code to any language (via C).
Stay away from FORTRAN77 which is almost a half-century old, even Fortran 90 is already more than 3 decades old. The latest Fortran standard was released in 2018, which together with Fortran 2008, makes Fortran an extremely powerful, high-level, fast, natively vectorized, concurrent, shared, and distributed parallel programming language for numerical computing.