Re: xor

[Georg Bauhaus <rm.dash-bauhaus@futureapps.de>]

On 28.03.12 22:49, Dennis Lee Bieber wrote:
> On Wed, 28 Mar 2012 18:36:28 +0100, Michael Moeller<mic2@t-online.de>
> declaimed the following in comp.lang.ada:
>
>
>> I see. Alas, none of my books or manuals even mentions binary file I/O.
>
> 	Maybe because anything that is NOT derived from Text_IO is
> considered to be Binary.

(Or, maybe, because prior to Unix, the somewhat simplistic
distinction  "r"/"b" wasn't that popular? Structured files
being offered by the operating systems, IINM.)

In any case, traditional Ada I/O (other than Text_IO) is
focusing on types:

Let an object be of some type T.  If you want that object
to be input or output, instantiate an I/O module for
type T, and there you go, inputting and outputting objects
of type T using subprograms from the instance.

For I/O of a mix of types ("binary" I/O), streams come in handy.
Again, the mechanism focuses on types: every type is associated
with two pairs of functions:

   T'Read      T'Write
   T'Input     T'Output

Roughly speaking, the first pair writes bare data (representations),
the second pair adds more "administrative" information about the
type T. There is a guarantee about what they do. When a program
outputs an object of type T using one function, then the corresponding
function can input the object of type T, and vice versa.
(I guess that this is some form of idempotence, however, I should
leave this to the mathematicians.)

The above functions' profiles consist of a pointer to an object of
some stream type, and an object of type T, to be read, or written.

Somewhat internally, every stream type has two (primitive) subprograms
again called Read and Write. These can implement the data transmission
layer of the streaming functions mentioned above; they operate in
terms of Storage_Element_Array. That's the binary layer, so to speak.
They are similar to Unix's read(2) and write(2) calls.
Subprograms taking Storage_Element_Array parameters operate at the
same level as subprograms related to "sequence of bytes" in the
C sense (I would say so). You can use these when implementing your
own streaming functions, or when you have data suitable for a "cast",
so that the bits are re-interpreted as Storage_Element_Array
(through an instance of Ada.Unchecked_Conversion).

If it interests you, there is

http://www.adaic.org/learn/materials/

Ada 95 material is fine, too, insofar as recent changes to the
language are mostly non-destructive.