CVS difference for ai05s/ai05-0110-1.txt

--- ai05s/ai05-0110-1.txt	2011/04/15 05:38:48	1.13
+++ ai05s/ai05-0110-1.txt	2011/05/05 06:46:37	1.14
@@ -1,8 +1,9 @@
-!standard 3.4(7)                                  11-04-14  AI05-0110-1/04
+!standard 3.4(7)                                  11-05-05  AI05-0110-1/05
 !standard 7.3(16/2)
 !standard 12.5.1(20/2)
 !standard 12.5.1(21/3)
 !class binding interpretation 08-08-08
+!status Amendment 2012 11-05-05
 !status ARG Approved  8-0-0  11-04-07
 !status work item 08-08-08
 !status received 08-05-21
@@ -59,9 +60,9 @@
 
      AARM note:
      The characteristics of a type do not include its primitive
-     subprograms (including predefined operators). The rules governing
-     availability/visibility and inheritance of characteristics are separate
-     from those for primitive subprograms.
+     subprograms (primitive subprograms include predefined operators). The
+     rules governing availability/visibility and inheritance of characteristics
+     are separate from those for primitive subprograms.
 
    [Add "characteristics" to the index for this paragraph, in addition to
    the definition in 7.3.]
@@ -137,8 +138,77 @@
 We also add a definition and indexing for "characteristics" in 3.4, as this
 is where the properties that are characteristics are defined.
 
---!corrigendum 12.5.1(21/2)
+!corrigendum 3.4(7)
 
+@drepl
+The characteristics of the derived type are defined as follows: 
+@dby
+The @i<characteristics> and implicitly declared primitive subprograms
+of the derived type are defined as follows:
+
+!corrigendum 7.3(16/2)
+
+@drepl
+A private extension inherits components (including discriminants unless there
+is a new @fa<discriminant_part> specified) and user-defined primitive
+subprograms from its ancestor type and its progenitor types (if any), in the
+same way that a record extension inherits components and user-defined primitive
+subprograms from its parent type and its progenitor types (see 3.4).
+@dby
+For a private extension, the characteristics (including components, but
+excluding discriminants if there is a new @fa<discriminant_part> specified),
+predefined operators, and inherited user-defined primitive subprograms are
+determined by its ancestor type and its progenitor types (if any), in the
+same way that those of a record extension are determined by those of its
+parent type and its progenitor types (see 3.4 and 7.3.1).
+
+!corrigendum 12.5.1(20/2)
+
+@drepl
+If the ancestor type is a composite type that is not an array type, the formal
+type inherits components from the ancestor type (including discriminants if a
+new @fa<discriminant_part> is not specified), as for a derived type defined by
+a @fa<derived_type_definition> (see 3.4 and 7.3.1).
+@dby
+For a formal derived type, the characteristics
+(including components, but excluding discriminants if there
+is a new @fa<discriminant_part> specified), predefined operators,
+and inherited user-defined primitive subprograms are determined
+by its ancestor type and its progenitor types (if any), in the
+same way that those of a derived type are determined
+by those of its parent type and its progenitor types (see 3.4 and 7.3.1).
+
+
+!corrigendum 12.5.1(21/2)
+
+@drepl
+For a formal derived type, the predefined operators and inherited user-defined
+subprograms are determined by the ancestor type and any progenitor types, and
+are implicitly declared at the earliest place, if any, immediately within the
+declarative region in which the formal type is declared, where the
+corresponding primitive subprogram of the ancestor or progenitor is visible
+(see 7.3.1). In an instance, the copy of such an implicit declaration declares
+a view of the corresponding primitive subprogram of the ancestor or progenitor
+of the formal derived type, even if this primitive has been overridden for the
+actual type. When the ancestor or progenitor of the formal derived type is
+itself a formal type, the copy of the implicit declaration declares a view of
+the corresponding copied operation of the ancestor or progenitor. In the case
+of a formal private extension, however, the tag of the formal type is that of
+the actual type, so if the tag in a call is statically determined to be that of
+the formal type, the body executed will be that corresponding to the actual
+type.
+@dby
+In an instance, the copy of an implicit declaration of a
+primitive subprogram of a formal derived type declares 
+a view of the corresponding primitive subprogram of the ancestor or progenitor
+of the formal derived type, even if this primitive has been overridden for the
+actual type and even if it is never declared for the actual type. When the
+ancestor or progenitor of the formal derived type is itself a formal type, the
+copy of the implicit declaration declares a view of the corresponding copied
+operation of the ancestor or progenitor. In the case of a formal private
+extension, however, the tag of the formal type is that of the actual type, so
+if the tag in a call is statically determined to be that of the formal type,
+the body executed will be that corresponding to the actual type.
 
 !ACATS Test