# B.5 Interfacing with Fortran

This Reference Manual output has not been verified, and may contain omissions or errors. Report any problems on the tracking issue

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.

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

3The library package Interfaces.Fortran has the following declaration:

```
with Ada.Numerics.Generic_Complex_Types; -- see G.1.1
pragma Elaborate_All(Ada.Numerics.Generic_Complex_Types);
package Interfaces.Fortran
with Pure is
5type Fortran_Integer is range implementation-defined;
6type Real is digits implementation-defined;
type Double_Precision is digits implementation-defined;
7type Logical is new Boolean;
8package Single_Precision_Complex_Types is
new Ada.Numerics.Generic_Complex_Types (Real);
9type Complex is new Single_Precision_Complex_Types.Complex;
10subtype 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/5package Double_Precision_Complex_Types is
new Ada.Numerics.Generic_Complex_Types (Double_Precision);
10.2/5type Double_Complex is new Double_Precision_Complex_Types.Complex;
10.3/5subtype Double_Imaginary is Double_Precision_Complex_Types.Imaginary;
11type Character_Set is implementation-defined character type;
12/3type Fortran_Character is array (Positive range <>) of Character_Set
with Pack;
13function To_Fortran (Item : in Character) return Character_Set;
function To_Ada (Item : in Character_Set) return Character;
14function To_Fortran (Item : in String) return Fortran_Character;
function To_Ada (Item : in Fortran_Character) return String;
15procedure To_Fortran (Item : in String;
Target : out Fortran_Character;
Last : out Natural);
16procedure To_Ada (Item : in Fortran_Character;
Target : out String;
Last : out Natural);
17end Interfaces.Fortran;
```

The types Fortran_Integer, Real, Double_Precision, Logical, Complex, Double_Complex, Character_Set, and Fortran_Character are Fortran-compatible.

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/3An implementation shall support specifying aspect Convention with a Fortran *convention*_`identifier`

for a Fortran-eligible type (see B.1).

#### Implementation Permissions

21/5An 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:2017 .

#### Implementation Advice

22An Ada implementation should support the following interface correspondences between Ada and Fortran:

- An Ada procedure corresponds to a Fortran subroutine.
- An Ada function corresponds to a Fortran function.
- 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.
- 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.

#### Examples

29*Example of Interfaces.Fortran:*

```
with Interfaces.Fortran;
use Interfaces.Fortran;
procedure Ada_Application is
31/5type 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
32Rank : constant Fortran_Integer := 100;
My_Matrix : Fortran_Matrix (1 .. Rank, 1 .. Rank);
32.1/5Precision: 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
33begin
34...
My_Matrix := ...;
...
Invert (Rank, My_Matrix);
...
34.1/5Deviation := ...;
...
35end Ada_Application;
```