 (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.
(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.
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
 Email comments, additions, corrections, gripes, kudos, etc. to:
Magnus Kempe  Magnus.Kempe@di.epfl.ch
Copyright statement
Page last generated: 950312