CVS difference for ai12s/ai12-0413-1.txt

Differences between 1.2 and version 1.3
Log of other versions for file ai12s/ai12-0413-1.txt

--- ai12s/ai12-0413-1.txt	2020/12/11 22:22:26	1.2
+++ ai12s/ai12-0413-1.txt	2021/01/15 07:40:06	1.3
@@ -1,4 +1,4 @@
-!standard 3.9.3(7)                                     20-12-11  AI12-0413-1/02
+!standard 3.9.3(7)                                     20-12-17  AI12-0413-1/03
 !standard 4.5.2(14.1/3)
 !standard 4.5.2(24.1/3)
 !standard 12.5(8/3)
@@ -151,7 +151,7 @@
      (actual) untagged record type is declared abstract, then
      Program_Error will be raised if the equality operator of the formal
      type is in fact invoked within an instance of a generic body (see
-     4.5.2(24.1/3)). If the operator is invoked within an instance
+     4.5.2). If the operator is invoked within an instance
      of the generic spec, the instance is illegal.
 
 !discussion
@@ -222,6 +222,70 @@
 to the use of the abstract "=" in the instance of the generic spec, but if we 
 remove the declaration of A, then it would be legal, but raise Program_Error at
 the use of "=" and its rename "F" in the instance of the generic body.
+
+!corrigendum 3.9.3(7)
+
+@drepl
+A call on an abstract subprogram shall be a dispatching call;
+nondispatching calls to an abstract subprogram are not allowed.
+@dby
+A call on an abstract subprogram shall be a dispatching call;
+nondispatching calls to an abstract subprogram are not allowed. 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.
+
+!corrigendum 4.5.2(14.1/3)
+
+@ddel
+For a derived type whose parent is an untagged record type, predefined equality
+is defined in terms of the primitive (possibly user-defined) equals operator of
+the parent type.
+
+!corrigendum 4.5.2(24.1/3)
+
+@drepl
+If the primitive equals operator for an untagged record type is abstract,
+then Program_Error is raised at the point of any (implicit)
+call to that abstract subprogram.
+@dby
+If the primitive equals operator for an untagged record type is abstract,
+then Program_Error is raised at the point of any call to that abstract
+subprogram, implicitly as part of an equality operation on an enclosing
+composite object, or in an instance of a generic with a formal private type
+where the actual type is a record type with an abstract "=".
+
+!corrigendum 12.5(8/3)
+
+@drepl
+The formal type also belongs to each category that contains the determined
+category. The primitive subprograms of the type are as for any type in the
+determined category. For a formal type other than a formal derived type, these
+are the predefined operators of the type. For an elementary formal type, the
+predefined operators are implicitly declared immediately after the declaration
+of the formal type. For a composite formal type, the predefined operators are
+implicitly declared either immediately after the declaration of the formal
+type, or later immediately within the declarative region in which the type is
+declared according to the rules of 7.3.1. In an instance, the copy of such an
+implicit declaration declares a view of the predefined operator of the actual
+type, even if this operator has been overridden for the actual type and even if
+it is never declared for the actual type. The rules specific to formal derived
+types are given in 12.5.1.
+@dby
+The formal type also belongs to each category that contains the determined
+category. The primitive subprograms of the type are as for any type in the
+determined category. For a formal type other than a formal derived type, these
+are the predefined operators of the type. For an elementary formal type, the
+predefined operators are implicitly declared immediately after the declaration
+of the formal type. For a composite formal type, the predefined operators are
+implicitly declared either immediately after the declaration of the formal
+type, or later immediately within the declarative region in which the type is
+declared according to the rules of 7.3.1. In an instance, the copy of such an
+implicit declaration declares a view of the predefined operator of the actual
+type, even if this operator has been overridden for the actual type and even if
+it is never declared for the actual type, unless the actual type is an untagged
+record type, in which case it declares a view of the primitive (equality)
+operator. The rules specific to formal derived types are given in 12.5.1.
 
 !ASIS
 

Questions? Ask the ACAA Technical Agent