CVS difference for ais/ai-10260.txt

Differences between 1.4 and version 1.5
Log of other versions for file ais/ai-10260.txt

--- ais/ai-10260.txt	2004/11/17 00:52:59	1.4
+++ ais/ai-10260.txt	2004/12/09 19:55:39	1.5
@@ -1,8 +1,10 @@
-!standard  3.09  (06)                               04-10-27  AI95-00260-02/02
+!standard  3.09  (06)                               04-12-01  AI95-00260-02/03
 !standard  3.09  (07)
 !standard  3.09  (12)
 !standard  3.09  (18)
 !standard  3.09  (25)
+!standard  3.09  (30)
+!standard  3.09.02 (01)
 !standard  3.09.02 (02)
 !standard  3.09.03 (03)
 !standard  3.09.03 (11)
@@ -10,14 +12,15 @@
 !standard 12.06  (04)
 !standard 12.06  (08)
 !standard 12.06  (10)
-!standard 12.06  (18)
-!standard 13.13.2  (31)
+!standard 12.06  (16)
 !class amendment 04-09-08
+!status Amendment 200Y 04-12-01
+!status ARG Approved 9-0-1  04-11-19
 !status work item 04-09-08
 !status received 04-09-08
 !priority Medium
 !difficulty Medium
-!subject How to control the tag representation in a stream
+!subject Abstract formal subprograms and dispatching constuctors
 
 !summary
 
@@ -29,7 +32,7 @@
 controlling result. This unit makes it possible to write functions with similar
 semantics to T'Class'Input, including a complete replacement for the function.
 
-A operation is defined in Ada.Tags to get the tag of a parent type.
+An operation is defined in Ada.Tags to get the tag of a parent type.
 
 !problem
 
@@ -42,7 +45,7 @@
 attribute to have the object streamed as an XML object. This is surprising,
 as external tags are defined as strings. It is possible to change the external
 tag string value by using Ada.Tags facilities. But the tag will always
-be streamed as an unbounded string object. This means that the tag string value
+be streamed as an object of type String. This means that the tag string value
 will be written preceded by the string bounds -- which are binary data. There
 is no way to prevent this binary data from being sent. In other words, there
 is no way to stream an object with a plain text representation.
@@ -61,6 +64,10 @@
 
    function Parent_Tag (T : Tag) return Tag;
 
+Add after 3.9(9):
+
+No_Tag is the default initial value of type Tag.
+
 Add after 3.9(12):
 
 The function Parent_Tag returns the tag of the parent type of the type whose
@@ -74,42 +81,38 @@
 
 Add after 3.9(18):
 
-Static Semantics
-
 The following language-defined generic functions exist:
 
     generic
-         type T (<>) is abstract tagged private;
-         type Parameters (<>) is limited private;
-         with function Constructor (Params : access Parameters)
-              return T is abstract;
+        type T (<>) is abstract tagged private;
+        type Parameters (<>) is limited private;
+        with function Constructor (Params : access Parameters)
+            return T is abstract;
     function Ada.Tags.Generic_Dispatching_Constructor
-      (The_Tag : Tag;
-       Params : access Parameters) return T'Class;
-    pragma Pure (Generic_Dispatching_Constructor);
+       (The_Tag : Tag;
+        Params : access Parameters) return T'Class;
+    pragma Preelaborate (Generic_Dispatching_Constructor);
     pragma Convention (Intrinsic, Generic_Dispatching_Constructor);
 
     generic
-         type T (<>) is abstract tagged limited private;
-         type Parameters (<>) is limited private;
-         with function Constructor (Params : access Parameters)
-              return T is abstract;
+        type T (<>) is abstract tagged limited private;
+        type Parameters (<>) is limited private;
+        with function Constructor (Params : access Parameters)
+             return T is abstract;
     function Ada.Tags.Generic_Limited_Dispatching_Constructor
