The ModulaTor logo 7KB

The ModulaTor

Oberon-2 and Modula-2 Technical Publication

Erlangen's First Independent Modula_2 Journal! Nr. 8/Sep-1991


The ISO Modula-2 Standard Library

Definition of Interface Modules & Examples by Elmar Baumgart, ModulaWare.

2nd ed., 13-Aug-1992
3rd ed., 01-Sep-1992 (extended example TestSeq)
4th ed., 05-Mar-1993 (modules LowLong and LowReal added)
5th ed., 09-Apr-1994 (general update for minor changes in 2nd committee draft ISO 10154 (Dec-1992), last updated by sc22.wg13 in Feb-1993)
6th ed., 17-Jun-1994 (S_, T_FLOATING and _COMPLEX as well for MaX AXP/OpenVMS Modula-2 implementation; G_COMPLEX support added for both MaX and MVR).
7th ed., 22-Dec-1996: TestSCopy redirection example added.

Compared to the ISO Modula-2 I/O-Library of the 3rd and 4th Interim Working Draft, the main changes of the 4WD resulted from renaming of module, procedure and parameter names. This paper serves as a reference of the "final" version which I am currently implementing for the next major release of MVR and H2O (ModulaWare's Modula-2 and Oberon-2 compiler for DEC VAX/VMS). [Ed. note: the M2 Std Lib implementation for MVR was first released Mar-92.] Where our current implementation (for MVR V3.20) deviates from the 4WD because of compiler restrictions, this is indicated by an additional comment "temporary for MVR". These are only two modules: ConvTypes (modified type ScanType) and RndFiles (modified type FilePos).

In the collection below, the so-called simple I/O modules with the prefix "S" (SRawIO, STextIO, SRealIO, SLongIO, SLongGIO*, SWholeIO, SIOResult) were omitted, because their definition is identical to the corresponding modules without the prefix "S", except that always the parameter cid of type IOChan.ChanId is missing (i.e. implicit, see module StdChans).

To be complete, I've also included all auxiliary string conversion definition modules *_Str (which are equivalent to the *Str modules of the 4WD), because in ModulaWare's library implementation, the modules WholeIO, RealIO, LongGIO and LongIO of the I/O-Library are based on these modules.

Also the ISO M2 Std Lib modules SysClock, Processes, Semaphores, RealMath, LongMath, LongGMath*, ComplexMath, LongComplexMath, LongComplexGMath, LowReal, LowLong, LowLongG*, Storage and Strings are included.

* The G_FLOATING low-level real, [complex] math, I/O- and string conversion modules which are ModulaWare's (AXP|VAX)/OpenVMS specific non-standard extension to the ISO M2 Std Lib are also included. The type SYSTEM.G_COMPLEX is used Long[Complex]GMath; this new type and associated operations are available in both MVR and MaX since V4.05d. Corresponding S_FLOATING and T_FLOATING modules are available for MaX, ModulaWare's AXP/VMS Modula-2 compiler (first version was released in Jul-94); these modules are similar to the corresponding G_FLOATING and G_COMPLEX modules and are not listed here. The modules for S_FLOATING and S_COMPLEX are called RealSIO, SRealSIO, LowRealS, RealSStr, RealS_Str, RealSConv, RealSMath, ComplexSMath and the modules for T_FLOATING and T_COMPLEX are called LongTIO, SLongTIO, LowLongT, LongTStr, LongT_Str, LongTConv, LongTMath, LongComplexTMath. MaX supports 64 bit whole number types and associated operations.

The I/O and number/string conversion modules modules for SYSTEM.[UN]SIGNED_64 are called WholeLIO, SWholeLIO, WholeLStr, WholeL_Str, WholeLConv. Since they are similar to the Whole* modules, their definition is not listed below.

The extended set of library module for (S | T)_(FLOATING | COMPLEX) and [UN]SIGNED_64 are only available on AXP with MaX.

The library definitions are based on the 4th Interim WD and the minutes from the 6th WG-meeting in Tuebingen. (See also summary of changes in Report from the 6th ISO SC22/WG13 Modula-2 WG Meeting in [1, 7.1]. For the 5th ed. of this article, the electronic distribution of sc22.wg13 of Feb-1993 was used as a reference.)

No warranty for correctness is given and no guarantee can be given that this set of definitions exactly matches those of the soon-to-be-released ISO Modula-2 Standard. Some minor changes concerning the exception handling enumeration values and procedures were already agreed at the ISO meeting in Delft Sep-92.

These changes were not yet included in the 4th ed. of this article, since the resulting 2nd CD of ISO 10154 (Modula-2) was published in late Dec-1992 and was not available to the national bodies before Jan-1993.

ModulaWare apologizes for these changes and for the inconveniences this might imply, but the ISO committee changed their mind virtually with every release of a working or committee draft. Even the simplest renamings of identifiers creates a lot of uncreative maintainance work. The Draft International Standard (DIS) was finally released in 1994 and approved (by majority vote) in Jan-1995.

In summary here are the most important changes introduced with the 2nd CD together with some migration hints for existing application programs using the previous version of the ISO M2 Std Lib:

  1. Identifiers in the modules ChanConsts, IOChan, RawIO, RndFile, SeqFile, StreamFile, SRawIO, and TermFile containing the string binary were renamed to raw. Migration hint: (a) replace all IOChan, IOConsts and *File related occurences of the string "binary" in your source code by "raw". Recompilation of application programs importing those modules is necessary.
  2. Number/string conversion modules: the previous versions of RealStr, LongStr and WholeStr were renamed to Real_Str, Long_Str and Whole_Str (now rated non standard module, but supported by ModulaWare). The string number/conversion procedures in RealStr, LongStr and WholeStr no longer have the width parameter. Hint: replace all imports of the *Str modules by *_Str.
  3. The exception reporting procedures and some associated constants were renamed (note, that exceptions are not yet supported on MVR and MAX). Examples: An example how to copy a text file is also included at the end of this collection. Module TestCopy takes it's file name parameters in and out from command line (argument channel). Module TestSCopy has the same functionality as TestCopy, but uses redirection of standard input, output and argument channels via module StdChans. TestSeq writes and reads sequential text and binary files, to obtain I/O-performance data.

    Further test and example programs are contained in The ModulaTor, Mar-1992 (mdlt20). The Oberon-2 interfaces to this Modula-2 implementation of the OSO M2 Std Lib is contained in The ModulaTor, Sep-92 (mdlt26). Implementation specific extensions are marked with an *

    The comment description contained in the definition modules uses wide margins lines with more than 80 characters; this is the original format of the DIS.

    
    ________________________________________________________________________
    
    IOConsts
    DEFINITION MODULE IOConsts;
    
      (* Types and constants for input/output modules *)
    
    TYPE
      ReadResults =  (* This type is used to classify the result of an input operation *)
      (
        notKnown,    (* no read result is set *)
        allRight,    (* data is as expected or as required *)
        outOfRange,  (* data cannot be represented *)
        wrongFormat, (* data not in expected format *)
        endOfLine,   (* end of line seen before expected data *)
        endOfInput   (* end of input seen before expected data *)
      );
    
    END IOConsts.
    
    ________________________________________________________________________
    
    ChanConsts
    DEFINITION MODULE ChanConsts;
    
      (* Common types and values for channel open requests and results *)
    
    TYPE
      ChanFlags =        (* Request flags possibly given when a channel is opened *)
      ( readFlag,        (* input operations are requested/available *)
        writeFlag,       (* output operations are requested/available *)
        oldFlag,         (* a file may/must/did exist before the channel is opened *)
        textFlag,        (* text operations are requested/available *)
        rawFlag,         (* raw operations are requested/available *)
        interactiveFlag, (* interactive use is requested/applies *)
        echoFlag         (* echoing by interactive device on removal of characters from input
                            stream requested/applies *)
      );
    
      FlagSet = SET OF ChanFlags;
    
      (* Singleton values of FlagSet, to allow for example, read + write *)
    
    CONST
      read = FlagSet{readFlag};   (* input operations are requested/available *)
      write = FlagSet{writeFlag}; (* output operations are requested/available *)
      old = FlagSet{oldFlag};     (* a file may/must/did exist before the channel is opened *)
      text = FlagSet{textFlag};   (* text operations are requested/available *)
      raw = FlagSet{rawFlag};     (* raw operations are requested/available *)
      interactive = FlagSet{interactiveFlag}; (* interactive use is requested/applies *)
      echo = FlagSet{echoFlag};   (* echoing by interactive device on removal of characters from
                                     input stream requested/applies *)
    
    TYPE
      OpenResults =        (* Possible results of open requests *)
        (opened,           (* the open succeeded as requested *)
         wrongNameFormat,  (* given name is in the wrong format for the implementation *)
         wrongFlags,       (* given flags include a value that does not apply to the device *)
         tooManyOpen,      (* this device cannot support any more open channels *)
         outOfChans,       (* no more channels can be allocated *)
         wrongPermissions, (* file or directory permissions do not allow request *)
         noRoomOnDevice,   (* storage limits on the device prevent the open *)
         noSuchFile,       (* a needed file does not exist *)
         fileExists,       (* a file of the given name already exists when a new one is required *)
         wrongFileType,    (* the file is of the wrong type to support the required operations *)
          noTextOperations, (* text operations have been requested, but are not supported *)
         noRawOperations,  (* raw operations have been requested, but are not supported *)
         noMixedOperations,(* text and raw operations have been requested, but they
                              are not supported in combination *)
         alreadyOpen,      (* the source/destination is already open for operations not supported
                              in combination with the requested operations *)
         otherProblem      (* open failed for some other reason *)
        );
    
    END ChanConsts.
    
    ________________________________________________________________________
    
    IOChan
    DEFINITION MODULE IOChan;
    
      (* Types and procedures forming the interface to channels for device-independent data
         transfer modules
      *)
    
    IMPORT IOConsts, ChanConsts, SYSTEM;
    
    TYPE
      ChanId; (* Values of this type are used to identify channels *)
    
      (* There is one pre-defined value identifying an invalid channel on which no data transfer
         operations are available.  It may be used to initialize variables of type ChanId.
      *)
    
    PROCEDURE InvalidChan (): ChanId;
      (* Returns the value identifying the invalid channel. *)
    
      (* For each of the following operations, if the device supports the operation on the
         channel, the behaviour of the procedure conforms with the description below.  The full
         behaviour is defined for each device module.  If the device does not support the
         operation on the channel, the behaviour of the procedure is to raise the exception
         notAvailable.
      *)
    
      (* Text operations - these perform any required translation between the internal and
         external representation of text.
      *)
    
    PROCEDURE Look (cid: ChanId; VAR ch: CHAR; VAR res: IOConsts.ReadResults);
      (* If there is a character as the next item in the input stream cid, assigns its value to
         ch without removing it from the stream; otherwise the value of ch is not defined.  res
         (and the stored read result) are set to the value allRight, endOfLine, or endOfInput.
      *)
    
    PROCEDURE Skip (cid: ChanId);
      (* If the input stream cid has ended, the exception skipAtEnd is raised; otherwise the
         next character or line mark in cid is removed, and the stored read result is set to the
         value allRight.
      *)
    
    PROCEDURE SkipLook (cid: ChanId; VAR ch: CHAR; VAR res: IOConsts.ReadResults);
      (* If the input stream cid has ended, the exception skipAtEnd is raised; otherwise the
         next character or line mark in cid is removed.  If there is a character as the next
         item in cid stream, assigns its value to ch without removing it from the stream.
         Otherwise, the value of ch is not defined.  res (and the stored read result) are set to
         the value allRight, endOfLine, or endOfInput.
      *)
    
    PROCEDURE WriteLn (cid: ChanId);
      (* Writes a line mark over the channel cid. *)
    
    PROCEDURE TextRead (cid: ChanId; to: SYSTEM.ADDRESS; maxChars: CARDINAL;
                        VAR charsRead: CARDINAL);
      (* Reads at most maxChars characters from the current line in cid, and assigns
         corresponding values to successive components of an ARRAY OF CHAR variable for which
         the address of the first component is to. The number of characters read is assigned
         to charsRead. The stored read result is set to allRight, endOfLine, or endOfInput.
      *)
    
    PROCEDURE TextWrite (cid: ChanId; from: SYSTEM.ADDRESS; charsToWrite: CARDINAL);
      (* Writes a number of characters given by the value of charsToWrite, from successive
         components of an ARRAY OF CHAR variable for which the address of the first component
         is from, to the channel cid.
      *)
    
      (* Direct raw operations  - these do not effect translation between the internal and
         external representation of data
      *)
    
    PROCEDURE RawRead (cid: ChanId; to: SYSTEM.ADDRESS; maxLocs: CARDINAL;
                       VAR locsRead: CARDINAL);
      (* Reads at most maxLocs items from cid, and assigns corresponding values to successive
         components of an ARRAY OF LOC variable for which the address of the first component
         is to. The number of characters read is assigned to charsRead. The stored read result
         is set to the value allRight, or endOfInput.
      *)
    
    PROCEDURE RawWrite (cid: ChanId; from: SYSTEM.ADDRESS; locsToWrite: CARDINAL);
      (* Writes a number of items given by the value of charsToWrite, from successive
         components of an ARRAY OF LOC variable for which the address of the first component
         is from, to the channel cid.
      *)
    
      (* Common operations *)
    
    PROCEDURE GetName (cid: ChanId; VAR s: ARRAY OF CHAR);
      (* Copies to s a name associated with the channel cid, possibly truncated
         (depending on the capacity of s).
      *)
    
    PROCEDURE Reset (cid: ChanId);
      (* Resets the channel cid to a state defined by the device module. *)
    
    PROCEDURE Flush (cid: ChanId);
      (* Flushes any data buffered by the device module out to the channel cid. *)
    
      (* Access to read results *)
    
    PROCEDURE SetReadResult (cid: ChanId; res: IOConsts.ReadResults);
      (* Sets the read result value for the channel cid to the value res. *)
    
    PROCEDURE ReadResult (cid: ChanId): IOConsts.ReadResults;
      (* Returns the stored read result value for the channel cid. (This is initially the value
         notKnown).
      *)
    
      (* Users can discover which flags actually apply to a channel *)
    
    PROCEDURE CurrentFlags (cid: ChanId): ChanConsts.FlagSet;
      (* Returns the set of flags that currently apply to the channel cid. *)
    
      (* The following exceptions are defined for this module and its clients *)
    
    TYPE
      ChanExceptions =
        (wrongDevice,      (* device specific operation on wrong device *)
         notAvailable,     (* operation attempted that is not available on that channel *)
         skipAtEnd,        (* attempt to skip data from a stream that has ended *)
         softDeviceError,  (* device specific recoverable error *)
         hardDeviceError,  (* device specific non-recoverable error *)
         textParseError,   (* input data does not correspond to a character or line mark -
                              optional detection *)
         notAChannel       (* given value does not identify a channel - optional detection *)
        );
    
    PROCEDURE IsChanException (): BOOLEAN;
      (* Returns TRUE if the current coroutine is in the exceptional execution state
         because of the raising of an exception from ChanExceptions;
         otherwise returns FALSE.
      *)
    
    PROCEDURE ChanException (): ChanExceptions;
      (* If the current coroutine is in the exceptional execution state because of the
         raising of an exception from ChanExceptions, returns the corresponding
         enumeration value, and otherwise raises an exception.
      *)
    
      (* When a device procedure detects a device error, it raises the exception softDeviceError
         or hardDeviceError.  If these exceptions are handled, the following facilities may be
         used to discover an implementation-defined error number for the channel.
      *)
    
    TYPE
      DeviceErrNum = INTEGER;
    
    PROCEDURE DeviceError (cid: ChanId): DeviceErrNum;
      (* If a device error exception has been raised for the channel cid, returns the error
         number stored by the device module.
      *)
    
    END IOChan.
    
    ________________________________________________________________________
    
    IOLink
    DEFINITION MODULE IOLink;
    
      (* Types and procedures for the standard implementation of channels *)
    
    IMPORT IOChan, IOConsts, ChanConsts, SYSTEM;
    
    TYPE
      DeviceId;
        (* Values of this type are used to identify new device modules, and are normally
           obtained by them during their initialization.
        *)
    
    PROCEDURE AllocateDeviceId (VAR did: DeviceId);
      (* Allocates a unique value of type DeviceId, and assigns this value to did. *)
    
    PROCEDURE MakeChan (did: DeviceId; VAR cid: IOChan.ChanId);
      (* Attempts to make a new channel for the device module identified by did. If no more
         channels can be made, the identity of the invalid channel is assigned to cid.
         Otherwise, the identity of a new channel is assigned to cid.
      *)
    
    PROCEDURE UnMakeChan (did: DeviceId; VAR cid: IOChan.ChanId);
      (* If the device module identified by did is not the module that made the channel
         identified by cid, the exception wrongDevice is raised; otherwise the channel is
         deallocated, and the value identifying the invalid channel is assigned to cid.
      *)
    
    TYPE
      DeviceTablePtr = POINTER TO DeviceTable;
        (* Values of this type are used to refer to device tables *)
    
    TYPE
      LookProc =      PROCEDURE (DeviceTablePtr, VAR CHAR, VAR IOConsts.ReadResults);
      SkipProc =      PROCEDURE (DeviceTablePtr);
      SkipLookProc =  PROCEDURE (DeviceTablePtr, VAR CHAR, VAR IOConsts.ReadResults);
      WriteLnProc =   PROCEDURE (DeviceTablePtr);
      TextReadProc =  PROCEDURE (DeviceTablePtr, SYSTEM.ADDRESS, CARDINAL, VAR CARDINAL);
      TextWriteProc = PROCEDURE (DeviceTablePtr, SYSTEM.ADDRESS, CARDINAL);
      RawReadProc =   PROCEDURE (DeviceTablePtr, SYSTEM.ADDRESS, CARDINAL, VAR CARDINAL);
      RawWriteProc =  PROCEDURE (DeviceTablePtr, SYSTEM.ADDRESS, CARDINAL);
      GetNameProc =   PROCEDURE (DeviceTablePtr, VAR ARRAY OF CHAR);
      ResetProc =     PROCEDURE (DeviceTablePtr);
      FlushProc =     PROCEDURE (DeviceTablePtr);
      FreeProc =      PROCEDURE (DeviceTablePtr);
          (* Carry out the operations involved in closing the corresponding channel, including
             flushing buffers, but do not unmake the channel.
          *)
    
    TYPE
      DeviceData = SYSTEM.ADDRESS;
    
      DeviceTable =
        RECORD                         (* Initialized by MakeChan to: *)
          cd: DeviceData;              (* the value NIL *)
          did: DeviceId;               (* the value given in the call of MakeChan *)
          cid: IOChan.ChanId;          (* the identity of the channel *)
          result: IOConsts.ReadResults;(* the value notKnown *)
          errNum: IOChan.DeviceErrNum; (* undefined *)
          flags: ChanConsts.FlagSet;   (* ChanConsts.FlagSet{} *)
          doLook: LookProc;            (* raise exception notAvailable *)
          doSkip: SkipProc;            (* raise exception notAvailable *)
          doSkipLook: SkipLookProc;    (* raise exception notAvailable *)
          doLnWrite: WriteLnProc;      (* raise exception notAvailable *)
          doTextRead: TextReadProc;    (* raise exception notAvailable *)
          doTextWrite: TextWriteProc;  (* raise exception notAvailable *)
          doRawRead: RawReadProc;      (* raise exception notAvailable *)
          doRawWrite: RawWriteProc;    (* raise exception notAvailable *)
          doGetName: GetNameProc;      (* return the empty string *)
          doReset: ResetProc;          (* do nothing *)
          doFlush: FlushProc;          (* do nothing *)
          doFree: FreeProc;            (* do nothing *)
        END;
    
      (* The pointer to the device table for a channel is obtained using the
         following procedure: *)
    
    TYPE
      DevExceptionRange = [IOChan.notAvailable ..  IOChan.textParseError];
    
    PROCEDURE DeviceTablePtrValue (cid: IOChan.ChanId; did: DeviceId;
                                   x: DevExceptionRange; s:  ARRAY OF CHAR): DeviceTablePtr;
      (* If the device module identified by did is not the module that made the channel 
         identified by cid, the exception wrongDevice is raised; otherwise the given exception
         is raised, and the string value in s is included in the exception message.
      *)
    
    PROCEDURE IsDevice (cid: IOChan.ChanId; did: DeviceId) : BOOLEAN;
      (* Tests if the device module identified by did is the module that made the channel
         identified by cid.
      *)
    
    PROCEDURE RAISEdevException (cid: IOChan.ChanId; did: DeviceId;
                                 x: DevExceptionRange; s: ARRAY OF CHAR);
    
      (* If the device module identified by did is not the module that made the channel
         identified by cid, the exception wrongDevice is raised; otherwise the given exception
         is raised, and the string value in s is included in the exception message.
      *)
    
    PROCEDURE IsIOException () : BOOLEAN;
      (* Returns TRUE if the current coroutine is in the exceptional execution state
         because of the raising af an exception from ChanExceptions;
         otherwise FALSE.
      *)
    
    PROCEDURE IOException () : IOChan.ChanExceptions;
      (* If the current coroutine is in the exceptional execution state because of the 
         raising af an exception from ChanExceptions, returns the corresponding
         enumeration value, and otherwise raises an exception.
      *)
    
    END IOLink.
    
    ________________________________________________________________________
    
    RawIO
    DEFINITION MODULE RawIO;
    
      (* Reading and writing data over specified channels using raw operations, that is, with no
         conversion or interpretation. The read result is of the type IOConsts.ReadResults.
      *)
    
    IMPORT IOChan, SYSTEM;
    
    PROCEDURE Read (cid: IOChan.ChanId; VAR to: ARRAY OF SYSTEM.LOC);
      (* Reads storage units from cid, and assigns them to successive components of to. The read
         result is set to the value allRight, wrongFormat, or endOfInput.
      *)
    
    PROCEDURE Write (cid: IOChan.ChanId; from: ARRAY OF SYSTEM.LOC);
      (* Writes storage units to cid from successive components of from. *)
    
    END RawIO.
    
    ________________________________________________________________________
    
    TextIO
    DEFINITION MODULE TextIO;
    
      (* Input and output of character and string types over specified channels.
         The read result is of the type IOConsts.ReadResults.
      *)
    
    IMPORT IOChan;
    
      (* The following procedures do not read past line marks *)
    
    PROCEDURE ReadChar (cid: IOChan.ChanId; VAR ch: CHAR);
      (* If possible, removes a character from the input stream cid and assigns the
         corresponding value to ch.  The read result is set to the value allRight, endOfLine, or
         endOfInput.
      *)
    
    PROCEDURE ReadRestLine (cid: IOChan.ChanId; VAR s: ARRAY OF CHAR);
      (* Removes any remaining characters from the input stream cid before the next line mark,
         copying to s as many as can be accommodated as a string value. The read result is set
         to the value allRight, outOfRange, endOfLine, or endOfInput.
      *)
    
    PROCEDURE ReadString (cid: IOChan.ChanId; VAR s: ARRAY OF CHAR);
      (* Removes only those characters from the input stream cid before the next line mark that
         can be accommodated in s as a string value, and copies them to s.  The read result is
         set to the value allRight, endOfLine, or endOfInput.
      *)
    
    PROCEDURE ReadToken (cid: IOChan.ChanId; VAR s: ARRAY OF CHAR);
      (* Skips leading spaces, and then removes characters from the input stream cid before the
         next space or line mark, copying to s as many as can be accommodated as a string value.
         The read result is set to the value allRight, outOfRange, endOfLine, or endOfInput.
      *)
    
      (* The following procedure reads past the next line mark *)
    
    PROCEDURE SkipLine (cid: IOChan.ChanId);
      (* Removes successive items from the input stream cid up to and including the next line
         mark, or until the end of input is reached.  The read result is set to the value
         allRight, or endOfInput.
      *)
    
      (* Output procedures *)
    
    PROCEDURE WriteChar (cid: IOChan.ChanId; ch: CHAR);
      (* Writes the value of ch to the output stream cid. *)
    
    PROCEDURE WriteLn (cid: IOChan.ChanId);
      (* Writes a line mark to the output stream cid. *)
    
    PROCEDURE WriteString (cid: IOChan.ChanId; s: ARRAY OF CHAR);
      (* Writes the string value in s to the output stream cid. *)
    
    END TextIO.
    
    ________________________________________________________________________
    
    RealIO
    DEFINITION MODULE RealIO;
    
      (* Input and output of real numbers in decimal text form over specified channels.
         The read result is of the type IOConsts.ReadResults.
      *)
    
    IMPORT IOChan;
    
      (* The text form of a signed fixed-point real number is
           ["+" | "-"], decimal digit, {decimal digit},
           [".", {decimal digit}]
    
         The text form of a signed floating-point real number is
           signed fixed-point real number,
           "E", ["+" | "-"], decimal digit, {decimal digit}
      *)
    
    PROCEDURE ReadReal (cid: IOChan.ChanId; VAR real: REAL);
      (* Skips leading spaces, and removes any remaining characters from cid that form part of a
         signed fixed or floating point number.  The value of this number is assigned to real.
         The read result is set to the value allRight, outOfRange, wrongFormat, endOfLine, or
         endOfInput.
      *)
    
    PROCEDURE WriteFloat (cid: IOChan.ChanId; real: REAL; sigFigs: CARDINAL; width:
    CARDINAL);
      (* Writes the value of real to cid in floating-point text form, with sigFigs significant
         figures, in a field of the given minimum width.
      *)
    
    PROCEDURE WriteEng (cid: IOChan.ChanId; real: REAL; sigFigs: CARDINAL; width: CARDINAL);
      (* As for WriteFloat, except that the number is scaled with one to three digits in the
         whole number part, and with an exponent that is a multiple of three.
      *)
    
    PROCEDURE WriteFixed (cid: IOChan.ChanId; real: REAL; place: INTEGER; width: CARDINAL);
      (* Writes the value of real to cid in fixed-point text form, rounded to the given place
         relative to the decimal point, in a field of the given minimum width.
      *)
    
    PROCEDURE WriteReal (cid: IOChan.ChanId; real: REAL; width: CARDINAL);
      (* Writes the value of real to cid, as WriteFixed if the sign and magnitude can be shown
         in the given width, or otherwise as WriteFloat.  The number of places or significant
         digits depends on the given width.
      *)
    
    END RealIO.
    
    ________________________________________________________________________
    
    LongIO
    DEFINITION MODULE LongIO;
    
      (* Input and output of long real numbers in decimal text form over specified channels.
         The read result is of the type IOConsts.ReadResults.
      *)
    
    IMPORT IOChan;
    
      (* The text form of a signed fixed-point real number is
           ["+" | "-"], decimal digit, {decimal digit}, [".", {decimal digit}]
    
         The text form of a signed floating-point real number is
           signed fixed-point real number,
           "E", ["+" | "-"], decimal digit, {decimal digit}
      *)
    
    PROCEDURE ReadReal (cid: IOChan.ChanId; VAR real: LONGREAL);
      (* Skips leading spaces, and removes any remaining characters from cid that form part of a
         signed fixed or floating point number.  The value of this number is assigned to real.
         The read result is set to the value allRight, outOfRange, wrongFormat, endOfLine, or
         endOfInput.
      *)
    
    PROCEDURE WriteFloat (cid: IOChan.ChanId; real: LONGREAL; sigFigs: CARDINAL; width: CARDINAL);
      (* Writes the value of real to cid in floating-point text form, with sigFigs significant
         figures, in a field of the given minimum width.
      *)
    
    PROCEDURE WriteEng (cid: IOChan.ChanId; real: LONGREAL; sigFigs: CARDINAL; width: CARDINAL);
      (* As for WriteFloat, except that the number is scaled with one to three digits in the
         whole number part, and with an exponent that is a multiple of three.
      *)
    
    PROCEDURE WriteFixed (cid: IOChan.ChanId; real: LONGREAL; place: INTEGER; width: CARDINAL);
      (* Writes the value of real to cid in fixed-point text form, rounded to the given place
         relative to the decimal point, in a field of the given minimum width.
      *)
    
    PROCEDURE WriteReal (cid: IOChan.ChanId; real: LONGREAL; width: CARDINAL);
      (* Writes the value of real to cid, as WriteFixed if the sign and magnitude can be shown
         in the given width, or otherwise as WriteFloat.  The number of places or significant
         digits depends on the given width.
      *)
    
    END LongIO.
    
    ________________________________________________________________________
    
    LongGIO
    DEFINITION MODULE LongGIO;
    (* ISO Modula-2 Standard Library extension,
       (AXP | VAX) / OpenVMS implementation
    
       Based on LongIO
    
       (C) 1994 by ModulaWare GmbH,
       CS/09-Mar-1994
    *)
    IMPORT IOChan;
    IMPORT SYSTEM;
    
    TYPE LONGREAL = SYSTEM.G_FLOATING;
    
      (* The text form of a signed fixed-point real number is
           ["+" | "-"], decimal digit, {decimal digit}, [".", {decimal digit}]
    
         The text form of a signed floating-point real number is
           signed fixed-point real number,
           "E", ["+" | "-"], decimal digit, {decimal digit}
      *)
    
    PROCEDURE ReadReal (cid: IOChan.ChanId; VAR real: LONGREAL);
      (* Skips leading spaces, and removes any remaining characters from cid that form part of a
         signed fixed or floating point number. The value of this number is assigned to real.
         The read result is set to the value allRight, outOfRange, wrongFormat, endOfLine, or
         endOfInput.
      *)
    
    PROCEDURE WriteFloat (cid: IOChan.ChanId; real: LONGREAL; sigFigs: CARDINAL; width: CARDINAL);
      (* Writes the value of real to cid in floating-point text form, with sigFigs significant
         figures, in a field of the given minimum width.
      *)
    
    PROCEDURE WriteEng (cid: IOChan.ChanId; real: LONGREAL; sigFigs: CARDINAL; width: CARDINAL);
      (* As for WriteFloat, except that the number is scaled with one to three digits in the
         whole number part, and with an exponent that is a multiple of three.
      *)
    
    PROCEDURE WriteFixed (cid: IOChan.ChanId; real: LONGREAL; place: INTEGER; width: CARDINAL);
      (* Writes the value of real to cid in fixed-point text form, rounded to the given place
         relative to the decimal point, in a field of the given minimum width.
      *)
    
    PROCEDURE WriteReal (cid: IOChan.ChanId; real: LONGREAL; width: CARDINAL);
      (* Writes the value of real to cid, as WriteFixed if the sign and magnitude can be shown
         in the given width, or otherwise as WriteFloat.  The number of places or significant
         digits depends on the given width.
      *)
    
    END LongGIO.
    
    ________________________________________________________________________
    
    WholeIO
    DEFINITION MODULE WholeIO;
    
      (* Input and output of whole numbers in decimal text form over specified channels.
         The read result is of the type IOConsts.ReadResults.
      *)
    
    IMPORT IOChan;
    
      (* The text form of a signed whole number is
           ["+" | "-"], decimal digit, {decimal digit}
    
         The text form of an unsigned whole number is
           decimal digit, {decimal digit}
      *)
    
    PROCEDURE ReadInt (cid: IOChan.ChanId; VAR int: INTEGER);
      (* Skips leading spaces, and removes any remaining characters from cid that form part of a
         signed whole number.  The value of this number is assigned to int.  The read result is
         set to the value allRight, outOfRange, wrongFormat, endOfLine, or endOfInput.
      *)
    
    PROCEDURE WriteInt (cid: IOChan.ChanId; int: INTEGER; width: CARDINAL);
      (* Writes the value of int to cid in text form, in a field of the given minimum width. *)
    
    PROCEDURE ReadCard (cid: IOChan.ChanId; VAR card: CARDINAL);
      (* Skips leading spaces, and removes any remaining characters from cid that form part of
         an unsigned whole number.  The value of this number is assigned to card. The read
         result is set to the value allRight, outOfRange, wrongFormat, endOfLine, or endOfInput.
      *)
    
    PROCEDURE WriteCard (cid: IOChan.ChanId; card: CARDINAL; width: CARDINAL);
      (* Writes the value of card to cid in text form, in a field of the given minimum width. *)
    
    END WholeIO.
    
    ________________________________________________________________________
    
    IOResult
    DEFINITION MODULE IOResult;
    
      (* Read results for specified channels *)
    
    IMPORT IOConsts, IOChan;
    
    TYPE
      ReadResults = IOConsts.ReadResults;
    
      (*
        ReadResults =  (* This type is used to classify the result of an input operation *)
        (
          notKnown,    (* no read result is set *)
          allRight,    (* data is as expected or as required *)
          outOfRange,  (* data cannot be represented *)
          wrongFormat, (* data not in expected format *)
          endOfLine,   (* end of line seen before expected data *)
          endOfInput   (* end of input seen before expected data *)
        );
      *)
    
    PROCEDURE ReadResult (cid: IOChan.ChanId): ReadResults;
      (* Returns the result for the last read operation on the channel cid. *)
    
    END IOResult.
    
    ________________________________________________________________________
    
    TermFile
    DEFINITION MODULE TermFile;
    
      (* Access to the terminal device *)
    
      (* Channels opened by this module are connected to a single terminal device; typed
         characters are distributed between channels according to the sequence of read requests.
      *)
    
    IMPORT IOChan, ChanConsts;
    
    TYPE
      ChanId = IOChan.ChanId;
      FlagSet = ChanConsts.FlagSet;
      OpenResults = ChanConsts.OpenResults;
    
      (* Accepted singleton values of FlagSet *)
    
    CONST
      read = FlagSet{ChanConsts.readFlag};   (* input operations are requested/available *)
      write = FlagSet{ChanConsts.writeFlag}; (* output operations are requested/available *)
      text = FlagSet{ChanConsts.textFlag};   (* text operations are requested/available *)
      raw = FlagSet{ChanConsts.rawFlag};     (* raw operations are requested/available *)
      echo = FlagSet{ChanConsts.echoFlag};   (* echoing by interactive device on reading of
                                                characters from input stream requested/applies
                                             *)
    
    PROCEDURE Open (VAR cid: ChanId; flags: FlagSet; VAR res: OpenResults);
      (* Attempts to obtain and open a channel connected to the terminal.
         Without the raw flag, text is implied.
         Without the echo flag, line mode is requested, otherwise single character mode is
         requested.
         If successful, assigns to cid the identity of the opened channel, and assigns the value
         opened to res.
         If a channel cannot be opened as required, the value of res indicates the reason, and
         cid identifies the invalid channel.
      *)
    
    PROCEDURE IsTermFile (cid: ChanId): BOOLEAN;
      (* Tests if the channel identified by cid is open to the terminal. *)
    
    PROCEDURE Close (VAR cid: ChanId);
      (* If the channel identified by cid is not open to the terminal, the exception wrongDevice
         is raised; otherwise closes the channel and assigns the value identifying the invalid
         channel to cid.
      *)
    
    END TermFile.
    
    ________________________________________________________________________
    
    RndFile
    DEFINITION MODULE RndFile;
    
      (* Random access files *)
    
    IMPORT IOChan, ChanConsts, SYSTEM;
    
    TYPE
      ChanId = IOChan.ChanId;
      FlagSet = ChanConsts.FlagSet;
      OpenResults = ChanConsts.OpenResults;
    
      (* Accepted singleton values of FlagSet *)
    
    CONST
      read = FlagSet{ChanConsts.readFlag};   (* input operations are requested/available *)
      write = FlagSet{ChanConsts.writeFlag}; (* output operations are requested/available *)
      old = FlagSet{ChanConsts.oldFlag};     (* a file may/must/did exist before the channel is
                                                opened *)
      text = FlagSet{ChanConsts.textFlag};   (* text operations are requested/available *)
      raw = FlagSet{ChanConsts.rawFlag};     (* raw operations are requested/available *)
    
    PROCEDURE OpenOld (VAR cid: ChanId; name: ARRAY OF CHAR; flags: FlagSet;
                       VAR res: OpenResults);
      (* Attempts to obtain and open a channel connected to a stored random access file of the
         given name.
         The old flag is implied; without the write flag, read is implied; without the text
         flag, raw is implied.
         If successful, assigns to cid the identity of the opened channel, assigns the value
         opened to res, and sets the read/write position to the start of the file.
         If a channel cannot be opened as required, the value of res indicates the reason, and
         cid identifies the invalid channel.
      *)
    
    PROCEDURE OpenClean (VAR cid: ChanId; name: ARRAY OF CHAR; flags: FlagSet;
                         VAR res: OpenResults);
      (* Attempts to obtain and open a channel connected to a stored random access file of the
         given name.
         The write flag is implied; without the text flag, raw is implied.
         If successful, assigns to cid the identity of the opened channel, assigns the value
         opened to res, and truncates the file to zero length.
         If a channel cannot be opened as required, the value of res indicates the reason, and
         cid identifies the invalid channel.
      *)
    
    PROCEDURE IsRndFile (cid: ChanId): BOOLEAN;
      (* Tests if the channel identified by cid is open to a random access file. *)
    
    PROCEDURE IsRndFileException (): BOOLEAN;
      (* Returns TRUE if the current coroutine is in the exceptional execution state because
         of the raising of a RndFile exception; otherwise returns FALSE.
      *)
    
    (* ISO-Definition:
    CONST
      FilePosSize = <implementation-defined whole number greater than zero>;
    
    TYPE
      FilePos = ARRAY [1 .. FilePosSize] OF SYSTEM.LOC;
    *)
    
    (*temporary definition for MVR V3: *)
    CONST
      FilePosSize = SYSTEM.TSIZE(SYSTEM.QUADWORD);
    
    TYPE
      FilePos = SYSTEM.QUADWORD; (*ARRAY[1..FilePosSize] OF SYSTEM.LOC;*)
    
    PROCEDURE StartPos (cid: ChanId): FilePos;
      (* If the channel identified by cid is not open to a random access file, the exception
         wrongDevice is raised; otherwise returns the position of the start of the file.
      *)
    
    PROCEDURE CurrentPos (cid: ChanId): FilePos;
      (* If the channel identified by cid is not open to a random access file, the exception
         wrongDevice is raised; otherwise returns the position of the current read/write
         position.
      *)
    
    PROCEDURE EndPos (cid: ChanId): FilePos;
      (* If the channel identified by cid is not open to a random access file, the exception
         wrongDevice is raised; otherwise returns the first position after which there have been
         no writes.
      *)
    
    PROCEDURE NewPos (cid: ChanId; chunks: INTEGER; chunkSize: CARDINAL; from: FilePos): FilePos;
      (* If the channel identified by cid is not open to a random access file, the exception
         wrongDevice is raised; otherwise returns the position (chunks * chunkSize) relative to
         the position given by from, or raises the exception posRange if the required position
         cannot be represented as a value of type FilePos.
      *)
    
    PROCEDURE SetPos (cid: ChanId; pos: FilePos);
      (* If the channel identified by cid is not open to a random access file, the exception
         wrongDevice is raised; otherwise sets the read/write position to the value given by
         pos.
      *)
    
    PROCEDURE Close (VAR cid: ChanId);
      (* If the channel identified by cid is not open to a random access file, the exception
         wrongDevice is raised; otherwise closes the channel, and assigns the value identifying
         the invalid channel to cid.
      *)
    
    END RndFile.
    
    ________________________________________________________________________
    
    SeqFile
    DEFINITION MODULE SeqFile;
    
      (* Rewindable sequential files *)
    
    IMPORT IOChan, ChanConsts;
    
    TYPE
      ChanId = IOChan.ChanId;
      FlagSet = ChanConsts.FlagSet;
      OpenResults = ChanConsts.OpenResults;
    
      (* Accepted singleton values of FlagSet *)
    
    CONST
      read = FlagSet{ChanConsts.readFlag};   (* input operations are requested/available *)
      write = FlagSet{ChanConsts.writeFlag}; (* output operations are requested/available *)
      old = FlagSet{ChanConsts.oldFlag};     (* a file may/must/did exist before the channel is
                                                opened *)
      text = FlagSet{ChanConsts.textFlag};   (* text operations are requested/available *)
      raw = FlagSet{ChanConsts.rawFlag};     (* raw operations are requested/available *)
    
    PROCEDURE OpenWrite (VAR cid: ChanId; name: ARRAY OF CHAR; flags: FlagSet;
                         VAR res: OpenResults);
      (* Attempts to obtain and open a channel connected to a stored rewindable file of the
         given name.
         The write flag is implied; without the raw flag, text is implied.
         If successful, assigns to cid the identity of the opened channel, assigns the value
         opened to res, and selects output mode, with the write position at the start of the
         file (i.e. the file is of zero length).
         If a channel cannot be opened as required, the value of res indicates the reason, and
         cid identifies the invalid channel.
      *)
    
    PROCEDURE OpenAppend (VAR cid: ChanId; name: ARRAY OF CHAR; flags: FlagSet;
                          VAR res: OpenResults);
      (* Attempts to obtain and open a channel connected to a stored rewindable file of the
         given name.
         The write and old flags are implied; without the raw flag, text is implied.
         If successful, assigns to cid the identity of the opened channel, assigns the value
         opened to res, and selects output mode, with the write position corresponding to the
         length of the file.
         If a channel cannot be opened as required, the value of res indicates the reason, and
         cid identifies the invalid channel.
      *)
    
    PROCEDURE OpenRead (VAR cid: ChanId; name: ARRAY OF CHAR; flags: FlagSet;
                        VAR res: OpenResults);
      (* Attempts to obtain and open a channel connected to a stored rewindable file of the
         given name.
         The read and old flags are implied; without the raw flag, text is implied.
         If successful, assigns to cid the identity of the opened channel, assigns the value
         opened to res, and selects input mode, with the read position corresponding to the
         start of the file.
         If a channel cannot be opened as required, the value of res indicates the reason, and
         cid identifies the invalid channel.
      *)
    
    PROCEDURE IsSeqFile (cid: ChanId): BOOLEAN;
      (* Tests if the channel identified by cid is open to a rewindable sequential file. *)
    
    PROCEDURE Reread (cid: ChanId);
      (* If the channel identified by cid is not open to a rewindable sequential file, the
         exception wrongDevice is raised; otherwise attempts to set the read position to the
         start of the file, and to select input mode.
         If the operation cannot be performed (perhaps because of insufficient permissions)
         neither input mode nor output mode is selected.
      *)
    
    PROCEDURE Rewrite (cid: ChanId);
      (* If the channel identified by cid is not open to a rewindable sequential file, the
         exception wrongDevice is raised; otherwise, attempts to truncate the file to zero
         length, and to select output mode.
         If the operation cannot be performed (perhaps because of insufficient permissions)
         neither input mode nor output mode is selected.
      *)
    
    PROCEDURE Close (VAR cid: ChanId);
      (* If the channel identified by cid is not open to a rewindable sequential file, the
         exception wrongDevice is raised; otherwise closes the channel, and assigns the value
         identifying the invalid channel to cid.
      *)
    
    END SeqFile.
    
    ________________________________________________________________________
    
    StreamFile
    DEFINITION MODULE StreamFile;
    
      (* Independent sequential data streams *)
    
    IMPORT IOChan, ChanConsts;
    
    TYPE
      ChanId = IOChan.ChanId;
      FlagSet = ChanConsts.FlagSet;
      OpenResults = ChanConsts.OpenResults;
    
      (* Accepted singleton values of FlagSet *)
    
    CONST
      read = FlagSet{ChanConsts.readFlag};   (* input operations are requested/available *)
      write = FlagSet{ChanConsts.writeFlag}; (* output operations are requested/available *)
      old = FlagSet{ChanConsts.oldFlag};     (* a file may/must/did exist before the channel is
                                                opened *)
      text = FlagSet{ChanConsts.textFlag};   (* text operations are requested/available *)
      raw = FlagSet{ChanConsts.rawFlag};     (* raw operations are requested/available *)
    
    PROCEDURE Open (VAR cid: ChanId; name: ARRAY OF CHAR; flags: FlagSet; VAR res: OpenResults);
    
      (* Attempts to obtain and open a channel connected to a sequential stream of the given
         name.
         The read flag implies old; without the raw flag, text is implied.
         If successful, assigns to cid the identity of the opened channel, and assigns the value
         opened to res.
         If a channel cannot be opened as required, the value of res indicates the reason, and
         cid identifies the invalid channel.
      *)
    
    PROCEDURE IsStreamFile (cid: ChanId): BOOLEAN;
      (* Tests if the channel identified by cid is open to a sequential stream. *)
    
    PROCEDURE Close (VAR cid: ChanId);
      (* If the channel identified by cid is not open to a sequential stream, the exception
         wrongDevice is raised; otherwise closes the channel, and assigns the value identifying
         the invalid channel to cid.
      *)
    
    END StreamFile.
    
    ________________________________________________________________________
    
    ProgramArgs
    DEFINITION MODULE ProgramArgs;
     
      (* Access to program arguments *)
     
    IMPORT IOChan;
     
    TYPE
      ChanId = IOChan.ChanId;
     
    PROCEDURE ArgChan (): ChanId;
      (* Returns a value that identifies a channel for reading program arguments *)
     
    PROCEDURE IsArgPresent (): BOOLEAN;
      (* Tests if there is a current argument to read from. If not, read <=
         IOChan.CurrentFlags() will be FALSE, and attempting to read from the argument channel
         will raise the exception notAvailable.
      *)
     
    PROCEDURE NextArg ();
      (* If there is another argument, causes subsequent input from the argument device to come
         from the start of the next argument.  Otherwise there is no argument to read from, and
         a call of IsArgPresent will return FALSE.
      *)
     
    END ProgramArgs.
    
    ________________________________________________________________________
    
    StdChans
    DEFINITION MODULE StdChans;
    
      (* Access to standard and default channels *)
    
    IMPORT IOChan;
    
    TYPE
      ChanId = IOChan.ChanId;
        (* Values of this type are used to identify channels *)
    
      (* The following functions return the standard channel values.
         These channels cannot be closed.
      *)
    
    PROCEDURE StdInChan (): ChanId;
      (* Returns the identity of the implementation-defined standard source for program
         input.
      *)
    
    PROCEDURE StdOutChan (): ChanId;
      (* Returns the identity of the implementation-defined standard source for program
         output.
      *)
    
    PROCEDURE StdErrChan (): ChanId;
      (* Returns the identity of the implementation-defined standard destination for program
         error messages.
      *)
    
    PROCEDURE NullChan (): ChanId;
      (* Returns the identity of a channel open to the null device. *)
    
      (* The following functions return the default channel values *)
    
    PROCEDURE InChan (): ChanId;
      (* Returns the identity of the current default input channel. *)
    
    PROCEDURE OutChan (): ChanId;
      (* Returns the identity of the current default output channel. *)
    
    PROCEDURE ErrChan (): ChanId;
      (* Returns the identity of the current default error message channel. *)
    
      (* The following procedures allow for redirection of the default channels *)
    
    PROCEDURE SetInChan (cid: ChanId);
      (* Sets the current default input channel to that identified by cid. *)
    
    PROCEDURE SetOutChan (cid: ChanId);
      (* Sets the current default output channel to that identified by cid. *)
    
    PROCEDURE SetErrChan (cid: ChanId);
      (* Sets the current default error channel to that identified by cid. *)
    
    END StdChans.
    
    ________________________________________________________________________
     
    
    String Conversions Library
    
    ________________________________________________________________________
    
    WholeConv
    DEFINITION MODULE WholeConv;
    
      (* Low-level whole-number/string conversions *)
    
    IMPORT
      ConvTypes;
    
    TYPE
      ConvResults = ConvTypes.ConvResults; (* strAllRight, strOutOfRange, strWrongFormat, strEmpty *)
    
    PROCEDURE ScanInt (inputCh: CHAR; VAR chClass: ConvTypes.ScanClass;
                       VAR nextState: ConvTypes.ScanState);
      (* Represents the start state of a finite state scanner for signed whole numbers -
         assigns class of inputCh to chClass and a procedure representing the next state to
         nextState.
      *)
    
    PROCEDURE FormatInt (str: ARRAY OF CHAR): ConvResults;
      (* Returns the format of the string value for conversion to INTEGER. *)
    
    PROCEDURE ValueInt (str: ARRAY OF CHAR): INTEGER;
      (* Returns the value corresponding to the signed whole number string value str if str
         is well-formed; otherwise raises the WholeConv exception.
      *)
    
    PROCEDURE LengthInt (int: INTEGER): CARDINAL;
      (* Returns the number of characters in the string representation of int. *)
    
    PROCEDURE ScanCard (inputCh: CHAR; VAR chClass: ConvTypes.ScanClass;
                        VAR nextState: ConvTypes.ScanState);
      (* Represents the start state of a finite state scanner for unsigned whole numbers -
         assigns class of inputCh to chClass and a procedure representing the next state to
         nextState.
      *)
    
    PROCEDURE FormatCard (str: ARRAY OF CHAR): ConvResults;
      (* Returns the format of the string value for conversion to CARDINAL. *)
    
    PROCEDURE ValueCard (str: ARRAY OF CHAR): CARDINAL;
      (* Returns the value corresponding to the unsigned whole number string value str if
         str is well-formed; otherwise raises the WholeConv exception.
       *)
    
    PROCEDURE LengthCard (card: CARDINAL): CARDINAL;
      (* Returns the number of characters in the string representation of card. *)
    
    PROCEDURE IsWholeConvException (): BOOLEAN;
      (* Returns TRUE if the current coroutine is in the exceptional execution state because
         of the raising of an exception in a routine from this module; otherwise returns
         FALSE.
      *)
    
    END WholeConv.
    
    ________________________________________________________________________
    
    RealConv
    DEFINITION MODULE RealConv;
    
      (* Low-level REAL/string conversions *)
    
    IMPORT
      ConvTypes;
    
    TYPE
      ConvResults = ConvTypes.ConvResults; (* strAllRight, strOutOfRange, strWrongFormat, strEmpty *)
    
    PROCEDURE ScanReal (inputCh: CHAR; VAR chClass: ConvTypes.ScanClass;
                        VAR nextState: ConvTypes.ScanState);
      (* Represents the start state of a finite state scanner for real numbers - assigns
         class of inputCh to chClass and a procedure representing the next state to
         nextState.
       *)
    
    PROCEDURE FormatReal (str: ARRAY OF CHAR): ConvResults;
      (* Returns the format of the string value for conversion to REAL. *)
    
    PROCEDURE ValueReal (str: ARRAY OF CHAR): REAL;
      (* Returns the value corresponding to the real number string value str if str is
         well-formed; otherwise raises the RealConv exception.
      *)
    
    PROCEDURE LengthFloatReal (real: REAL; sigFigs: CARDINAL): CARDINAL;
      (* Returns the number of characters in the floating-point string representation of
         real with sigFigs significant figures.
      *)
    
    PROCEDURE LengthEngReal (real: REAL; sigFigs: CARDINAL): CARDINAL;
      (* Returns the number of characters in the floating-point engineering string
         representation of real with sigFigs significant figures.
      *)
    
    PROCEDURE LengthFixedReal (real: REAL; place: INTEGER): CARDINAL;
      (* Returns the number of characters in the fixed-point string representation of real
         rounded to the given place relative to the decimal point.
      *)
    
    PROCEDURE IsRConvException (): BOOLEAN;
      (* Returns TRUE if the current coroutine is in the exceptional execution state because
         of the raising of an exception in a routine from this module; otherwise returns
         FALSE.
      *)
    
    END RealConv.
    
    ________________________________________________________________________
    
    LongConv
    DEFINITION MODULE LongConv;
    
      (* Low-level LONGREAL/string conversions *)
    
    IMPORT
      ConvTypes;
    
    TYPE
      ConvResults = ConvTypes.ConvResults; (* strAllRight, strOutOfRange, strWrongFormat, strEmpty *)
    
    PROCEDURE ScanReal (inputCh: CHAR; VAR chClass: ConvTypes.ScanClass;
                        VAR nextState: ConvTypes.ScanState);
      (* Represents the start state of a finite state scanner for real numbers - assigns
         class of inputCh to chClass and a procedure representing the next state to
         nextState.
      *)
    
    PROCEDURE FormatReal (str: ARRAY OF CHAR): ConvResults;
      (* Returns the format of the string value for conversion to LONGREAL. *)
    
    PROCEDURE ValueReal (str: ARRAY OF CHAR): LONGREAL;
      (* Returns the value corresponding to the real number string value str if str is
         well-formed; otherwise raises the LongConv exception.
      *)
    
    PROCEDURE LengthFloatReal (real: LONGREAL; sigFigs: CARDINAL): CARDINAL;
      (* Returns the number of characters in the floating-point string representation of
         real with sigFigs significant figures.
      *)
    
    PROCEDURE LengthEngReal (real: LONGREAL; sigFigs: CARDINAL): CARDINAL;
      (* Returns the number of characters in the floating-point engineering string
         representation of real with sigFigs significant figures.
      *)
    
    PROCEDURE LengthFixedReal (real: LONGREAL; place: INTEGER): CARDINAL;
      (* Returns the number of characters in the fixed-point string representation of real
         rounded to the given place relative to the decimal point.
      *)
    
    PROCEDURE IsRConvException (): BOOLEAN;
      (* Returns TRUE if the current coroutine is in the exceptional execution state because
         of the raising of an exception in a routine from this module; otherwise returns
         FALSE.
      *)
    
    END LongConv.
    
    ________________________________________________________________________
    
    LongGConv
    DEFINITION MODULE LongGConv;
    (* ISO Modula-2 Standard Library extension,
       (AXP | VAX) / OpenVMS implementation
    
       Based on LongConv
    
       (C) 1994 by ModulaWare GmbH,
       CS/09-Mar-1994
    *)
    IMPORT ConvTypes;
    IMPORT SYSTEM;
    
    TYPE
      ConvResults = ConvTypes.ConvResults; (* strAllRight, strOutOfRange, strWrongFormat, strEmpty *)
      LONGREAL = SYSTEM.G_FLOATING;
    
    PROCEDURE ScanReal (inputCh: CHAR; VAR chClass: ConvTypes.ScanClass; 
                        VAR nextState: ConvTypes.ScanState);
      (* Represents the start state of a finite state scanner for real numbers - assigns
         class of inputCh to chClass and a procedure representing the next state to
         nextState.
      *)
    
    PROCEDURE FormatReal (str: ARRAY OF CHAR): ConvResults;
      (* Returns the format of the string value for conversion to LONGREAL. *)
    
    PROCEDURE ValueReal (str: ARRAY OF CHAR): LONGREAL;
      (* Returns the value corresponding to the real number string value str if str is
         well-formed; otherwise raises the LongConv exception.
      *)
    
    PROCEDURE LengthFloatReal (real: LONGREAL; sigFigs: CARDINAL): CARDINAL;
      (* Returns the number of characters in the floating-point string representation of
         real with sigFigs significant figures.
      *)
    
    PROCEDURE LengthEngReal (real: LONGREAL; sigFigs: CARDINAL): CARDINAL;
      (* Returns the number of characters in the floating-point engineering string 
         representation of real with sigFigs significant figures.
      *)
    
    PROCEDURE LengthFixedReal (real: LONGREAL; place: INTEGER): CARDINAL;
      (* Returns the number of characters in the fixed-point string representation of real
         rounded to the given place relative to the decimal point.
      *)
    
    PROCEDURE IsRConvException (): BOOLEAN;
      (* Returns TRUE if the current coroutine is in the exceptional execution state because
         of the raising of an exception in a routine from this module; otherwise returns 
         FALSE.
      *)
    
    END LongGConv.
    
    ________________________________________________________________________
    
    ConvTypes
    DEFINITION MODULE ConvTypes;
    
      (* Common types used in the string conversion modules *)
    
    IMPORT SYSTEM;
    
    TYPE
      ConvResults =     (* Values of this type are used to express the format of a string *)
      (
        strAllRight,    (* the string format is correct for the corresponding conversion *)
        strOutOfRange,  (* the string is well-formed but the value cannot be represented *)
        strWrongFormat, (* the string is in the wrong format for the conversion *)
        strEmpty        (* the given string is empty *)
      );
    
      ScanClass =  (* Values of this type are used to classify input to finite state scanners *)
      (
        padding,   (* a leading or padding character at this point in the scan - ignore it *)
        valid,     (* a valid character at this point in the scan - accept it *)
        invalid,   (* an invalid character at this point in the scan - reject it *)
        terminator (* a terminating character at this point in the scan (not part of token) *)
      );
    
    (*
      ScanState =  (* The type of lexical scanning control procedures *)
        PROCEDURE (CHAR, VAR ScanClass, VAR ScanState);
    *)
    
    (* temporary for MVR: *)
      ScanState = PROCEDURE(CHAR, VAR ScanClass, VAR SYSTEM.WORD (*ScanState*));
    
    END ConvTypes.
    
    ________________________________________________________________________
    
    WholeStr
    DEFINITION MODULE WholeStr;
    
      (* Whole-number/string conversions *)
    
    IMPORT
      ConvTypes;
    
    TYPE
      ConvResults = ConvTypes.ConvResults; (* strAllRight, strOutOfRange, strWrongFormat, strEmpty *)
    
    (* the string form of a signed whole number is
         ["+" | "-"], decimal digit, {decimal digit}
    *)
    
    PROCEDURE StrToInt (str: ARRAY OF CHAR; VAR int: INTEGER; VAR res: ConvResults);
      (* Ignores any leading spaces in str. If the subsequent characters in str are in the
         format of a signed whole number, assigns a corresponding value to int. Assigns a
         value indicating the format of str to res.
      *)
    
    PROCEDURE IntToStr (int: INTEGER; VAR str: ARRAY OF CHAR);
      (* Converts the value of int to string form and copies the possibly truncated result to str. *)
    
    (* the string form of an unsigned whole number is
         decimal digit, {decimal digit}
    *)
    
    PROCEDURE StrToCard (str: ARRAY OF CHAR; VAR card: CARDINAL; VAR res: ConvResults);
      (* Ignores any leading spaces in str. If the subsequent characters in str are in the
         format of an unsigned whole number, assigns a corresponding value to card.
         Assigns a value indicating the format of str to res.
      *)
    
    PROCEDURE CardToStr (card: CARDINAL; VAR str: ARRAY OF CHAR);
      (* Converts the value of card to string form and copies the possibly truncated result to str. *)
    
    END WholeStr.
    
    ________________________________________________________________________
    
    Whole_Str
    DEFINITION MODULE Whole_Str;
    (* ISO Modula-2 Standard Library extension,
       (AXP | VAX) / OpenVMS implementation
    
       
       Whole-number/string conversions 
    
       (C) 1994 by ModulaWare GmbH,
       CS/17-Mar-1994
    *)
    IMPORT
      ConvTypes;
    
    TYPE
      ConvResults = ConvTypes.ConvResults; (* strAllRight, strOutOfRange, strWrongFormat, strEmpty *)
    
    (* the string form of a signed whole number is
         ["+" | "-"], decimal digit, {decimal digit}
    *)
    
    PROCEDURE StrToInt (str: ARRAY OF CHAR; VAR int: INTEGER; VAR res: ConvResults);
      (* Ignores any leading spaces in str. If the subsequent characters in str are in the
         format of a signed whole number, assigns a corresponding value to int. Assigns a
         value indicating the format of str to res.
      *)
    
    PROCEDURE IntToStr (int: INTEGER; width: CARDINAL; VAR str: ARRAY OF CHAR);
      (* Converts the value of int to string form, using the requested field width,
         and copies the possibly truncated result to str.
       *)
    
    (* the string form of an unsigned whole number is
         decimal digit, {decimal digit}
    *)
    
    PROCEDURE StrToCard (str: ARRAY OF CHAR; VAR card: CARDINAL; VAR res: ConvResults);
      (* Ignores any leading spaces in str. If the subsequent characters in str are in the
         format of an unsigned whole number, assigns a corresponding value to card.
         Assigns a value indicating the format of str to res.
      *)
    
    PROCEDURE CardToStr (card: CARDINAL; width: CARDINAL; VAR str: ARRAY OF CHAR);
      (* Converts the value of card to string form, using the requested field width,
         and copies the possibly truncated result to str.
      *)
    
    END Whole_Str.
    
    ________________________________________________________________________
    
    RealStr
    DEFINITION MODULE RealStr;
    
      (* REAL/string conversions *)
    
    IMPORT
      ConvTypes;
    
    TYPE
      ConvResults = ConvTypes.ConvResults; (* strAllRight, strOutOfRange, strWrongFormat, strEmpty *)
    
    (* the string form of a signed fixed-point real number is
         ["+" | "-"], decimal digit, {decimal digit}, [".", {decimal digit}]
    *)
    
    (* the string form of a signed floating-point real number is
         signed fixed-point real number, "E", ["+" | "-"], decimal digit, {decimal digit}
    *)
    
    PROCEDURE StrToReal (str: ARRAY OF CHAR; VAR real: REAL; VAR res: ConvResults);
      (* Ignores any leading spaces in str. If the subsequent characters in str are in the
         format of a signed real number, assigns a corresponding value to real.
         Assigns a value indicating the format of str to res.
      *)
    
    PROCEDURE RealToFloat (real: REAL; sigFigs: CARDINAL; VAR str: ARRAY OF CHAR);
      (* Converts the value of real to floating-point string form, with sigFigs significant
         figures, and copies the possibly truncated result to str.
      *)
    
    PROCEDURE RealToEng (real: REAL; sigFigs: CARDINAL; VAR str: ARRAY OF CHAR);
      (* Converts the value of real to floating-point string form, with sigFigs significant
         figures, and copies the possibly truncated result to str. The number is scaled with
         one to three digits in the whole number part and with an exponent that is a
         multiple of three.
      *)
    
    PROCEDURE RealToFixed (real: REAL; place: INTEGER; VAR str: ARRAY OF CHAR);
      (* Converts the value of real to fixed-point string form, rounded to the given place
         relative to the decimal point, and copies the possibly truncated result to str.
      *)
    
    PROCEDURE RealToStr (real: REAL; VAR str: ARRAY OF CHAR);
      (* Converts the value of real as RealToFixed if the sign and magnitude can be shown
         within the capacity of str, or otherwise as RealToFloat, and copies the possibly
         truncated result to str. The number of places or significant digits are
         implementation-defined.
      *)
    
    END RealStr.
    
    ________________________________________________________________________
    
    Real_Str
    DEFINITION MODULE Real_Str;
    (* ISO Modula-2 Standard Library extension,
       (AXP | VAX) / OpenVMS implementation
    
       REAL/string conversions
    
       (C) 1994 by ModulaWare GmbH,
       CS/09-Mar-1994
    *)
    IMPORT
      ConvTypes;
    
    TYPE
      ConvResults = ConvTypes.ConvResults; (* strAllRight, strOutOfRange, strWrongFormat, strEmpty *)
    
    (* the string form of a signed fixed-point real number is
         ["+" | "-"], decimal digit, {decimal digit}, [".", {decimal digit}]
    *)
    
    (* the string form of a signed floating-point real number is
         signed fixed-point real number, "E", ["+" | "-"], decimal digit, {decimal digit}
    *)
    
    PROCEDURE StrToReal (str: ARRAY OF CHAR; VAR real: REAL; VAR res: ConvResults);
      (* Ignores any leading spaces in str. If the subsequent characters in str are in the
         format of a signed real number, assigns a corresponding value to real.
         Assigns a value indicating the format of str to res.
      *)
    
    PROCEDURE RealToFloat (real: REAL; sigFigs: CARDINAL; width: CARDINAL;
      VAR str: ARRAY OF CHAR);
      (* Converts the value of real to floating-point string form, with sigFigs significant
         figures, using the requested field width, and copies the possibly truncated
         result to str.
      *)
    
    PROCEDURE RealToEng (real: REAL; sigFigs: CARDINAL; width: CARDINAL;
      VAR str: ARRAY OF CHAR);
      (* Converts the value of real to floating-point string form, with sigFigs significant
         figures, using the requested field width, and copies the possibly truncated
         result to str. The number is scaled with one to three digits in the whole number
         part and with an exponent that is a multiple of three.
      *)
    
    PROCEDURE RealToFixed (real: REAL; place: INTEGER; width: CARDINAL;
      VAR str: ARRAY OF CHAR);
      (* Converts the value of real to fixed-point string form, rounded to the given place
         relative to the decimal point, using the requested field width, and copies the
         possibly truncated result to str.
      *)
    
    PROCEDURE RealToStr (real: REAL; width: CARDINAL; VAR str: ARRAY OF CHAR);
      (* Converts the value of real as RealToFixed if the sign and magnitude can be shown
         in the given width, or otherwise as RealToFloat, and copies the possibly truncated
         result to str. The number of places or significant digits depend on the given width.
      *)
    
    END Real_Str.
    
    ________________________________________________________________________
    
    LongStr
    DEFINITION MODULE LongStr;
    
      (* LONGREAL/string conversions *)
    
    IMPORT
      ConvTypes;
    
    TYPE
      ConvResults = ConvTypes.ConvResults; (* strAllRight, strOutOfRange, strWrongFormat, strEmpty *)
    
    (* the string form of a signed fixed-point real number is
         ["+" | "-"], decimal digit, {decimal digit}, [".", {decimal digit}]
    *)
    
    (* the string form of a signed floating-point real number is
         signed fixed-point real number, "E", ["+" | "-"], decimal digit, {decimal digit}
    *)
    
    PROCEDURE StrToReal (str: ARRAY OF CHAR; VAR real: LONGREAL; VAR res: ConvResults);
      (* Ignores any leading spaces in str. If the subsequent characters in str are in the
         format of a signed real number, assigns a corresponding value to real.
         Assigns a value indicating the format of str to res.
      *)
    
    PROCEDURE RealToFloat (real: LONGREAL; sigFigs: CARDINAL; VAR str: ARRAY OF CHAR);
      (* Converts the value of real to floating-point string form, with sigFigs significant
         figures, and copies the possibly truncated result to str.
      *)
    
    PROCEDURE RealToEng (real: LONGREAL; sigFigs: CARDINAL; VAR str: ARRAY OF CHAR);
      (* Converts the value of real to floating-point string form, with sigFigs significant
         figures, and copies the possibly truncated result to str. The number is scaled with
         one to three digits in the whole number part and with an exponent that is a
         multiple of three.
      *)
    
    PROCEDURE RealToFixed (real: LONGREAL; place: INTEGER; VAR str: ARRAY OF CHAR);
      (* Converts the value of real to fixed-point string form, rounded to the given place
         relative to the decimal point, and copies the possibly truncated result to str.
      *)
    
    PROCEDURE RealToStr (real: LONGREAL; VAR str: ARRAY OF CHAR);
      (* Converts the value of real as RealToFixed if the sign and magnitude can be shown
         within the capacity of str, or otherwise as RealToFloat, and copies the possibly
         truncated result to str. The number of places or significant digits depend on the
         capacity of str.
      *)
    
    END LongStr.
    
    ________________________________________________________________________
    
    Long_Str
    DEFINITION MODULE Long_Str;
    (* ISO Modula-2 Standard Library extension,
       (AXP | VAX) / OpenVMS implementation
    
       LONGREAL/string conversions
    
       (C) 1994 by ModulaWare GmbH,
       CS/17-Mar-1994
    *)
    IMPORT
      ConvTypes;
    
    TYPE
      ConvResults = ConvTypes.ConvResults; (* strAllRight, strOutOfRange, strWrongFormat, strEmpty *)
    
    (* the string form of a signed fixed-point real number is
         ["+" | "-"], decimal digit, {decimal digit}, [".", {decimal digit}]
    *)
    
    (* the string form of a signed floating-point real number is
         signed fixed-point real number, "E", ["+" | "-"], decimal digit, {decimal digit}
    *)
    
    PROCEDURE StrToReal (str: ARRAY OF CHAR; VAR real: LONGREAL; VAR res: ConvResults);
      (* Ignores any leading spaces in str. If the subsequent characters in str are in the
         format of a signed real number, assigns a corresponding value to real.
         Assigns a value indicating the format of str to res.
      *)
    
    PROCEDURE RealToFloat (real: LONGREAL; sigFigs: CARDINAL; width: CARDINAL;
      VAR str: ARRAY OF CHAR);
      (* Converts the value of real to floating-point string form, with sigFigs significant
         figures, using the requested field width, and copies the possibly truncated
         result to str.
      *)
    
    PROCEDURE RealToEng (real: LONGREAL; sigFigs: CARDINAL; width: CARDINAL;
      VAR str: ARRAY OF CHAR);
      (* Converts the value of real to floating-point string form, with sigFigs significant
         figures, using the requested field width, and copies the possibly truncated
         result to str. The number is scaled with one to three digits in the whole number
         part and with an exponent that is a multiple of three.
      *)
    
    PROCEDURE RealToFixed (real: LONGREAL; place: INTEGER; width: CARDINAL;
      VAR str: ARRAY OF CHAR);
      (* Converts the value of real to fixed-point string form, rounded to the given place
         relative to the decimal point, using the requested field width, and copies the
         possibly truncated result to str.
      *)
    
    PROCEDURE RealToStr (real: LONGREAL; width: CARDINAL; VAR str: ARRAY OF CHAR);
      (* Converts the value of real as RealToFixed if the sign and magnitude can be shown
         in the given width, or otherwise as RealToFloat, and copies the possibly truncated
         result to str. The number of places or significant digits depend on the given width.
      *)
    
    END Long_Str.
    
    ________________________________________________________________________
    
    LongGStr
    DEFINITION MODULE LongGStr;
    (* ISO Modula-2 Standard Library extension,
       (AXP | VAX) / OpenVMS implementation
    
       Based on LongStr
    
       (C) 1994 by ModulaWare GmbH,
       CS/17-Mar-1994
    *)
    IMPORT
      ConvTypes, SYSTEM;
    
    TYPE
      LONGREAL = SYSTEM.G_FLOATING;
      ConvResults = ConvTypes.ConvResults; (* strAllRight, strOutOfRange, strWrongFormat, strEmpty *)
    
    (* the string form of a signed fixed-point real number is
         ["+" | "-"], decimal digit, {decimal digit}, [".", {decimal digit}]
    *)
    
    (* the string form of a signed floating-point real number is
         signed fixed-point real number, "E", ["+" | "-"], decimal digit, {decimal digit}
    *)
    
    PROCEDURE StrToReal (str: ARRAY OF CHAR; VAR real: LONGREAL; VAR res: ConvResults);
      (* Ignores any leading spaces in str. If the subsequent characters in str are in the
         format of a signed real number, assigns a corresponding value to real.
         Assigns a value indicating the format of str to res.
      *)
    
    PROCEDURE RealToFloat (real: LONGREAL; sigFigs: CARDINAL; VAR str: ARRAY OF CHAR);
      (* Converts the value of real to floating-point string form, with sigFigs significant
         figures, and copies the possibly truncated result to str.
      *)
    
    PROCEDURE RealToEng (real: LONGREAL; sigFigs: CARDINAL; VAR str: ARRAY OF CHAR);
      (* Converts the value of real to floating-point string form, with sigFigs significant
         figures, and copies the possibly truncated result to str. The number is scaled with
         one to three digits in the whole number part and with an exponent that is a
         multiple of three.
      *)
    
    PROCEDURE RealToFixed (real: LONGREAL; place: INTEGER; VAR str: ARRAY OF CHAR);
      (* Converts the value of real to fixed-point string form, rounded to the given place
         relative to the decimal point, and copies the possibly truncated result to str.
      *)
    
    PROCEDURE RealToStr (real: LONGREAL; VAR str: ARRAY OF CHAR);
      (* Converts the value of real as RealToFixed if the sign and magnitude can be shown
         within the capacity of str, or otherwise as RealToFloat, and copies the possibly
         truncated result to str. The number of places or significant digits depend on the
         capacity of str.
      *)
    
    END LongGStr.
    
    ________________________________________________________________________
    
    LongG_Str
    DEFINITION MODULE LongG_Str;
    (* ISO Modula-2 Standard Library extension,
       (AXP | VAX) / OpenVMS implementation
    
       Based on Long_Str
    
       (C) 1994 by ModulaWare GmbH,
       CS/09-Mar-1994
    *)
    IMPORT
      ConvTypes, SYSTEM;
    
    TYPE
      ConvResults = ConvTypes.ConvResults; (* strAllRight, strOutOfRange, strWrongFormat, strEmpty *)
      LONGREAL = SYSTEM.G_FLOATING;
    
    (* the string form of a signed fixed-point real number is
         ["+" | "-"], decimal digit, {decimal digit}, [".", {decimal digit}]
    *)
    
    (* the string form of a signed floating-point real number is
         signed fixed-point real number, "E", ["+" | "-"], decimal digit, {decimal digit}
    *)
    
    PROCEDURE StrToReal (str: ARRAY OF CHAR; VAR real: LONGREAL; VAR res: ConvResults);
      (* Ignores any leading spaces in str. If the subsequent characters in str are in the
         format of a signed real number, assigns a corresponding value to real.
         Assigns a value indicating the format of str to res.
      *)
    
    PROCEDURE RealToFloat (real: LONGREAL; sigFigs: CARDINAL; width: CARDINAL;
      VAR str: ARRAY OF CHAR);
      (* Converts the value of real to floating-point string form, with sigFigs significant
         figures, using the requested field width, and copies the possibly truncated
         result to str.
      *)
    
    PROCEDURE RealToEng (real: LONGREAL; sigFigs: CARDINAL; width: CARDINAL;
      VAR str: ARRAY OF CHAR);
      (* Converts the value of real to floating-point string form, with sigFigs significant
         figures, using the requested field width, and copies the possibly truncated
         result to str. The number is scaled with one to three digits in the whole number
         part and with an exponent that is a multiple of three.
      *)
    
    PROCEDURE RealToFixed (real: LONGREAL; place: INTEGER; width: CARDINAL;
      VAR str: ARRAY OF CHAR);
      (* Converts the value of real to fixed-point string form, rounded to the given place
         relative to the decimal point, using the requested field width, and copies the
         possibly truncated result to str.
      *)
    
    PROCEDURE RealToStr (real: LONGREAL; width: CARDINAL; VAR str: ARRAY OF CHAR);
      (* Converts the value of real as RealToFixed if the sign and magnitude can be shown
         in the given width, or otherwise as RealToFloat, and copies the possibly truncated
         result to str. The number of places or significant digits depend on the given width.
      *)
    
    END LongG_Str.
    
    ________________________________________________________________________
    
    CharClass
    DEFINITION MODULE CharClass;
    
      (* Classification of values of the type CHAR *)
    
    PROCEDURE IsNumeric (ch: CHAR): BOOLEAN;
      (* Returns TRUE if and only if ch is classified as a numeric character *)
    
    PROCEDURE IsLetter (ch: CHAR): BOOLEAN;
      (* Returns TRUE if and only if ch is classified as a letter *)
    
    PROCEDURE IsUpper (ch: CHAR): BOOLEAN;
      (* Returns TRUE if and only if ch is classified as an upper case letter *)
    
    PROCEDURE IsLower (ch: CHAR): BOOLEAN;
      (* Returns TRUE if and only if ch is classified as a lower case letter *)
    
    PROCEDURE IsControl (ch: CHAR): BOOLEAN;
      (* Returns TRUE if and only if ch represents a control function *)
    
    PROCEDURE IsWhiteSpace (ch: CHAR): BOOLEAN;
      (* Returns TRUE if and only if ch represents a space character or a format effector *)
    
    END CharClass.
    
    ________________________________________________________________________
    

    Example 1: How to copy a text file

    
    ________________________________________________________________________
    
    TestCopy
    MODULE TestCopy;
    (* Copy a textfile with ISO-Modula-2 I/O-Library
       reading the in- and out-file specification
       as parameter from the command line.
    
    Example: The OpenVMS command
    
    $ run testcopy
    $_ x.lis y.lis
    
    copies file x.lis to file y.lis.
    When installed as a foreign command, the arguments
    can be specified in the command line:
    
    $ testcopy :== $dev:[dir]testcopy.exe
    $ testcopy x.lis y.lis
    
    Copyright (1993-1996) by Guenter Dotzel
    http://www.modulaware.com/
    
    GD/1993
    *)
    FROM ProgramArgs IMPORT IsArgPresent, ArgChan;
    FROM IOResult IMPORT ReadResults, ReadResult;  
    FROM SeqFile IMPORT OpenRead, OpenWrite, OpenResults,
      Close, ChanId, read, write;
    FROM TextIO IMPORT ReadRestLine, SkipLine, ReadToken,
      WriteLn, WriteString;
    IMPORT STextIO, SWholeIO;
    
    TYPE fnam= ARRAY [0..254] OF CHAR;
    VAR in,out: fnam;
      ores: OpenResults;
      input, output: ChanId;
      line: ARRAY[0..8191] OF CHAR;
      lines: INTEGER;
    
    PROCEDURE usage;
    BEGIN
      STextIO.WriteString("TestCopy usage: 'testcopy IN.EXT OUT.EXT'");
      STextIO.WriteLn;
    END usage;
    
    BEGIN
      lines:=0;
      IF IsArgPresent() THEN
        ReadToken(ArgChan(), in);
        IF IsArgPresent() THEN
          ReadToken(ArgChan(), out);
          OpenRead(input, in, read, ores); 
          IF ores=opened THEN
            OpenWrite(output, out, write, ores);
            IF ores=opened THEN
              ReadRestLine(input, line);
              WHILE ReadResult(input) <> endOfInput DO
                IF ReadResult(input) = allRight THEN 
                  WriteString(output, line); WriteLn(output);
                  INC(lines);
                ELSIF ReadResult(input) = endOfLine THEN
                  WriteLn(output);
                  INC(lines);
                ELSE
                  STextIO.WriteString("TestCopy error reading infile");
                  STextIO.WriteLn;
                  HALT;
                END;
                SkipLine(input); ReadRestLine(input, line);
              END;
              Close(input);
            ELSE
              STextIO.WriteString("TestCopy can't create outfile");
              STextIO.WriteLn;
            END;
            Close(output);
            STextIO.WriteString("TestCopy: endOfInput reached, lines copied=");
            SWholeIO.WriteInt(lines,0);
            STextIO.WriteLn;
          ELSE
            STextIO.WriteString("TestCopy can't open infile");
            STextIO.WriteLn;
          END;
        ELSE usage;
        END;
      ELSE usage;
      END;
    END TestCopy.
    ________________________________________________________________________
    

    Example 2: How to copy a text file with redirection

    
    ________________________________________________________________________
    
    TestSCopy
    MODULE TestSCopy;
    (* Same as TestCopy.mod, but copies a textfile
       via redirection using the ISO-Modula-2 I/O-Library
       StdChans.SetIn/OutChan
    
    Example: The OpenVMS command
    
    $ run testscopy
    $_ x.lis y.lis
    
    copies file x.lis to file y.lis.
    When installed as a foreign command, the arguments
    can be specified in the command line:
    
    $ testscopy :== $dev:[dir]testscopy.exe
    $ testscopy x.lis y.lis
    
    Copyright (1993-1996) by Guenter Dotzel
    http://www.modulaware.com/
    
    GD/22-Nov-1996
    *)
    FROM ProgramArgs IMPORT IsArgPresent, ArgChan;
    FROM SIOResult IMPORT ReadResults, ReadResult;  
    FROM SeqFile IMPORT OpenRead, OpenWrite, OpenResults,
      Close, ChanId, read, write;
    IMPORT STextIO, SWholeIO, SIOResult, StdChans;
    FROM STextIO IMPORT ReadRestLine, SkipLine, 
      ReadToken, WriteLn, WriteString;
    
    TYPE fnam= ARRAY [0..254] OF CHAR;
    VAR in,out: fnam;
      ores: OpenResults;
      input, output: ChanId;
      line: ARRAY[0..8191] OF CHAR;
      lines: INTEGER;
    
    PROCEDURE usage;
    BEGIN
      STextIO.WriteString("TestSCopy usage: 'testscopy IN.EXT OUT.EXT'");
      STextIO.WriteLn;
    END usage;
    
    BEGIN
      lines:=0;
      IF IsArgPresent() THEN
        StdChans.SetInChan(ArgChan());
        ReadToken(in);
        IF IsArgPresent() THEN
          ReadToken(out);
          OpenRead(input, in, read, ores); 
          IF ores=opened THEN
            OpenWrite(output, out, write-read, ores);
            StdChans.SetOutChan(output);
            IF ores=opened THEN
              StdChans.SetInChan(input);
              ReadRestLine(line);
              WHILE ReadResult() <> endOfInput DO
                IF ReadResult() = allRight THEN 
                  WriteString(line); WriteLn;
                  INC(lines);
                ELSIF ReadResult() = endOfLine THEN
                  WriteLn;
                  INC(lines);
                ELSE
                  StdChans.SetOutChan(StdChans.StdOutChan());
                  STextIO.WriteString("TestSCopy error reading infile");
                  STextIO.WriteLn;
                  HALT;
                END;
                SkipLine; ReadRestLine(line);
              END;
              Close(input);
            ELSE
              StdChans.SetOutChan(StdChans.StdOutChan());
              STextIO.WriteString("TestSCopy can't create outfile");
              STextIO.WriteLn;
            END;
            Close(output);
            StdChans.SetOutChan(StdChans.StdOutChan());
            STextIO.WriteString("TestSCopy: endOfInput reached, lines copied=");
            SWholeIO.WriteInt(lines,0);
            STextIO.WriteLn;
          ELSE
            StdChans.SetOutChan(StdChans.StdOutChan());
            STextIO.WriteString("TestSCopy can't open infile");
            STextIO.WriteLn;
          END;
        ELSE usage;
        END;
      ELSE usage;
      END;
    END TestSCopy.
    ________________________________________________________________________
    

    Example 3: Sequential write & read text and binary files:

    In addition to some ISO M2 Std Lib modules, module TestSeq imports three auxiliary, private modules GetConvTime, Measures and EXCEPTIONS. Their definitions are listed below. Note, the functionality of GetConvTime and Measures could not be provided by the ISO M2 Std Lib module SysClock, since Testseq evaluates not only the elapsed time but also the cpu-time and or other information also available from Measures.GetTimer.

    In MaX | MVR, Module EXCEPTIONS is not yet a pseudo module such as SYSTEM, (SYSTEM is a compiler known (built-in) module in ISO M2), although it's definition is compatible with ISO M2's EXCEPTIONS module.

    Module TestSeq is followed by the command trace for compilation, linking and image execution with the output listing that it generates. The timings are actual values measured on a (relatively slow) VAXStation3100/VMS as well as on an AXP/OpenVMS system. If the performance on the VAX looks poor to you, this is due to the slow machine used and is not an indicator for a poor library implementation. Actually, except for number-to-string conversions, MaX and MVR have identical source code. From the architectural viewpoint, ModulaWare's ISO M2 Std Lib is efficiently implemented (although all run-time checks are still enabled for subranges, enumerations, and array indices).

    
    ________________________________________________________________________
    
    GetConvTime
    DEFINITION MODULE GetConvTime;
    (* same as [mrkit]DateTime, but with Hundredths of a second.
    
    (C) 1992 Guenter Dotzel, http://www.modulaware.com
    *)
    
    IMPORT SYSTEM;
    
    TYPE TimeType= SYSTEM.QUADWORD;
    
    (*
     * Procedures Time and Date return the current time
     * in system format or as a string.
     *)
    
    PROCEDURE Time(
       VAR time:    TimeType
       );
    
    PROCEDURE Date(
       VAR date:    ARRAY OF CHAR
       );
    (*
     * The conversion procedures convert a time value from
     * system format to string and vice versa.
     *)
    
    PROCEDURE ConvertTime(
           time:    TimeType; 
       VAR date:    ARRAY OF CHAR
       );
    
    PROCEDURE ConvertDate(
           date:    ARRAY OF CHAR; 
       VAR time:    TimeType
       );
    (*
     * The following procedures return portions of a
     * time value in system format as a cardinal
     *)
    
    PROCEDURE Year(
           time:    TimeType
       ): CARDINAL;
    
    PROCEDURE Month(
           time:    TimeType
       ): CARDINAL;
    
    PROCEDURE Day(
           time:    TimeType
       ): CARDINAL;
    
    PROCEDURE Hours(
           time:    TimeType
       ): CARDINAL;
    
    PROCEDURE Minutes(
           time:    TimeType
       ): CARDINAL;
    
    PROCEDURE Seconds(
           time:    TimeType
       ): CARDINAL;
    
    PROCEDURE Hundredths(
           time:    TimeType
       ): CARDINAL;
    
    END GetConvTime.
    
    ________________________________________________________________________
    
    Measures
    DEFINITION MODULE Measures;  
    FROM DateTime IMPORT TimeType;
    
    PROCEDURE InitTimer;
    
    PROCEDURE FreeTimer;
    
    PROCEDURE GetTimer( 
       VAR elapsed:   TimeType;
       VAR cputime:   CARDINAL;
       VAR bufio:     CARDINAL;
       VAR dirio:     CARDINAL;
       VAR pagefault: CARDINAL );
    
    PROCEDURE ShowTimer;
    
    END Measures.
    
    ________________________________________________________________________
    
    EXCEPTIONS
    DEFINITION MODULE EXCEPTIONS;
    
    (* Provides facilities for raising user exceptions
       and for making enquiries concerning the current execution state.
    *)
    
    TYPE
      ExceptionSource;                (* values of this type are used within library modules to
                                         identify the source of raised exceptions
     *)
      ExceptionNumber = CARDINAL;
    
    PROCEDURE AllocateSource(VAR newSource: ExceptionSource);
      (* Allocates a unique value of type ExceptionSource *)
    
    PROCEDURE RAISE (source: ExceptionSource; number: ExceptionNumber; message: ARRAY OF CHAR);
      (* Associates the given values of source, number and message with the current context
         and raises an exception.
      *)
    
    PROCEDURE CurrentNumber (source: ExceptionSource): ExceptionNumber;
      (* If the current coroutine is in the exceptional execution state because of the raising
         of an exception from source, returns the corresponding number, and otherwise
         raises an exception.
      *)
    
    PROCEDURE GetMessage (VAR text: ARRAY OF CHAR);
      (* If the current coroutine is in the exceptional execution state, returns the possibly
         truncated string associated with the current context.
         Otherwise, in normal execution state, returns the empty string.
      *)
    
    PROCEDURE IsCurrentSource (source: ExceptionSource): BOOLEAN;
      (* If the current coroutine is in the exceptional execution state because of the raising
         of an exception from source, returns TRUE, and otherwise returns FALSE.
      *)
    
    PROCEDURE IsExceptionalExecution (): BOOLEAN;
      (* If the current coroutine is in the exceptional execution state because of the raising
         of an exception, returns TRUE, and otherwise returns FALSE.
      *)
    
    END EXCEPTIONS.
    
    ________________________________________________________________________
    
    TestSeq
    MODULE TestSeq;
    (*
      Test program for
      ISO 10154 Modula-2 Standard Library [Extension] of
    
      MaX|MVR V4 Modula-2 Compiler for AXP|VAX/OpenVMS
      Distribution Kit
    
    Copyright (1994) Guenter Dotzel, ModulaWare,
    http://www.modulaware.com/
    
    This software source code constitutes intellectual property rights of Guenter Dotzel, ModulaWare and is furnished under a Non-Disclosure Agreement and may only be used, processed and stored according to the terms and conditions of this agreement.

    All rights reserved.

    This is an extended performance test program written in Oberon-2 for the ISO Modula-2 Std I/O-Lib. TestSeq reads/writes whole data structures and single bytes from/to binary and text files and evaluates the individual data transfer speed in Bytes/Second (elapsed- and CPU-time). The actual timings when run on a VAX and AXP workstations are also provided below. when comparing the speed with other libs, note that run-time checks are still enabled in our ISO M2 Std library implementation. Also, the elapsed time is varying and depends heavily on the server activities.

    TestSeq creates two temporary files: BINA.LIS and TEXT.LIS which are truncated to zero size ad the end.

    An Oberon-2 version of TestSeq is also available on request.

    
    Written by Elmar Baumgart, 01-Sep-1992.
    Revised by GD/27-May-1994: 
     - variable parameters for check procedures,
     - upper limit increased for performance test (timer resolution is too low)
     - increased repeat count
    *)
    
    IMPORT IOResult, SeqFile, TextIO, SRealIO, SWholeIO, STextIO, RawIO,
      GetConvTime, Measures, SYSTEM;
    
    CONST
      Check = TRUE; (* enable/disable io read checks *)
    
      BigBlocks = 1;
      Blocks = 1;
      Bytes = 1;
    
      lenB = ((BigBlocks * 63 + Blocks) * 512 + Bytes);
      lenT = 8190;
    
    TYPE(*
      CARDINAL = LONGINT;
      INTEGER  = LONGINT;*)
      DataB = ARRAY [0..lenB-1] OF CHAR;
      DataT = ARRAY [0..lenT-1] OF CHAR;
    
    CONST
      bin = 'BINA.LIS';
      tex = 'TEXT.LIS';
    
      F = 8;
      RepeatI = F*17000; (* integers written binary *)
      RepeatB = F*2;     (* binary fields           *)
      RepeatT = F*8;     (* text fields             *)
                      (* approx. F*64K for each test*)
      SizeI = SYSTEM.TSIZE(INTEGER) * RepeatI;
      SizeB = SYSTEM.TSIZE(DataB) * RepeatB;
      SizeT = SYSTEM.TSIZE(DataT) * RepeatT;
    
    VAR
      f: SeqFile.ChanId; ores: SeqFile.OpenResults;
      i,j: INTEGER;
      ch, chRead: CHAR; eq: BOOLEAN;
    
      elapsed:   GetConvTime.TimeType;
      cputime:   CARDINAL;
      bufio:     CARDINAL;
      dirio:     CARDINAL;
      pagefault: CARDINAL;
    
      fieldB, lastB: DataB;
      fieldT, lastLine: DataT;
    
      PROCEDURE InitFields(VAR t: DataT; VAR b: DataB);
      VAR ch: CHAR; i: INTEGER;
      BEGIN
        FOR i:= 0 TO lenB-1 DO b[i]:= CHR(i MOD 256);
        END;
        ch:= ' ';
        FOR i:= 0 TO lenT-1 DO
          t[i]:= ch; ch:= CHR(ORD(ch) + 1);
          IF ch = CHR(255) THEN ch:= ' ';
          END;
        END;
      END InitFields;
    
      PROCEDURE IsCorrectB((**)VAR(**) a: DataB): BOOLEAN;
      VAR i: INTEGER; eq: BOOLEAN;
      BEGIN
        i:= 0;
        eq:= a[i] = CHR(i MOD 256);
        WHILE eq & (i < lenB-1) DO
          INC(i); eq:= a[i] = CHR(i MOD 256);
        END;
        RETURN eq;
      END IsCorrectB;
    
      PROCEDURE IsCorrectT((**)VAR(**)a: DataT): BOOLEAN;
      VAR ch: CHAR; i: INTEGER; eq: BOOLEAN;
      BEGIN
        ch:= ' '; i:= 0;
        eq:= a[i] = ch;
        WHILE eq & (i < lenT-1) DO
          INC(i); ch:= CHR(ORD(ch) + 1);
          IF ch = CHR(255) THEN ch:= ' ';
          END;
          eq:= a[i] = ch;
        END;
        RETURN eq;
      END IsCorrectT;
    
      PROCEDURE Float(i: INTEGER): REAL;
      BEGIN RETURN FLOAT(i);
      END Float;
      
      PROCEDURE Header;
      BEGIN (* '                    ' *)
        STextIO.WriteLn;
        STextIO.WriteLn;
        STextIO.WriteString('                    ');
        STextIO.WriteString('   Kbytes/sec  Kbytes/cpusec');
        STextIO.WriteLn;
        STextIO.WriteString('                    ');
        STextIO.WriteString('transfer rate  transfer rate  bufio  dirio  pagefaults');
        STextIO.WriteLn; STextIO.WriteLn;
      END Header;
    
      PROCEDURE InitTimer;
      VAR i: INTEGER;
      BEGIN Measures.InitTimer;
      END InitTimer;
    
      PROCEDURE Info(a: ARRAY OF CHAR; Size: CARDINAL);
      VAR t: CARDINAL;
      BEGIN (* cputime is in 10 ms units *)
        Measures.GetTimer(elapsed, cputime, bufio, dirio, pagefault);
        cputime := cputime*10; (* convert to 1 ms units *)
        t:= 10*GetConvTime.Hundredths(elapsed)+1000*GetConvTime.Seconds(elapsed)
          +60000*GetConvTime.Minutes(elapsed); (* t is in 1 ms units *)
    
        STextIO.WriteString(a); STextIO.WriteString('  ');
        IF t > 0 THEN
          SRealIO.WriteFixed(Float(Size)/Float(t), 0, 11);
        ELSE (* assume it took up-to 10 ms *)
          (* resolution of timer is not sufficient; avoid div by zero *)
          STextIO.WriteChar(">");
          SRealIO.WriteFixed(Float(Size), 0, 10);
        END;
        STextIO.WriteString('  ');
        IF cputime > 0 THEN 
          SRealIO.WriteFixed(Float(Size)/Float(cputime), 0, 13);
        ELSE (* assume it took up-to 10 ms *)
          STextIO.WriteChar(">"); (*div by zero*)
          SRealIO.WriteFixed(Float(Size), 0, 12);
        END;
        SWholeIO.WriteInt(bufio, 7);
        SWholeIO.WriteInt(dirio, 7);
        SWholeIO.WriteInt(pagefault,12);
        STextIO.WriteLn;
      END Info;
    
    BEGIN
      STextIO.WriteLn;
      STextIO.WriteString('test of SeqFile, binary and text'); STextIO.WriteLn;
      STextIO.WriteString('-init fields-'); STextIO.WriteLn;
    
      InitFields(fieldT, fieldB);
      Header;
      SeqFile.OpenWrite(f, tex, SeqFile.read + SeqFile.text, ores);
      IF ores = SeqFile.opened THEN
    
        InitTimer;
        FOR i:= 1 TO RepeatT DO
          TextIO.WriteString(f, fieldT); TextIO.WriteLn(f);
        END;
        Info('       writing text ', SizeT);
    
        SeqFile.Rewrite(f);
        InitTimer;
        FOR i:= 1 TO RepeatT DO
          TextIO.WriteString(f, fieldT); TextIO.WriteLn(f);
        END;
        Info('       writing text ', SizeT);
    
        SeqFile.Rewrite(f);
        InitTimer;
        FOR i:= 1 TO RepeatT DO
          FOR j:=0 TO lenT-1 DO
            TextIO.WriteChar(f, fieldT[j]);
          END;
          TextIO.WriteLn(f);
        END;
        Info('write text bytewise ', SizeT);
        STextIO.WriteLn;
    
        SeqFile.Reread(f);
        i:= 0;
        InitTimer;
        TextIO.ReadRestLine(f, fieldT);
        WHILE (IOResult.ReadResult(f) # IOResult.endOfInput) DO
          INC(i); TextIO.SkipLine(f);
          IF Check THEN lastLine:= fieldT;
          END;
          TextIO.ReadRestLine(f, fieldT);
        END;
        Info('       reading text ', SizeT);
        IF Check & (~ IsCorrectT(lastLine) OR (i # RepeatT)) THEN
          SWholeIO.WriteInt(i, 5); STextIO.WriteString(' lines read'); STextIO.WriteLn;
          STextIO.WriteString('TestSeq-err: read text failed'); HALT;
        END;
    
        SeqFile.Reread(f);
        i:=0; ch:= ' '; eq:= TRUE;
        InitTimer;
        TextIO.ReadChar(f, chRead);
        WHILE eq & (IOResult.ReadResult(f) # IOResult.endOfInput) DO
          IF (IOResult.ReadResult(f) = IOResult.endOfLine) THEN
            INC(i); TextIO.SkipLine(f); ch:= CHR(254);
          ELSE
            eq:= ch = chRead;
          END;
          ch:= CHR(ORD(ch) + 1);
          IF ch = CHR(255) THEN ch:= ' ';
          END;
          TextIO.ReadChar(f, chRead);
        END;
        Info(' read text bytewise ', SizeT);
        IF Check & (~ eq OR (i # RepeatT)) THEN
          SWholeIO.WriteInt(i, 5); STextIO.WriteString(' lines read'); STextIO.WriteLn;
          STextIO.WriteString('TestSeq-err: read text failed'); HALT;
        END;
        STextIO.WriteLn;
    
        SeqFile.Rewrite(f); (* dealloc disk space *)
        SeqFile.Close(f);
      ELSE STextIO.WriteString('TestSeq-err: OPENWRITE text failed'); HALT;
      END;
    
      SeqFile.OpenWrite(f, bin, SeqFile.read + SeqFile.raw, ores);
      IF ores = SeqFile.opened THEN
    
        InitTimer;
        FOR i:= 1 TO RepeatB DO
          RawIO.Write(f, fieldB);
        END;
        Info('     writing binary ', SizeB);
    
        SeqFile.Rewrite(f);
        InitTimer;
        FOR i:= 1 TO RepeatB DO
          RawIO.Write(f, fieldB);
        END;
        Info('     writing binary ', SizeB);
    
        SeqFile.Rewrite(f);
        InitTimer;
        FOR i:= 1 TO RepeatB DO
          FOR j:=0 TO lenB-1 DO
            RawIO.Write(f, fieldB[j]);
          END;
        END;
        Info(' write bin bytewise ', SizeB);
        STextIO.WriteLn;
    
        SeqFile.Reread(f);
        i:= 0;
        InitTimer;
        RawIO.Read(f, fieldB);
        WHILE (IOResult.ReadResult(f) # IOResult.endOfInput) DO
          INC(i); 
          IF Check THEN lastB:= fieldB;
          END;
          RawIO.Read(f, fieldB);
        END;
        Info('     reading binary ', SizeB);
        IF Check & (~ IsCorrectB(lastB) OR (i # RepeatB)) THEN
          STextIO.WriteString('TestSeq-err: read binary failed'); HALT;
        END;
    
        SeqFile.Reread(f);
        i:=0; eq:= TRUE;
        RawIO.Read(f, chRead);
        InitTimer;
        WHILE eq & (IOResult.ReadResult(f) # IOResult.endOfInput) DO
          eq:= chRead = CHR(i MOD 256);
          RawIO.Read(f, chRead);
          i:= (i + 1) MOD lenB;   (* must be 0 on eof *)
        END;
        Info('  read bin bytewise ', SizeB);
        IF Check & (~ eq OR (i # 0)) THEN
          STextIO.WriteString('TestSeq-err: read binary failed'); HALT;
        END;
    
        SeqFile.Rewrite(f);
        InitTimer;
        FOR i:= 1 TO RepeatI DO RawIO.Write(f, i);
        END;
        STextIO.WriteLn;
        Info(' write bin integers ', SizeI);
    
        SeqFile.Reread(f);
        i:= 1;
        RawIO.Read(f, j);
        WHILE (IOResult.ReadResult(f) # IOResult.endOfInput) DO
          IF Check & (i # j) THEN
            STextIO.WriteString('TestSeq-err: read binary integers failed'); HALT;
          END;
          RawIO.Read(f, i); INC(j);
        END;
        Info('  read bin integers ', SizeI);
    
        SeqFile.Rewrite(f);
        SeqFile.Close(f);
      ELSE STextIO.WriteString('TestSeq-err: OPENWRITE binary failed'); HALT;
      END;
    END TestSeq.
    
    ________________________________________________________________________
    $mod testseq/iso=4
    VMS ISO-Modula-2 MVR V4.05d(C)1994 by ModulaWare GmbH, D-91054 Erlangen/FRG
     compiling _PSLAVE$DKA0:[EDISON.ISO]TESTSEQ.MOD;20/DEBUG/NORELATIONAL/ISO=4/NAME_SEPA
    RATOR='.'
    Syntax analysis
     IOResult: _PSLAVE$DKA0:[EDISON.ISO]IORESULT.SYM;8
     SeqFile: _PSLAVE$DKA0:[EDISON.ISO]SEQFILE.SYM;9
     TextIO: _PSLAVE$DKA0:[EDISON.ISO]TEXTIO.SYM;8
     SRealIO: _PSLAVE$DKA0:[EDISON.ISO]SREALIO.SYM;8
     SWholeIO: _PSLAVE$DKA0:[EDISON.ISO]SWHOLEIO.SYM;8
     STextIO: _PSLAVE$DKA0:[EDISON.ISO]STEXTIO.SYM;8
     RawIO: _PSLAVE$DKA0:[EDISON.ISO]RAWIO.SYM;9
     GetConvTime: _PSLAVE$DKA0:[MVR3_20]GETCONVTIME.SYM;5
     Measures: _PSLAVE$DKA0:[MVR3_20]MEASURES.SYM;6
     EXCEPTIONS: _PSLAVE$DKA0:[EDISON.ISO]EXCEPTIONS.SYM;6
    Declaration analysis
    Body analysis
    Code generation
    End of compilation, source file: _PSLAVE$DKA0:[EDISON.ISO]TESTSEQ.MOD;20
    $ link testseq,io/lib
    $ run 
    
    test of SeqFile, binary and text
    -init fields-
    
                           Kbytes/sec  Kbytes/cpusec
                        transfer rate  transfer rate  bufio  dirio  pagefaults
    
           writing text           55.           406.     32    301          15
           writing text          148.           738.      0     64           0
    write text bytewise           10.            10.      0     64           0
    
           reading text          107.           214.      0     64          15
     read text bytewise            7.             7.      0     64           0
    
         writing binary           80.           783.      9    211          48
         writing binary          186.          1808.      0     32           0
     write bin bytewise            7.             9.      0   1024           0
    
         reading binary          215.          2017.      0     33          63
      read bin bytewise            5.             5.      0   1024           0
    
     write bin integers           15.            27.      2   1062           0
      read bin integers            8.            11.     13   2127           0
    
    The above measurement was done on VAX/VMS V5.4 (VAXstation 3100/30). The below measurment was done on AXP/OpenVMS V1.5H1 (DEC 3000-300LX/125 MHz). Both compilations were with run-time array index checks enabled.
    
    test of SeqFile, binary and text
    -init fields-
    
                           Kbytes/sec  Kbytes/cpusec
                        transfer rate  transfer rate  bufio  dirio  pagefaults
    
           writing text          173.          1638.     32    151           0
           writing text          472.          4765.      0     64           0
    write text bytewise           93.           123.      0     64           0
    
           reading text         1028.          1542.      0      1           0
     read text bytewise           60.            61.      0      0           0
    
         writing binary          324.          6554.      9     76           3
         writing binary          718.         13108.      0     32           0
     write bin bytewise           23.            52.      0   1024           0
    
         reading binary         8738.          7490.      0      1           3
      read bin bytewise           35.            36.      0      0           0
    
     write bin integers           45.           151.      2   1062           0
      read bin integers           32.            68.     13   1065           0
    $
    ________________________________________________________________________
    

    Strings Library


    Strings DEFINITION MODULE Strings; (* Facilities for manipulating strings *) TYPE String1 = ARRAY [0..0] OF CHAR; (* String1 is provided for constructing a value of a single-character string type from a single character value in order to pass CHAR values to ARRAY OF CHAR parameters. *) PROCEDURE Length (stringVal: ARRAY OF CHAR): CARDINAL; (* Returns the length of stringVal (the same value as would be returned by the pervasive function LENGTH). *) (* The following seven procedures construct a string value, and attempt to assign it to a variable parameter. They all have the property that if the length of the constructed string value exceeds the capacity of the variable parameter, a truncated value is assigned, while if the length of the constructed string value is less than the capacity of the variable parameter, a string terminator is appended before assignment is performed. *) PROCEDURE Assign (source: ARRAY OF CHAR; VAR destination: ARRAY OF CHAR); (* Copies source to destination *) PROCEDURE Extract (source: ARRAY OF CHAR; startIndex, numberToExtract: CARDINAL; VAR destination: ARRAY OF CHAR); (* Copies at most numberToExtract characters from source to destination, starting at position startIndex in source. *) PROCEDURE Delete (VAR stringVar: ARRAY OF CHAR; startIndex, numberToDelete: CARDINAL); (* Deletes at most numberToDelete characters from stringVar, starting at position startIndex. *) PROCEDURE Insert (source: ARRAY OF CHAR; startIndex: CARDINAL; VAR destination: ARRAY OF CHAR); (* Inserts source into destination at position startIndex *) PROCEDURE Replace (source: ARRAY OF CHAR; startIndex: CARDINAL; VAR destination: ARRAY OF CHAR); (* Copies source into destination, starting at position startIndex. Copying stops when all of source has been copied, or when the last character of the string value in destination has been replaced. *) PROCEDURE Append (source: ARRAY OF CHAR; VAR destination: ARRAY OF CHAR); (* Appends source to destination. *) PROCEDURE Concat (source1, source2: ARRAY OF CHAR; VAR destination: ARRAY OF CHAR); (* Concatenates source2 onto source1 and copies the result into destination. *) (* The following predicates provide for pre-testing of the operation-completion conditions for the procedures above. *) PROCEDURE CanAssignAll (sourceLength: CARDINAL; VAR destination: ARRAY OF CHAR): BOOLEAN; (* Returns TRUE if a number of characters, indicated by sourceLength, will fit into destination; otherwise returns FALSE. *) PROCEDURE CanExtractAll (sourceLength, startIndex, numberToExtract: CARDINAL; VAR destination: ARRAY OF CHAR): BOOLEAN; (* Returns TRUE if there are numberToExtract characters starting at startIndex and within the sourceLength of some string, and if the capacity of destination is sufficient to hold numberToExtract characters; otherwise returns FALSE. *) PROCEDURE CanDeleteAll (stringLength, startIndex, numberToDelete: CARDINAL): BOOLEAN; (* Returns TRUE if there are numberToDelete characters starting at startIndex and within the stringLength of some string; otherwise returns FALSE. *) PROCEDURE CanInsertAll (sourceLength, startIndex: CARDINAL; VAR destination: ARRAY OF CHAR): BOOLEAN; (* Returns TRUE if there is room for the insertion of sourceLength characters from some string into destination starting at startIndex; otherwise returns FALSE. *) PROCEDURE CanReplaceAll (sourceLength, startIndex: CARDINAL; VAR destination: ARRAY OF CHAR): BOOLEAN; (* Returns TRUE if there is room for the replacement of sourceLength characters in destination starting at startIndex; otherwise returns FALSE. *) PROCEDURE CanAppendAll (sourceLength: CARDINAL; VAR destination: ARRAY OF CHAR): BOOLEAN; (* Returns TRUE if there is sufficient room in destination to append a string of length sourceLength to the string in destination; otherwise returns FALSE. *) PROCEDURE CanConcatAll (source1Length, source2Length: CARDINAL; VAR destination: ARRAY OF CHAR): BOOLEAN; (* Returns TRUE if there is sufficient room in destination for a two strings of lengths source1Length and source2Length; otherwise returns FALSE. *) (* The following type and procedures provide for the comparison of string values, and for the location of substrings within strings. *) TYPE CompareResults = (less, equal, greater); PROCEDURE Compare (stringVal1, stringVal2: ARRAY OF CHAR): CompareResults; (* Returns less, equal, or greater, according as stringVal1 is lexically less than, equal to, or greater than stringVal2. *) PROCEDURE Equal (stringVal1, stringVal2: ARRAY OF CHAR): BOOLEAN; (* Returns Strings.Compare(stringVal1, stringVal2) = Strings.equal *) PROCEDURE FindNext (pattern, stringToSearch: ARRAY OF CHAR; startIndex: CARDINAL; VAR patternFound: BOOLEAN; VAR posOfPattern: CARDINAL); (* Looks forward for next occurrence of pattern in stringToSearch, starting the search at position startIndex. If startIndex < LENGTH(stringToSearch) and pattern is found, patternFound is returned as TRUE, and posOfPattern contains the start position in stringToSearch of pattern. Otherwise patternFound is returned as FALSE, and posOfPattern is unchanged. *) PROCEDURE FindPrev (pattern, stringToSearch: ARRAY OF CHAR; startIndex: CARDINAL; VAR patternFound: BOOLEAN; VAR posOfPattern: CARDINAL); (* Looks backward for the previous occurrence of pattern in stringToSearch and returns the position of the first character of the pattern if found. The search for the pattern begins at startIndex. If pattern is found, patternFound is returned as TRUE, and posOfPattern contains the start position in stringToSearch of pattern in the range [0..startIndex]. Otherwise patternFound is returned as FALSE, and posOfPattern is unchanged. *) PROCEDURE FindDiff (stringVal1, stringVal2: ARRAY OF CHAR; VAR differenceFound: BOOLEAN; VAR posOfDifference: CARDINAL); (* Compares the string values in stringVal1 and stringVal2 for differences. If they are equal, differenceFound is returned as FALSE, and TRUE otherwise. If differenceFound is TRUE, posOfDifference is set to the position of the first difference; otherwise posOfDifference is unchanged. *) PROCEDURE Capitalize (VAR stringVar: ARRAY OF CHAR); (* Applies the function CAP to each character of the string value in stringVar. *) END Strings. ________________________________________________________________________

    Storage Library

    ________________________________________________________________________ Storage DEFINITION MODULE Storage; (* Facilities for dynamically allocating and deallocating storage *) IMPORT SYSTEM; PROCEDURE ALLOCATE (VAR addr: SYSTEM.ADDRESS; amount: CARDINAL); (* Allocates storage for a variable of size amount and assigns the address of this variable to addr. If there is insufficient unallocated storage to do this, the value NIL is assigned to addr. *) PROCEDURE DEALLOCATE (VAR addr: SYSTEM.ADDRESS; amount: CARDINAL); (* Deallocates amount locations allocated by ALLOCATE for the storage of the variable addressed by addr and assigns the value NIL to addr. *) TYPE StorageExceptions = ( nilDeallocation, (* first argument to DEALLOCATE is NIL *) pointerToUnallocatedStorage, (* storage to deallocate not allocated by ALLOCATE *) wrongStorageToUnallocate (* amount to deallocate is not amount allocated *) ); PROCEDURE IsStorageException (): BOOLEAN; (* Returns TRUE if the current coroutine is in the exceptional execution state because of the raising of an exception from StorageExceptions; otherwise returns FALSE. *) PROCEDURE StorageException (): StorageExceptions; (* If the current coroutine is in the exceptional execution state because of the raising of an exception from StorageExceptions, returns the corresponding enumeration value, and otherwise raises an exception. *) END Storage. ________________________________________________________________________

    Mathematical Library

    ________________________________________________________________________ RealMath DEFINITION MODULE RealMath; (* Mathematical functions for the type REAL *) CONST pi = 3.1415926535897932384626433832795028841972; exp1 = 2.7182818284590452353602874713526624977572; PROCEDURE sqrt (x: REAL): REAL; (* Returns the positive square root of x *) PROCEDURE exp (x: REAL): REAL; (* Returns the exponential of x *) PROCEDURE ln (x: REAL): REAL; (* Returns the natural logarithm of x *) (* The angle in all trigonometric functions is measured in radians *) PROCEDURE sin (x: REAL): REAL; (* Returns the sine of x *) PROCEDURE cos (x: REAL): REAL; (* Returns the cosine of x *) PROCEDURE tan (x: REAL): REAL; (* Returns the tangent of x *) PROCEDURE arcsin (x: REAL): REAL; (* Returns the arcsine of x *) PROCEDURE arccos (x: REAL): REAL; (* Returns the arccosine of x *) PROCEDURE arctan (x: REAL): REAL; (* Returns the arctangent of x *) PROCEDURE power (base, exponent: REAL): REAL; (* Returns the value of the number base raised to the power exponent *) PROCEDURE round (x: REAL): INTEGER; (* Returns the value of x rounded to the nearest integer *) PROCEDURE IsRMathException (): BOOLEAN; (* Returns TRUE if the current coroutine is in the exceptional execution state because of the raising of an exception in a routine from this module; otherwise returns FALSE. *) (* not yet impl. on MVR | MAX *) END RealMath. ________________________________________________________________________ LongMath DEFINITION MODULE LongMath; (* Mathematical functions for the type LONGREAL *) CONST pi = 3.1415926535897932384626433832795028841972; exp1 = 2.7182818284590452353602874713526624977572; PROCEDURE sqrt (x: LONGREAL): LONGREAL; (* Returns the positive square root of x *) PROCEDURE exp (x: LONGREAL): LONGREAL; (* Returns the exponential of x *) PROCEDURE ln (x: LONGREAL): LONGREAL; (* Returns the natural logarithm of x *) (* The angle in all trigonometric functions is measured in radians *) PROCEDURE sin (x: LONGREAL): LONGREAL; (* Returns the sine of x *) PROCEDURE cos (x: LONGREAL): LONGREAL; (* Returns the cosine of x *) PROCEDURE tan (x: LONGREAL): LONGREAL; (* Returns the tangent of x *) PROCEDURE arcsin (x: LONGREAL): LONGREAL; (* Returns the arcsine of x *) PROCEDURE arccos (x: LONGREAL): LONGREAL; (* Returns the arccosine of x *) PROCEDURE arctan (x: LONGREAL): LONGREAL; (* Returns the arctangent of x *) PROCEDURE power (base, exponent: LONGREAL): LONGREAL; (* Returns the value of the number base raised to the power exponent *) PROCEDURE round (x: LONGREAL): INTEGER; (* Returns the value of x rounded to the nearest integer *) PROCEDURE IsRMathException (): BOOLEAN; (* Returns TRUE if the current coroutine is in the exceptional execution state because of the raising of an exception in a routine from this module; otherwise returns FALSE. *) (* not yet impl. on MVR | MAX *) END LongMath. ________________________________________________________________________ LongGMath DEFINITION MODULE LongGMath; (* ISO Modula-2 Standard Library extension, (AXP | VAX) / OpenVMS implementation Based on LongMath (C) 1994 by ModulaWare GmbH, CS/09-Mar-1994 *) IMPORT SYSTEM; TYPE LONGREAL = SYSTEM.G_FLOATING; CONST pi = VAL(LONGREAL, 3.1415926535897932384626433832795028841972); exp1 = VAL(LONGREAL, 2.7182818284590452353602874713526624977572); PROCEDURE sqrt (x: LONGREAL): LONGREAL; (* Returns the positive square root of x *) PROCEDURE exp (x: LONGREAL): LONGREAL; (* Returns the exponential of x *) PROCEDURE ln (x: LONGREAL): LONGREAL; (* Returns the natural logarithm of x *) (* The angle in all trigonometric functions is measured in radians *) PROCEDURE sin (x: LONGREAL): LONGREAL; (* Returns the sine of x *) PROCEDURE cos (x: LONGREAL): LONGREAL; (* Returns the cosine of x *) PROCEDURE tan (x: LONGREAL): LONGREAL; (* Returns the tangent of x *) PROCEDURE arcsin (x: LONGREAL): LONGREAL; (* Returns the arcsine of x *) PROCEDURE arccos (x: LONGREAL): LONGREAL; (* Returns the arccosine of x *) PROCEDURE arctan (x: LONGREAL): LONGREAL; (* Returns the arctangent of x *) PROCEDURE power (base, exponent: LONGREAL): LONGREAL; (* Returns the value of the number base raised to the power exponent *) PROCEDURE round (x: LONGREAL): INTEGER; (* Returns the value of x rounded to the nearest integer *) PROCEDURE IsRMathException (): BOOLEAN; (* not yet impl. on MVR | MAX *) (* Returns TRUE if the current coroutine is in the exceptional execution state because of the raising of an exception in a routine from this module; otherwise returns FALSE. *) END LongGMath. ________________________________________________________________________

    Complex Library

    ________________________________________________________________________ ComplexMath DEFINITION MODULE ComplexMath; (* Mathematical functions for the type COMPLEX *) CONST i = CMPLX (0.0, 1.0); one = CMPLX (1.0, 0.0); zero = CMPLX (0.0, 0.0); PROCEDURE abs (z: COMPLEX): REAL; (* Returns the length of z *) PROCEDURE arg (z: COMPLEX): REAL; (* Returns the angle that z subtends to the positive real axis *) PROCEDURE conj (z: COMPLEX): COMPLEX; (* Returns the complex conjugate of z *) PROCEDURE power (base: COMPLEX; exponent: REAL): COMPLEX; (* Returns the value of the number base raised to the power exponent *) PROCEDURE sqrt (z: COMPLEX): COMPLEX; (* Returns the principal square root of z *) PROCEDURE exp (z: COMPLEX): COMPLEX; (* Returns the complex exponential of z *) PROCEDURE ln (z: COMPLEX): COMPLEX; (* Returns the principal value of the natural logarithm of z *) PROCEDURE sin (z: COMPLEX): COMPLEX; (* Returns the sine of z *) PROCEDURE cos (z: COMPLEX): COMPLEX; (* Returns the cosine of z *) PROCEDURE tan (z: COMPLEX): COMPLEX; (* Returns the tangent of z *) PROCEDURE arcsin (z: COMPLEX): COMPLEX; (* Returns the arcsine of z *) PROCEDURE arccos (z: COMPLEX): COMPLEX; (* Returns the arccosine of z *) PROCEDURE arctan (z: COMPLEX): COMPLEX; (* Returns the arctangent of z *) PROCEDURE polarToComplex (abs, arg: REAL): COMPLEX; (* Returns the complex number with the specified polar coordinates *) PROCEDURE scalarMult (scalar: REAL; z: COMPLEX): COMPLEX; (* Returns the scalar product of scalar with z *) PROCEDURE IsCMathException (): BOOLEAN; (* Returns TRUE if the current coroutine is in the exceptional execution state because of the raising of an exception in a routine from this module; otherwise returns FALSE. *) (* not yet impl. on MVR | MAX *) END ComplexMath. ________________________________________________________________________ LongComplexMath DEFINITION MODULE LongComplexMath; (* Mathematical functions for the type LONGCOMPLEX *) CONST i = CMPLX (0.0, 1.0); one = CMPLX (1.0, 0.0); zero = CMPLX (0.0, 0.0); PROCEDURE abs (z: LONGCOMPLEX): LONGREAL; (* Returns the length of z *) PROCEDURE arg (z: LONGCOMPLEX): LONGREAL; (* Returns the angle that z subtends to the positive real axis *) PROCEDURE conj (z: LONGCOMPLEX): LONGCOMPLEX; (* Returns the complex conjugate of z *) PROCEDURE power (base: LONGCOMPLEX; exponent: LONGREAL): LONGCOMPLEX; (* Returns the value of the number base raised to the power exponent *) PROCEDURE sqrt (z: LONGCOMPLEX): LONGCOMPLEX; (* Returns the principal square root of z *) PROCEDURE exp (z: LONGCOMPLEX): LONGCOMPLEX; (* Returns the complex exponential of z *) PROCEDURE ln (z: LONGCOMPLEX): LONGCOMPLEX; (* Returns the principal value of the natural logarithm of z *) PROCEDURE sin (z: LONGCOMPLEX): LONGCOMPLEX; (* Returns the sine of z *) PROCEDURE cos (z: LONGCOMPLEX): LONGCOMPLEX; (* Returns the cosine of z *) PROCEDURE tan (z: LONGCOMPLEX): LONGCOMPLEX; (* Returns the tangent of z *) PROCEDURE arcsin (z: LONGCOMPLEX): LONGCOMPLEX; (* Returns the arcsine of z *) PROCEDURE arccos (z: LONGCOMPLEX): LONGCOMPLEX; (* Returns the arccosine of z *) PROCEDURE arctan (z: LONGCOMPLEX): LONGCOMPLEX; (* Returns the arctangent of z *) PROCEDURE polarToComplex (abs, arg: LONGREAL): LONGCOMPLEX; (* Returns the complex number with the specified polar coordinates *) PROCEDURE scalarMult (scalar: LONGREAL; z: LONGCOMPLEX): LONGCOMPLEX; (* Returns the scalar product of scalar with z *) PROCEDURE IsCMathException (): BOOLEAN; (* Returns TRUE if the current coroutine is in the exceptional execution state because of the raising of an exception in a routine from this module; otherwise returns FALSE. *) (* not yet impl. on MVR | MAX *) END LongComplexMath. ________________________________________________________________________ LongComplexGMath DEFINITION MODULE LongComplexGMath; (* ISO Modula-2 Standard Library extension, (AXP | VAX) / OpenVMS implementation Based on LongComplexMath (C) 1994 by ModulaWare GmbH, CS/30-May-1994 *) IMPORT SYSTEM; TYPE LONGREAL = SYSTEM.G_FLOATING; LONGCOMPLEX = SYSTEM.G_COMPLEX; VAR i, one, zero: LONGCOMPLEX; (* read only *) PROCEDURE abs (z: LONGCOMPLEX): LONGREAL; (* Returns the length of z *) PROCEDURE arg (z: LONGCOMPLEX): LONGREAL; (* Returns the angle that z subtends to the positive real axis *) PROCEDURE conj (z: LONGCOMPLEX): LONGCOMPLEX; (* Returns the complex conjugate of z *) PROCEDURE power (base: LONGCOMPLEX; exponent: LONGREAL): LONGCOMPLEX; (* Returns the value of the number base raised to the power exponent *) PROCEDURE sqrt (z: LONGCOMPLEX): LONGCOMPLEX; (* Returns the principal square root of z *) PROCEDURE exp (z: LONGCOMPLEX): LONGCOMPLEX; (* Returns the complex exponential of z *) PROCEDURE ln (z: LONGCOMPLEX): LONGCOMPLEX; (* Returns the principal value of the natural logarithm of z *) PROCEDURE sin (z: LONGCOMPLEX): LONGCOMPLEX; (* Returns the sine of z *) PROCEDURE cos (z: LONGCOMPLEX): LONGCOMPLEX; (* Returns the cosine of z *) PROCEDURE tan (z: LONGCOMPLEX): LONGCOMPLEX; (* Returns the tangent of z *) PROCEDURE arcsin (z: LONGCOMPLEX): LONGCOMPLEX; (* Returns the arcsine of z *) PROCEDURE arccos (z: LONGCOMPLEX): LONGCOMPLEX; (* Returns the arccosine of z *) PROCEDURE arctan (z: LONGCOMPLEX): LONGCOMPLEX; (* Returns the arctangent of z *) PROCEDURE polarToComplex (abs, arg: LONGREAL): LONGCOMPLEX; (* Returns the complex number with the specified polar coordinates *) PROCEDURE scalarMult (scalar: LONGREAL; z: LONGCOMPLEX): LONGCOMPLEX; (* Returns the scalar product of scalar with z *) PROCEDURE IsCMathException (): BOOLEAN; (* Returns TRUE if the current coroutine is in the exceptional execution state because of the raising of an exception in a routine from this module; otherwise returns FALSE. *) (* not yet impl. on MVR | MAX *) END LongComplexGMath. ________________________________________________________________________

    Low-level Real-number Representation Support

    ________________________________________________________________________ LowReal DEFINITION MODULE LowReal; (* Access to underlying properties of the type REAL *) CONST radix = 2; places = 23; expoMin = -127; expoMax = 127; large = MAX(REAL); small = 2.938736E-39; IEEE = FALSE; ISO = FALSE; rounds = FALSE; gUnderflow = FALSE; exception = FALSE; extend = FALSE; nModes = 1; TYPE Modes = SET OF [0 .. nModes-1]; PROCEDURE exponent (x: REAL): INTEGER; (* Returns the exponent value of x *) PROCEDURE fraction (x: REAL): REAL; (* Returns the significand (or significant part) of x *) PROCEDURE sign (x: REAL): REAL; (* Returns the signum of x *) PROCEDURE succ (x: REAL): REAL; (* Returns the next value of the type REAL greater than x *) PROCEDURE ulp (x: REAL): REAL; (* Returns the value of a unit in the last place of x *) PROCEDURE pred (x: REAL): REAL; (* Returns the previous value of the type REAL less than x *) PROCEDURE intpart (x: REAL): REAL; (* Returns the integer part of x *) PROCEDURE fractpart (x: REAL): REAL; (* Returns the fractional part of x *) PROCEDURE scale (x: REAL; n: INTEGER): REAL; (* Returns the value of x * radix ** n *) PROCEDURE trunc (x: REAL; n: INTEGER): REAL; (* Returns the value of the first n places of x *) PROCEDURE round (x: REAL; n: INTEGER): REAL; (* Returns the value of x rounded to the first n places *) PROCEDURE synthesize (expart: INTEGER; frapart: REAL): REAL; (* Returns a value of the type REAL constructed from the given expart and frapart *) PROCEDURE setMode (m: Modes); (* not yet impl. on MVR | MAX *) (* Sets status flags appropriate to the underlying implementation of the type REAL *) PROCEDURE currentMode (): Modes; (* not yet impl. on MVR | MAX *) (* Returns the current status flags in the form set by setMode *) PROCEDURE IsLowException (): BOOLEAN; (* not yet impl. on MVR | MAX *) (* Returns TRUE if the current coroutine is in the exceptional execution state because of the raising of an exception in a routine from this module; otherwise returns FALSE. *) END LowReal. ________________________________________________________________________ LowLong DEFINITION MODULE LowLong; (* Access to underlying properties of the type LONGREAL *) CONST radix = 2; places = 23 + 32; expoMin = -127; expoMax = 127; large = MAX (LONGREAL); small = 2.93873587705571878E-39; (*temporary for MVR, adjusted for MVR scanner to produce exactly 000000000000080H *) IEEE = FALSE; ISO = FALSE; rounds = FALSE; gUnderflow = FALSE; exception = FALSE; extend = FALSE; nModes = 1; TYPE Modes = SET OF [0 .. nModes-1]; PROCEDURE exponent (x: LONGREAL): INTEGER; (* Returns the exponent value of x *) PROCEDURE fraction (x: LONGREAL): LONGREAL; (* Returns the significand (or significant part) of x *) PROCEDURE sign (x: LONGREAL): LONGREAL; (* Returns the signum of x *) PROCEDURE succ (x: LONGREAL): LONGREAL; (* Returns the next value of the type LONGREAL greater than x *) PROCEDURE ulp (x: LONGREAL): LONGREAL; (* Returns the value of a unit in the last place of x *) PROCEDURE pred (x: LONGREAL): LONGREAL; (* Returns the previous value of the type LONGREAL less than x *) PROCEDURE intpart (x: LONGREAL): LONGREAL; (* Returns the integer part of x *) PROCEDURE fractpart (x: LONGREAL): LONGREAL; (* Returns the fractional part of x *) PROCEDURE scale (x: LONGREAL; n: INTEGER): LONGREAL; (* Returns the value of x * radix ** n *) PROCEDURE trunc (x: LONGREAL; n: INTEGER): LONGREAL; (* Returns the value of the first n places of x *) PROCEDURE round (x: LONGREAL; n: INTEGER): LONGREAL; (* Returns the value of x rounded to the first n places *) PROCEDURE synthesize (expart: INTEGER; frapart: LONGREAL): LONGREAL; (* Returns a value of the type LONGREAL constructed from the given expart and frapart *) PROCEDURE setMode (m: Modes); (* not yet impl. on MVR | MAX *) (* Sets status flags appropriate to the underlying implementation of the type LONGREAL *) PROCEDURE currentMode (): Modes; (* not yet impl. on MVR | MAX *) (* Returns the current status flags in the form set by setMode *) PROCEDURE IsLowException (): BOOLEAN; (* not yet impl. on MVR | MAX *) (* Returns TRUE if the current coroutine is in the exceptional execution state because of the raising of an exception in a routine from this module; otherwise returns FALSE. *) END LowLong. ________________________________________________________________________ LowLongG DEFINITION MODULE LowLongG; (* ISO Modula-2 Standard Library extension, (AXP | VAX) / OpenVMS implementation Based on LowLong (C) 1994 by ModulaWare GmbH, CS/16-Mar-1994 *) IMPORT SYSTEM; TYPE LONGREAL = SYSTEM.G_FLOATING; CONST radix = 2; places = 20 + 32; expoMin = -1023; expoMax = 1023; large = MAX (LONGREAL); (*small = VAL(LONGREAL,5.562684646268003E-309); (*= CAST(LONGREAL,0000000000000010H)*) *) (*temporary adjusted for MVR scanner to produce exactly the above pattern: *) n = VAL(LONGREAL,1.0E-30); (* n is for internal use only *) small = VAL(LONGREAL,5.562684646267999)* n*n*n*n*n*n*n*n*n*n *VAL(LONGREAL,1.0E-9); IEEE = FALSE; ISO = FALSE; rounds = FALSE; gUnderflow = FALSE; exception = FALSE; extend = FALSE; nModes = 1; TYPE Modes = SET OF [0 .. nModes-1]; PROCEDURE exponent (x: LONGREAL): INTEGER; (* Returns the exponent value of x *) PROCEDURE fraction (x: LONGREAL): LONGREAL; (* Returns the significand (or significant part) of x *) PROCEDURE sign (x: LONGREAL): LONGREAL; (* Returns the signum of x *) PROCEDURE succ (x: LONGREAL): LONGREAL; (* Returns the next value of the type LONGREAL greater than x *) PROCEDURE ulp (x: LONGREAL): LONGREAL; (* Returns the value of a unit in the last place of x *) PROCEDURE pred (x: LONGREAL): LONGREAL; (* Returns the previous value of the type LONGREAL less than x *) PROCEDURE intpart (x: LONGREAL): LONGREAL; (* Returns the integer part of x *) PROCEDURE fractpart (x: LONGREAL): LONGREAL; (* Returns the fractional part of x *) PROCEDURE scale (x: LONGREAL; n: INTEGER): LONGREAL; (* Returns the value of x * radix ** n *) PROCEDURE trunc (x: LONGREAL; n: INTEGER): LONGREAL; (* Returns the value of the first n places of x *) PROCEDURE round (x: LONGREAL; n: INTEGER): LONGREAL; (* Returns the value of x rounded to the first n places *) PROCEDURE synthesize (expart: INTEGER; frapart: LONGREAL): LONGREAL; (* Returns a value of the type LONGREAL constructed from the given expart and frapart *) PROCEDURE setMode (m: Modes); (* not yet impl. on MVR | MAX *) (* Sets status flags appropriate to the underlying implementation of the type LONGREAL *) PROCEDURE currentMode (): Modes; (* not yet impl. on MVR | MAX *) (* Returns the current status flags in the form set by setMode *) PROCEDURE IsLowException (): BOOLEAN; (* not yet impl. on MVR | MAX *) (* Returns TRUE if the current coroutine is in the exceptional execution state because of the raising of an exception in a routine from this module; otherwise returns FALSE. *) END LowLongG. ________________________________________________________________________

    Concurrent Processes Library

    ________________________________________________________________________ Processes DEFINITION MODULE Processes; (* This module allows concurrent algorithms to be expressed using processes. A process is a unit of a program that has the potential to run in parallel with other processes. *) IMPORT SYSTEM; TYPE ProcessId; (* Used to identify processes *) Parameter = SYSTEM.ADDRESS; (* Used to pass data between processes *) Body = PROC; (* Used as the type of a process body *) Urgency = INTEGER; (* Used by the internal scheduler *) Sources = CARDINAL; (* Used to identify event sources *) ProcessesExceptions = (* Exceptions raised by this module *) (passiveProgram, processError); (* The following procedures create processes and switch control between them. *) PROCEDURE Create (procBody: Body; extraSpace: CARDINAL; procUrg: Urgency; procParams: Parameter; VAR procId: ProcessId); (* Creates a new process with procBody as its body, and with urgency and parameters given by procUrg and procParams. At least as much workspace (in units of SYSTEM.LOC) as is specified by extraSpace is allocated to the process. An identity for the new process is returned in procId. The process is created in the passive state; it will not run until activated. *) PROCEDURE Start (procBody: Body; extraSpace: CARDINAL; procUrg: Urgency; procParams: Parameter; VAR procId: ProcessId); (* Creates a new process, with parameters as for Create. The process is created in the ready state; it is eligible to run immediately. *) PROCEDURE StopMe (); (* Terminates the calling process. The process must not be associated with a source of events. *) PROCEDURE SuspendMe (); (* Causes the calling process to enter the passive state. The procedure only returns when the calling process is again activated by another process. *) PROCEDURE Activate (procId: ProcessId); (* Causes the process identified by procId to enter the ready state, and thus to become eligible to run again. *) PROCEDURE SuspendMeAndActivate (procId: ProcessId); (* Executes an atomic sequence of SuspendMe() and Activate(procId). *) PROCEDURE Switch (procId: ProcessId; VAR info: Parameter); (* Causes the calling process to enter the passive state; the process identified by procId becomes the currently executing process. info is used to pass parameter information from the calling to the activated process. On return, info will contain information from the process that chooses to switch back to this one (or will be NIL if Activate or SuspendMeAndActivate are used instead of Switch). *) PROCEDURE Wait (); (* Causes the calling process to enter the waiting state. The procedure will return when the calling process is activated by another process, or when one of its associated eventSources has generated an event. *) (* The following procedures allow the association of processes with sources of external events. *) PROCEDURE Attach (eventSource: Sources); (* Associates the specified eventSource with the calling process. *) PROCEDURE Detach (eventSource: Sources); (* Dissociates the specified eventSource from the program. *) PROCEDURE IsAttached (eventSource: Sources): BOOLEAN; (* Returns TRUE if and only if the specified eventSource is currently associated with one of the processes of the program. *) PROCEDURE Handler (eventSource: Sources): ProcessId; (* Returns the identity of the process, if any, that is associated with the specified eventSource. *) (* The following procedures allow processes to obtain their identity, parameters, and urgency. *) PROCEDURE Me (): ProcessId; (* Returns the identity of the calling process (as assigned when the process was first created). *) PROCEDURE MyParam (): Parameter; (* Returns the value specified as procParams when the calling process was created. *) PROCEDURE UrgencyOf (procId: ProcessId): Urgency; (* Returns the urgency established when the process identified by procId was first created. *) (* The following procedure provides facilities for exception handlers. *) PROCEDURE ProcessesException (): ProcessesExceptions; (* If the current coroutine is in the exceptional execution state because of the raising of a language exception, returns the corresponding enumeration value, and otherwise raises an exception. *) PROCEDURE IsProcessesException (): BOOLEAN; (* Returns TRUE if the current coroutine is in the exceptional execution state because of the raising of an exception in a routine from this module; otherwise returns FALSE. *) END Processes. ________________________________________________________________________ Semaphores DEFINITION MODULE Semaphores; (* Provides mutual exclusion facilities for use by processes. *) TYPE SEMAPHORE; PROCEDURE Create (VAR s: SEMAPHORE; initialCount: CARDINAL ); (* Creates and returns s as the identity of a new semaphore that has its associated count initialized to initialCount, and has no processes yet waiting on it. *) PROCEDURE Destroy (VAR s: SEMAPHORE); (* Recovers the resources used to implement the semaphore s, provided that no process is waiting for s to become free. *) PROCEDURE Claim (s: SEMAPHORE); (* If the count associated with the semaphore s is non-zero, decrements this count and allows the calling process to continue; otherwise suspends the calling process until s is released. *) PROCEDURE Release (s: SEMAPHORE); (* If there are any processes waiting on the semaphore s, allows one of them to enter the ready state; otherwise increments the count associated with s. *) PROCEDURE CondClaim (s: SEMAPHORE): BOOLEAN; (* Returns TRUE if the call Claim(s) would cause the calling process to be suspended; in this case the count associated with s is not changed. Otherwise returns TRUE and the associated count is decremented. *) END Semaphores. ________________________________________________________________________


    IMPRESSUM: The ModulaTor is an unrefereed journal. Technical papers are to be taken as working papers and personal rather than organizational statements. Items are printed at the discretion of the Editor based upon his judgement on the interest and relevancy to the readership. Letters, announcements, and other items of professional interest are selected on the same basis. Office of publication. The Editor of The ModulaTor is Günter Dotzel; he can be reached at mailto:[email deleted due to spam]


    Home | Site_index | Legal | OpenVMS_compiler | Alpha_Oberon_System | ModulaTor | Bibliography | Oberon[-2]_links | Modula-2_links |

    Amazon.com [3KB] [Any browser]

    Books Music Video Enter keywords...


    Amazon.com logo

    Webdesign by www.otolo.com/webworx, 16-Dec-1998