CVS difference for ai12s/cor15con.txt

Differences between 1.10 and version 1.11
Log of other versions for file ai12s/cor15con.txt

--- ai12s/cor15con.txt	2015/03/28 02:40:50	1.10
+++ ai12s/cor15con.txt	2015/03/31 23:55:50	1.11
@@ -145,6 +145,81 @@
 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
@@ -212,6 +287,28 @@
 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
@@ -236,7 +333,142 @@
 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
@@ -254,6 +486,28 @@
 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
@@ -272,7 +526,6 @@
 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
@@ -308,6 +561,46 @@
 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
@@ -331,9 +624,25 @@
 @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
@@ -343,12 +652,13 @@
 if any, of a @fa<raise_statement> or @fa<raise_expression> is expected
 to be of type String.
 
-A @fa<raise_expression> is expected to be of any type.
+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
@@ -371,7 +681,7 @@
 @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 rather than the one denoted by the @i<exception_>@fa<name>
+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)
@@ -408,6 +718,47 @@
 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
@@ -483,15 +834,16 @@
 @fa<default_name> for that parameter causes freezing.>
 @dinss
 @xbullet<At the occurrence of an @fa<expression_function_declaration> that is a
-completion, the @fa<expression> of the expression function causes freezing.>
+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 @fa<expression> of the expression function causes
-freezing.>
+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
@@ -508,8 +860,30 @@
 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
+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

Questions? Ask the ACAA Technical Agent