-      (The_Tag : Tag;
-       Params : access Parameters) return T'Class;
-    pragma Pure (Generic_Limited_Dispatching_Constructor);
+       (The_Tag : Tag;
+        Params : access Parameters) return T'Class;
+    pragma Preelaborate (Generic_Limited_Dispatching_Constructor);
     pragma Convention (Intrinsic, Generic_Limited_Dispatching_Constructor);
 
-Generic_Dispatching_Constructor and Generic_Limited_Dispatching_Constructor
+Tags.Generic_Dispatching_Constructor and Tags.Generic_Limited_Dispatching_Constructor
 provide a mechanism to create an object of an appropriate type from just a tag
-value. This capability is sometimes known as a *factory*. The function
-Constructor does the actual creation of the object, using the information
-provided in a value of type Parameters to control the initial state of the
-object.
+value. The function Constructor is expected to create the object given a
+reference to an object of type Parameters.
 
 AARM Note: This specification is designed to make it easy to create dispatching
 constructors for streams; in particular, this can be used to construct
-overriddings for T'Class'Input.
+overridings for T'Class'Input.
 
 
 Add after 3.9(25):
@@ -120,52 +123,60 @@
 [Editor's Note: If AI-344 is included in the Amendment, this rule should
 include Descendant_Tag and Is_Descendant_At_Same_Level.]
 
-An instance of Generic_Dispatching_Constructor or
-Generic_Limited_Dispatching_Constructor raises Tag_Error if The_Tag does not
+An instance of Tags.Generic_Dispatching_Constructor or
+Tags.Generic_Limited_Dispatching_Constructor raises Tag_Error if The_Tag does not
 represent a concrete descendant of T.
-Otherwise, it dispatches to the version of Constructor for the type identified
-by the tag The_Tag, passing Params, and returns the result.
+Otherwise, it dispatches to the primitive function denoted by the formal
+Constructor for the type identified by the tag The_Tag, passing Params, and
+returns the result. Any exception raised by the function is propagated.
+
+AARM Note (Ramification): The tag check checks both that The_Tag is in T'Class,
+and that it is not abstract. These checks are similar to the ones required by
+streams for T'Class'Input (see 13.13.2). [Note to readers, these are found in
+AI-279.]
 
-AARM Note: The tag check checks both that The_Tag is in T'Class, and that it
-is not abstract. [Note: Those checks come from AI-279.]
-
 Erroneous Execution
 
-If the internal tag provided to an instance of Generic_Dispatching_Constructor
-or Generic_Limited_Dispatching_Constructor identifies a specific type whose tag
+If the internal tag provided to an instance of Tags.Generic_Dispatching_Constructor
+or Tags.Generic_Limited_Dispatching_Constructor identifies a specific type whose tag
 has not been elaborated, or does not exist in the partition at the time of the
 call, execution is erroneous.
 
 AARM Note: For a library-level type, this shouldn't be possible presuming that
 the tag value came from the current execution of the partition. T'Tag freezes
-the type (and thus elaborates the tag), and Internal_Tag and Descendant_Tag
-cannot return the tag of a library-level type that has not been elaborated.
+the type (and thus creates the tag), and Internal_Tag and Descendant_Tag
+cannot return the tag of a library-level type that has not been created.
 Finally, library-level types never cease to exist. Thus, if the tag comes from
 a library-level type, there cannot be erroneous execution (the use of
-Descendant_Tag rather than Internal_Tag can help insure this). [Note: This rule
-also comes from AI-279.]
+Descendant_Tag rather than Internal_Tag can help insure that the tag is
+of a library-level type). This is also similar to the rules for T'Class'Input
+(see 13.13.2). [Note to readers, this also is found in AI-279.]
+
+Add after 3.9(30):
+
+The capability provided by Tags.Generic_Dispatching_Constructor and
+Tags.Generic_Limited_Dispatching_Constructor is sometimes known as a factory.
+
+Change the first sentence of 3.9.2(1):
+
+The primitive subprograms of a tagged type are called *dispatching operations*,
+as are subprograms declared by a formal_abstract_subprogram_declaration.
 
 Change the first sentence of 3.9.2(2):
 
 A *call on a dispatching operation* is a call whose name or prefix denotes the
