CVS difference for ais/ai-00419.txt

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

--- ais/ai-00419.txt	2005/04/13 05:37:24	1.3
+++ ais/ai-00419.txt	2005/05/05 02:43:02	1.4
@@ -1,6 +1,9 @@
-!standard 3.4(02)                                    05-03-16  AI95-00419-01/02
+!standard 3.4(01)                                   05-04-16  AI95-00419-01/03
+!standard 3.4(02)
+!standard 3.4(03)
 !standard 3.4(05)
 !standard 3.4(15)
+!standard 3.9.4(01)
 !standard 7.3(02)
 !standard 7.3(06)
 !standard 7.3(08)
@@ -8,6 +11,8 @@
 !standard 7.5(02)
 !standard 7.5(04)
 !standard 7.5(06)
+!standard 9.1(9.1)
+!standard 9.4(11)
 !standard 12.5.1(03)
 !class amendment 05-03-09
 !status Amendment 200Y 05-03-10
@@ -89,15 +94,33 @@
 as well allow it uniformly for every derived type: it could be used as a
 documentation. Although this is optional syntax, and we don't like optional
 syntax too much, one could argue that it should have been that way from day
-one as the implicit nature of limitness is hiding an important property.
+one as the implicit nature of limitedness is hiding an important property.
 
+We also note that derived types are undefined in the Standard; there is no
+wording saying that a derived type comes from a derived_type_declaration.
+Similarly, various types that aren't derived types need to have wording to
+trigger the inheritance rules.
+
 !wording
+
+Change 3.4(1) as amended by AI95-00401 to read:
+
+    A derived_type_definition defines a new {*derived} type{*} (and its
+    first subtype) whose characteristics are derived from those of a
+    parent type, and possibly from progenitor types.
 
-Change 3.4(2) as amended by AI95-00251 to read:
+Change 3.4(2) as amended by AI95-00251 to read (note: interface_list is moved):
 
 derived_type_definition ::=
     [abstract] [limited] new parent_subtype_indication [[and interface_list] record_extension_part]
 
+Change 3.4(3) as amended by AI95-00251 and AI95-00401 to read:
+
+The parent_subtype_indication defines the *parent subtype*; its type is the
+*parent type*. The interface_list defines the progenitor types (see 3.9.4).
+A derived type has one parent type and zero or more {progenitor}
+types.
+
 
 Add after 3.4(5)
 
@@ -116,27 +139,18 @@
   End AARM.
 
 
-Change 3.4(15) to read:
+Delete 3.4(15) (this is defined in 7.5).
 
-o  Redundant[The derived type is limited if the parent is a limited type that
-   is not an interface type, or if the reserved word *limited* appears.]
+Add the following to the syntax in the new subclause 3.9.4:
 
-  AARM Reason: We considered a rule where limitedness was always inherited from
-  the parent, but in the case of a type whose parent is an interface, this
-  meant that the first interface was more equal than other interfaces. It also
-  would have forced users to declare dummy nonlimited interfaces just to get
-  the limitedness right. We also considered a syntax like *not limited* to
-  specify nonlimitedness when the parent was limited, but that was unsavory.
-  The rule is more uniform and simpler to understand.
-
-  The rules are unsymmetrical, but the language is not: if the parent interface
-  is limited, the presence of the word *limited* determines the limitedness,
-  and nonlimited progenitors are illegal by the rules in 3.9.4. If the parent
-  interface is nonlimited, the word *limited* is illegal by the rules in this
-  section. The net effect is that the order of the interfaces doesn't matter.
-  End AARM.
+interface_list ::= interface_subtype_mark {and interface_subtype_mark}
+
+Add the following at the end of the Static Semantics of the new subclause 3.9.4:
 
+An interface_subtype_mark in an interface_list names a
+*progenitor subtype*; its type is the *progenitor type*.
 
+
 Change 7.3(3) as amended by AI95-0251 to read:
 
 private_extension_declaration ::=
@@ -185,6 +199,54 @@
 *  A composite type with a limited component;
 *  A derived type whose parent is limited and is not an interface.
 
