• IO Module BITSET

• IO Module OCTET
• IO Module CHAR
• IO Module UNICHAR
• IO Module CARDINAL
• IO Module LONGCARD
• IO Module INTEGER
• IO Module LONGINT
• IO Module REAL
• IO Module LONGREAL

• IO Module BOOLEAN

• IO Module OCTET?

• IO Module BOOLEAN?
• IO Module CHAR?
• IO Module UNICHAR?
• IO Module CARDINAL?
• IO Module LONGCARD?
• IO Module INTEGER?
• IO Module LONGINT?
• IO Module REAL?
• IO Module LONGREAL?

Since it may be inconvenient to have to import each pervasive type's I/O module explicitly, the standard library should also provide a consolidated module that can serve as an import aggregator if desired. A module named PervasiveIO can be provided to serve this function.

For each pervasive type the standard library provides one type specific I/O module. In order to facilitate the use of pervasive macros READ and WRITE, the type specific modules are named identical to their respective types.

• IO Module BOOLEAN? for type BOOLEAN
• IO Module CHAR? for type CHAR
• IO Module UNICHAR? for type UNICHAR
• IO Module CARDINAL? for type CARDINAL
• IO Module LONGCARD? for type LONGCARD
• IO Module INTEGER? for type INTEGER
• IO Module LONGINT? for type LONGINT
• IO Module REAL? for type REAL
• IO Module LONGREAL? for type LONGREAL

The modules have to be imported directly or indirectly in order to use the pervasive macros READ and WRITE.

[@MODULE Example1;

IMPORT CHAR; (* explicit import of CHAR's I/O module *)

VAR file : File; ch : CHAR;

    ...

    READ( file, ch );   (* equivalent to CHAR.Read( file, ch ); *)

    WRITE( file, ch );  (* equivalent to CHAR.Write( file, ch ); *)

END Example1.@]

Since it may be inconvenient to have to import each pervasive type's I/O module explicitly, the standard library should also provide a consolidated module that can serve as an import aggregator if desired. A module named Pervasive IO? can be provided to serve this function.

[@MODULE Example2;

FROM File IO? IMPORT File;

IMPORT Pervasive IO?; (* implicit import of all pervasive type I/O modules *)

VAR file : File; ch : CHAR;

    ...

    READ( file, ch );   (* equivalent to CHAR.Read( file, ch ); *)

    WRITE( file, ch );  (* equivalent to CHAR.Write( file, ch ); *)

END Example2.@]

The compiler will first expand a macro invocation such as WRITE( file, char ); to CHAR.Write( file, char ); which in turn is translated into PervasiveIO.WriteChar( file, char ); because the Write procedure is declared with the <*INLINE*> pragma.

The compiler will first expand a macro invocation such as WRITE( file, char ); to CHAR.Write( file, ch ); which in turn is translated into PervasiveIO.WriteChar( file, ch ); because the Write procedure is declared with the <*INLINE*> pragma.

The actual I/O procedures for all pervasive types reside in module PervasiveIO. In order to accommodate the proper functioning of macros READ and WRITE, a separate wrapper IO module for each pervasive type is provided as follows:

The corresponding implementation part is shown below:

The actual I/O procedures for all pervasive types reside in module Pervasive IO?. In order to accommodate the proper functioning of macros READ and WRITE, a separate wrapper IO module for each pervasive type is provided as follows:

DEFINITION MODULE CHAR;

FROM FileIO IMPORT File;

FROM PervasiveIO IMPORT ReadChar, WriteChar;

<*INLINE*> PROCEDURE Read( fid : File; VAR ch : CHAR );

<*INLINE*> PROCEDURE Write( fid : File; ch : CHAR );

END CHAR.

The implementation module is shown below:

IMPLEMENTATION MODULE CHAR;

FROM FileIO IMPORT File;

FROM PervasiveIO IMPORT ReadChar, WriteChar;

<*INLINE*> PROCEDURE Read( fid : File; VAR ch : CHAR );
BEGIN
    ReadChar( fid, ch );
END Read;

<*INLINE*> PROCEDURE Write( fid : File; ch : CHAR );
BEGIN
    WriteChar( fid, ch );
END Write;

END CHAR.

The compiler will first expand a macro invocation such as WRITE( file, char ); to CHAR.Write( file, ch ); which in turn is translated into Pervasive IO.Write Char?( file, ch ); because the Write procedure is declared with the <*INLINE*> pragma.