B.2 The Package Interfaces
1
Package Interfaces is the parent of several library
packages that declare types and other entities useful for interfacing
to foreign languages. It also contains some implementation-defined types
that are useful across more than one language (in particular for interfacing
to assembly language).
1.a
Implementation defined: The contents
of the visible part of package Interfaces and its language-defined descendants.
Static Semantics
2
The library package
Interfaces has the following skeletal declaration:
3
package Interfaces
is
pragma Pure(Interfaces);
4
type Integer_n is range -2**(n-1) .. 2**(n-1) - 1; --2's complement
5
type Unsigned_n is mod 2**n;
6
function Shift_Left (Value : Unsigned_n; Amount : Natural)
return Unsigned_n;
function Shift_Right (Value : Unsigned_n; Amount : Natural)
return Unsigned_n;
function Shift_Right_Arithmetic (Value : Unsigned_n; Amount : Natural)
return Unsigned_n;
function Rotate_Left (Value : Unsigned_n; Amount : Natural)
return Unsigned_n;
function Rotate_Right (Value : Unsigned_n; Amount : Natural)
return Unsigned_n;
...
end Interfaces;
Implementation Requirements
7
An implementation shall
provide the following declarations in the visible part of package Interfaces:
8
Signed and modular integer types of n bits,
if supported by the target architecture, for each n that is at
least the size of a storage element and that is a factor of the word
size. The names of these types are of the form Integer_n for the
signed types, and Unsigned_n for the modular types;
8.a
Ramification: For example, for a typical
32-bit machine the corresponding types might be Integer_8, Unsigned_8,
Integer_16, Unsigned_16, Integer_32, and Unsigned_32.
8.b
The wording above implies, for example, that
Integer_16'Size = Unsigned_16'Size = 16. Unchecked conversions between
same-Sized types will work as expected.
9
For each
such modular type in Interfaces, shifting and rotating subprograms as
specified in the declaration of Interfaces above. These subprograms are
Intrinsic. They operate on a bit-by-bit basis, using the binary representation
of the value of the operands to yield a binary representation for the
result. The Amount parameter gives the number of bits by which to shift
or rotate. For shifting, zero bits are shifted in, except in the case
of Shift_Right_Arithmetic, where one bits are shifted in if Value is
at least half the modulus.
9.a
Reason: We considered making shifting
and rotating be primitive operations of all modular types. However, it
is a design principle of Ada that all predefined operations should be
operators (not functions named by identifiers). (Note that an early version
of Ada had "abs" as an identifier, but it was changed
to a reserved word operator before standardization of Ada 83.) This is
important because the implicit declarations would hide non-overloadable
declarations with the same name, whereas operators are always overloadable.
Therefore, we would have had to make shift and rotate into reserved words,
which would have been upward incompatible, or else invent new operator
symbols, which seemed like too much mechanism.
10
Floating point types corresponding to each floating
point format fully supported by the hardware.
10.a
Implementation Note: The names for these
floating point types are not specified.
However,
if IEEE arithmetic is supported, then the names should be IEEE_Float_32
and IEEE_Float_64 for single and double precision, respectively.
10.1/3
{
AI95-00204-01}
{
AI05-0229-1}
{
AI05-0262-1}
Support for interfacing to any foreign language
is optional. However, an implementation shall not provide any aspect,
attribute, library unit, or pragma having
the same name as an aspect, attribute,
library unit, or pragma (respectively) specified in the following
clauses of this Annex unless the
provided construct is either as specified in those clauses or is more
limited in capability than that required by those clauses. A program
that attempts to use an unsupported capability of this Annex shall either
be identified by the implementation before run time or shall raise an
exception at run time. 10.b/2
Discussion: The
intent is that the same rules apply for language interfacing as apply
for Specialized Needs Annexes. See 1.1.3
for a discussion of the purpose of these rules.
Implementation Permissions
11
An implementation may provide implementation-defined
library units that are children of Interfaces, and may add declarations
to the visible part of Interfaces in addition to the ones defined above.
11.a/2
Implementation defined: Implementation-defined
children of package Interfaces. The contents of
the visible part of package Interfaces.
11.1/3
{
AI95-00204-01}
{
AI05-0229-1}
A child package of package Interfaces with the
name of a convention may be provided independently of whether the convention
is supported by the pragma
Convention aspect
and vice versa. Such a child package should
contain any declarations that would be useful for interfacing to the
language (implementation) represented by the convention. Any declarations
useful for interfacing to any language on the given hardware architecture
should be provided directly in Interfaces. 11.b/2
Ramification: For
example, package Interfaces.XYZ_Pascal might contain declarations of
types that match the data types provided by the XYZ implementation of
Pascal, so that it will be more convenient to pass parameters to a subprogram
whose convention is XYZ_Pascal.
Implementation Advice
12/2
This paragraph was
deleted.{
AI95-00204-01}
For each implementation-defined convention identifier,
there should be a child package of package Interfaces with the corresponding
name. This package should contain any declarations that would be useful
for interfacing to the language (implementation) represented by the convention.
Any declarations useful for interfacing to any language on the given
hardware architecture should be provided directly in Interfaces.
12.a/2
This paragraph
was deleted.Ramification: For
example, package Interfaces.XYZ_Pascal might contain declarations of
types that match the data types provided by the XYZ implementation of
Pascal, so that it will be more convenient to pass parameters to a subprogram
whose convention is XYZ_Pascal.
13
An implementation supporting an interface to C, COBOL,
or Fortran should provide the corresponding package or packages described
in the following clauses.
13.a.1/2
Implementation Advice:
If an interface to C, COBOL, or Fortran
is provided, the corresponding package or packages described in Annex
B, “Interface to Other Languages”
should also be provided.
13.a
Implementation
Note: The intention is that an implementation might support several
implementations of the foreign language: Interfaces.This_Fortran and
Interfaces.That_Fortran might both exist. The “default” implementation,
overridable by the user, should be declared as a renaming:
13.b
package Interfaces.Fortran renames Interfaces.This_Fortran;
Wording Changes from Ada 95
13.c/2
{
AI95-00204-01}
Clarified that interfacing to foreign languages
is optional and has the same restrictions as a Specialized Needs Annex.
Ada 2005 and 2012 Editions sponsored in part by Ada-Europe