+  AARM Reason: We considered a rule where limitedness was always inherited from
+  the parent for derived types, but in the case of a type whose parent is an
+  interface, this meant that the first interface is treated differently than
+  other interfaces. It also would have forced users to declare dummy nonlimited
+  interfaces just to get the limitedness right. We also considered a syntax
+  like *not limited* to specify nonlimitedness when the parent was limited, but
+  that was unsavory. The rule is more uniform and simpler to understand.
+
+  The rules for interfaces are unsymmetrical, but the language is not: if the
+  parent interface is limited, the presence of the word *limited* determines
+  the limitedness, and nonlimited progenitors are illegal by the rules in
+  3.9.4. If the parent interface is nonlimited, the word *limited* is illegal
+  by the rules in 3.4. The net effect is that the order of the
+  interfaces doesn't matter.
+  End AARM.
+
+
+
+Modify the first paragraph added after 9.1(9.1) by AI-345 as follows:
+
+    For a task_type_declaration {with an interface_list, the task type
+    inherits user-defined primitive subprograms from each progenitor
+    type (see 3.9.4), in the same way that a derived type inherits
+    user-defined primitive subprograms from its progenitor types (see
+    3.4).} [i]{I}f the first parameter of a primitive inherited
+    subprogram is of the task type or an access parameter designating
+    the task type, and there is an entry_declaration for a single
+    entry with the same identifier within the task_type_declaration,
+    whose profile is type conformant with the prefixed view profile of
+    inherited subprogram, the inherited subprogram is said to be
+    implemented by the conforming task entry.
+
+Modify the first paragraph added after 9.1(11) by AI-345 as follows:
+
+    For a protected_type_declaration {with an interface_list, the
+    protected type inherits user-defined primitive subprograms from each
+    progenitor type (see 3.9.4), in the same way that a derived type
+    inherits user-defined primitive subprograms from its progenitor
+    types (see 3.4).}  [i]{I}f the first parameter of a primitive
+    inherited subprogram is of the protected type or an access parameter
+    designating the protected type, and there is a
+    protected_operation_declaration for a protected subprogram or single
+    entry with the same identifier within the
+    protected_type_declaration, whose profile is type conformant with
+    the prefixed view profile of the inherited subprogram, the inherited
+    subprogram is said to be implemented by the conforming protected
+    subprogram or entry.
+
 Change 12.5.1(3) as amended by AI95-00251 to read:
 
 formal_derived_type_definition ::=
@@ -199,6 +261,17 @@
 
 (See proposal.)
 
+!corrigendum 3.4(01)
+!comment This includes the changes of AI-00401.
+
+@drepl
+A @fa<derived_type_definition> defines a new type (and its first subtype) whose
+characteristics are @i<derived> from those of a @i<parent type>.
+@dby
+A @fa<derived_type_definition> defines a new @i<derived type> (and its
+first subtype) whose characteristics are derived from those of a
+parent type, and possibly from progenitor types.
+
 !corrigendum 3.4(02)
 
 @drepl
@@ -209,7 +282,16 @@
 @xcode<@fa<derived_type_definition ::=
     [>@ft<@b<abstract>>@fa<] [>@ft<@b<limited>>@fa<] >@ft<@b<new> @i<parent_>>@fa<subtype_indication [[>@ft<@b<and>>@fa< interface_list] record_extension_part]>>
 
+!corrigendum 3.4(03)
 
+@drepl
+The @i<parent>@fa<_subtype_indication> defines the @i<parent subtype>; its type
+is the parent type.
+@dby
+The @i<parent>@fa<_subtype_indication> defines @i<the parent subtype>; its type
+is the @i<parent type>. The @fa<interface_list> defines the progenitor types
+(see 3.9.4). A derived type has one parent type and zero or more progenitor types.
+
 !corrigendum 3.4(05)
 
 @dinsa
@@ -223,10 +305,17 @@
 
 !corrigendum 3.4(15)
 
-@drepl
+@ddel
 @xbullet<The derived type is limited if and only if the parent type is limited.>
+
+
+!corrigendum 3.9.4(01)
+!Dummy to cause a conflict.
+
+@drepl
+@xcode<@fa<interface_list ::= >@ft<@i<interface_>>@fa<subtype_mark {>@ft<@b<and>>@fa< >@ft<@i<interface_>>@fa<subtype_mark}>>
 @dby
-@xbullet<The derived type is limited if the parent is a limited type that is not an interface type, or if the reserved word @b<limited> appears.>
+@xcode<@fa<interface_list ::= >@ft<@i<interface_>>@fa<subtype_mark {>@ft<@b<and>>@fa< >@ft<@i<interface_>>@fa<subtype_mark}>>
 
 
 !corrigendum 7.3(02)
@@ -328,6 +417,20 @@
 @xbullet<a composite type with a limited component;>
 
 @xbullet<a derived type whose parent is limited and is not an interface.>
+
+!corrigendum 9.1(9.1)
+!comment Dummy to force conflict; actual change is in the conflict file.
+@drepl
+Dummy.
+@dby
+Dummy.
+
+!corrigendum 9.4(11)
+!comment Dummy to force conflict; actual change is in the conflict file.
+@drepl
+Dummy.
+@dby
+Dummy.
 
 !corrigendum 12.5.1(03)
 

Questions? Ask the ACAA Technical Agent