-declaration of a primitive operation of a tagged type {or an abstract formal
-subprogram}, that is, a dispatching operation.
+declaration of a dispatching operation.
 
-Add after 3.9.3(3):
+Change the first sentence of 3.9.3(3):
 
-The subprogram declared by a formal_abstract_subprogram_declaration is an
-abstract subprogram.
+A subprogram declared by an abstract_subprogram_declaration (see 6.1) or
+declared by a formal_abstract_subprogram_declaration (see 12.6) is an abstract
+subprogram.
 
-[Editor's note: The second sentence of 3.9.3(3) does not apply to abstract
-formal subprograms; they have their own rules for controlling operands given in
-12.6. Thus I did not add this rule to paragraph 3.9.3(3), but rather created a
-new paragraph. Luckily the original wording does not say that it applies to all
-abstract subprograms, so no change is needed to it.]
-
 Replace the first sentence of 3.9.3(11) by:
 
-A generic actual subprogram shall not be abstract unless the generic formal
-subprogram is a formal_abstract_subprogram_declaration.
+A generic actual subprogram shall not be an abstract subprogram unless the
+generic formal subprogram is a formal_abstract_subprogram_declaration.
 
 
 Replace 12.6(2) by:
@@ -175,35 +186,44 @@
 formal_concrete_subprogram_declaration ::=
         with subprogram_specification [is subprogram_default];
 formal_abstract_subprogram_declaration ::=
-        with subprogram_specification is abstract;
+        with subprogram_specification is abstract [subprogram_default];
 
 Add after 12.6(8):
 
-If a formal parameter of an formal_abstract_subprogram_declaration has a
-specific tagged type T or is an anonymous access designating a specific tagged
-type T, T is called a dispatching type of the
+If a formal parameter of an formal_abstract_subprogram_declaration is of a
+specific tagged type T or of an anonymous access designating a specific tagged
+type T, T is called a controlling type of the
 formal_abstract_subprogram_declaration. Similarly, if the result of an
-formal_abstract_subprogram_declaration for a function has a specific tagged
-type T or is an anonymous access designating a specific tagged type T, T is
-called a dispatching type of the formal_abstract_subprogram_declaration. A
-formal_abstract_subprogram_declaration shall have exactly one dispatching type.
+formal_abstract_subprogram_declaration for a function is of a specific tagged
+type T or of an anonymous access designating a specific tagged type T, T is
+called a controlling type of the formal_abstract_subprogram_declaration. A
+formal_abstract_subprogram_declaration shall have exactly one controlling type.
 
-AARM Note:
+AARM Notes:
 The specific tagged type could be any of a formal tagged private type,
 a formal derived type, or a normal tagged type. While the last case doesn't
 seem to be very useful, there isn't any good reason for disallowing it.
 This rule insures that the operation is a dispatching operation of some
 type, and that we unambiguously know what that type is.
-End AARM Note.
 
+We informally call a subprogram declared by
+a formal_abstract_subprogram_declaration an *abstract formal subprogram*,
+but we do not use this term in normative wording.
+[Editor's note: This is so that it is indexed in the AARM (not the RM), and it
+gives an ordering for the two modifiers.]
+End AARM Notes.
+
 The actual subprogram for a formal_abstract_subprogram_declaration shall be a
-primitive operation of the dispatching type of the
+dispatching operation of the controlling type or of the actual type
+corresponding to the controlling type of the
 formal_abstract_subprogram_declaration.
 
