AARM95 - The Package System
Author: JTC1/SC22/WG9/ARG, by Randall Brukardt, ARG Editor

Contents Index Previous Next

# 13.7 The Package System

1
[For each implementation there is a library package called System which includes the definitions of certain configuration-dependent characteristics.]

#### Static Semantics

2
The following language-defined library package exists:
2.a
Implementation defined: The contents of the visible part of package System and its language-defined children.
3
`
package System is
pragma Preelaborate(System);`
4
`type Name is implementation-defined-enumeration-type;
System_Name : constant Name := implementation-defined;`
5
`-- System-Dependent Named Numbers:`
6
`Min_Int : constant := root_integer'First;
Max_Int : constant := root_integer'Last;`
7
`Max_Binary_Modulus : constant := implementation-defined;
Max_Nonbinary_Modulus : constant := implementation-defined;`
8
`Max_Base_Digits : constant := root_real'Digits;
Max_Digits : constant := implementation-defined;`
9
`Max_Mantissa : constant := implementation-defined;
Fine_Delta : constant := implementation-defined;`
10
`Tick : constant := implementation-defined;`
11
`-- Storage-related Declarations:`
12
`type Address is implementation-defined;
Null_Address : constant Address;`
13
`Storage_Unit : constant := implementation-defined;
Word_Size : constant := implementation-defined * Storage_Unit;
Memory_Size : constant := implementation-defined;`
14
`-- Address Comparison:
function "<" (Left, Right : Address) return Boolean;
function "<="(Left, Right : Address) return Boolean;
function ">" (Left, Right : Address) return Boolean;
function ">="(Left, Right : Address) return Boolean;
function "=" (Left, Right : Address) return Boolean;
-- function "/=" (Left, Right : Address) return Boolean;
-- "/=" is implicitly defined
pragma Convention(Intrinsic, "<");
... -- and so on for all language-defined subprograms in this package`
15
`-- Other System-Dependent Declarations:
type Bit_Order is (High_Order_First, Low_Order_First);
Default_Bit_Order : constant Bit_Order;`
16
`-- Priority-related declarations (see D.1):
subtype Any_Priority is Integer range implementation-defined;
subtype Priority is Any_Priority range Any_Priority'First ..
implementation-defined;
subtype Interrupt_Priority is Any_Priority range Priority'Last+1 ..
Any_Priority'Last;`
17
`Default_Priority : constant Priority :=
(Priority'First + Priority'Last)/2;`
18
`private
... -- not specified by the language
end System;`
19
Name is an enumeration subtype. Values of type Name are the names of alternative machine configurations handled by the implementation. System_Name represents the current machine configuration.
20
The named numbers Fine_Delta and Tick are of the type universal_real; the others are of the type universal_integer.
21
The meanings of the named numbers are:
22

[ Min_Int
  The smallest (most negative) value allowed for the expressions of a signed_integer_type_definition.

23

Max_Int
  The largest (most positive) value allowed for the expressions of a signed_integer_type_definition.

24

Max_Binary_Modulus
  A power of two such that it, and all lesser positive powers of two, are allowed as the modulus of a modular_type_definition.

25

Max_Nonbinary_Modulus
  A value such that it, and all lesser positive integers, are allowed as the modulus of a modular_type_definition.

25.a
Ramification: There is no requirement that Max_Nonbinary_Modulus be less than or equal to Max_Binary_Modulus, although that's what makes most sense. On a typical 32-bit machine, for example, Max_Binary_Modulus will be 2**32 and Max_Nonbinary_Modulus will be 2**31, because supporting nonbinary moduli in above 2**31 causes implementation difficulties.
26

Max_Base_Digits
  The largest value allowed for the requested decimal precision in a floating_point_definition.

27

Max_Digits
  The largest value allowed for the requested decimal precision in a floating_point_definition that has no real_range_specification. Max_Digits is less than or equal to Max_Base_Digits.

28

Max_Mantissa
  The largest possible number of binary digits in the mantissa of machine numbers of a user-defined ordinary fixed point type. (The mantissa is defined in Annex G.)

29

Fine_Delta
  The smallest delta allowed in an ordinary_fixed_point_definition that has the real_range_specification range -1.0 .. 1.0. ]

