CVS difference for ais/ai-00132.txt

--- ais/ai-00132.txt	2000/07/15 02:29:58	1.9
+++ ais/ai-00132.txt	2000/08/01 05:39:33	1.10
@@ -41,15 +41,15 @@
 13.13.1(8) admits to the notion of "end of stream" for stream types:
 
    The Read operation transfers Item'Length stream elements from the
-   specified stream to fill the array Item.  The index of the last
-   stream element transferred is returned in Last.  Last is less than
+   specified stream to fill the array Item. The index of the last
+   stream element transferred is returned in Last. Last is less than
    Item'Last only if the end of the stream is reached.
 
 The Read operation does not raise any exception at end of stream -- it
-just indicates this fact in the value returned in Last.  Of course, what
-constitutes end of stream is defined by the particular stream type.  The
+just indicates this fact in the value returned in Last. Of course, what
+constitutes end of stream is defined by the particular stream type. The
 stream returned by Text_Streams.Stream has a notion of end of stream
-that corresponds to the end of the text file.  A user-defined stream
+that corresponds to the end of the text file. A user-defined stream
 might have a different notion of end of stream, or might not have any
 such notion -- it is quite possible to implement a stream type that
 represents an infinitely long sequence.
@@ -73,53 +73,53 @@
 Note that it is somewhat odd that the Read attribute can raise
 IO_Exceptions.Data_Error, since streams have nothing directly to do with
 I/O, and a given invocation of the Read attribute does not know whether
-it is dealing with a file stream or not.  Nonetheless, that's what it
-says.  Raising IO_Exceptions.End_Error is no more or less odd in this
+it is dealing with a file stream or not. Nonetheless, that's what it
+says. Raising IO_Exceptions.End_Error is no more or less odd in this
 regard.
 
 Possibilities are:
 
 Alternative 1: Either Data_Error is raised, or an abnormal value is
-returned.  This alternative is supported by the wording of A.13(13,17).
+returned. This alternative is supported by the wording of A.13(13,17).
 Reading zero bytes, or an insufficient number of bytes, clearly gives a
-malformed piece of data.  The programmer is forced to encode the number
+malformed piece of data. The programmer is forced to encode the number
 of elements in the stream somehow, or otherwise encode the end of stream
 explicitly, in order to avoid erroneous execution.
 
-Alternative 2: Data_Error is raised.  There is really no implementation
+Alternative 2: Data_Error is raised. There is really no implementation
 reason for allowing abnormal values, since the condition is easy to
-detect, and a very minor efficiency hit.  However, this alternative
+detect, and a very minor efficiency hit. However, this alternative
 still forces the programmer to encode the end of stream by hand, since
 Data_Error does not distinguish between malformed data and end of
 stream.
 
-Alternative 3: End_Error is raised.  This alternative *still* forces the
+Alternative 3: End_Error is raised. This alternative *still* forces the
 programmer to encode the end of stream by hand, because it does not
 distinguish between encountering the end of the stream in between stream
 elements, versus in the middle of an element -- the latter being a case
 of malformed data.
 
 Alternative 4: End_Error is raised if the programmer calls the T'Read
-and the stream is at end of stream.  However, Data_Error is raised if
-end of stream is encountered in the middle.  This allows the programmer
+and the stream is at end of stream. However, Data_Error is raised if
+end of stream is encountered in the middle. This allows the programmer
 to reliably read a sequence of items from a stream, and notice when the
 last item has been read (by detecting End_Error), and distinguish this
-situation from malformed data (Data_Error).  Thus, the programmer does
+situation from malformed data (Data_Error). Thus, the programmer does
 not need to add extra data to the stream to explicitly encode end of
-stream.  However, this alternative is harder to implement, since Read
-attributes are highly recursive.  For example, suppose T is a record
-type with two components.  If 'Read raises End_Error on the second
+stream. However, this alternative is harder to implement, since Read
+attributes are highly recursive. For example, suppose T is a record
+type with two components. If 'Read raises End_Error on the second
 component, T'Read must catch that exception, and turn it into Data_Error
 -- the second component wasn't malformed, but the record as a whole *is*
-malformed.  On the other hand, an End_Error raised by reading the first
-component would simply be propagated by T'Read.  In addition, if the
+malformed. On the other hand, an End_Error raised by reading the first
+component would simply be propagated by T'Read. In addition, if the
 user-defined overriding of the Read attribute would presumably want to
-mimic this behavior.  (Note: AI83-00307 requires a similar behavior for
+mimic this behavior. (Note: AI83-00307 requires a similar behavior for
 Get procedures in Text_IO.)
 
 Alternatives 5,6,7,8: Same as alternatives 1,2,3,4, but define
 Data_Error and/or End_Error exceptions in Streams, rather than using the
-ones from IO_Exceptions.  This might be more elegant, but serves no
+ones from IO_Exceptions. This might be more elegant, but serves no
 practical purpose, and is too big a change to make at this point.
 
 We choose Alternative 3, because it seems the friendliest alternative
@@ -141,9 +141,9 @@
 for each scalar component that is a discriminant or whose
 @fa<component_declaration> includes a @fa<default_expression>, a check is
 made that the value
-returned by Read for the component belongs to its subtype.  Constraint_Error
+returned by Read for the component belongs to its subtype. Constraint_Error
 is raised if this check fails. For other scalar components, no check is
-made.  For each component that is of an access type, if the implementation
+made. For each component that is of an access type, if the implementation
 can detect that the value returned by Read for the component is not a value
 of its subtype, Constraint_Error is raised. If the value is not a value of
 its subtype and this error is not detected, the component has an abnormal