-AARM Note: This means that it is a dispatching operation of the dispatching
-type. Also note that this prevents the dispatching type from being class-wide,
-as only specific types have primitive operations. This could happen in a case
-like:
+AARM Note: This means that it is either a primitive operation of the
+controlling type, or an abstract formal subprogram. Also note that this
+prevents the controlling type from being class-wide,
+as only specific types have primitive operations (and a formal subprogram
+eventually has to have an actual that is a primitive of some type). This could
+happen in a case like:
 
    generic
      type T(<>) is tagged private;
@@ -220,19 +240,19 @@
 Add after 12.6(10):
 
 The subprogram declared by a formal_abstract_subprogram_declaration with a
-dispatching type T is a dispatching operation of type T.
+controlling type T is a dispatching operation of type T.
 
 AARM Note:
 This is necessary to trigger all of the dispatching operation
 rules. It otherwise would not be considered a dispatching operation, as
 formal subprograms are never primitive operations.
 
-Replace 12.6(18) by:
+Replace 12.6(16) by:
 
 18 The actual subprogram cannot be abstract unless the formal
 subprogram is a formal_abstract_subprogram_declaration (see 3.9.3).
 
-Add a new note after 12.6(18):
+Add a new note after 12.6(16):
 
 19 The subprogram declared by a formal_abstract_subprogram_declaration
 is an abstract subprogram. All calls on a subprogram declared by a
@@ -240,15 +260,6 @@
 [Editor's Note: These things are defined in 3.9.3, but they are important to
 mention here.]
 
