CVS difference for arm/source/03c.mss

Differences between 1.61 and version 1.62
Log of other versions for file arm/source/03c.mss

--- arm/source/03c.mss	2005/11/16 06:42:47	1.61
+++ arm/source/03c.mss	2005/11/24 02:15:01	1.62
@@ -1,9 +1,9 @@
  @Part(03, Root="ada.mss")
-@Comment{$Date: 2005/11/16 06:42:47 $}
+@Comment{$Date: 2005/11/24 02:15:01 $}
 @Comment{$Source: e:\\cvsroot/ARM/Source/03c.mss,v $}
-@Comment{$Revision: 1.61 $}
+@Comment{$Revision: 1.62 $}
 @LabeledClause{Tagged Types and Type Extensions}
@@ -1178,7 +1178,7 @@
 @LabeledSubClause{Dispatching Operations of Tagged Types}
 @RootDefn{dispatching operation}
 @Defn2{Term=[dispatching call], Sec=(on a dispatching operation)}
 @Defn2{Term=[nondispatching call], Sec=(on a dispatching operation)}
@@ -1187,8 +1187,11 @@
 @Defn{run-time polymorphism}
 @Defn2{Term=[controlling tag], Sec=(for a call on a dispatching operation)}
-The primitive subprograms of a tagged type@Chg{Version=[2],New=[ and the
-subprograms declared by @nt{formal_abstract_subprogram_declaration}s],Old=[]}
+The primitive subprograms of a tagged type@Chg{Version=[2],New=[, the
+subprograms declared by @nt{formal_abstract_subprogram_declaration}s,
+and and the stream attributes of a specific tagged type that are available (see
+@RefSecNum{Stream-Oriented Attributes}) at the end of the declaration list
+where the type is declared],Old=[]}
 are called @i(dispatching operations).
 @Redundant[A dispatching operation can be called using a statically
 determined @i{controlling} tag, in which case the body to be
@@ -1208,6 +1211,19 @@
 @IndexSee{Term=[message],See=[dispatching call]}
 @IndexSee{Term=[method],See=[dispatching subprogram]}
 @IndexSee{Term=[virtual function],See=[dispatching subprogram]}
+@ChgAdded{Version=[2],Text=[For the stream attributes of a type
+declared immediately within a @nt{package_specification} that has a
+partial view, the declaration list to consider is the visible part of the
+package. Stream attributes that are not available in the same declaration
+list are not dispatching as there is no guarantee that descendants of the
+type have available attributes (there is such a guarantee for visibly
+available attributes). If we allowed dispatching for any available
+attribute, then for attributes defined in the private part we could end up
+executing a non-existent body.]}
@@ -1785,6 +1801,12 @@
   @ChgAdded{Version=[2],Text=[Dispatching calls include operations
   implemented by entries and protected operations, so we have to update the
   wording to reflect that.]}
+  @ChgRef{Version=[2],Kind=[AddedNormal],ARef=[AI95-00260-02]}
+  @ChgAdded{Version=[2],Text=[An stream attribute of a tagged type is
+  is usually a dispatching operation, even though it is not a primitive
+  operation. If they weren't dispatching, T'Class'Input and T'Class'Output
+  wouldn't work.]}
@@ -2308,7 +2330,7 @@
   except possibly null procedures. Interface types are used for
   composing other interfaces and tagged types and thereby
   provide multiple inheritance. Only an interface type can be used as a
-  progenitor of a derived type.]}>}
+  progenitor of another type.]}>}
@@ -2370,9 +2392,8 @@
   Text=<@ChgAdded{Version=[2],Text=[A synchronized entity is one
   that will work safely with multiple tasks at one time. A synchronized
-  interface can be used with either a task or a protected type, while a
-  synchronized tagged type is any of a tagged task type, tagged protected type,
-  or a synchronized interface.]}>}
+  interface can be an ancestor of either a task or a protected type. Such a
+  task or protected type is called a synchronized tagged type.]}>}
 @ChgAdded{Version=[2],Text=[@Defn{synchronized tagged type}
@@ -2441,9 +2462,10 @@
 primitive subprograms from its progenitor types
 (see @RefSecNum{Derived Types and Classes}).]}
-  Text=<@ChgAdded{Version=[2],Text=[A progenitor type of a derived type is
-  one of the types mentioned in the definition of the derived type other
-  than the first. A progenitor type is always an interface type.]}>}
+  Text=<@ChgAdded{Version=[2],Text=[A progenitor of a derived type is
+  one of the types given in the definition of the derived type other
+  than the first. A progenitor is always an interface type.
+  Interfaces, tasks, and protected types may also have progenitors.]}>}

Questions? Ask the ACAA Technical Agent