Version 1.14 of ai12s/amd2xcon.txt
!comment This file contains Corrigendum conflicts for Amendment 3 (Ada 202x).
!comment Conflicts occur when multiple issues change the same
!comment paragraph of the standard.
!comment This file (and the reading of it in the program) would need to
!comment be changed for a new Corrigendum or Amendment.
!comment The paragraphs must be in sorted order!!
!corrigendum 1.1.3(17/3)
!AI-0179-1
!AI-0265-1
@dinsa
An implementation conforming to this International Standard may provide
additional aspects, attributes, library units, and pragmas. However, it 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 a Specialized Needs Annex unless the provided construct is either as
specified in the Specialized Needs Annex or is more limited in capability than
that required by the Annex. A program that attempts to use an unsupported
capability of an Annex shall either be identified by the implementation before
run time or shall raise an exception at run time.
@dinst
For an implementation that conforms to this Standard, the implementation of
a language-defined unit shall abide by all postconditions, type invariants,
and default initial conditions specified for the unit by this International
Standard (see 11.4.2).
!corrigendum 1.2(3/2)
!AI-0058-1
!AI-0224-1
@drepl
ISO/IEC 1539-1:2004, @i<Information technology @emdash Programming languages
@emdash Fortran @emdash Part 1: Base language>.
@dby
ISO/IEC 1539-1:2018, @i<Information technology @emdash Programming languages
@emdash Fortran @emdash Part 1: Base language>.
!corrigendum 2.1(4.1/3)
!AI-0004-1
!AI-0263-1
@drepl
The semantics of an Ada program whose text is not in Normalization Form KC
(as defined by Clause 21 of ISO/IEC 10646:2011) is implementation defined.
@dby
The semantics of an Ada program whose text is not in Normalization Form C
(as defined by Clause 21 of ISO/IEC 10646:2017) is implementation defined.
!corrigendum 2.3(4/3)
!AI-0004-1
!AI-0263-1
@dinsa
An @fa<identifier> shall not contain two consecutive characters in category
@fa<punctuation_connector>, or end with a character in that category.
@dinst
@s8<@i<Legality Rules>>
An identifier shall only contain characters that may be present in
Normalization Form KC (as defined by Clause 21 of ISO/IEC 10646:2017).
!corrigendum 3.3(23.7/3)
!AI-0226-1
!AI-0228-1
@dinsa
@xbullet<it is part of the object denoted by a @fa<function_call> or
@fa<aggregate>; or>
@dinst
@xbullet<it is a value conversion or @fa<qualified_expression> where the
operand denotes a view of a composite object that is known to be constrained; or>
!corrigendum 4.2.1(0)
!AI-0249-1
!AI-0295-1
@dinsc
Using one or more of the aspects defined below, a type may be specified
to allow the use of one or more kinds of literals as values of the type.
@s8<@i<Static Semantics>>
The following nonoverridable, type-related operational aspects may be
specified for any type @i<T>:
@xhang<@xterm<Integer_Literal>
This aspect is specified by a @i<function_>@fa<name> that denotes a
primitive function of @i<T> with one parameter of type String and a
result type of @i<T>.>
@xhang<@xterm<Real_Literal>
This aspect is specified by a @i<function_>@fa<name> that denotes a
primitive function of @i<T> with one parameter of type String and a
result type of @i<T>.>
@xhang<@xterm<String_Literal>
This aspect is specified by a @i<function_>@fa<name> that denotes a
primitive function of @i<T> with one parameter of type
Wide_Wide_String and a result type of @i<T>.>
@xindent<A type with a specified String_Literal aspect is considered a
@i<string type>.>
@s8<@i<Legality Rules>>
The Integer_Literal or Real_Literal aspect shall not be specified for a
type @i<T> if the full view of @i<T> is a numeric type. The String_Literal
aspect shall not be specified for a type @i<T> if the full view of @i<T> is
a string type (in the absence of the String_Literal aspect specification).
In addition to the places where Legality Rules normally apply (see 12.3),
these rules also apply in the private part of an instance of a generic unit.
@s8<@i<Dynamic Semantics>>
For the evaluation of an integer (or real) literal with expected type
having an Integer_Literal (or Real_Literal) aspect specified, the value
is the result of a call on the function specified by the aspect, with
the parameter being a string with lower bound one whose value corresponds
to the textual representation of the integer (or real) literal.
For the evaluation of a @fa<string_literal> with expected type having a
String_Literal aspect specified, the value is the result of a call on
the function specified by the aspect, with the parameter being the
Wide_Wide_String with lower bound one that corresponds to the literal.
@s8<@i<Bounded (Run-Time) Errors>>
It is a bounded error if the evaluation of a literal with expected type
having a corresponding _Literal aspect specified, propagates an
exception. The possible effect is that an error is reported prior to
run time, or Program_Error or the exception propagated by the evaluation
is raised at the point of use of the value of the literal.
!corrigendum 4.3.1(17/3)
!AI-0086-1
!AI-0127-1
@drepl
The value of a discriminant that governs a @fa<variant_part> @i<P> shall
be given by a static expression, unless @i<P> is nested within a
@fa<variant> @i<V> that is not selected by the discriminant value
governing the @fa<variant_part> enclosing @i<V>.
@dby
For a @fa<record_aggregate> or @fa<extension_aggregate>, if a
@fa<variant_part> @i<P> is nested within a @fa<variant> @i<V> that is not
selected by the discriminant value governing the @fa<variant_part> enclosing
@i<V>, then there is no restriction on the discriminant governing @i<P>.
Otherwise, the value of the discriminant that governs @i<P> shall be given by
a static expression, or by a nonstatic expression having a constrained static
nominal subtype. In this latter case of a nonstatic expression, there shall be
exactly one @fa<discrete_choice_list> of @i<P> that covers each value that
belongs to the nominal subtype and satisfies the predicates of the subtype,
and there shall be at least one such value.
!corrigendum 4.3.3(17/3)
!AI-0061-1
!AI-0127-1
@drepl
The @fa<discrete_choice_list> of an @fa<array_component_association> is allowed to
have a @fa<discrete_choice> that is a nonstatic @fa<choice_expression> or that is a
@fa<subtype_indication> or @fa<range> that defines a nonstatic or null range, only
if it is the single @fa<discrete_choice> of its @fa<discrete_choice_list>, and there
is only one @fa<array_component_association> in the @fa<array_aggregate>.
@dby
The @fa<discrete_choice_list> of an @fa<array_component_association> (including
an @fa<iterated_component_association>) is allowed to
have a @fa<discrete_choice> that is a nonstatic @fa<choice_expression> or that is a
@fa<subtype_indication> or @fa<range> that defines a nonstatic or null range, only
if it is the single @fa<discrete_choice> of its @fa<discrete_choice_list>, and
either there is only one @fa<array_component_association> in the
enclosing @fa<array_component_association_list> or the enclosing @fa<aggregate> is
an @fa<array_delta_aggregate>, not an @fa<array_aggregate>.
!corrigendum 5.5(3/3)
!AI-0119-1
!AI-0189-1
!AI-0251-1
@drepl
@xcode<@fa<iteration_scheme>@fa< ::= >@ft<@b<while>> @fa<condition>
| @ft<@b<for>> @fa<loop_parameter_specification>
| @ft<@b<for>> @fa<iterator_specification>>
@dby
@xcode<@fa<iteration_scheme>@fa< ::= >@ft<@b<while>> @fa<condition>
| @ft<@b<for>> @fa<loop_parameter_specification>
| @ft<@b<for>> @fa<iterator_specification>
| @ft<@b<for>> @fa<procedural_iterator>
| @ft<@b<parallel>> [(@fa<chunk_specification>)]
@ft<@b<for>> @fa<loop_parameter_specification>>
@xcode<@fa<chunk_specification>@fa< ::= >@ft<@i<integer_>>@fa<simple_expression>
| @fa<defining_identifier> @ft<@b<in>> @fa<discrete_subtype_definition>>
!corrigendum 5.5(5)
!AI-0119-1
!AI-0251-1
@dinsa
If a @fa<loop_statement> has a @i<loop_>@fa<statement_identifier>, then the
@fa<identifier> shall be repeated after the @b<end loop>; otherwise, there
shall not be an @fa<identifier> after the @fa<end loop>.
@dinst
An @fa<iteration_scheme> that begins with the reserved word @b<parallel> shall
not have the reserved word @b<reverse> in its @fa<loop_parameter_specification>.
@s8<@i<Name Resolution Rules>>
In a @fa<chunk_specification> that is an @i<integer_>@fa<simple_expression>, the
@i<integer_>@fa<simple_expression> is expected to be of any integer type.
!corrigendum 5.5(6)
!AI-0061-1
!AI-0251-1
@drepl
A @fa<loop_parameter_specification> declares a @i<loop parameter>,
which is an object whose subtype is that defined by the
@fa<discrete_subtype_definition>.
@dby
A @fa<loop_parameter_specification> declares a @i<loop parameter>,
which is an object whose subtype (and nominal subtype) is that defined
by the @fa<discrete_subtype_definition>.
In a @fa<chunk_specification> that has a @fa<discrete_subtype_definition>, the
@fa<chunk_specification> declares a @i<chunk parameter> object whose subtype
(and nominal subtype) is that defined by the @fa<discrete_subtype_definition>.
!corrigendum 5.5(9/4)
!AI-0119-1
!AI-0251-1
!AI-0294-1
@drepl
For the execution of a @fa<loop_statement> with the @fa<iteration_scheme>
being @b<for> @fa<loop_parameter_specification>,
the @fa<loop_parameter_specification> is first elaborated. This
elaboration creates the loop parameter and elaborates the
@fa<discrete_subtype_definition>.
If the @fa<discrete_subtype_definition> defines a subtype with a null range,
the execution of the @fa<loop_statement> is complete. Otherwise, the
@fa<sequence_of_statements> is executed once for each value of the
discrete subtype defined by the @fa<discrete_subtype_definition> that
satisfies the predicates of the subtype (or until
the loop is left as a consequence of a transfer of control).
Prior to each such iteration,
the corresponding value of the discrete subtype is assigned to the
loop parameter. These values are assigned in increasing order unless
the reserved word @b<reverse> is present, in which case the values
are assigned in decreasing order.
@dby
For the execution of a @fa<loop_statement> that has an @fa<iteration_scheme>
including a @fa<loop_parameter_specification>, after elaborating the
@fa<chunk_specification>, if any, the @fa<loop_parameter_specification> is
elaborated. This elaboration elaborates the @fa<discrete_subtype_definition>,
which defines the subtype of the loop parameter. If the
@fa<discrete_subtype_definition> defines a subtype
with a null range, the execution of the @fa<loop_statement> is complete.
Otherwise, the @fa<sequence_of_statements> is executed once for each value of
the discrete subtype defined by the @fa<discrete_subtype_definition> that
satisfies the predicates of the subtype (or until the loop is left as a
consequence of a transfer of control). Prior to each such iteration, the
corresponding value of the discrete subtype is assigned to the loop
parameter associated with the given iteration. If the loop is a parallel
loop, each chunk has its own logical thread of control with its own copy
of the loop parameter; otherwise (a @i<sequential loop>), a single logical
thread of control performs the loop, and there is a single copy of the
loop parameter. Each logical thread of control handles a distinct
subrange of the values of the subtype of the loop parameter such that
all values are covered with no overlaps. Within each logical thread of
control, the values are assigned to the loop parameter in increasing
order unless the reserved word @b<reverse> is present, in which case the
values are assigned in decreasing order.
If a @fa<chunk_specification> with a @fa<discrete_subtype_definition> is
present, then the logical thread of control associated with a given chunk
has its own copy of the chunk parameter initialized with a distinct value from
the discrete subtype defined by the @fa<discrete_subtype_definition>. The
values of the chunk parameters are assigned such that they increase with
increasing values of the ranges covered by the corresponding loop
parameters.
Whether or not a @fa<chunk_specification> is present in a parallel loop,
the total number of iterations of the loop represents an upper bound
on the number of logical threads of control devoted to the loop.
!corrigendum 5.5.2(5/4)
!AI-0156-1
!AI-0183-1
@drepl
The subtype defined by the @fa<subtype_indication>, if any, of an array
component iterator shall statically match the component subtype of the type of
the @i<iterable_>@fa<name>. The subtype defined by the @fa<subtype_indication>,
if any, of a container element iterator shall statically match the default
element subtype for the type of the @i<iterable_>@fa<name>.
@dby
The subtype defined by the @fa<loop_parameter_subtype_indication>, if any, of a
generalized iterator shall statically match the iteration cursor subtype.
The subtype defined by the @fa<loop_parameter_subtype_indication>, if any, of an array
component iterator shall statically match the component subtype of the type of
the @i<iterable_>@fa<name>. The subtype defined by the @fa<loop_parameter_subtype_indication>,
if any, of a container element iterator shall statically match the default
element subtype for the type of the @i<iterable_>@fa<name>.
!corrigendum 5.5.3(0)
!AI-0189-1
!AI-0292-1
!AI-0294-1
@dinsc
A @fa<procedural_iterator> invokes a user-defined procedure, passing in the body of
the enclosing @fa<loop_statement> as a parameter of an anonymous access-to-procedure
type, to allow the loop body to be executed repeatedly as part of the invocation
of the user-defined procedure.
@s8<@i<Syntax>>
@xcode<@fa<procedural_iterator>@fa< ::= >
@fa<iterator_parameter_specification> @ft<@b<of>> @fa<iterator_procedure_call>>
@xcode<@fa<iterator_parameter_specification>@fa< ::= >
@fa<formal_part>
| (@fa<identifier>{, @fa<identifier>})>
@xcode<@fa<iterator_procedure_call>@fa< ::= >
@ft<@i<procedure_>>@fa<name>
| @ft<@i<procedure_>>@fa<prefix> @fa<iterator_actual_parameter_part>>
@xcode<@fa<iterator_actual_parameter_part>@fa< ::= >
(@fa<iterator_parameter_association> {, @fa<iterator_parameter_association>})>
@xcode<@fa<iterator_parameter_association>@fa< ::= >
@fa<parameter_association>
| @fa<parameter_association_with_box>>
@xcode<@fa<parameter_association_with_box>@fa< ::= >
[ @ft<@i<formal_parameter_>>@fa<selector_name> =@> ] <@>>
At most one @fa<iterator_parameter_association> within an
@fa<iterator_actual_parameter_part> shall be a
@fa<parameter_association_with_box>.
@s8<@i<Name Resolution Rules>>
The @fa<name> or @fa<prefix> given in an @fa<iterator_procedure_call> shall
resolve to denote a callable entity @i<C> that is a procedure, or an entry
renamed as (viewed as) a procedure. When there is an
@fa<iterator_actual_parameter_part>, the @fa<prefix>
can be an @fa<implicit_dereference> of an access-to-subprogram value.
An @fa<iterator_procedure_call> without a @fa<parameter_association_with_box>
is equivalent to one with an @fa<iterator_actual_parameter_part> with an
additional @fa<parameter_association_with_box> at the end, with the
@i<formal_parameter_>@fa<selector_name> identifying the last formal parameter of
the callable entity denoted by the @fa<name> or @fa<prefix>.
An @fa<iterator_procedure_call> shall contain at most one
@fa<iterator_parameter_association> for each formal parameter of the callable
entity @i<C>. Each formal parameter without an
@fa<iterator_parameter_association> shall have a @fa<default_expression> (in
the profile of the view of @i<C> denoted by the @fa<name> or @fa<prefix>). This
rule is an overloading rule (see 8.6).
The formal parameter of the callable entity @i<C> associated with the
@fa<parameter_association_with_box> shall be of an anonymous
access-to-procedure type @i<A>.
@s8<@i<Legality Rules>>
The anonymous access-to-procedure type @i<A> shall have at least one formal
parameter in its parameter profile. If the @fa<iterator_parameter_specification>
is a @fa<formal_part>, then this @fa<formal_part> shall be mode conformant
with that of @i<A>. If the @fa<iterator_parameter_specification> is a list of
@fa<identifier>s, the number of formal parameters of @i<A> shall be the same as the
length of this list.
If the @fa<name> or @fa<prefix> given in an @fa<iterator_procedure_call>
denotes an abstract subprogram, the subprogram shall be a dispatching
subprogram.
@s8<@i<Static Semantics>>
A @fa<loop_statement> with an @fa<iteration_scheme> that has a
@fa<procedural_iterator> is equivalent to a local declaration of a procedure P
followed by a @fa<procedure_call_statement> that is formed from the
@fa<iterator_procedure_call> by replacing the <@> of the
@fa<parameter_association_with_box> with P'Access.
The @fa<formal_part> of the locally declared procedure P is formed from the
@fa<formal_part> of the anonymous access-to-procedure type @i<A>, by replacing
the @fa<identifier> of each formal parameter of this @fa<formal_part> with the
@fa<identifier> of the corresponding formal parameter or element of the list
of @fa<identifier>s given in the @fa<iterator_parameter_specification>.
The following aspect may be specified for a subprogram or entry S that
has at least one formal parameter of an anonymous access-to-subprogram
type:
@xhang<@xterm<Allows_Exit>
The Allows_Exit aspect is of type Boolean. The specified value shall
be static. The Allows_Exit of an inherited primitive subprogram is
True if Allows_Exit is True either for the corresponding subprogram
of the progenitor type or for any other inherited subprogram that it
overrides. If not specified or inherited as True, the Allows_Exit
aspect of a subprogram or entry is False.>
@xindent<Specifying the Allows_Exit aspect True for a subprogram asserts
that the subprogram is prepared to be completed by arbitrary transfers of
control from the subprogram represented by the access-to-subprogram value,
including propagation of exceptions. A subprogram for which
Allows_Exit is True should use finalization for any necessary cleanup, and
in particular should not use exception handling to implement cleanup.>
@s8<@i<Legality Rules>>
If a subprogram or entry overrides an inherited dispatching subprogram
that has a True Allows_Exit aspect, only a confirming specification of
True is permitted for the aspect on the overriding declaration.
The @fa<sequence_of_statements> of a @fa<loop_statement> with a
@fa<procedural_iterator> as its @fa<iteration_scheme> shall contain an
@fa<exit_statement>, return statement, @fa<goto_statement>, or
@fa<requeue_statement> that leaves the loop only if the callable entity @i<C>
associated with the @fa<procedural_iterator> has an Allows_Exit
aspect specified True.
The @fa<sequence_of_statements> of a @fa<loop_statement> with a
@fa<procedural_iterator> as its @fa<iteration_scheme> shall not contain
an @fa<accept_statement>.
@s8<@i<Examples>>
Example of iterating over a map from My_Key_Type to My_Element_Type (see
A.18.4):
@xcode<@b<for> (C : Cursor) @b<of> My_Map.Iterate @b<loop>
Put_Line (My_Key_Type'Image (Key (C)) & " =@> " &
My_Element_Type'Image (Element (C)));
@b<end loop>;>
@xcode<--@ft<@i< The above is equivalent to:>>>
@xcode<@b<declare>
@b<procedure> P (C : Cursor) @b<is>
@b<begin>
Put_Line (My_Key_Type'Image (Key (c)) & " =@> " &
My_Element_Type'Image (Element (C)));
@b<end> P;
@b<begin>
My_Map.Iterator (P'access);
@b<end>;>
Example of iterating over the environment variables (see A.17):
@xcode<@b<for> (Name, Val) @b<of> Ada.Environment_Variables.Iterate(<@>) @b<loop>
--@ft<@i< "(<@>)" is optional because it is the last parameter>>
Put_Line (Name & " =@> " & Val);
@b<end loop>;>
@xcode<--@ft<@i< The above is equivalent to:>>>
@xcode<@b<declare>
@b<procedure> P (Name : String; Val : String) @b<is>
@b<begin>
Put_Line (Name & " =@> " & Val);
@b<end> P;
@b<begin>
Ada.Environment_Variables.Iterate (P'access);
@b<end>;>
!corrigendum 6.1.1(1/4)
!AI-0220-1
!AI-0272-1
@drepl
For a noninstance subprogram, a generic subprogram, or an entry, the
following language-defined aspects may be specified with
an @fa<aspect_specification> (see 13.1.1):
@dby
For a noninstance subprogram (including a generic formal subprogram), a
generic subprogram, an entry, or an access-to-subprogram type, the
following language-defined aspects may be specified with
an @fa<aspect_specification> (see 13.1.1):
!corrigendum 6.1.1(29/4)
!AI-0185-1
!AI-0220-1
@drepl
@xhang<@xterm<F'Result>Within
a postcondition expression for function F, denotes
the result object of the function. The type of this attribute is that
of the function result except within a Post'Class postcondition
expression for a function with a controlling result or with a
controlling access result. For a controlling result, the type of the
attribute is @i<T>'Class, where @i<T> is the function result type. For a
controlling access result, the type of the attribute is an anonymous
access type whose designated type is @i<T>'Class, where @i<T> is the
designated type of the function result type.>
@dby
@xhang<@xterm<F'Result>Within
a postcondition expression for F, denotes the return object of the
function call for which the postcondition expression is evaluated.
The type of this attribute is that of the result subtype of the
function or access-to-function type except within a Post'Class
postcondition expression for a function with a controlling result or with a
controlling access result; in those cases the type of the attribute was
described previously.>
!corrigendum 6.1.1(39/3)
!AI-0220-1
!AI-0272-1
@drepl
For a call via an access-to-subprogram value, all precondition and
postcondition checks performed are determined by the subprogram or entry
denoted by the prefix of the Access attribute reference that produced the
value.
@dby
For a call via an access-to-subprogram value, precondition and postcondition
checks performed are as determined by the subprogram or entry denoted by the
prefix of the Access attribute reference that produced the value. In addition,
a precondition check of any precondition expression associated with the
access-to-subprogram type is performed. Similarly, a postcondition check of
any postcondition expression associated with the access-to-subprogram type is
performed.
For a call on a generic formal subprogram, precondition and
postcondition checks performed are as determined by the subprogram or entry
denoted by the actual subprogram, along with any specific precondition
and specific postcondition of the formal subprogram itself.
!corrigendum 7.3.2(8/3)
!AI-0075-1
!AI-0199-1
@drepl
If the Type_Invariant'Class aspect is specified for a tagged type @i<T>,
then the invariant expression applies to all descendants of @i<T>.
@dby
If the Type_Invariant'Class aspect is specified for a tagged type @i<T>,
then a @i<corresponding expression> also applies to each nonabstract
descendant @i<T1> of @i<T> (including @i<T> itself if it is nonabstract).
The corresponding expression is constructed from the associated expression
as follows:
@xbullet<References to non-discriminant components of @i<T> (or to @i<T>
itself) are replaced with references to the corresponding components of @i<T1>
(or to @i<T1> as a whole).>
@xbullet<References to discriminants of @i<T> are replaced with references to
the corresponding discriminant of @i<T1>, or to the specified value for the
discriminant, if the discriminant is specified by the
@fa<derived_type_definition> for some type that is an ancestor of @i<T1> and
a descendant of @i<T> (see 3.7).>
If one or more invariant expressions apply to a nonabstract type @i<T>, then
a subprogram or entry is said to be @i<type-invariant preserving> for @i<T> if
@xbullet<it is declared within the immediate scope of @i<T> (or by an instance
of a generic unit, and the generic is declared within the immediate
scope of type @i<T>), or is the Read or Input stream-oriented attribute
of type @i<T>, and either:>
@xinbull<@i<T> is a private type or a private extension and the subprogram or
entry is visible outside the immediate scope of type @i<T> or overrides
an inherited operation that is visible outside the immediate scope
of @i<T>; or>
@xinbull<@i<T> is a record extension, and the subprogram or entry is a primitive
operation visible outside the immediate scope of type @i<T> or overrides
an inherited operation that is visible outside the immediate scope
of @i<T>.>
@xbullet<and at least one of the following applies to the callable entity:>
@xinbull<has a result with a part of type @i<T>;>
@xinbull<has one or more @b<out> or @b<in out> parameters with a part of
type @i<T>;>
@xinbull<has an access-to-object parameter or result whose designated type has
a part of type @i<T>; or>
@xinbull<is a procedure or entry that has an @b<in> parameter with a part of type
@i<T>.>
@xindent<Each such part of type @i<T> is said to be @i<subject to an invariant
check> for @i<T>.>
!corrigendum 7.3.2(20/3)
!AI-0075-1
!AI-0193-1
@ddel
The check is performed on each such part of type @i<T>.
!corrigendum 7.3.3(0)
!AI-0265
!AI-0272
@dinsc
For a private type or private extension (including a generic formal type),
the following language-defined aspect
may be specified with an @fa<aspect_specification> (see 13.1.1):
@xhang<@xterm<Default_Initial_Condition>This aspect shall be specified by an
@fa<expression>, called a @i<default initial condition expression>.
Default_Initial_Condition may be specified on a
@fa<private_type_declaration>, a @fa<private_extension_declaration>, a
@fa<formal_private_type_definition>, or a @fa<formal_derived_type_definition>.>
@s8<@i<Name Resolution Rules>>
The expected type for a default initial condition expression is any
boolean type.
@s8<@i<Legality Rules>>
The Default_Initial_Condition aspect shall not be specified for
a type whose partial view has unknown
discriminants, whether explicitly declared or inherited.
@s8<@i<Static Semantics>>
If the Default_Initial_Condition aspect is specified for a type T, then
the default initial condition expression applies to T and to all
descendants of T.
@s8<@i<Dynamic Semantics>>
If one or more default initial condition expressions apply to a
type T, then a default initial condition check is performed
after successful default initialization of an object of type T by
default (see 3.3.1). In the case of a controlled type, the check
is performed after the call to the type's Initialize procedure
(see 7.6).
If performing checks is required by the Default_Initial_Condition
assertion policy (see 11.4.2) in effect at the point of the
corresponding @fa<aspect_specification> applicable to a given type, then
the respective default initial condition expression is
considered enabled.
The default initial condition check consists of the evaluation of
each enabled default initial condition expression that applies to T.
These evaluations, if there are more than one, are performed in an
arbitrary order. If any of these evaluate to False,
Assertions.Assertion_Error is raised at the point of the object
initialization.
For a generic formal type T, default initial condition checks
performed are as determined by the actual type, along with any default initial
condition of the formal type itself.
!corrigendum 7.3.4(0)
!AI-0187-1
!AI-0272-1
!AI-0285-1
@dinsc
It is usual that some of the characteristics of a data type are unchanged by
most of the primitive operations on the type. Such characteristics are called
@i<stable properties> of the type.
@s8<@i<Static Semantics>>
A @i<property function> of type @i<T> is a function with a single parameter of
type @i<T> or of a class-wide type that covers @i<T>.
A @i<type property aspect definition> is a list of @fa<name>s written in the
syntax of a @fa<positional_array_aggregate>. A @i<subprogram property aspect
definition> is a list of @fa<name>s preceded by an optional @b<not> written
in the syntax of a @fa<positional_array_aggregate>.
For a nonformal private type, nonformal private extension, or full type that
does not have a partial view, the following language-defined aspects may be
specified with an @fa<aspect_specification> (see 13.1.1):
@xhang<@xterm<Stable_Properties>This aspect
shall be specified by a type property aspect definition; each
@fa<name> shall statically denote a single property function of the type. This
aspect defines the @i<stable property functions> of the associated type.>
@xhang<@xterm<Stable_Properties'Class>This aspect
shall be specified by a type property aspect definition; each
@fa<name> shall statically denote a single property function of the type. This
aspect defines the @i<class-wide stable property functions> of the associated type.
Unlike most class-wide aspects, Stable_Properties'Class is not
inherited by descendant types and subprograms, but the enhanced class-wide
postconditions are inherited in the normal manner.>
For a primitive subprogram, the following language-defined aspects may be
specified with an @fa<aspect_specification> (see 13.1.1):
@xhang<@xterm<Stable_Properties>This aspect
shall be specified by a subprogram property aspect definition;
each @fa<name> shall statically denote a single property function of a type for
which the associated subprogram is primitive.>
@xhang<@xterm<Stable_Properties'Class>This aspect
shall be specified by a subprogram property aspect definition;
each @fa<name> shall statically denote a single property function of a tagged
type for which the associated subprogram is primitive. Unlike most
class-wide aspects, Stable_Properties'Class is not inherited by descendant
subprograms, but the enhanced class-wide postconditions are inherited in
the normal manner.>
@s8<@i<Legality Rules>>
A stable property function of a type @i<T> (including a class-wide stable property
function) shall have a nonlimited return type and shall be:
@xbullet<a primitive function with a single parameter of mode @b<in> of
type @i<T>; or>
@xbullet<a function that is declared immediately within the declarative region
in which an ancestor type of @i<T> is declared and has a single parameter of
mode @b<in> of a class-wide type that covers @i<T>.>
In a subprogram property aspect definition for a subprogram @i<S>:
@xbullet<all or none of the items shall be preceded by @b<not>;>
@xbullet<any property functions mentioned after @b<not> shall be a stable
property function of a type for which @i<S> is primitive.>
@s8<@i<Static Semantics>>
For a primitive subprogram @i<S> of a type @i<T>, the stable property functions
for @i<S> for type @i<T> are:
@xbullet<if @i<S> has an aspect Stable_Properties specified that does not
include @b<not>, those functions denoted in the aspect Stable_Properties for
@i<S> that have a parameter of @i<T> or @i<T>'Class;>
@xbullet<if @i<S> has an aspect Stable_Properties specified that includes
@b<not>, those functions denoted in the aspect Stable_Properties for @i<T>,
excluding those denoted in the aspect Stable_Properties for @i<S>;>
@xbullet<if @i<S> does not have an aspect Stable_Properties, those functions
denoted in the aspect Stable_Properties for @i<T>, if any.>
A similar definition applies for class-wide stable property functions by
replacing aspect Stable_Properties with aspect Stable_Properties'Class
in the above definition.
The @i<explicit> specific postcondition expression for a subprogram @i<S>
is the @fa<expression> directly specified for @i<S> with the Post aspect.
Similarly, the @i<explicit> class-wide postcondition expression for a
subprogram @i<S> is the @fa<expression> directly specified for @i<S> with the
Post'Class aspect.
For every primitive subprogram @i<S> of a type @i<T>
that is not a stable property function of @i<T>, the specific postcondition
expression of @i<S> is modified to include expressions of the form
@fc<@i<F>(@i<P>) = @i<F>(@i<P>)'Old>, all @b<and>ed with each other
and any explicit specific postcondition expression, where @i<F> is each stable
property function of @i<S> for type @i<T> that does not occur in the explicit
specific postcondition expression of @i<S>, and @i<P> is each parameter of
@i<S> that has type @i<T>. The resulting specific postcondition expression of
@i<S> is used in place of the explicit specific postcondition expression of
@i<S> when interpreting the meaning of the postcondition as defined in 6.1.1.
For every primitive subprogram @i<S> of a type @i<T>
that is not a stable property function of @i<T>, the class-wide postcondition
expression of @i<S> is modified to include expressions of the form
@fc<@i<F>(@i<P>) = @i<F>(@i<P>)'Old>, all @b<and>ed with each other and any
explicit class-wide postcondition expression, where @i<F> is each class-wide
stable property function of @i<S> for type @i<T> that does not occur in any
class-wide postcondition expression that applies to @i<S>, and @i<P> is each
parameter of @i<S> that has type @i<T>. The resulting class-wide postcondition
expression of @i<S> is used in place of the explicit class-wide postcondition
expression of @i<S> when interpreting the meaning of the
postcondition as defined in 6.1.1.
@xindent<@s9<NOTES@hr
14 For an example of the use of these aspects, see the Vector container
definition in A.18.2.>>
!corrigendum 9.5(17/3)
!AI-0064-2
!AI-0247-1
!AI-0267-1
@dinsa
In addition to the places where Legality Rules normally apply (see 12.3),
these rules also apply in the private part of an instance of a generic unit.
@dinss
@s8<@i<Static Semantics>>
An @fa<expression> is @i<nonblocking-static> if it is one of the following:
@xbullet<a static expression;>
@xbullet<a Nonblocking @fa<attribute_reference>;>
@xbullet<a call to a predefined boolean logical operator @b<and> where each
operand is nonblocking-static;>
@xbullet<an @b<and then> short-circuit control form where each operand is
nonblocking-static;>
@xbullet<a parenthesized nonblocking-static @fa<expression>.>
For a program unit, task entry, formal package, formal
subprogram, formal object of an anonymous access-to-subprogram type,
enumeration literal, and for a type (including a formal type), the
following language-defined operational aspect is defined:
@xhang<@xterm<Nonblocking>
This aspect specifies the blocking restriction for the entity; it shall
be specified by an @fa<expression>, called a @i<nonblocking expression>. If
directly specified, the @fa<aspect_definition> shall be a
nonblocking-static expression. The expected type for the @fa<expression> is
the predefined type Boolean. The @fa<aspect_definition> can be
omitted from the specification of this aspect; in that case the
nonblocking expression for the entity is the enumeration literal True.>
@xindent<The Nonblocking aspect may be specified for all entities for
which it is defined, except for protected operations and
task entries. In particular, Nonblocking may be specified for
generic formal parameters.>
@xindent<When the nonblocking expression is static for an entity,
the expression is evaluated to produce a static value for the aspect.
When aspect Nonblocking is statically False for an entity, the entity
might contain a potentially blocking operation; such an entity @i<allows
blocking>. If the aspect is statically True for an entity, the entity
is said to be @i<nonblocking>.>
@xindent<For a generic instantiation and entities declared within such an
instance, the aspect is determined by the nonblocking
expression for the corresponding entity of the generic unit, with
any Nonblocking attributes of the generic formal parameters replaced
by the appropriate nonblocking expression of the corresponding actual
parameters. If the aspect is directly specified for an instance, the
specified expression shall be static and have the same value as the
nonblocking expression of the instance (after replacement).>
@xindent<For a (protected or task) entry, the Nonblocking aspect is
the Boolean literal False.>
@xindent<For an enumeration literal, the Nonblocking aspect is the Boolean
literal True.>
@xindent<For a predefined operator of an elementary type, the Nonblocking
aspect is the Boolean literal True. For a predefined operator of a
composite type, the Nonblocking aspect of the operator is
the same as the Nonblocking aspect for the type.>
@xindent<For a dereference of an access-to-subprogram type, the Nonblocking
aspect of the designated subprogram is that of the access-to-subprogram type.>
@xindent<For a full type declaration that has a partial view, the
aspect is the same as that of the partial view.>
@xindent<For an inherited primitive dispatching subprogram that is null or
abstract, the subprogram is nonblocking if and only if a corresponding
subprogram of at least one ancestor is nonblocking. For any other
inherited subprogram, it is nonblocking if and only if the
corresponding subprogram of the parent is nonblocking.>
@xindent<Unless directly specified, overridings of dispatching operations
inherit this aspect.>
@xindent<Unless directly specified, for a formal type, formal package, or
formal subprogram, the Nonblocking aspect is that of the actual type,
package, or subprogram.>
@xindent<Unless directly specified, for a derived type, the Nonblocking
aspect is that of the parent type.>
@xindent<Unless directly specified, for any other program unit, type, or formal
object, the Nonblocking aspect of the entity is determined by the
Nonblocking aspect for the innermost program unit enclosing the entity.>
@xindent<If not specified for a library unit, the nonblocking expression
is the Boolean literal True if the library unit is declared pure and is
not a generic unit, or the Boolean literal False otherwise.>
For a @fa<prefix> S that denotes a subprogram (including a formal subprogram):
@xhang<@xterm<S'Nonblocking>
Denotes whether subprogram S is considered nonblocking; the type
of this attribute is the predefined type Boolean.>
@xindent<The @fa<prefix> S shall statically denote a subprogram.>
@xindent<S'Nonblocking represents the nonblocking expression of S;
evaluation of S'Nonblocking evaluates that expression.>
For a @fa<prefix> P that denotes a package (including a formal package):
@xhang<@xterm<P'Nonblocking>
Denotes whether package P is considered nonblocking; the type
of this attribute is the predefined type Boolean.
P'Nonblocking represents the nonblocking expression of P;
evaluation of P'Nonblocking evaluates that expression.>
For a @fa<prefix> S that denotes a subtype (including formal subtypes):
@xhang<@xterm<S'Nonblocking>
Denotes whether predefined operators (and in the case of
access-to-subprogram subtypes) a subprogram designated by a value of
type S are considered nonblocking; the type of this attribute is the
predefined type Boolean. S'Nonblocking represents the nonblocking
expression of S; evaluation of S'Nonblocking evaluates that expression.>
The following are defined to be @i<potentially blocking> operations:
@xbullet<a @fa<select_statement>;>
@xbullet<an @fa<accept_statement>;>
@xbullet<an @fa<entry_call_statement>, or a call on a procedure that
renames or is implemented by an entry;>
@xbullet<a @fa<delay_statement>;>
@xbullet<an @fa<abort_statement>;>
@xbullet<task creation or activation;>
@xbullet<during a protected action, an external call on a protected subprogram
(or an external requeue) with the same target object as that of the
protected action.>
If a language-defined subprogram allows blocking, then a call on the
subprogram is a potentially blocking operation.
@s8<@i<Legality Rules>>
A parallel construct or a nonblocking program unit shall not contain, other
than within nested units with Nonblocking specified as statically False, a
call on a callable entity for which the Nonblocking aspect is statically
False, nor shall it contain any of the following:
@xbullet<a @fa<select_statement>;>
@xbullet<an @fa<accept_statement>;>
@xbullet<a @fa<delay_statement>;>
@xbullet<an @fa<abort_statement>;>
@xbullet<task creation or activation.>
For the purposes of the above rule, an @fa<entry_body> is considered
nonblocking if the immediately enclosing protected unit is nonblocking.
A subprogram shall be nonblocking if it overrides a nonblocking
dispatching operation. An entry shall not implement a nonblocking
procedure. If an inherited dispatching subprogram allows blocking, then
the corresponding subprogram of each ancestor shall allow blocking.
It is illegal to specify aspect Nonblocking for the full view of a type
that has a partial view.
Aspect Nonblocking shall be specified for a derived type only if it
fully conforms to the nonblocking expression of the ancestor type
or if it is specified to have the Boolean literal True.
If aspect Nonblocking is specified for an entity that is not a generic
unit or declared inside of a generic unit, the @fa<aspect_definition> shall
be a static expression.
If the prefix of a Nonblocking @fa<attribute_reference> denotes a generic
unit @i<G>, the reference shall occur within the declarative region of @i<G>.
The predefined equality operator for a composite type is illegal if it is
nonblocking and, for a record type, it is not overridden by a primitive
equality operator, and:
@xbullet<for a record type, the parent primitive "=" allows blocking; or>
@xbullet<any component that has a record type that has a primitive "=" that
allows blocking; or>
@xbullet<any component that has a non-record type that has a predefined "="
that allows blocking.>
In a generic instantiation (after replacement in the nonblocking
expressions by values of the actuals as described previously):
@xbullet<the actual subprogram corresponding to a nonblocking formal
subprogram shall be nonblocking (an actual that is an
entry is not permitted in this case);>
@xbullet<the actual type corresponding to a nonblocking formal
private, derived, array, or access-to-subprogram type shall
be nonblocking;>
@xbullet<the actual object corresponding to a formal object of a
nonblocking access-to-subprogram type shall be of a nonblocking
access-to-subprogram type;>
@xbullet<the actual instance corresponding to a nonblocking formal package
shall be nonblocking.>
In addition to the places where Legality Rules normally apply
(see 12.3), the above rules also apply in the private part of an
instance of a generic unit.
A program unit @i<P> declared inside of a generic unit but not in a generic body
or that is a generic specification not declared in a generic unit
is considered nonblocking for the purposes of checking the restrictions on a
nonblocking unit only if the value of its Nonblocking aspect is statically
True. For the purposes of checks in @i<P>, a call to a subprogram is considered
nonblocking unless the value of its Nonblocking aspect is statically False.
A program unit @i<P> declared inside of a generic body or that is a generic body
is considered nonblocking for the purposes of checking the restrictions on a
nonblocking unit unless the value of its Nonblocking aspect is statically
False. For the purposes of checks in @i<P>, a call to a subprogram is considered
to allow blocking unless:
@xbullet<the value of its Nonblocking aspect is statically True, or>
@xbullet<its nonblocking expression (that is, Nonblocking aspect)
conforms exactly to that of @i<P>, or conforms to some part of the
nonblocking expression of @i<P> that is combined with the remainder of the
nonblocking expression of @i<P> by one or more @b<and> or @b<and then>
operations.>
!corrigendum 9.5.1(18)
!AI-0064-2
!AI-0247-1
@drepl
Certain language-defined subprograms are potentially blocking. In particular,
the subprograms of the language-defined input-output packages that manipulate
files (implicitly or explicitly) are potentially blocking. Other potentially
blocking subprograms are identified where they are defined. When not
specified as potentially blocking, a language-defined subprogram is
nonblocking.
@dby
During a protected action, a call on a subprogram whose body contains a
potentially blocking operation is a bounded error. If the bounded error is
detected, Program_Error is raised; otherwise, the call proceeds normally.
!corrigendum 11.4.2(23.1/3)
!AI-0179-1
!AI-0265-1
@dinsa
It is a bounded error to invoke a potentially blocking operation (see 9.5.1)
during the evaluation of an assertion expression associated with a call on, or
return from, a protected operation. If the bounded error is detected,
Program_Error is raised. If not detected, execution proceeds normally, but if
it is invoked within a protected action, it might result in deadlock or a
(nested) protected action.
@dinss
@s8<@i<Implementation Requirements>>
Any postcondition expression, type invariant expression, or default initial
condition expression occurring in the specification of a language-defined unit
is enabled (see 6.1.1, 7.3.2, and 7.3.3).
The evaluation of any such postcondition, type invariant, or default initial
condition expression shall either yield True or propagate an exception from
a @fa<raise_expression> that appears within the assertion expression.
!corrigendum 12.6(8.2/2)
!AI-0183-1
!AI-0287-1
@drepl
@xbullet<if the actual matching the @fa<formal_subprogram_declaration>
denotes a generic formal object of another generic unit @i<G>, and the
instantiation containing the actual that occurs within the body
of a generic unit @i<G> or within the body of a generic unit declared within
the declarative region of the generic unit @i<G>, then the corresponding
parameter or result type of the formal subprogram of @i<G> shall have a
@fa<null_exclusion>;>
@dby
@xbullet<if the actual matching the @fa<formal_subprogram_declaration>
statically denotes a generic formal subprogram of another generic unit @i<G>,
and the instantiation containing the actual occurs within the body
of a generic unit @i<G> or within the body of a generic unit declared within
the declarative region of the generic unit @i<G>, then the corresponding
parameter or result type of the formal subprogram of @i<G> shall have a
@fa<null_exclusion>;>
!corrigendum 13.1(9/4)
!AI-0181-1
!AI-0222-1
@drepl
A representation item that directly specifies an aspect of an entity shall
appear before the entity is frozen (see 13.14). In addition, a
representation item that directly specifies an aspect of a subtype or type
shall appear after the type is completely defined (see 3.11.1).
@dby
A representation item or operational item that directly specifies an aspect
of an entity shall appear before the entity is frozen (see 13.14).
!corrigendum 13.1(9.1/4)
!AI-0181-1
!AI-0222-1
@drepl
An operational item that directly specifies an aspect of an entity shall
appear before the entity is frozen (see 13.14).
@dby
An @fa<expression> or @fa<name> that freezes an entity shall not occur within
an @fa<aspect_specification> that specifies a representation or operational
aspect of that entity.
A representation aspect of a subtype or type shall not be specified (whether
by a representation item or an @fa<aspect_specification>) before the type is
completely defined (see 3.11.1).
!corrigendum 13.1.1(4/3)
!AI-0187-1
!AI-0285-1
@drepl
@xcode<@fa<aspect_definition ::= name | expression | identifier>>
@dby
@xcode<@fa<aspect_definition>@fa< ::=>
@fa<name>@fa< | >@fa<expression>@fa< | >@fa<identifier>@fa< | >@fa<aggregate>>
!corrigendum 13.1.1(12/3)
!AI-0180-1
!AI-0220-1
@drepl
If the associated declaration is for a subprogram or entry, the names of the
formal parameters are directly visible within the @fa<aspect_definition>, as are certain
attributes, as specified elsewhere in this International Standard for the
identified aspect. If the associated declaration is a @fa<type_declaration>, within
the @fa<aspect_definition> the names of any components are directly visible, and the
name of the first subtype denotes the current instance of the type (see 8.6). If the
associated declaration is a @fa<subtype_declaration>, within the
@fa<aspect_definition> the name of the new subtype denotes the current instance
of the subtype.
@dby
If the associated declaration is for a subprogram, entry, or access-to-subprogram
type, the names of the
formal parameters are directly visible within the @fa<aspect_definition>, as
are certain attributes, as specified elsewhere in this International Standard
for the identified aspect. If the associated declaration is a @fa<type_declaration>,
within the @fa<aspect_definition> the names of any visible components, protected
subprograms, and entries are directly visible, and the name of the first subtype
denotes the current instance of the type (see 8.6). If the associated declaration
is a @fa<subtype_declaration>, within the @fa<aspect_definition> the name of the
new subtype denotes the current instance of the subtype.
!corrigendum 13.1.1(17/3)
!AI-0064-2
!AI-0194-1
@drepl
There are no language-defined aspects that may be specified on a @fa<renaming_declaration>,
a @fa<generic_formal_parameter_declaration>, a @fa<subunit>, a @fa<package_body>,
a @fa<task_body>, a @fa<protected_body>, or a @fa<body_stub> other than a
@fa<subprogram_body_stub>.
@dby
There are no language-defined aspects that may be specified on
a @fa<renaming_declaration>, a @fa<subunit>, a @fa<package_body>,
a @fa<task_body>, a @fa<protected_body>, an @fa<entry_body>, or a @fa<body_stub>
other than a @fa<subprogram_body_stub>.
!corrigendum 13.1.1(18.3/4)
!AI-0206-1
!AI-0211-1
@drepl
If a nonoverridable aspect is directly specified for a type @i<T>, then any
explicit specification of that aspect for any other descendant of @i<T>
shall be @i<confirming>; that is, the specified @fa<name> shall @i<match>
the inherited aspect, meaning that the specified @fa<name> shall denote the
same declarations as would the inherited @fa<name>.
@dby
If a nonoverridable aspect is directly specified for a type @i<T>, then any
explicit specification of that aspect for any descendant of @i<T>
(other than @i<T> itself) shall be @i<confirming>. In the case of an aspect
whose value is a @fa<name>,
this means that the specified @fa<name> shall @i<match> the inherited aspect
in the sense that it shall denote the same declarations as would the inherited
@fa<name>.
!corrigendum 13.1.1(18.6/4)
!AI-0206-1
!AI-0256-1
@drepl
The Default_Iterator, Iterator_Element, Implicit_Dereference,
Constant_Indexing, and Variable_Indexing aspects are nonoverridable.
@dby
The Default_Iterator, Iterator_Element, Implicit_Dereference,
Constant_Indexing, Variable_Indexing, Max_Entry_Queue_Length, and
No_Controlled_Parts aspects are nonoverridable.
!corrigendum 13.14(3/4)
!AI-0155-1
!AI-0168-1
@drepl
The end of a @fa<declarative_part>, @fa<protected_body>, or a declaration of a
library package or generic library package, causes @i<freezing> of each entity
and profile declared within it, except for incomplete types. A @fa<proper_body>,
@fa<body_stub>, or @fa<entry_body> causes freezing of each entity and profile
declared before it within the same @fa<declarative_part> that is not an
incomplete type; it only causes freezing of an incomplete type if the body is
within the immediate scope of the incomplete type.
@dby
The end of a @fa<declarative_part>, @fa<protected_body>, or a declaration of a
library package or generic library package, causes @i<freezing> of each entity
and profile declared within it. A noninstance @fa<proper_body>,
@fa<body_stub>, or @fa<entry_body> causes freezing of each entity and profile
declared before it within the same @fa<declarative_part>.
!corrigendum A.3.2(32.5/3)
!AI-0004-1
!AI-0263-1
@dinsa
@xhang<@xterm<Is_Space>
True if Item is a character with position 32 (' ') or 160 (No_Break_Space).>
@dinst
@xhang<@xterm<Is_NFKC>
True if Item could be present in a string normalized to Normalization
Form KC (as defined by Clause 21 of ISO/IEC 10646:2017); this includes
all characters except those with positions 160, 168, 170, 175, 178, 179,
180, 181, 184, 185, 186, 188, 189, and 190.>
!corrigendum A.3.5(51/3)
!AI-0004-1
!AI-0263-1
@dinsa
@xindent<Returns True if the Wide_Character designated by Item is categorized as
@fa<separator_space>, otherwise returns False.>
@dinss
@xcode<@b<function> Is_NFKC (Item : Wide_Character) @b<return> Boolean;>
@xindent<Returns True if the Wide_Character designated by Item could be present
in a string normalized to Normalization Form KC (as defined by Clause
21 of ISO/IEC 10646:2017), otherwise returns False.>
!corrigendum B.5(21)
!AI-0058-1
!AI-0263-1
@drepl
An implementation may add additional declarations to the Fortran interface
packages. For example, the Fortran interface package for an implementation
of Fortran 77 (ANSI X3.9-1978) that defines types like Integer*@i<n>,
Real*@i<n>, Logical*@i<n>, and Complex*@i<n> may contain the declarations
of types named Integer_Star_@i<n>, Real_Star_@i<n>, Logical_Star_@i<n>, and
Complex_Star_@i<n>. (This convention should not apply to Character*@i<n>, for
which the Ada analog is the constrained array subtype Fortran_Character
(1..n).) Similarly, the Fortran interface package for an implementation of
Fortran 90 that provides multiple kinds of intrinsic types, e.g.
Integer (Kind=@i<n>), Real (Kind=@i<n>), Logical (Kind=@i<n>),
Complex (Kind=@i<n>), and Character (Kind=@i<n>), may contain the declarations
of types with the recommended names Integer_Kind_@i<n>, Real_Kind_@i<n>,
Logical_Kind_@i<n>, Complex_Kind_@i<n>, and Character_Kind_@i<n>.
@dby
An implementation may add additional declarations to the Fortran interface
packages. For example, declarations are permitted
for the character types corresponding to Fortran character kinds 'ascii' and
'iso_10646', which in turn correspond to ISO/IEC 646:1991 and
to UCS-4 as specified in ISO/IEC 10646:2017.
!corrigendum D.2.1(7/3)
!AI-0241-1
!AI-0279-1
@drepl
A call of Yield is a task dispatching point. Yield is a potentially blocking
operation (see 9.5.1).
@dby
A call of Yield is a task dispatching point.
If the Yield aspect has the value True, then a call to Yield is included
within the body of the associated callable entity, and invoked
immediately prior to returning from the body if and only if no other
task dispatching points were encountered during the execution of the
body.
!corrigendum D.4(7/2)
!AI-0163-1
!AI-0183-1
@drepl
Two queuing policies, FIFO_Queuing and
Priority_Queuing, are language defined. If no Queuing_Policy pragma applies
to any of the program units comprising the partition, the queuing policy
for that partition is FIFO_Queuing. The rules for this policy are specified
in 9.5.3 and 9.7.1.
@dby
Three queuing policies, FIFO_Queuing, Ordered_FIFO_Queuing, and
Priority_Queuing, are language defined. If no Queuing_Policy pragma applies
to any of the program units comprising the partition, the queuing policy
for that partition is FIFO_Queuing. The rules for the FIFO_Queuing policy are
specified in 9.5.3 and 9.7.1.
The Ordered_FIFO_Queuing policy is defined as follows:
@xbullet<Calls are selected on a given entry queue in order of arrival.>
@xbullet<When more than one condition of an @fa<entry_barrier> of a protected
object becomes True, and more than one of the respective queues is nonempty,
the call that arrived first is selected.>
@xbullet<If the expiration time of two or more open @fa<delay_alternative>s
is the same and no other @fa<accept_alternative>s are open, the
@fa<sequence_of_statements> of the @fa<delay_alternative> that is first in
textual order in the @fa<selective_accept> is executed.>
@xbullet<When more than one alternative of a @fa<selective_accept> is open
and has queued calls, the alternative whose queue has the call that arrived
first is selected.>
!corrigendum H.5(5/2)
!AI-0247-1
!AI-0267-1
@drepl
An implementation is required to detect a potentially blocking operation within
a protected operation, and to raise Program_Error (see 9.5.1).
@dby
An implementation is required to detect a potentially blocking operation that
occurs during the execution of a protected operation or a parallel construct
defined within a compilation unit to which the pragma applies, and to raise
Program_Error (see 9.5).
Questions? Ask the ACAA Technical Agent