IMPLEMENTATION MODULE GfileManager;
(*
Graphics commands are written to the Gfile as array of words. The
file is fixed length file with 512 bytes per record. This module provides
procedures to write words tothe Gfile.
*)

FROM SYSTEM IMPORT WORD;
FROM FileSystem IMPORT
    (*TYPE*) File,
    (*PROC*) Done,Create, Open, Close, ReadWord, WriteWord;
FROM InOut IMPORT WriteString, WriteLn;

CONST WPRec = 128;        (* 512 DIV TSIZE( WORD ) *)
VAR
    WBindex : CARDINAL;   
    WBuffer : ARRAY [ 1..WPRec ] OF WORD;

PROCEDURE CreateGfile( 
    VAR Gfile  : File          (* out *) ;
        Gfname : ARRAY OF CHAR (* in *) ) : BOOLEAN;
    (*
    Create and open Gfname for writing. Return true if successful.
    *)
    BEGIN
        Create( Gfile, Gfname, FALSE, FALSE );
        IF NOT Done( ) THEN
            WriteString( "Trouble creating " );
            WriteString( Gfname );
            WriteLn;
            RETURN FALSE
        END;
        RETURN TRUE
    END CreateGfile;

PROCEDURE OpenGfile( 
    VAR Gfile  : File          (* out *);
    Gfname     : ARRAY OF CHAR (* in *);
    ReadOnly   : BOOLEAN       (* in *) ) : BOOLEAN;
    (*
    Open an existing Gfile. The parameter ReadOnly can be true or
    false. value returned is true if successful.
    *)
    BEGIN
        Open( Gfile, Gfname, ( NOT ReadOnly ) );
        RETURN ( Done( ) = TRUE )
    END OpenGfile;

PROCEDURE PutW( 
    VAR Gfile : File (* in/out *);
        Arg   : WORD (* in     *) ) : BOOLEAN;
    (*
    Put a word on Gfile. Return true if OK.
    *)
    VAR
        J : CARDINAL;
    BEGIN
            INC( WBindex );
            WBuffer[ WBindex ] := Arg;
            IF WBindex = WPRec THEN
                FOR J := 1 TO WPRec DO
                    WriteWord( Gfile, WBuffer[ J ] )
                END;
                IF NOT Done( ) THEN
                    WriteString("Trouble writing to Gfile ");
                    WriteLn;
                    RETURN FALSE
                END;
                WBindex := 0;
            END;
        RETURN TRUE
    END PutW;

PROCEDURE PutWords( 
    VAR Gfile : File (* in/out *);
        Arg   : ARRAY OF WORD (* in *);
        wc    : CARDINAL (* in *) ) : BOOLEAN;
    (*
    Put an array of words to Gfile. 
    *)
    VAR
        I : CARDINAL;
    BEGIN
        FOR I := 0 TO wc-1 DO
            IF NOT PutW( Gfile, Arg[ I ] ) THEN
                RETURN FALSE
            END
        END;
        RETURN TRUE
    END PutWords;

PROCEDURE GetW(
    VAR Gfile  : File  (* in/out *);
    VAR AWord  : WORD  (* out    *) ): BOOLEAN;
    (*
    Read a word from Gfile at the current positions. Errors or EOF indicated
    by a RETURN of FALSE.
    *)
    BEGIN
        ReadWord( Gfile, AWord );
        RETURN ( Done( ) = TRUE )
    END GetW;

PROCEDURE GetWords(
    VAR Gfile : File (* in/out *);
    VAR Words : ARRAY OF WORD (* out *);
        Wcnt  : CARDINAL (* in *) ) : BOOLEAN;
    (*
    Get "wcnt" number of words from Gfile.
    *)
    VAR
        I : CARDINAL;
    BEGIN
        FOR I := 1 TO Wcnt DO
            IF NOT GetW( Gfile, Words[ I-1 ] ) THEN
                RETURN FALSE
            END
        END;
        RETURN TRUE
    END GetWords;

PROCEDURE CloseGfile(
    VAR Gfile : File (* in/out *) ) : BOOLEAN;
    (*
    Close file. Make sure that there is nothing pending in WBuffer. If
    so, flush it.
    *)
    VAR
        J : CARDINAL;
    BEGIN
            IF WBindex > 0 THEN
                FOR J := 1 TO WBindex DO
                    WriteWord( Gfile, WBuffer[ J ] )
                END;
                IF NOT Done( ) THEN
                    WriteString("Trouble flushing buffer to Gfile ");
                    WriteLn;
                    RETURN FALSE
                END;
                WBindex := 0;
            END;
        Close( Gfile );
        RETURN TRUE
    END CloseGfile;

BEGIN (* initialization *)
    WBindex := 0;
END GfileManager.