B.1 Interfacing Pragmas
Import is used to import an entity defined in a foreign language into
an Ada program, thus allowing a foreign-language subprogram to be called
from Ada, or a foreign-language variable to be accessed from Ada. In
contrast, a pragma
Export is used to export an Ada entity to a foreign language, thus allowing
an Ada subprogram to be called from a foreign language, or an Ada object
to be accessed from a foreign language. The pragma
Import and Export are intended primarily for objects and subprograms,
although implementations are allowed to support other entities.
Convention is used to specify that an Ada entity should use the conventions
of another language. It is intended primarily for types and “callback”
subprograms. For example, “pragma
implies that Matrix should be represented according to the conventions
of the supported Fortran implementation, namely column-major order.
Linker_Options is used to specify the system linker parameters needed
when a given compilation unit is included in a partition.
is a representation pragma
that is one of the pragma
Import, Export, or Convention. Their forms, together with that of the
Linker_Options, are as follows:
Import and Export, the argument for Link_Name shall not be given without
unless the argument for External_Name is given.
Name Resolution Rules
The expected type for a string_expression
in an interfacing pragma or in pragma Linker_Options is String.
of an interfacing pragma shall be the name of a convention
convention names are implementation defined, except for certain language-defined
ones, such as Ada and Intrinsic, as explained in 6.3.1
convention names generally represent the calling conventions of foreign
languages, language implementations, or specific run-time models.
convention of a callable entity is its calling convention
is a convention_identifier
for a language, then a type T is said to be compatible with convention
, (alternatively, is said to be an L-compatible type
any of the following conditions are met:
- T is declared in a language interface
package corresponding to L and is defined to be L-compatible
(see B.3, B.3.1,
B.3.2, B.4, B.5),
L has been specified for T in a pragma
Convention, and T is eligible for convention L; that is:
- T is an array type with either
an unconstrained or statically-constrained first subtype, and its component
type is L-compatible,
- T is a record type that has
no discriminants and that only has components with statically-constrained
subtypes, and each component type is L-compatible,
- T is an access-to-object type,
and its designated type is L-compatible,
- T is an access-to-subprogram
type, and its designated profile's parameter and result types are all
- T is derived from an L-compatible
- The implementation permits T as an
Convention applies to a type, then the type shall either be compatible
with or eligible for the convention specified in the pragma.
specified as the Entity argument to a pragma
Import (or pragma
Export) is said to be imported
The declaration of an imported object shall not include
an explicit initialization expression. Default initializations are not
The type of an imported or exported object shall
be compatible with the convention specified in the corresponding pragma
For an imported or exported subprogram, the result
and parameter types shall each be compatible with the convention specified
in the corresponding pragma.
Export, and Convention pragma
are representation pragmas that specify the convention
addition, Import and Export pragma
specify the imported
aspects of representation,
interfacing pragma is a program unit pragma when applied to a program
unit (see 10.1.5
An interfacing pragma
defines the convention of the entity denoted by the local_name
The convention represents the calling convention or representation convention
of the entity. For an access-to-subprogram type, it represents the calling
convention of designated subprograms. In addition:
- A pragma
Import specifies that the entity is defined externally (that is, outside
the Ada program).
- A pragma
Export specifies that the entity is used externally.
- A pragma
Import or Export optionally specifies an entity's external name, link
name, or both.
An external name
string value for the name used by a foreign language program either for
an entity that an Ada program imports, or for referring to an entity
that an Ada program exports.
A link name
is a string
value for the name of an exported or imported entity, based on the conventions
of the foreign language's compiler in interfacing with the system's linker
The meaning of link names is implementation defined.
If neither a link name nor the Address attribute of an imported or exported
entity is specified, then a link name is chosen in an implementation-defined
manner, based on the external name if one is specified.
Pragma Linker_Options has the effect of passing its
string argument as a parameter to the system linker (if one exists),
if the immediately enclosing compilation unit is included in the partition
being linked. The interpretation of the string argument, and the way
in which the string arguments from multiple Linker_Options pragmas are
combined, is implementation defined.
what this International Standard says elsewhere, the elaboration of a
declaration denoted by the local_name
of a pragma
Import does not create the entity. Such an elaboration has no other effect
than to allow the defining name to denote the external entity.
It is the programmer's responsibility
to ensure that the use of interfacing pragmas does not violate Ada semantics;
otherwise, program execution is erroneous.
If an implementation supports pragma Export to a
given language, then it should also allow the main subprogram to be written
in that language. It should support some mechanism for invoking the elaboration
of the Ada library units included in the system, and for invoking the
finalization of the environment task. On typical systems, the recommended
mechanism is to provide two subprograms whose link names are "adainit"
and "adafinal". Adainit should contain the elaboration code
for library units. Adafinal should contain the finalization code. These
subprograms should have no effect the second and subsequent time they
Automatic elaboration of preelaborated packages should
be provided when pragma
Export is supported.
For each supported convention L
Intrinsic, an implementation should support Import and Export pragma
for objects of L
-compatible types and for subprograms, and pragma
Convention for L
-eligible types and for subprograms, presuming
the other language has corresponding features. Pragma
Convention need not be supported for scalar types.
1 Implementations may place restrictions
on interfacing pragmas; for example, requiring each exported entity to
be declared at the library level.
2 A pragma
Import specifies the conventions for accessing external entities. It
is possible that the actual entity is written in assembly language, but
reflects the conventions of a particular language. For example, pragma
Import(Ada, ...) can be used to interface to an assembly language routine
that obeys the Ada compiler's calling conventions.
3 To obtain “call-back” to
an Ada subprogram from a foreign language environment, pragma
Convention should be specified both for the access-to-subprogram type
and the specific subprogram(s) to which 'Access is applied.
4 It is illegal to specify more than one
of Import, Export, or Convention for a given entity.
5 The local_name
in an interfacing pragma can denote more than one entity in the case
of overloading. Such a pragma
applies to all of the denoted entities.
7 If both External_Name and Link_Name are
specified for an Import or Export pragma, then the External_Name is ignored.
This paragraph was
Example of interfacing
package Fortran_Library is
function Sqrt (X : Float) return Float;
function Exp (X : Float) return Float;
pragma Import(Fortran, Sqrt);
pragma Import(Fortran, Exp);