Contents   Index   Previous   Next

B.5 Interfacing with Fortran

1
   {interface to Fortran} {Fortran interface} The facilities relevant to interfacing with the Fortran language are the package Interfaces.Fortran and support for the Import, Export and Convention pragmas 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
with Ada.Numerics.Generic_Complex_Types;  -- see G.1.1
pragma Elaborate_All(Ada.Numerics.Generic_Complex_Types);
package Interfaces.Fortran is
   pragma Pure(Fortran);
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;
11
   type Character_Set is implementation-defined character type;
12
   type Fortran_Character is array (Positive range <>) of Character_Set;
   pragma Pack (Fortran_Character);
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;
17.a.1/1
Implementation defined: The types Fortran_Integer, Real, Double_Precision, and Character_Set in Interfaces.Fortran.
17.a
Ramification: The means by which the Complex type is provided in Interfaces.Fortran creates a dependence of Interfaces.Fortran on Numerics.Generic_Complex_Types (see G.1.1). This dependence is intentional and unavoidable, if the Fortran-compatible Complex type is to be useful in Ada code without duplicating facilities defined elsewhere.
18
    The types Fortran_Integer, Real, Double_Precision, Logical, Complex, 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
    An implementation shall support pragma Convention with a Fortran convention_identifier for a Fortran-eligible type (see B.1).

Implementation Permissions

21
    An implementation may add additional declarations to the Fortran interface packages. For example, the Fortran interface package for an implementation of Fortran 77 (ANSI X3.9-1978) that defines types like Integer*n, Real*n, Logical*n, and Complex*n may contain the declarations of types named Integer_Star_n, Real_Star_n, Logical_Star_n, and Complex_Star_n. (This convention should not apply to Character*n, for which the Ada analog is the constrained array subtype Fortran_Character (1..n).) Similarly, the Fortran interface package for an implementation of Fortran 90 that provides multiple kinds of intrinsic types, e.g. Integer (Kind=n), Real (Kind=n), Logical (Kind=n), Complex (Kind=n), and Character (Kind=n), may contain the declarations of types with the recommended names Integer_Kind_n, Real_Kind_n, Logical_Kind_n, Complex_Kind_n, and Character_Kind_n.
21.a
Discussion: Implementations may add auxiliary declarations as needed to assist in the declarations of additional Fortran-compatible types. For example, if a double precision complex type is defined, then Numerics.Generic_Complex_Types may be instantiated for the double precision type. Similarly, if a wide character type is defined to match a Fortran 90 wide character type (accessible in Fortran 90 with the Kind modifier), then an auxiliary character set may be declared to serve as its component type.

Implementation Advice

22
    An Ada implementation should support the following interface correspondences between Ada and Fortran:
23
24
25
26
NOTES
27
17  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''.

Examples

28
    Example of Interfaces.Fortran:
29
with Interfaces.Fortran;
use Interfaces.Fortran;
procedure Ada_Application is
30
   type Fortran_Matrix is array (Integer range <>,
                                 Integer range <>) of Double_Precision;
   pragma Convention (Fortran, Fortran_Matrix);    -- stored in Fortran's
                                                   -- column-major order
   procedure Invert (Rank : in Fortran_Integer; X : in out Fortran_Matrix);
   pragma Import (Fortran, Invert);                -- a Fortran subroutine
31
   Rank      : constant Fortran_Integer := 100;
   My_Matrix : Fortran_Matrix (1 .. Rank, 1 .. Rank);
32
begin
33
   ...
   My_Matrix := ...;
   ...
   Invert (Rank, My_Matrix);
   ...
34
end Ada_Application;

Contents   Index   Previous   Next   Legal