Gold Fish 3/goldfish_volume_3.bin/files/fish/disks/d1115.lha/Programs/CX/Quelltext/CXFileIO.mod

Modula Implementation | 1995-06-06 | 5.7 KB | 232 lines

IMPLEMENTATION MODULE CXFileIO;

(*$ DEFINE DEBUG:=FALSE *)

IMPORT
    dd:DosD, dl:DosL, ds:DosSupport,
    ed:ExecD, el:ExecL, es:ExecSupport,
    String,
    cxw:CXWindow;

(*$ IF DEBUG *)
IMPORT io:InOut;
(*$ ENDIF *)

FROM SYSTEM IMPORT
    ADDRESS, CAST, ADR;



TYPE
    ListItem = ARRAY [0..39] OF CHAR;
    StrPtr = POINTER TO ARRAY [0..127] OF CHAR;



VAR
    removeList: ed.ListPtr;
    removeItems: POINTER TO ARRAY [0..99] OF ListItem;
    itemCount: INTEGER;

(* --------------------------------------------------------------- *)

PROCEDURE AddToRemoveList (VAR n: INTEGER; string: ARRAY OF CHAR);
(* Fügt den neuen Broker zur "nur * entfernen"-Liste dazu. *)
VAR
    newnode: ed.NodePtr;
BEGIN
    (*$ IF DEBUG *)
        io.WriteString ("cxf.AddToRemoveList...\n");
    (*$ ENDIF *)

    newnode := el.AllocMem(SIZE(ed.Node), ed.MemReqSet{ed.memClear});
    IF newnode # NIL THEN
        String.Copy (removeItems^[n], string);
        newnode^.name := ADR(removeItems^[n]);
        el.AddTail (removeList, newnode);
        INC (n);
    END;
END AddToRemoveList;

(* --------------------------------------------------------------- *)

PROCEDURE LoadRemoveList (filename: ADDRESS);
(* "nur * entfernen"-Liste laden *)
VAR
    hdl: dd.FileHandlePtr;
    li: LONGINT;
    newstring: ARRAY [0..127] OF CHAR;
    n, nc: INTEGER;
    c: CHAR;
BEGIN
    (*$ IF DEBUG *)
        io.WriteString ("cxf.LoadRemoveList...\n");
    (*$ ENDIF *)

    IF removeList # NIL THEN
        hdl := ds.Open(filename, dd.readOnly);

        IF hdl # NIL THEN
            (* LineFeeds zählen: *)
            itemCount := 0;
            REPEAT
                li := dl.Read(hdl, ADR(c), 1);
                IF c = CHR(10) THEN
                    INC (itemCount);
                END;
            UNTIL li <= 0;
            li := dl.Seek(hdl, 0, dd.beginning);

            (* Speicher für Strings reservieren: *)
            removeItems := el.AllocMem(SIZE(ListItem)*itemCount, ed.MemReqSet{ed.memClear});
            IF removeItems # NIL THEN
                n := 0;
                REPEAT
                    newstring := "";
                    nc := 0;
                    LOOP
                        li := dl.Read(hdl, ADR(c), 1);
                        IF (li <= 0) OR (c = "\n") THEN EXIT; END;
                        newstring[nc] := c;
                        INC (nc);
                    END;
                    newstring[nc] := 0C;
                    AddToRemoveList (n, newstring);
                UNTIL (li = -1) OR (li = 0);
            END;
            ds.Close (hdl);
        END;
    END;
END LoadRemoveList;

(* --------------------------------------------------------------- *)

PROCEDURE IsInRemoveList (name: ADDRESS) : BOOLEAN;
(* Überprüft, ob der übergebene Broker(name) in der "nur * entfernen"-
 * Liste vorhanden ist und gibt dann TRUE zurück, FALSE, wenn nicht.
 *)
BEGIN
    (*$ IF DEBUG *)
        io.WriteString ("cxf.IsInRemoveList...\n");
    (*$ ENDIF *)

    IF removeList # NIL THEN
        RETURN el.FindName(removeList, name) # NIL;
    END;
END IsInRemoveList;

(* --------------------------------------------------------------- *)

PROCEDURE FreeRemoveList;
(* Belegte Resourcen wieder freigeben. *)
VAR
    node, nnode: ed.NodePtr;
BEGIN
    (*$ IF DEBUG *)
        io.WriteString ("cxf.FreeRemoveList...\n");
    (*$ ENDIF *)

    IF removeList # NIL THEN
        IF removeItems # NIL THEN
            node := removeList^.head;
            WHILE node^.succ # NIL DO
                nnode := node^.succ;
                el.FreeMem (node, SIZE(ed.Node));
                node := nnode;
            END;

            el.FreeMem(removeItems, itemCount*SIZE(ListItem));
            removeItems := NIL;
        END;
        el.FreeMem (removeList, SIZE(ed.List));
        removeList := NIL;
    END;
END FreeRemoveList;

(* --------------------------------------------------------------- *)

CONST
    OPTIONSCOUNT = 4;

PROCEDURE LoadOptions (VAR options: cxw.Options);
VAR
    hdl: dd.FileHandlePtr;
    li: LONGINT;
    opt: ARRAY [0..OPTIONSCOUNT-1] OF CHAR;
BEGIN
    (*$ IF DEBUG *)
        io.WriteString ("cxf.LoadOptions...\n");
    (*$ ENDIF *)

    hdl := ds.Open(ADR("S:CX.prefs"), dd.readOnly);
    IF hdl # NIL THEN
        li := dl.Read(hdl, ADR(opt), OPTIONSCOUNT);
        ds.Close (hdl);
        WITH options DO
            AUTOSIZE := opt[0] = "1";
            REQUESTER := opt[1] = "1";
            REMOVEONLY := opt[2] = "1";
            SIZEABLE := opt[3] = "1";
        END;
    END;
END LoadOptions;

PROCEDURE SaveOptions (VAR options: cxw.Options);
VAR
    hdl: dd.FileHandlePtr;
    li: LONGINT;
    opt: ARRAY [0..OPTIONSCOUNT-1] OF CHAR;
BEGIN
    (*$ IF DEBUG *)
        io.WriteString ("cxf.SaveOptions...\n");
    (*$ ENDIF *)

    WITH options DO
        IF AUTOSIZE THEN
            opt[0] := "1";
        ELSE
            opt[0] := "0";
        END;
        IF REQUESTER THEN
            opt[1] := "1";
        ELSE
            opt[1] := "0";
        END;
        IF REMOVEONLY THEN
            opt[2] := "1";
        ELSE
            opt[2] := "0";
        END;
        IF SIZEABLE THEN
            opt[3] := "1";
        ELSE
            opt[3] := "0";
        END;
    END;
    hdl := ds.Open(ADR("S:CX.prefs"), dd.newFile);
    IF hdl # NIL THEN
        li := dl.Write(hdl, ADR(opt), OPTIONSCOUNT);
        ds.Close (hdl);
    END;
END SaveOptions;

(* --------------------------------------------------------------- *)

BEGIN
    (*$ IF DEBUG *)
        io.WriteString ("Module CXFileIO loaded...\n");
    (*$ ENDIF *)

    removeList := el.AllocMem(SIZE(ed.List), ed.MemReqSet{ed.memClear});
    IF removeList # NIL THEN
        es.NewList (removeList);
    END;

CLOSE
    FreeRemoveList;

    (*$ IF DEBUG *)
        io.WriteString ("Module CXFileIO closed.\n");
    (*$ ENDIF *)
END CXFileIO.