Contents Index Search Previous Next
3.5.4 Integer Types
1
An
integer_type_definition defines
an integer type; it defines either a
signed integer type, or a
modular integer type. The base range of a signed integer type
includes at least the values of the specified range. A modular type is
an integer type with all arithmetic modulo a specified positive
modulus;
such a type corresponds to an unsigned type with wraparound semantics.
Syntax
2
integer_type_definition
::= signed_integer_type_definition 
modular_type_definition
3
signed_integer_type_definition
::= range static_simple_expression ..
static_simple_expression
4
modular_type_definition
::= mod static_expression
Name Resolution Rules
5
Each
simple_expression
in a
signed_integer_type_definition
is expected to be of any integer type; they need not be of the same type.
The
expression
in a
modular_type_definition is
likewise expected to be of any integer type.
Legality Rules
6
The simple_expressions
of a signed_integer_type_definition
shall be static, and their values shall be in the range System.Min_Int
.. System.Max_Int.
7
The
expression of a
modular_type_definition
shall be static, and its value (the
modulus) shall be positive,
and shall be no greater than System.Max_Binary_Modulus if a power of
2, or no greater than System.Max_Nonbinary_Modulus if not.
Static Semantics
8
The set of values for a signed integer type is
the (infinite) set of mathematical integers, though only values of the
base range of the type are fully supported for runtime operations. The
set of values for a modular integer type are the values from 0 to one
less than the modulus, inclusive.
9
A
signed_integer_type_definition
defines an integer type whose base range includes at least the values
of the
simple_expressions and is
symmetric about zero, excepting possibly an extra negative value.
A
signed_integer_type_definition also
defines a constrained first subtype of the type, with a range whose bounds
are given by the values of the
simple_expressions,
converted to the type being defined.
10
A
modular_type_definition
defines a modular type whose base range is from zero to one less than
the given modulus.
A
modular_type_definition
also defines a constrained first subtype of the type with a range that
is the same as the base range of the type.
11
There is a predefined signed
integer subtype named Integer, declared in the visible part of package
Standard. It is constrained to the base range of its type.
12
Integer
has two predefined subtypes, declared in the visible part of package
Standard:
13
subtype Natural is Integer range 0 .. Integer'Last;
subtype Positive is Integer range 1 .. Integer'Last;
14
A
type defined by an
integer_type_definition
is implicitly derived from
root_integer, an anonymous predefined
(specific) integer type, whose base range is System.Min_Int .. System.Max_Int.
However, the base range of the new type is not inherited from
root_integer,
but is instead determined by the range or modulus specified by the
integer_type_definition.
Integer literals are all of the
type
universal_integer, the universal type (see
3.4.1)
for the class rooted at
root_integer, allowing their use with
the operations of any integer type.
15
The
position number
of an integer value is equal to the value.
16
For every modular
subtype S, the following attribute is defined:
17
 S'Modulus

S'Modulus yields the modulus
of the type of S, as a value of the type universal_integer.
Dynamic Semantics
18
The elaboration of an
integer_type_definition
creates the integer type and its first subtype.
19
For a modular type, if the result of the execution
of a predefined operator (see
4.5) is outside
the base range of the type, the result is reduced modulo the modulus
of the type to a value that is within the base range of the type.
20
For
a signed integer type, the exception Constraint_Error is raised by the
execution of an operation that cannot deliver the correct result because
it is outside the base range of the type.
For
any integer type, Constraint_Error is raised by the operators "/",
"
rem", and "
mod" if the right operand
is zero.
Implementation Requirements
21
In an implementation, the
range of Integer shall include the range 2**15+1 .. +2**151.
22
If Long_Integer is predefined
for an implementation, then its range shall include the range 2**31+1
.. +2**311.
23
System.Max_Binary_Modulus shall be at least 2**16.
Implementation Permissions
24
For the execution of a predefined operation of
a signed integer type, the implementation need not raise Constraint_Error
if the result is outside the base range of the type, so long as the correct
result is produced.
25
An implementation
may provide additional predefined signed integer types, declared in the
visible part of Standard, whose first subtypes have names of the form
Short_Integer, Long_Integer, Short_Short_Integer, Long_Long_Integer,
etc. Different predefined integer types are allowed to have the same
base range. However, the range of Integer should be no wider than that
of Long_Integer. Similarly, the range of Short_Integer (if provided)
should be no wider than Integer. Corresponding recommendations apply
to any other predefined integer types. There need not be a named integer
type corresponding to each distinct base range supported by an implementation.
The range of each first subtype should be the base range of its type.
26
An implementation may provide
nonstandard integer types, descendants of
root_integer
that are declared outside of the specification of package Standard, which
need not have all the standard characteristics of a type defined by an
integer_type_definition. For example,
a nonstandard integer type might have an asymmetric base range or it
might not be allowed as an array or loop index (a very long integer).
Any type descended from a nonstandard integer type is also nonstandard.
An implementation may place arbitrary restrictions on the use of such
types; it is implementation defined whether operators that are predefined
for ``any integer type'' are defined for a particular nonstandard integer
type. In any case, such types are not permitted as
explicit_generic_actual_parameters
for formal scalar types  see
12.5.2.
27
For a one's complement machine,
the high bound of the base range of a modular type whose modulus is one
less than a power of 2 may be equal to the modulus, rather than one less
than the modulus. It is implementation defined for which powers of 2,
if any, this permission is exercised.
27.1/1
For a one's complement machine, implementations
may support nonbinary modulus values greater than System.Max_Nonbinary_Modulus.
It is implementation defined which specific values greater than System.Max_Nonbinary_Modulus,
if any, are supported.
Implementation Advice
28
An implementation should
support Long_Integer in addition to Integer if the target machine supports
32bit (or longer) arithmetic. No other named integer subtypes are recommended
for package Standard. Instead, appropriate named integer subtypes should
be provided in the library package Interfaces (see
B.2).
29
An implementation for a two's
complement machine should support modular types with a binary modulus
up to System.Max_Int*2+2. An implementation should support a nonbinary
modulus up to Integer'Last.
30
25 Integer
literals are of the anonymous predefined integer type universal_integer.
Other integer types have no literals. However, the overload resolution
rules (see 8.6, ``The
Context of Overload Resolution'') allow expressions of the type universal_integer
whenever an integer type is expected.
31
26 The same arithmetic
operators are predefined for all signed integer types defined by a signed_integer_type_definition
(see 4.5, ``Operators
and Expression Evaluation''). For modular types, these same operators
are predefined, plus bitwise logical operators (and, or,
xor, and not). In addition, for the unsigned types declared
in the languagedefined package Interfaces (see B.2),
functions are defined that provide bitwise shifting and rotating.
32
27 Modular types match
a generic_formal_parameter_declaration
of the form "type T is mod <>;"; signed
integer types match "type T is range <>;"
(see 12.5.2).
Examples
33
Examples of
integer types and subtypes:
34
type Page_Num is range 1 .. 2_000;
type Line_Size is range 1 .. Max_Line_Size;
35
subtype Small_Int is Integer range 10 .. 10;
subtype Column_Ptr is Line_Size range 1 .. 10;
subtype Buffer_Size is Integer range 0 .. Max;
36
type Byte is mod 256;  an unsigned byte
type Hash_Index is mod 97;  modulus is prime
Contents Index Search Previous Next Legal