Version 1.11 of ai12s/cor15con.txt

Unformatted version of ai12s/cor15con.txt version 1.11
Other versions for file ai12s/cor15con.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 3.2.4(4/3)
!AI-0071-1
!AI-0099-1
@drepl @xbullet<For a (first) subtype defined by a derived type declaration, the predicates of the parent subtype and the progenitor subtypes apply.> @dby @xbullet<For a (first) subtype defined by a type declaration, any predicates of parent or progenitor subtypes apply.>
!corrigendum 3.2.4(31/3)
!AI-0054-2
!AI-0071-1
@drepl @xindent<On every subtype conversion, the predicate of the target subtype is evaluated, and a check is performed that the predicate is True. This includes all parameter passing, except for certain parameters passed by reference, which are covered by the following rule: After normal completion and leaving of a subprogram, for each @b<in out> or @b<out> parameter that is passed by reference, the predicate of the subtype of the actual is evaluated, and a check is performed that the predicate is True. For an object created by an @fa<object_declaration> with no explicit initialization @fa<expression>, or by an uninitialized @fa<allocator>, if any subcomponents have @fa<default_expression>s, the predicate of the nominal subtype of the created object is evaluated, and a check is performed that the predicate is True. Assertions.Assertion_Error is raised if any of these checks fail.> @dby @xindent<On every subtype conversion, a check is performed that the operand satisfies the predicates of the target subtype. This includes all parameter passing, except for certain parameters passed by reference, which are covered by the following rule: After normal completion and leaving of a subprogram, for each @b<in out> or @b<out> parameter that is passed by reference, a check is performed that the value of the parameter satisfies the predicates of the subtype of the actual. For an object created by an @fa<object_declaration> with no explicit initialization @fa<expression>, or by an uninitialized @fa<allocator>, if any subcomponents have @fa<default_expression>s, a check is performed that the value of the created object satisfies the predicates of the nominal subtype.>
@xindent<If any of the predicate checks fail, Assertion_Error is raised, unless the subtype whose directly-specified predicate aspect evaluated to False also has a directly-specified Predicate_Failure aspect. In that case, the specified Predicate_Failure @fa<expression> is evaluated; if the evaluation of the Predicate_Failure @fa<expression> propagates an exception occurrence, then this occurrence is propagated for the failure of the predicate check; otherwise, Assertion_Error is raised, with an associated message string defined by the value of the Predicate_Failure @fa<expression>. In the absence of such a Predicate_Failure aspect, an implementation-defined message string is associated with the Assertion_Error exception.>
!corrigendum 3.2.4(35/3)
!AI-0054-2
!AI-0071-1
@dinsa @xindent<@s9<6 A Static_Predicate, like a constraint, always remains True for all objects of the subtype, except in the case of uninitialized variables and other invalid values. A Dynamic_Predicate, on the other hand, is checked as specified above, but can become False at other times. For example, the predicate of a record subtype is not checked when a subcomponent is modified.>> @dinss @xindent<@s9<7 No predicates apply to the base subtype of a scalar type; every value of a scalar type @i<T> is considered to satisfy the predicates of @i<T>'Base.>>
@xindent<@s9<8 Predicate_Failure @fa<expression>s are never evaluated during the evaluation of a membership test (see 4.5.2) or Valid attribute (see 13.9.2).>>
@xindent<@s9<9 A Predicate_Failure @fa<expression> can be a @fa<raise_expression> (see 11.3).>>
@s8<@i<Examples>>
@xcode<@b<subtype> Basic_Letter @b<is> Character -- @ft<@I<See A.3.2 for "basic letter".>>
@b<with> Static_Predicate =@> Basic_Letter @b<in> 'A'..'Z' | 'a'..'z' | '@unicode<198>' | '@unicode<230>' | '@unicode<208>' | '@unicode<240>' | '@unicode<222>' | '@unicode<254>' | '@unicode<223>';>
@xcode<@b<subtype> Even_Integer @b<is> Integer
@b<with> Dynamic_Predicate =@> Even_Integer @b<mod> 2 = 0,
Predicate_Failure =@> "Even_Integer must be a multiple of 2";>
@i<Text_IO (see A.10.1) could have used predicates to describe some common exceptional conditions as follows:>
@xcode<@b<with> Ada.IO_Exceptions; @b<package> Ada.Text_IO @b<is>>
@xcode< @b<type> File_Type @b<is limited private>;>
@xcode< @b<subtype> Open_File_Type @b<is> File_Type
@b<with> Dynamic_Predicate =@> Is_Open (Open_File_Type),
Predicate_Failure =@> @b<raise> Status_Error @b<with> "File not open";
@b<subtype> Input_File_Type @b<is> Open_File_Type
@b<with> Dynamic_Predicate =@> Mode (Input_File_Type) = In_File,
Predicate_Failure =@> @b<raise> Mode_Error @b<with> "Cannot read file: " &
Name (Input_File_Type);
@b<subtype> Output_File_Type @b<is> Open_File_Type
@b<with> Dynamic_Predicate =@> Mode (Output_File_Type) /= In_File,
Predicate_Failure =@> @b<raise> Mode_Error @b<with> "Cannot write file: " &
Name (Output_File_Type);>
@xcode< ...>
@xcode< @b<function> Mode (File : @b<in> Open_File_Type) @b<return> File_Mode;
@b<function> Name (File : @b<in> Open_File_Type) @b<return> String; @b<function> Form (File : @b<in> Open_File_Type) @b<return> String;>
@xcode< ...>
@xcode< @b<procedure> Get (File : @b<in> Input_File_Type; Item : @b<out> Character);>
@xcode< @b<procedure> Put (File : @b<in> Output_File_Type; Item : @b<in> Character);>
@xcode< ...>
@xcode< -- @ft<@I<Similarly for all of the other input and output subprograms.>>>
!corrigendum 3.10.2(7/3)
!AI-0067-1
!AI-0089-1
@drepl @xbullet<An entity or view defined by a declaration and created as part of its elaboration has the same accessibility level as the innermost master of the declaration except in the cases of renaming and derived access types described below. Other than for an explicitly aliased parameter, a formal parameter of a callable entity has the same accessibility level as the master representing the invocation of the entity.> @dby @xbullet<An entity or view defined by a declaration and created as part of its elaboration has the same accessibility level as the innermost master of the declaration except in the cases of renaming and derived access types described below. Other than for an explicitly aliased parameter of a function or generic function, a formal parameter of a callable entity has the same accessibility level as the master representing the invocation of the entity.>
!corrigendum 3.10.2(19.2/3)
!AI-0089-1
!AI-0157-1
@drepl @xbullet<Inside a return statement that applies to a function @i<F>, when determining whether the accessibility level of an explicitly aliased parameter of @i<F> is statically deeper than the level of the return object of @i<F>, the level of the return object is considered to be the same as that of the level of the explicitly aliased parameter; for statically comparing with the level of other entities, an explicitly aliased parameter of @i<F> is considered to have the accessibility level of the body of @i<F>.> @dby @xbullet<Inside a return statement that applies to a function or generic function @i<F>, or the return expression of an expression function @i<F>, when determining whether the accessibility level of an explicitly aliased parameter of @i<F> is statically deeper than the level of the return object of @i<F>, the level of the return object is considered to be the same as that of the level of the explicitly aliased parameter; for statically comparing with the level of other entities, an explicitly aliased parameter of @i<F> is considered to have the accessibility level of the body of @i<F>.>
!corrigendum 3.10.2(19.3/3)
!AI-0089-1
!AI-0157-1
@drepl @xbullet<For determining whether a level is statically deeper than the level of the anonymous access type of an access result of a function, when within a return statement that applies to the function, the level of the master of the call is presumed to be the same as that of the level of the master that elaborated the function body.> @dby @xbullet<For determining whether a level is statically deeper than the level of the anonymous access type of an access result of a function or generic function @i<F>, when within a return statement that applies to @i<F> or the return expression of expression function @i<F>, the level of the master of the call is presumed to be the same as that of the level of the master that elaborated the body of @i<F>.>
!corrigendum 4.1.4(9/3)
!AI-0032-1
!AI-0159-1
@drepl An @fa<attribute_reference> denotes a value, an object, a subprogram, or some other kind of program entity. For an @fa<attribute_reference> that denotes a value or an object, if its type is scalar, then its nominal subtype is the base subtype of the type; if its type is tagged, its nominal subtype is the first subtype of the type; otherwise, its nominal subtype is a subtype of the type without any constraint or @fa<null_exclusion>. Similarly, unless explicitly specified otherwise, for an @fa<attribute_reference> that denotes a function, when its result type is scalar, its result subtype is the base subtype of the type, when its result type is tagged, the result subtype is the first subtype of the type, and when the result type is some other type, the result subtype is a subtype of the type without any constraint or @fa<null_exclusion>. @dby An @fa<attribute_reference> denotes a value, an object, a subprogram, or some other kind of program entity. Unless explicitly specified otherwise, for an @fa<attribute_reference> that denotes a value or an object, if its type is scalar, then its nominal subtype is the base subtype of the type; if its type is tagged, its nominal subtype is the first subtype of the type; otherwise, its nominal subtype is a subtype of the type without any constraint, @fa<null_exclusion>, or predicate. Similarly, unless explicitly specified otherwise, for an @fa<attribute_reference> that denotes a function, when its result type is scalar, its result subtype is the base subtype of the type, when its result type is tagged, the result subtype is the first subtype of the type, and when the result type is some other type, the result subtype is a subtype of the type without any constraint, @fa<null_exclusion>, or predicate.
!corrigendum 4.4(3/3)
!AI-0022-1
!AI-0039-1
@drepl @xcode<@fa<relation ::=
simple_expression [relational_operator simple_expression] | simple_expression [>@ft<@b<not>>@fa<] >@ft<@b<in>>@fa< membership_choice_list>>
@dby @xcode<@fa<relation ::=
simple_expression [relational_operator simple_expression] | @i<tested_>simple_expression [>@ft<@b<not>>@fa<] >@ft<@b<in>>@fa< membership_choice_list | raise_expression>>
!corrigendum 4.5.2(29/3)
!AI-0039-1
!AI-0071-1
@drepl @xbullet<The @fa<membership_choice> is a @fa<subtype_mark>, the tested type is scalar, the value of the @fa<simple_expression> belongs to the range of the named subtype, and the predicate of the named subtype evaluates to True.> @dby @xbullet<The @fa<membership_choice> is a @fa<subtype_mark>, the tested type is scalar, the value of the @i<tested_>@fa<simple_expression> belongs to the range of the named subtype, and the value satisfies the predicates of the named subtype.>
!corrigendum 4.5.2(30/3)
!AI-0039-1
!AI-0071-1
@drepl @xbullet<The @fa<membership_choice> is a @fa<subtype_mark>, the tested type is not scalar, the value of the @fa<simple_expression> satisfies any constraints of the named subtype, the predicate of the named subtype evaluates to True, and:> @dby @xbullet<The @fa<membership_choice> is a @fa<subtype_mark>, the tested type is not scalar, the value of the @i<tested_>@fa<simple_expression> satisfies any constraints of the named subtype, the value satisfies the predicates of the named subtype, and:>
!corrigendum 5.5.2(6/3)
!AI-0047-1
!AI-0120-1
@dinsa In a container element iterator whose @i<iterable_>@fa<name> has type @i<T>, if the @i<iterable_>@fa<name> denotes a constant or the Variable_Indexing aspect is not specified for @i<T>, then the Constant_Indexing aspect shall be specified for @i<T>. @dinss The @i<iterator_>@fa<name> or @i<iterable_>@fa<name> of an @fa<iterator_specification> shall not denote a subcomponent that depends on discriminants of an object whose nominal subtype is unconstrained, unless the object is known to be constrained.
A container element iterator is illegal if the call of the default iterator function that creates the loop iterator (see below) is illegal.
A generalized iterator is illegal if the iteration cursor subtype of the @i<iterator_>@fa<name> is a limited type at the point of the generalized iterator. A container element iterator is illegal if the default cursor subtype of the type of the @i<iterable_>@fa<name> is a limited type at the point of the container element iterator.
!corrigendum 6.1.1(7/3)
!AI-0113-1
!AI-0159-1
@drepl Within the expression for a Pre'Class or Post'Class aspect for a primitive subprogram of a tagged type @i<T>, a name that denotes a formal parameter of type @i<T> is interpreted as having type @i<T>'Class. Similarly, a name that denotes a formal access parameter of type access-to-@i<T> is interpreted as having type access-to-@i<T>'Class. This ensures that the expression is well-defined for a primitive subprogram of a type descended from @i<T>. @dby Within the expression for a Pre'Class or Post'Class aspect for a primitive subprogram @i<S> of a tagged type @i<T>, a @fa<name> that denotes a formal parameter (or @i<S>'Result) of type @i<T> is interpreted as though it had a (notional) type @i<NT> that is a formal derived type whose ancestor type is @i<T>, with directly visible primitive operations. Similarly, a @fa<name> that denotes a formal access parameter (or @i<S>'Result) of type access-to-@i<T> is interpreted as having type access-to-@i<NT>. The result of this interpretation is that the only operations that can be applied to such @fa<name>s are those defined for such a formal derived type.
!corrigendum 6.1.1(18/3)
!AI-0113-1
!AI-0131-1
@drepl If a Pre'Class or Post'Class aspect is specified for a primitive subprogram of a tagged type @i<T>, then the associated expression also applies to the corresponding primitive subprogram of each descendant of @i<T>. @dby If a Pre'Class or Post'Class aspect is specified for a primitive subprogram @i<S> of a tagged type @i<T>, or such an aspect defaults to True, then a corresponding expression also applies to the corresponding primitive subprogram @i<S> of each descendant of @i<T>. The @i<corresponding expression> is constructed from the associated expression as follows:
@xbullet<References to formal parameters of @i<S> (or to @i<S> itself) are replaced with references to the corresponding formal parameters of the corresponding inherited or overriding subprogram @i<S> (or to the corresponding subprogram @i<S> itself).>
The primitive subprogram @i<S> is illegal if it is not abstract and the corresponding expression for a Pre'Class or Post'Class aspect would be illegal.
!corrigendum 6.1.1(26/3)
!AI-0032-1
!AI-0159-1
@drepl @xhang<@xterm<X'Old> For each X'Old in a postcondition expression that is enabled, a constant is implicitly declared at the beginning of the subprogram or entry. The constant is of the type of X and is initialized to the result of evaluating X (as an expression) at the point of the constant declaration. The value of X'Old in the postcondition expression is the value of this constant; the type of X'Old is the type of X. These implicit constant declarations occur in an arbitrary order.> @dby @xhang<@xterm<X'Old> Each X'Old in a postcondition expression that is enabled denotes a constant that is implicitly declared at the beginning of the subprogram body, entry body, or accept statement.>
@xindent<The implicitly declared entity denoted by each occurrence of X'Old is declared as follows:>
@xinbull<If X is of an anonymous access type defined by an @fa<access_definition> @i<A> then@hr @fc< @i<X'Old> : @b<constant> @i<A> := X;>>
@xinbull<If X is of a specific tagged type @i<T> then@hr @fc< @i<@ft<anonymous>> : @b<constant> @i<T>'Class := @i<T>'Class (X);@hr
@i<X'Old> : @i<T> @b<renames> @i<T>(@i<@ft<anonymous>>);>@hr where the name X'Old denotes the object renaming.>
@xinbull<Otherwise@hr @fc< @i<X'Old> : @b<constant> @i<S> := X;>@hr
where @i<S> is the nominal subtype of X. This includes
the case where the type of @i<S> is an anonymous array type or a universal type.>
@xindent<The nominal subtype of X'Old is as implied by the above definitions. The expected type of the prefix of an Old attribute is that of the attribute. Similarly, if an Old attribute shall resolve to be of some type, then the prefix of the attribute shall resolve to be of that type.>
!corrigendum 6.1.1(37/3)
!AI-0113-1
!AI-0159-1
@drepl For any subprogram or entry call (including dispatching calls), the checks that are performed to verify specific precondition expressions and specific and class-wide postcondition expressions are determined by those for the subprogram or entry actually invoked. Note that the class-wide postcondition expressions verified by the postcondition check that is part of a call on a primitive subprogram of type @i<T> includes all class-wide postcondition expressions originating in any progenitor of @i<T>, even if the primitive subprogram called is inherited from a type @i<T1> and some of the postcondition expressions do not apply to the corresponding primitive subprogram of @i<T1>. @dby For any call to a subprogram or entry @i<S> (including dispatching calls), the checks that are performed to verify specific precondition expressions and specific and class-wide postcondition expressions are determined by those for the subprogram or entry actually invoked. Note that the class-wide postcondition expressions verified by the postcondition check that is part of a call on a primitive subprogram of type @i<T> includes all class-wide postcondition expressions originating in any progenitor of @i<T>, even if the primitive subprogram called is inherited from a type @i<T1> and some of the postcondition expressions do not apply to the corresponding primitive subprogram of @i<T1>. Any operations within a class-wide postcondition expression that were resolved as primitive operations of the (notional) formal derived type @i<NT>, are in the evaluation of the postcondition bound to the corresponding operations of the type identified by the controlling tag of the call on @i<S>. This applies to both dispatching and non-dispatching calls on @i<S>.
!corrigendum 6.1.1(38/3)
!AI-0113-1
!AI-0159-1
@drepl The class-wide precondition check for a call to a subprogram or entry consists solely of checking the class-wide precondition expressions that apply to the denoted callable entity (not necessarily the one that is invoked). @dby The class-wide precondition check for a call to a subprogram or entry @i<S> consists solely of checking the class-wide precondition expressions that apply to the denoted callable entity (not necessarily to the one that is invoked). Any operations within such an expression that were resolved as primitive operations of the (notional) formal derived type @i<NT> are in the evaluation of the precondition bound to the corresponding operations of the type identified by the controlling tag of the call on @i<S>. This applies to both dispatching and non-dispatching calls on @i<S>.
!corrigendum 6.3.1(12)
!AI-0107-1
!AI-0159-1
@drepl @xbullet<The default calling convention is @i<protected> for a protected subprogram, and for an access-to-subprogram type with the reserved word @b<protected> in its definition.> @dby @xbullet<The default calling convention is @i<protected> for a protected subprogram, for a prefixed view of a subprogram with a synchronization kind of By_Protected_Procedure, and for an access-to-subprogram type with the reserved word @b<protected> in its definition.>
!corrigendum 6.3.1(13)
!AI-0107-1
!AI-0159-1
@drepl @xbullet<The default calling convention is @i<entry> for an entry.> @dby @xbullet<The default calling convention is @i<entry> for an entry and for a prefixed view of a subprogram with a synchronization kind of By_Entry.>
!corrigendum 6.4.1(13.1/3)
!AI-0074-1
!AI-0159-1
@drepl @xinbull<For a scalar type that has the Default_Value aspect specified, the formal parameter is initialized from the value of the actual, without checking that the value satisfies any constraint or any predicate;> @dby @xinbull<For a scalar type that has the Default_Value aspect specified, the formal parameter is initialized from the value of the actual, without checking that the value satisfies any constraint or any predicate. Furthermore, if the actual parameter is a view conversion and either> @xi2bull<there exists no type (other than a root numeric type) that is an ancestor of both the target type and the type of the operand of the conversion; or> @xi2bull<the Default_Value aspect is unspecified for the type of the operand of the conversion> @xindent<then Program_Error is raised;>
!corrigendum 7.3.2(3/3)
!AI-0041-1
!AI-0150-1
@drepl @xhang<@xterm<Type_Invariant'Class> This aspect shall be specified by an @fa<expression>, called an @i<invariant expression>. Type_Invariant'Class may be specified on a @fa<private_type_declaration> or a @fa<private_extension_declaration>.> @dby @xhang<@xterm<Type_Invariant'Class> This aspect shall be specified by an @fa<expression>, called an @i<invariant expression>. Type_Invariant'Class may be specified on a @fa<private_type_declaration>, a @fa<private_extension_declaration>, or a @fa<full_type_declaration> for an interface type. Type_Invariant'Class determines a @i<class-wide type invariant> for a tagged type.>
!corrigendum 7.3.2(5/3)
!AI-0150-1
!AI-0159-1
@drepl Within an invariant expression, the identifier of the first subtype of the associated type denotes the current instance of the type. Within an invariant expression associated with type @i<T>, the type of the current instance is @i<T> for the Type_Invariant aspect and @i<T>'Class for the Type_Invariant'Class aspect. @dby Within an invariant expression, the identifier of the first subtype of the associated type denotes the current instance of the type. Within an invariant expression for the Type_Invariant aspect of a type @i<T>, the type of this current instance is @i<T>. Within an invariant expression for the Type_Invariant'Class aspect of a type @i<T>, the type of this current instance is interpreted as though it had a (notional) type @i<NT> that is a visible formal derived type whose ancestor type is @i<T>. The effect of this interpretation is that the only operations that can be applied to this current instance are those defined for such a formal derived type.
!corrigendum 7.3.2(10/3)
!AI-0049-1
!AI-0133-1
@drepl @xbullet<After successful default initialization of an object of type @i<T>, the check is performed on the new object;> @dby @xbullet<After successful initialization of an object of type @i<T> by default (see 3.3.1), the check is performed on the new object unless the partial view of @i<T> has unknown discriminants;>
@xbullet<After successful explicit initialization of the completion of a deferred constant with a part of type @i<T>, if the completion is inside the immediate scope of the full view of @i<T>, and the deferred constant is visible outside the immediate scope of @i<T>, the check is performed on the part(s) of type @i<T>;>
!corrigendum 7.3.2(19/3)
!AI-0042-1
!AI-0044-1
!AI-0149-1
@drepl @xinbull<has a result with a part of type @i<T>, or one or more parameters with a part of type @i<T>, or an access to variable parameter whose designated type has a part of type @i<T>.> @dby @xinbull<and either:>
@xi2bull<has a result with a part of type @i<T>, or>
@xi2bull<has one or more @b<out> or @b<in out> parameters with a part of type @i<T>, or>
@xi2bull<has an access-to-object parameter or result whose designated type has a part of type @i<T>, or>
@xi2bull<is a procedure or entry that has an @b<in> parameter with a part of type @i<T>,>
@xinbull<and either:>
@xi2bull<@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>
@xi2bull<@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>.>
!corrigendum 7.3.2(21/3)
!AI-0080-1
!AI-0159-1
@drepl If performing checks is required by the Invariant or Invariant'Class assertion policies (see 11.4.2) in effect at the point of corresponding aspect specification applicable to a given type, then the respective invariant expression is considered @i<enabled>. @dby If performing checks is required by the Type_Invariant or Type_Invariant'Class assertion policies (see 11.4.2) in effect at the point of the corresponding aspect specification applicable to a given type, then the respective invariant expression is considered @i<enabled>.
!corrigendum 7.3.2(22/3)
!AI-0150-1
!AI-0159-1
@dinsa The invariant check consists of the evaluation of each enabled invariant expression that applies to @i<T>, on each of the objects specified above. If any of these evaluate to False, Assertions.Assertion_Error is raised at the point of the object initialization, conversion, or call. If a given call requires more than one evaluation of an invariant expression, either for multiple objects of a single type or for multiple types with invariants, the evaluations are performed in an arbitrary order, and if one of them evaluates to False, it is not specified whether the others are evaluated. Any invariant check is performed prior to copying back any by-copy @b<in out> or @b<out> parameters. Invariant checks, any postcondition check, and any constraint or predicate checks associated with @b<in out> or @b<out> parameters are performed in an arbitrary order. @dinst For an invariant check on a value of type @i<T1> based on a class-wide invariant expression inherited from an ancestor type @i<T>, any operations within the invariant expression that were resolved as primitive operations of the (notional) formal derived type @i<NT> are bound to the corresponding operations of type @i<T1> in the evaluation of the invariant expression for the check on @i<T1>.
!corrigendum 11.3(2/2)
!AI-0022-1
!AI-0152-1
@dinsa @xcode<@fa<raise_statement ::= >@ft<@b<raise>@fa<; |>
@ft<@b<raise> @i<exception_>>@fa<name [>>@ft<@b<with> @i<string_>>@fa<expression];>>
@dinss @xcode<@fa<raise_expression ::= @ft<@b<raise> @i<exception_>>@fa<name [>>@ft<@b<with> @i<string_>>@fa<simple_expression]>>
If a @fa<raise_expression> appears within the @fa<expression> of one of the following contexts, the @fa<raise_expression> shall appear within a pair of parentheses within the @fa<expression>:
@xbullet<@fa<object_declaration>;> @xbullet<@fa<modular_type_definition>;> @xbullet<@fa<floating_point_definition>;> @xbullet<@fa<ordinary_fixed_point_definition>;> @xbullet<@fa<decimal_fixed_point_definition>;> @xbullet<@fa<default_expression>;> @xbullet<@fa<ancestor_part>.>
!corrigendum 11.3(3)
!AI-0022-1
!AI-0159-1
@drepl The @fa<name>, if any, in a @fa<raise_statement> shall denote an exception. A @fa<raise_statement> with no @i<exception_>@fa<name> (that is, a @i<re-raise statement>) shall be within a handler, but not within a body enclosed by that handler. @dby The @i<exception_>@fa<name>, if any, of a @fa<raise_statement> or @fa<raise_expression> shall denote an exception. A @fa<raise_statement> with no @i<exception_>@fa<name> (that is, a @i<re-raise statement>) shall be within a handler, but not within a body enclosed by that handler.
!corrigendum 11.3(3.1/2)
!AI-0022-1
!AI-0152-1
!AI-0159-1
@drepl The @fa<expression>, if any, in a @fa<raise_statement>, is expected to be of type String. @dby The @i<string_>@fa<expression> or @i<string_>@fa<simple_expression>, if any, of a @fa<raise_statement> or @fa<raise_expression> is expected to be of type String.
The expected type for a @fa<raise_expression> shall be any single type.
!corrigendum 11.3(4/2)
!AI-0022-1
!AI-0062-1
!AI-0152-1
!AI-0159-1
@drepl To @i<raise an exception> is to raise a new occurrence of that exception, as explained in 11.4. For the execution of a @fa<raise_statement> with an @i<exception_>@fa<name>, the named exception is raised. If a @i<string_>@fa<expression> is present, the @fa<expression> is evaluated and its value is associated with the exception occurrence. For the execution of a re-raise statement, the exception occurrence that caused transfer of control to the innermost enclosing handler is raised again. @dby To @i<raise an exception> is to raise a new occurrence of that exception, as explained in 11.4. For the execution of a @fa<raise_statement> with an @i<exception_>@fa<name>, the named exception is raised. Similarly, for the evaluation of a @fa<raise_expression>, the named exception is raised. In both of these cases, if a @i<string_>@fa<expression> or @i<string_>@fa<simple_expression> is present, the expression is evaluated and its value is associated with the exception occurrence. For the execution of a re-raise statement, the exception occurrence that caused transfer of control to the innermost enclosing handler is raised again.
@xindent<@s9<NOTES@hr 1 If the evaluation of a @i<string_>@fa<expression> or @i<string_>@fa<simple_expression> raises an exception, that exception is propagated instead of the one denoted by the @i<exception_>@fa<name> of the @fa<raise_statement> or @fa<raise_expression>.>>
!corrigendum 11.4.1(10.1/3)
!AI-0022-1
!AI-0152-1
@drepl Exception_Message returns the message associated with the given Exception_Occurrence. For an occurrence raised by a call to Raise_Exception, the message is the Message parameter passed to Raise_Exception. For the occurrence raised by a @fa<raise_statement> with an @I<exception_>@fa<name> and a @I<string_>@fa<expression>, the message is the @i<string_>@fa<expression>. For the occurrence raised by a @fa<raise_statement> with an @i<exception_>@fa<name> but without a @i<string_>@fa<expression>, the message is a string giving implementation-defined information about the exception occurrence. For an occurrence originally raised in some other manner (including by the failure of a language-defined check), the message is an unspecified string. In all cases, Exception_Message returns a string with lower bound 1. @dby Exception_Message returns the message associated with the given Exception_Occurrence. For an occurrence raised by a call to Raise_Exception, the message is the Message parameter passed to Raise_Exception. For the occurrence raised by a @fa<raise_statement> or @fa<raise_expression> with an @I<exception_>@fa<name> and a @I<string_>@fa<expression> or @I<string_>@fa<simple_expression>, the message is the @I<string_>@fa<expression> or @I<string_>@fa<simple_expression>. For the occurrence raised by a @fa<raise_statement> or @fa<raise_expression> with an @i<exception_>@fa<name> but without a @I<string_>@fa<expression> or @I<string_>@fa<simple_expression>, the message is a string giving implementation-defined information about the exception occurrence. For an occurrence originally raised in some other manner (including by the failure of a language-defined check), the message is an unspecified string. In all cases, Exception_Message returns a string with lower bound 1.
!corrigendum 13.1.1(18/3)
!AI-0105-1
!AI-0138-1
@drepl A language-defined aspect shall not be specified in an @fa<aspect_specification> given on a @fa<subprogram_body> or @fa<subprogram_body_stub> that is a completion of another declaration. @dby A language-defined aspect shall not be specified in an @fa<aspect_specification> given on a completion of a subprogram or generic subprogram.
If an aspect of a derived type is inherited from an ancestor type and has the boolean value True, the inherited value shall not be overridden to have the value False for the derived type, unless otherwise specified in this International Standard.
Certain type-related aspects are defined to be @i<nonoverridable>; all such aspects are specified using an @fa<aspect_definition> that is a @fa<name>.
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>.
If a full type has a partial view, and a given nonoverridable aspect is allowed for both the full view and the partial view, then the given aspect for the partial view and the full view shall be the same: the aspect shall be directly specified only on the partial view; if the full type inherits the aspect, then a matching definition shall be specified (directly or by inheritance) for the partial view.
In addition to the places where Legality Rules normally apply (see 12.3), these rules about nonoverridable aspects also apply in the private part of an instance of a generic unit.
The Default_Iterator, Iterator_Element, Implicit_Dereference, Constant_Indexing, and Variable_Indexing aspects are nonoverridable.
!corrigendum 13.11.3(5/3)
!AI-0003-1
!AI-0136-1
@drepl The language-defined aspect Default_Storage_Pool may be specified for a generic instance; it defines the default pool for access types within an instance. The expected type for the Default_Storage_Pool aspect is Root_Storage_Pool'Class. The @fa<aspect_definition> must be a name that denotes a variable. This aspect overrides any Default_Storage_Pool pragma that might apply to the generic unit; if the aspect is not specified, the default pool of the instance is that defined for the generic unit. @dby The language-defined aspect Default_Storage_Pool may be specified for a generic instance; it defines the default pool for access types within an instance.
The Default_Storage_Pool aspect may be specified as Standard, which is an identifier specific to an aspect (see 13.1.1) and defines the default pool to be Standard. In this case, there shall not be a declaration with @fa<defining_identifier> Standard that is immediately visible at the point of the aspect specification, other than package Standard itself.
Otherwise, the expected type for the Default_Storage_Pool aspect is Root_Storage_Pool'Class and the @fa<aspect_definition> shall be a @fa<name> that denotes a variable. This aspect overrides any Default_Storage_Pool pragma that might apply to the generic unit; if the aspect is not specified, the default pool of the instance is that defined for the generic unit.
The effect of specifying the aspect Default_Storage_Pool on an instance of a language-defined generic unit is implementation-defined.
!corrigendum 13.13.2(38/3)
!AI-0106-1
!AI-0121-1
@drepl The stream-oriented attributes may be specified for any type via an @fa<attribute_definition_clause>. The subprogram name given in such a clause shall statically denote a subprogram that is not an abstract subprogram. Furthermore, if a stream-oriented attribute is specified for an interface type by an @fa<attribute_definition_clause>, the subprogram name given in the clause shall statically denote a null procedure. @dby The stream-oriented attributes may be specified for any type via an @fa<attribute_definition_clause>. Alternatively, each of the specific stream-oriented attributes may be specified using an @fa<aspect_specification> on any @fa<type_declaration>, with the aspect name being the corresponding attribute name. Each of the class-wide stream-oriented attributes may be specified using an @fa<aspect_specification> for a tagged type @i<T> using the name of the stream-oriented attribute followed by 'Class; such class-wide aspects do not apply to other descendants of @i<T>.
The subprogram name given in such an @fa<attribute_definition_clause> or @fa<aspect_specification> shall statically denote a subprogram that is not an abstract subprogram. Furthermore, if a specific stream-oriented attribute is specified for an interface type, the subprogram name given in the @fa<attribute_definition_clause> or @fa<aspect_specification> shall statically denote a null procedure.
!corrigendum 13.14(5/3)
!AI-0103-1
!AI-0132-1
@dinsa @xbullet<The occurrence of a @fa<generic_instantiation> causes freezing, except that a @fa<name> which is a generic actual parameter whose corresponding generic formal parameter is a formal incomplete type (see 12.5.1) does not cause freezing. In addition, if a parameter of the instantiation is defaulted, the @fa<default_expression> or @fa<default_name> for that parameter causes freezing.> @dinss @xbullet<At the occurrence of an @fa<expression_function_declaration> that is a completion, the return expression of the expression function causes freezing.>
@xbullet<At the occurrence of a renames-as-body whose @i<callable_entity_>@fa<name> denotes an expression function, the return expression of the expression function causes freezing.>
!corrigendum A(3)
!AI-0052-1
!AI-0114-1
!AI-0159-1
@drepl The implementation shall ensure that each language-defined subprogram is reentrant in the sense that concurrent calls on the same subprogram perform as specified, so long as all parameters that could be passed by reference denote nonoverlapping objects. @dby The implementation shall ensure that each language-defined subprogram is reentrant in the sense that concurrent calls on any language-defined subprogram perform as specified, so long as all objects that are denoted by parameters that could be passed by reference or designated by parameters of an access type are nonoverlapping.
For the purpose of determining whether concurrent calls on text input-output subprograms are required to perform as specified above, when calling a subprogram within Text_IO or its children that implicitly operates on one of the default input-output files, the subprogram is considered to have a parameter of Current_Input or Current_Output (as appropriate).
!corrigendum A.18.10(2/3)
!AI-0078-1
!AI-0159-1
@drepl A multiway tree container object manages a tree of internal @i<nodes>, each of which contains an element and pointers to the parent, first child, last child, next (successor) sibling, and previous (predecessor) sibling internal nodes. A cursor designates a particular node within a tree (and by extension the element contained in that node, if any). A cursor keeps designating the same node (and element) as long as the node is part of the container, even if the node is moved within the container. @dby A multiway tree container object manages a tree of @i<nodes>, consisting of a @i<root node> and a set of @i<internal nodes>; each internal node contains an element and pointers to the parent, first child, last child, next (successor) sibling, and previous (predecessor) sibling internal nodes. A cursor designates a particular node within a tree (and by extension the element contained in that node, if any). A cursor keeps designating the same node (and element) as long as the node is part of the container, even if the node is moved within the container.
!corrigendum D.13(6/3)
!AI-0055-1
!AI-0073-1
@drepl @xcode<@b<pragma> Task_Dispatching_Policy (FIFO_Within_Priorities); @b<pragma> Locking_Policy (Ceiling_Locking); @b<pragma> Detect_Blocking; @b<pragma> Restrictions (
No_Abort_Statements, No_Dynamic_Attachment, No_Dynamic_Priorities, No_Implicit_Heap_Allocations, No_Local_Protected_Objects, No_Local_Timing_Events, No_Protected_Type_Allocators, No_Relative_Delay, No_Requeue_Statements, No_Select_Statements, No_Specific_Termination_Handlers, No_Task_Allocators, No_Task_Hierarchy, No_Task_Termination, Simple_Barriers, Max_Entry_Queue_Length =@> 1, Max_Protected_Entries =@> 1, Max_Task_Entries =@> 0, No_Dependence =@> Ada.Asynchronous_Task_Control, No_Dependence =@> Ada.Calendar, No_Dependence =@> Ada.Execution_Time.Group_Budgets, No_Dependence =@> Ada.Execution_Time.Timers, No_Dependence =@> Ada.Task_Attributes, No_Dependence =@> System.Multiprocessors.Dispatching_Domains);>
@dby @xcode<@b<pragma> Task_Dispatching_Policy (FIFO_Within_Priorities); @b<pragma> Locking_Policy (Ceiling_Locking); @b<pragma> Detect_Blocking; @b<pragma> Restrictions (
No_Abort_Statements, No_Dynamic_Attachment, No_Dynamic_CPU_Assignment, No_Dynamic_Priorities, No_Implicit_Heap_Allocations, No_Local_Protected_Objects, No_Local_Timing_Events, No_Protected_Type_Allocators, No_Relative_Delay, No_Requeue_Statements, No_Select_Statements, No_Specific_Termination_Handlers, No_Task_Allocators, No_Task_Hierarchy, No_Task_Termination, Simple_Barriers, Max_Entry_Queue_Length =@> 1, Max_Protected_Entries =@> 1, Max_Task_Entries =@> 0, No_Dependence =@> Ada.Asynchronous_Task_Control, No_Dependence =@> Ada.Calendar, No_Dependence =@> Ada.Execution_Time.Group_Budgets, No_Dependence =@> Ada.Execution_Time.Timers, No_Dependence =@> Ada.Synchronous_Barriers, No_Dependence =@> Ada.Task_Attributes, No_Dependence =@> System.Multiprocessors.Dispatching_Domains);>
!corrigendum E.2.2(17/2)
!AI-0076-1
!AI-0085-1
@drepl @xbullet<The Storage_Pool attribute is not defined for a remote access-to-class-wide type; the expected type for an @fa<allocator> shall not be a remote access-to-class-wide type. A remote access-to-class-wide type shall not be an actual parameter for a generic formal access type. The Storage_Size attribute of a remote access-to-class-wide type yields 0; it is not allowed in an @fa<attribute_definition_clause>.> @dby @xbullet<The Storage_Pool attribute is not defined for a remote access-to-class-wide type; the expected type for an @fa<allocator> shall not be a remote access-to-class-wide type. A remote access-to-class-wide type shall not be an actual parameter for a generic formal access type. The Storage_Size attribute of a remote access-to-class-wide type yields 0. The Storage_Pool and Storage_Size aspects shall not be specified for a remote access-to-class-wide type.>
@s8<@i<Erroneous Execution>>
Execution is erroneous if some operation (other than the initialization or finalization of the object) modifies the value of a constant object declared in the visible part of a remote types package.

Questions? Ask the ACAA Technical Agent