-Replace 13.13.2(31) by:
-
-First writes the external tag of Item to Stream (by calling
-String'Output(Stream, Tags.External_Tag(Item'Tag)) -- see 3.9) and then
-dispatches to the subprogram denoted by the Output attribute of the specific
-type identified by the tag.
-
-[Editor's note: This corrects typos in the original paragraph.]
-
 !discussion
 
 A function like the instance of Generic_Dispatching_Constructor or
@@ -343,7 +354,7 @@
 
 This is presented as an alternative to the Tag_Read and Tag_Write attributes.
 It would be possible to support both, but there doesn't seem to be any strong
-need to do so. As shown below, with this proposal overridding T'Class'Input
+need to do so. As shown below, with this proposal overriding T'Class'Input
 and T'Class'Output is no more difficult than implementing Tag_Read and
 Tag_Write.
 
@@ -436,6 +447,7 @@
 
 end Class;
 
+with Ada.Tags.Generic_Dispatching_Constructor;
 package body Class is
 
    procedure Write (S : access Ada.Streams.Root_Stream_Type'Class;
@@ -457,7 +469,7 @@
       Object'Output (S, O); -- Dispatching call; calls Object'Write.
    end Class_Output;
 
-   function Dispatching_Input is new Generic_Dispatching_Constructor
+   function Dispatching_Input is new Ada.Tags.Generic_Dispatching_Constructor
      (T => Object, Parameters => Ada.Streams.Root_Stream_Type'Class,
       Constructor => Object'Input);
 
@@ -494,7 +506,7 @@
 
 which is what we need to write XML.
 
-Note that overridding the stream attributes is not necessarily appropriate
+Note that overriding the stream attributes is not necessarily appropriate
 (for instance, if a distributed program needed to marshall these objects).
 This proposal provides a way to provide this functionality without using
 the stream attributes directly (just use the subprograms directly, and
@@ -523,8 +535,8 @@
 
 (and of course in all of the descendants), then
 
-   function Factory is new Generic_Dispatching_Constructor (Root_Window_Type,
-       Construct_Params, Construct);
+   function Factory is new Ada.Tags.Generic_Dispatching_Constructor (
+       Root_Window_Type, Construct_Params, Construct);
 
    function Create_Object (Item_Tag : in Ada.Tags.Tag) return Access_Any_Window is
       Params : aliased Construct_Params;
@@ -540,11 +552,257 @@
 universe).
 
 Note that a GUI builder needs to stream these objects (to save them into
-a GUI project file) as well as construct them from a menu, so overridding
-T'Class'Input is not an option.
+a GUI project file) as well as construct them from a menu, so overriding
+T'Input so as to use T'Class'Input for this purpose is not an option.
+
+
+!corrigendum 3.9(6)
+
+@dinsa
+@xcode<@b<package> Ada.Tags @b<is>
+    @b<type> Tag @b<is private>;
+@dinst
+@xcode<    No_Tag : @b<constant> Tag;>
+
+!corrigendum 3.9(7)
+
+@dinsa
+@xcode<    @b<function> Expanded_Name(T : Tag) @b<return> String;
+    @b<function> External_Tag(T : Tag) @b<return> String;
+    @b<function> Internal_Tag(External : String) @b<return> Tag;>
+@dinst
+@xcode<    @b<function> Parent_Tag (T : Tag) return Tag;>
+
+!corrigendum 3.9(9)
+
+@dinsa
+@xcode<@b<private>
+   ... -- @ft<@i<not specified by the language>>
+@b<end> Ada.Tags;>
+@dinst
+No_Tag is the default initial value of type Tag.
+
+!corrigendum 3.9(12)
+
+@dinsa
+The function Internal_Tag returns the tag that corresponds to the given
+external tag, or raises Tag_Error if the given string is not the external tag
+for any specific type of the partition.
+
+The function Parent_Tag returns the tag of the parent type of the type whose
+tag is T. If the type does not have a parent type (that is, it was not
+declared by a derived_type_declaration), then No_Tag is returned.
+
+!corrigendum 3.9(18)
+
+@dinsa
+@xhang<@xterm<X'Tag>
+X'Tag denotes the tag of X. The value of this attribute is of type Tag.>
+@dinss
+The following language-defined generic functions exist:
+
+@xcode<@b<generic>
+    @b<type> T (<@>) @b<is abstract tagged private>;
+    @b<type> Parameters (<@>) @b<is limited private>;
+    @b<with function> Constructor (Params : @b<access> Parameters)
+        @b<return> T @b<is abstract>;
+@b<function> Ada.Tags.Generic_Dispatching_Constructor
+   (The_Tag : Tag;
+    Params : @b<access> Parameters) @b<return> T'Class;
+@b<pragma> Preelaborate (Generic_Dispatching_Constructor);
+@b<pragma> Convention (Intrinsic, Generic_Dispatching_Constructor);
+
+@b<generic>
+    @b<type> T (<@>) @b<is abstract tagged limited private>;
+    @b<type> Parameters (<@>) @b<is limited private>;
+    @b<with function> Constructor (Params : @b<access> Parameters)
+        @b<return> T @b<is abstract>;
+@b<function> Ada.Tags.Generic_Limited_Dispatching_Constructor
+   (The_Tag : Tag;
+    Params : @b<access> Parameters) @b<return> T'Class;
+@b<pragma> Preelaborate (Generic_Limited_Dispatching_Constructor);
+@b<pragma> Convention (Intrinsic, Generic_Limited_Dispatching_Constructor);>
+
+Tags.Generic_Dispatching_Constructor and Tags.Generic_Limited_Dispatching_Constructor
+provide a mechanism to create an object of an appropriate type from just a tag
+value. The function Constructor is expected to create the object given a
+reference to an object of type Parameters.
+
+!corrigendum 3.9(25)
+
+@dinsa
+The tag is preserved by type conversion and by parameter passing. The tag of a
+value is the tag of the associated object (see 6.2).
+@dinss
+Tag_Error is raised by a call of Expanded_Name, External_Tag, or Parent_Tag if
+any tag passed is No_Tag.
+
+An instance of Tags.Generic_Dispatching_Constructor or
+Tags.Generic_Limited_Dispatching_Constructor raises Tag_Error if The_Tag does not
+represent a concrete descendant of T.
+Otherwise, it dispatches to the primitive function denoted by the formal
+Constructor for the type identified by the tag The_Tag, passing Params, and
+returns the result. Any exception raised by the function is propagated.
+
+@i<@s8<Erroneous Execution>>
+
+If the internal tag provided to an instance of
+Tags.Generic_Dispatching_Constructor or
+Tags.Generic_Limited_Dispatching_Constructor identifies a specific type whose
+tag has not been elaborated, or does not exist in the partition at the time of
+the call, execution is erroneous.
+
+!corrigendum 3.9(30)
+
+@dinsa
+@xindent<@s9<65  If S denotes an untagged private type whose full type is
+tagged, then S'Class is also allowed before the full type definition, but only
+in the private part of the package in which the type is declared (see 7.3.1).
+Similarly, the Class attribute is defined for incomplete types whose full type
+is tagged, but only within the library unit in which the incomplete type is
+declared (see 3.10.1).>>
+@dinst
+@xindent<@s9<66  The capability provided by
+Tags.Generic_Dispatching_Constructor and
+Tags.Generic_Limited_Dispatching_Constructor is sometimes known as a
+@i<factory>.>>
+
+!corrigendum 3.9.2(1)
+
+@drepl
+The primitive subprograms of a tagged type are called @i<dispatching
+operations>. A dispatching operation can be called using a statically
+determined @i<controlling> tag, in which case the body to be executed is
+determined at compile time. Alternatively, the controlling tag can be
+dynamically determined, in which case the call @i<dispatches> to a body that is
+determined at run time; such a call is termed a @i<dispatching call>. As
+explained below, the properties of the operands and the context of a particular
+call on a dispatching operation determine how the controlling tag is
+determined, and hence whether or not the call is a dispatching call. Run-time
+polymorphism is achieved when a dispatching operation is called by a
+dispatching call.
+@dby
+The primitive subprograms of a tagged type are called @i<dispatching
+operations>, as are subprograms declared by a
+@fa<formal_abstract_subprogram_declaration>. A dispatching operation can be
+called using a statically determined @i<controlling> tag, in which case the
+body to be executed is determined at compile time. Alternatively, the
+controlling tag can be dynamically determined, in which case the call
+@i<dispatches> to a body that is determined at run time; such a call is termed
+a @i<dispatching call>. As explained below, the properties of the operands and
+the context of a particular call on a dispatching operation determine how the
+controlling tag is determined, and hence whether or not the call is a
+dispatching call. Run-time polymorphism is achieved when a dispatching
+operation is called by a dispatching call.
+
+!corrigendum 3.9.2(2)
+
+@drepl
+A @i<call on a dispatching operation> is a call whose @fa<name> or @fa<prefix>
+denotes the declaration of a primitive subprogram of a tagged type, that is, a
+dispatching operation. A @i<controlling operand> in a call on
+a dispatching operation of a tagged type T is one whose corresponding formal
+parameter is of type T or is of an anonymous access type with designated type
+T; the corresponding formal parameter is called
+a @i<controlling formal parameter>. If the controlling formal parameter is an
+access parameter, the controlling operand is the object designated by the
+actual parameter, rather than the actual parameter itself.
+If the call is to a (primitive) function with result type T, then the call has
+a @i<controlling result> -- the context of the call can control the dispatching.
+@dby
+A @i<call on a dispatching operation> is a call whose @fa<name> or @fa<prefix>
+denotes the declaration of a dispatching operation. A @i<controlling operand>
+in a call on a dispatching operation of a tagged type T is one whose
+corresponding formal parameter is of type T or is of an anonymous access type
+with designated type T; the corresponding formal parameter is called
+a @i<controlling formal parameter>. If the controlling formal parameter is an
+access parameter, the controlling operand is the object designated by the
+actual parameter, rather than the actual parameter itself.
+If the call is to a (primitive) function with result type T, then the call has
+a @i<controlling result> -- the context of the call can control the dispatching.
+
+!corrigendum 3.9.3(3)
+
+@drepl
+A subprogram declared by an @fa<abstract_subprogram_declaration> (see 6.1)
+is an @i<abstract subprogram>. If it is a primitive subprogram of a tagged
+type, then the tagged type shall be abstract.
+@dby
+A subprogram declared by an @fa<abstract_subprogram_declaration> (see 6.1) or
+declared declared by a @fa<formal_abstract_subprogram_declaration> (see 12.6)
+is an @i<abstract subprogram>. If it is a primitive subprogram of a tagged type,
+then the tagged type shall be abstract.
+
+!corrigendum 3.9.3(11)
+
+@drepl
+A generic actual subprogram shall not be an abstract subprogram.
+The @fa<prefix> of an @fa<attribute_reference> for the Access,
+Unchecked_Access, or Address attributes shall not denote an abstract
+subprogram.
+@dby
+A generic actual subprogram shall not be an abstract subprogram unless the
+generic formal subprogram is a @fa<formal_abstract_subprogram_declaration>.
+The @fa<prefix> of an @fa<attribute_reference> for the Access,
+Unchecked_Access, or Address attributes shall not denote an abstract
+subprogram.
+
+!corrigendum 12.6(02)
+
+@drepl
+@xcode<@fa<formal_subprogram_declaration ::= >@ft<@b<with>>@fa< subprogram_specification [>@ft<@b<is>>@fa< subprogram_default];>>
+@dby
+@xcode<@fa<formal_subprogram_declaration ::= formal_abstract_subprogram_declaration |
+	formal_concrete_subprogram_declaration
+formal_concrete_subprogram_declaration ::=
+        >@ft<@b<with>>@fa< subprogram_specification [>@ft<@b<is>>@fa< subprogram_default];
+formal_abstract_subprogram_declaration ::=
+        >@ft<@b<with>>@fa< subprogram_specification >@ft<@b<is abstract>>@fa< [subprogram_default];>>
 
+!corrigendum 12.6(08)
 
---!corrigendum 13.13.2(28)
+@dinsa
+The profiles of the formal and actual shall be mode-conformant.
+@dinss
+If a formal parameter of an @fa<formal_abstract_subprogram_declaration> is of a
+specific tagged type T or of an anonymous access designating a specific tagged
+type T, T is called a @i<controlling type> of the
+@fa<formal_abstract_subprogram_declaration>. Similarly, if the result of an
+@fa<formal_abstract_subprogram_declaration> for a function is of a specific
+tagged type T or of an anonymous access designating a specific tagged type T,
+T is called a @fa<controlling type> of the
+@fa<formal_abstract_subprogram_declaration>. A
+@fa<formal_abstract_subprogram_declaration> shall have exactly one controlling
+type.
+
+The actual subprogram for a @fa<formal_abstract_subprogram_declaration> shall
+be a dispatching operation of the controlling type or of the actual type
+corresponding to the controlling type of the
+@fa<formal_abstract_subprogram_declaration>.
+
+!corrigendum 12.6(10)
+
+@dinsa
+If a generic unit has a @fa<subprogram_default> specified by a box, and the
+corresponding actual parameter is omitted, then it is equivalent to an
+explicit actual parameter that is a usage name identical to the defining name
+of the formal.
+@dinst
+The subprogram declared by a @fa<formal_abstract_subprogram_declaration> with a
+controlling type T is a dispatching operation of type T.
+
+!corrigendum 12.6(16)
+
+@drepl
+@xindent<@s9<18  The actual subprogram cannot be abstract (see 3.9.3).>>
+@dby
+@xindent<@s9<18  The actual subprogram cannot be abstract unless the formal
+subprogram is a @fa<formal_abstract_subprogram_declaration> (see 3.9.3).>>
+
+@xindent<@s9<19  The subprogram declared by a
+@fa<formal_abstract_subprogram_declaration> is an abstract subprogram. All
+calls on a subprogram declared by a @fa<formal_abstract_subprogram_declaration>
+must be dispatching calls. See 3.9.3.>>
 
 
 !ACATS test

Questions? Ask the ACAA Technical Agent