30

Tick
  A period in seconds approximating the real time interval during which the value of Calendar.Clock remains constant.

30.a
Ramification: There is no required relationship between System.Tick and Duration'Small, other than the one described here.
30.b
The inaccuracy of the delay_statement has no relation to Tick. In particular, it is possible that the clock used for the delay_statement is less accurate than Calendar.Clock.
30.c
We considered making Tick a run-time-determined quantity, to allow for easier configurability. However, this would not be upward compatible, and the desired configurability can be achieved using functionality defined in Annex D, ``Real-Time Systems''.
31

Storage_Unit
  The number of bits per storage element.

32

Word_Size
  The number of bits per word.

33

Memory_Size
  An implementation-defined value [that is intended to reflect the memory size of the configuration in storage elements.]

33.a
Discussion: It is unspecified whether this refers to the size of the address space, the amount of physical memory on the machine, or perhaps some other interpretation of ``memory size.'' In any case, the value has to be given by a static expression, even though the amount of memory on many modern machines is a dynamic quantity in several ways. Thus, Memory_Size is not very useful.
34
Address is of a definite, nonlimited type. Address represents machine addresses capable of addressing individual storage elements. Null_Address is an address that is distinct from the address of any object or program unit.
34.a
Ramification: The implementation has to ensure that there is at least one address that nothing will be allocated to; Null_Address will be one such address.
34.b
Ramification: Address is the type of the result of the attribute Address.
34.c
Reason: Address is required to be nonlimited and definite because it is important to be able to assign addresses, and to declare uninitialized address variables.
35
See 13.5.3 for an explanation of Bit_Order and Default_Bit_Order.

#### Implementation Permissions

36
An implementation may add additional implementation-defined declarations to package System and its children. [However, it is usually better for the implementation to provide additional functionality via implementation-defined children of System.] Package System may be declared pure.
36.a
Ramification: The declarations in package System and its children can be implicit. For example, since Address is not limited, the predefined "=" and "/=" operations are probably sufficient. However, the implementation is not required to use the predefined "=".

#### Implementation Advice

37
Address should be of a private type.
37.a
Reason: This promotes uniformity by avoiding having implementation-defined predefined operations for the type. We don't require it, because implementations may want to stick with what they have.
37.b
Implementation Note: It is not necessary for Address to be able to point at individual bits within a storage element. Nor is it necessary for it to be able to point at machine registers. It is intended as a memory address that matches the hardware's notion of an address.
37.c
The representation of the null value of a general access type should be the same as that of Null_Address; instantiations of Unchecked_Conversion should work accordingly. If the implementation supports interfaces to other languages, the representation of the null value of a general access type should be the same as in those other languages, if appropriate.
37.d
Note that the children of the Interfaces package will generally provide foreign-language-specific null values where appropriate. See UI-0065 regarding Null_Address.
NOTES
38
14 There are also some language-defined child packages of System defined elsewhere.

#### Extensions to Ada 83

38.a.1/1
The declarations Max_Binary_Modulus, Max_Nonbinary_Modulus, Max_Base_Digits, Null_Address, Word_Size, Bit_Order, Default_Bit_Order, Any_Priority, Interrupt_Priority, and Default_Priority are added to System in Ada 95. The presence of ordering operators for type Address is also guaranteed (the existence of these depends on the definition of Address in an Ada 83 implementation). We do not list these as incompatibilities, as the contents of System can vary between implementations anyway; thus a program that depends on the contents of System (by using `use System;` for example) is already at risk of being incompatible when moved between Ada implementations.

#### Wording Changes from Ada 83

38.a
Much of the content of System is standardized, to provide more uniformity across implementations. Implementations can still add their own declarations to System, but are encouraged to do so via children of System.
38.b
Some of the named numbers are defined more explicitly in terms of the standard numeric types.
38.c
The pragmas System_Name, Storage_Unit, and Memory_Size are no longer defined by the language. However, the corresponding declarations in package System still exist. Existing implementations may continue to support the three pragmas as implementation-defined pragmas, if they so desire.
38.d
Priority semantics, including subtype Priority, have been moved to the Real Time Annex.

Contents Index Previous Next Legal