Ada Conformity Assessment Authority      Home Conformity Assessment   Test Suite ARGAda Standard
 
Ada Reference Manual (Ada 2022)Legal Information
Contents   Index   References   Search   Previous   Next 

B.5 Interfacing with Fortran

1/3
The facilities relevant to interfacing with the Fortran language are the package Interfaces.Fortran and support for specifying the Convention aspect with convention_identifier Fortran.
2
The package Interfaces.Fortran defines Ada types whose representations are identical to the default representations of the Fortran intrinsic types Integer, Real, Double Precision, Complex, Logical, and Character in a supported Fortran implementation. These Ada types can therefore be used to pass objects between Ada and Fortran programs.

Static Semantics

3
The library package Interfaces.Fortran has the following declaration: 
4/5
with Ada.Numerics.Generic_Complex_Types;  -- see G.1.1
pragma Elaborate_All(Ada.Numerics.Generic_Complex_Types);
package Interfaces.Fortran
   with Pure is
5
   type Fortran_Integer is range implementation-defined;
6
   type Real             is digits implementation-defined;
   type Double_Precision is digits implementation-defined;
7
   type Logical is new Boolean;
8
   package Single_Precision_Complex_Types is
      new Ada.Numerics.Generic_Complex_Types (Real);
9
   type Complex is new Single_Precision_Complex_Types.Complex;
10
   subtype Imaginary is Single_Precision_Complex_Types.Imaginary;
   i : Imaginary renames Single_Precision_Complex_Types.i;
   j : Imaginary renames Single_Precision_Complex_Types.j;
10.1/5
   package Double_Precision_Complex_Types is
      new Ada.Numerics.Generic_Complex_Types (Double_Precision);
10.2/5
   type Double_Complex is new Double_Precision_Complex_Types.Complex;
10.3/5
   subtype Double_Imaginary is Double_Precision_Complex_Types.Imaginary;
11
   type Character_Set is implementation-defined character type;
12/3
   type Fortran_Character is array (Positive range <>) of Character_Set
      with Pack;
13
   function To_Fortran (Item : in Character) return Character_Set;
   function To_Ada (Item : in Character_Set) return Character;
14
   function To_Fortran (Item : in String) return Fortran_Character;
   function To_Ada     (Item : in Fortran_Character) return String;
15
   procedure To_Fortran (Item       : in String;
                         Target     : out Fortran_Character;
                         Last       : out Natural);
16
   procedure To_Ada (Item     : in Fortran_Character;
                     Target   : out String;
                     Last     : out Natural);
17
end Interfaces.Fortran;
18/5
The types Fortran_Integer, Real, Double_Precision, Logical, Complex, Double_Complex, Character_Set, and Fortran_Character are Fortran-compatible.
19
The To_Fortran and To_Ada functions map between the Ada type Character and the Fortran type Character_Set, and also between the Ada type String and the Fortran type Fortran_Character. The To_Fortran and To_Ada procedures have analogous effects to the string conversion subprograms found in Interfaces.COBOL. 

Implementation Requirements

20/3
An implementation shall support specifying aspect Convention with a Fortran convention_identifier for a Fortran-eligible type (see B.1). 

Implementation Permissions

21/5
An implementation may add additional declarations to the Fortran interface packages. For example, declarations are permitted for the character types corresponding to Fortran character kinds 'ascii' and 'iso_10646', which in turn correspond to ISO/IEC 646:1991 and to UCS-4 as specified in ISO/IEC 10646:2020. 

Implementation Advice

22
An Ada implementation should support the following interface correspondences between Ada and Fortran: 
23
An Ada procedure corresponds to a Fortran subroutine.
24
An Ada function corresponds to a Fortran function.
25
An Ada parameter of an elementary, array, or record type T is passed as a TF argument to a Fortran procedure, where TF is the Fortran type corresponding to the Ada type T, and where the INTENT attribute of the corresponding dummy argument matches the Ada formal parameter mode; the Fortran implementation's parameter passing conventions are used. For elementary types, a local copy is used if necessary to ensure by-copy semantics.
26
An Ada parameter of an access-to-subprogram type is passed as a reference to a Fortran procedure whose interface corresponds to the designated subprogram's specification. 
27
NOTE 1   An object of a Fortran-compatible record type, declared in a library package or subprogram, can correspond to a Fortran common block; the type also corresponds to a Fortran “derived type”.
28/5
NOTE 2   For Fortran facilities not addressed by this subclause, consider using the Fortran to C interoperability features defined in ISO/IEC 1594-1:2018 along with the C interfacing features defined in B.3.

Examples

29
Example of Interfaces.Fortran:
30
with Interfaces.Fortran;
use Interfaces.Fortran;
procedure Ada_Application is
31/5
   type Fortran_Matrix is 
      array (Fortran_Integer range <>,
             Fortran_Integer range <>) of Double_Precision
      with Convention => Fortran;                  -- stored in Fortran's
                                                   -- column-major order
   procedure Invert (Rank : in Fortran_Integer; X : in out Fortran_Matrix)
      with Import => True, Convention => Fortran; -- a Fortran subroutine
32
   Rank      : constant Fortran_Integer := 100;
   My_Matrix : Fortran_Matrix (1 .. Rank, 1 .. Rank);
33/5
   Precision: constant := 6;
   type Standard_Deviation is digits Precision
      with Convention => Fortran;
   Deviation : Standard_Deviation;
      -- Declarations to match the following Fortran declarations:
      --   integer, parameter :: precision = selected_real_kind(p=6)
      --   real(precision) :: deviation
34
begin
35
   ...
   My_Matrix := ...;
   ...
   Invert (Rank, My_Matrix);
   ...
36/5
   Deviation := ...;
   ...
37
end Ada_Application;

Contents   Index   References   Search   Previous   Next 
Ada-Europe Ada 2005 and 2012 Editions sponsored in part by Ada-Europe