(***********************************************************************

    :Program.    alt2neu.mod
    :Contents.   wandelt Dateien der Version 1.0 von VTrainer in solche
    :Contents.   der Version 1.1 um
    :Author.     Dieter WILHELM
    :Address.    Albert-Schweitzer-Str.44, 8000 München 83
    :Phone.      089/671693
    :Copyright.  PD
    :Language.   Modula-2
    :Translator. M2Amiga A+L V4.0d
    :Imports.    Lists [bne] Amok#22, ArpD, Request, VEingabe
    :History.    V1.0 Dieter WILHELM 29.Sept.1990

**********************************************************************)

MODULE alt2neu;
  FROM ArpD        IMPORT DirName, FileName;
  FROM FileMessage IMPORT ResponseText, StrPtr;
  FROM FileSystem  IMPORT Close, File, Lookup, ReadBytes, Response,
                          WriteBytes;
  FROM GraphicsD   IMPORT jam1;
  FROM IntuitionD  IMPORT IDCMPFlagSet, IntuiText;
  FROM IntuitionL  IMPORT AutoRequest;
  FROM Lists       IMPORT AppendEntryC, CreateList, DeleteList,
                          EntriesInList, EntryPtr, FirstEntry, List,
                          ReadEntryC, Successor;
  FROM Request     IMPORT fString, Req;
  FROM String      IMPORT Copy, Delete, Insert, Length;
  FROM SYSTEM      IMPORT ADR;
  FROM VEingabe    IMPORT Modus, Vokabel, Zeile;


  TYPE Kennung = ARRAY [0..7] OF CHAR ;
       KennWort = ARRAY [0..5] OF CHAR ;
       VKopf = RECORD
                 Name     : FileName ;
                 Dir      : DirName ;
                 Mod      : Modus ;
                 KWort    : KennWort ;
                 Anzahl   : LONGINT ;
                 gefragtV : CARDINAL ;
                 gewusstV : CARDINAL ;
                 gefragtU : CARDINAL ;
                 gewusstU : CARDINAL ;
                 Gruppe   : ARRAY [0..3] OF List ;
               END ;  (* RECORD *)


  VAR VKennAlt, VKennNeu : Kennung ;
      KWort2             : KennWort ;
      mod                : Modus ;
      i, m, n,
      laenge             : CARDINAL ;
      Vok                : Vokabel ;
      Datei              : File ;
      DName, fName       : fString ;
      lDir, sDir         : fString ;
      ZGroesse, MGroesse : LONGINT ;
      req                : BOOLEAN ;
      schade, lang,
      modus, look,
      ende, liste,
      dateiformat,
      resp               : IntuiText ;
      Kopf               : VKopf ;
      lTitel, sTitel     : ARRAY [0..26] OF CHAR;
      dateiOk            : BOOLEAN;


  PROCEDURE Fehler(Resultat: Response; aktuell, Laenge: LONGINT):
                  BOOLEAN ;
    VAR Text : StrPtr ;
    BEGIN
      IF Resultat # done THEN
        ResponseText(Resultat, Text) ;
        resp.iText := Text ;
        req := AutoRequest(NIL, ADR(resp), NIL, ADR(schade),
                           IDCMPFlagSet{}, IDCMPFlagSet{}, 300, 65);
        RETURN TRUE ;
      END ;  (* IF *)
      IF aktuell # Laenge THEN
        req := AutoRequest(NIL, ADR(lang), NIL, ADR(schade),
                           IDCMPFlagSet{}, IDCMPFlagSet{}, 500, 65);
        RETURN TRUE ;
      END ;  (* IF *)
      RETURN FALSE ;
  END Fehler ;


  PROCEDURE NeueListe;
    BEGIN
      FOR m := 0 TO 3 DO
        IF EntriesInList(Kopf.Gruppe[m]) # 0 THEN
          DeleteList(Kopf.Gruppe[m]) ;
          IF NOT CreateList(Kopf.Gruppe[m]) THEN
            req := AutoRequest(NIL, ADR(liste), NIL, ADR(ende),
                               IDCMPFlagSet{}, IDCMPFlagSet{}, 300, 65);
            HALT ;
          END ;  (* IF NOT *);
        END ;  (* IF Entries *)
      END ;  (* FOR *)
      WITH Kopf DO
        Anzahl := 0 ;
        gefragtV := 0 ; gewusstV := 0 ;
        gefragtU := 0 ; gewusstU := 0 ;
      END ;  (* WITH *)
  END NeueListe ;


  PROCEDURE KennungFalsch(Kenn: Kennung): BOOLEAN ;
    BEGIN
      FOR i := 0 TO 7 DO
        IF Kenn[i] # VKennAlt[i] THEN
          RETURN TRUE ;
        END ;  (* IF *)
      END ;  (* FOR *)
      RETURN FALSE ;
  END KennungFalsch ;


  PROCEDURE Lesen(VAR dateiOk: BOOLEAN): BOOLEAN;
    VAR HKenn   : Kennung ;
        gelesen : LONGINT ;
        ok      : BOOLEAN ;
    BEGIN
      DName := ""; dateiOk := TRUE;
      IF Req(NIL, DName, lDir, lTitel) THEN
        fName := DName;
        IF (Length(lDir) > 0) AND (lDir[Length(lDir) - 1] # ":") THEN
          Insert(fName, 0, "/") ;
        END ;  (* IF (Length *)
        Insert(fName, 0, lDir) ;
        Lookup(Datei, fName, 2048, FALSE) ;
        IF Datei.res # done THEN
          req := AutoRequest(NIL, ADR(look), NIL, ADR(schade),
                             IDCMPFlagSet{}, IDCMPFlagSet{}, 350, 65);
          dateiOk := FALSE;
        ELSE
          ReadBytes(Datei, ADR(HKenn), 8, gelesen) ;
          IF Fehler(Datei.res, gelesen, 8) OR KennungFalsch(HKenn) THEN
            req := AutoRequest(NIL, ADR(dateiformat), NIL, ADR(schade),
                               IDCMPFlagSet{}, IDCMPFlagSet{}, 230, 65);
            dateiOk := FALSE;
          ELSE
            ReadBytes(Datei, ADR(KWort2), 6, gelesen) ;
            IF NOT Fehler(Datei.res, gelesen, 6) THEN
              ok := TRUE ; m := 0 ; Kopf.Anzahl := 0 ;
              WHILE (m < 4) AND ok DO
                ReadBytes(Datei, ADR(laenge), 2, gelesen) ;
                ok := NOT Fehler(Datei.res, gelesen, 2) ;
                n := 0 ;
                WHILE (n < laenge) AND ok DO
                  ReadBytes(Datei, ADR(Vok.Wort), ZGroesse, gelesen) ;
                  ok := NOT Fehler(Datei.res, gelesen, ZGroesse) ;
                  i := 0 ;
                  WHILE (i < 5) AND ok DO
                    ReadBytes(Datei, ADR(Vok.Uebersetzung[i]), ZGroesse,
                              gelesen) ;
                    ok := NOT Fehler(Datei.res, gelesen, ZGroesse) ;
                    i := i + 1 ;
                  END ;  (* WHILE i *)
                  FOR mod := v TO ue DO
                    IF ok THEN
                      ReadBytes(Datei, ADR(Vok.abgefragt[mod]), 2,
                                gelesen);
                      ok := NOT Fehler(Datei.res, gelesen, 2) ;
                      IF ok THEN
                        ReadBytes(Datei, ADR(Vok.gewusst[mod]), 2,
                                  gelesen);
                        ok := NOT Fehler(Datei.res, gelesen, 2) ;
                      END ;  (* IF ok *)
                    END ;  (* IF ok *)
                  END ;  (* FOR *)
                  IF ok THEN
                    AppendEntryC(Kopf.Gruppe[m], Vok) ;
                    INC(Kopf.Anzahl);
                  END ;  (* IF ok*)
                  INC(n);
                END ;  (* WHILE n *)
                INC(m);
              END ;  (* WHILE m *)
              dateiOk := ok;
              ReadBytes(Datei, ADR(Kopf.Mod), MGroesse, gelesen) ;
              IF Fehler(Datei.res, gelesen, MGroesse) THEN
                Kopf.Mod := v ;
                req := AutoRequest(NIL, ADR(modus), NIL, ADR(schade),
                               IDCMPFlagSet{}, IDCMPFlagSet{}, 350, 65);
              END ;  (* IF Fehler *)
            ELSE
              dateiOk := FALSE;
            END ;  (* IF Fehler *)
          END ;  (* IF Fehler OR KennungFalsch *)
          Close(Datei) ;
        END ;  (* IF Datei.res *)
        RETURN TRUE;
      ELSE
        RETURN FALSE;
      END ;  (* IF FileRequest *)
  END Lesen ;


  PROCEDURE Schreiben;
    VAR dummy       : BOOLEAN ;
        geschrieben : LONGINT ;
        ok          : BOOLEAN ;
        Eintrag     : EntryPtr ;
    BEGIN
      ok := TRUE ;
      IF (Kopf.Anzahl > 0) THEN
        IF Req(NIL, DName, sDir, sTitel) THEN
          IF (Length(sDir) > 0) AND (sDir[Length(sDir) - 1] # ":") THEN
            Insert(DName, 0, "/") ;
          END ;  (* IF (Length *)
          Insert(DName, 0, sDir) ;
          Lookup(Datei, DName, 2048, TRUE) ;
          IF Datei.res # done THEN
            req := AutoRequest(NIL, ADR(look), NIL, ADR(schade),
                               IDCMPFlagSet{}, IDCMPFlagSet{}, 350, 65);
          ELSE
          WriteBytes(Datei, ADR(VKennNeu), 8, geschrieben) ;
            dummy := Fehler(Datei.res, 8, geschrieben) ;
            FOR m := 0 TO 3 DO
              ok := TRUE ;
              laenge := EntriesInList(Kopf.Gruppe[m]) ;
              WriteBytes(Datei, ADR(laenge), 2, geschrieben) ;
              dummy := Fehler(Datei.res, 2, geschrieben) ;
              Eintrag := FirstEntry(Kopf.Gruppe[m]) ; n := 0 ;
              WHILE (n < laenge) AND ok DO
                ReadEntryC(Kopf.Gruppe[m], Eintrag, Vok) ;
                WriteBytes(Datei, ADR(Vok.Wort), ZGroesse, geschrieben);
                dummy := Fehler(Datei.res, ZGroesse, geschrieben) ;
                FOR i := 0 TO 4 DO
                  WriteBytes(Datei, ADR(Vok.Uebersetzung[i]), ZGroesse,
                             geschrieben) ;
                  dummy := Fehler(Datei.res, ZGroesse, geschrieben) ;
                END ;  (* FOR i *)
                FOR mod := v TO ue DO
                  WriteBytes(Datei, ADR(Vok.abgefragt[mod]), 2,
                             geschrieben);
                  dummy := Fehler(Datei.res, 2, geschrieben) ;
                  WriteBytes(Datei, ADR(Vok.gewusst[mod]), 2,
                             geschrieben);
                  dummy := Fehler(Datei.res, 2, geschrieben) ;
                END ;  (* FOR mod *)
                ok := Successor(Eintrag) ; INC(n);
              END ;  (* WHILE n *)
            END ;  (* FOR m *)
            WriteBytes(Datei, ADR(Kopf.Mod), MGroesse, geschrieben) ;
            dummy := Fehler(Datei.res, MGroesse, geschrieben) ;
            Close(Datei) ;
          END ;  (* IF Datei.res *)
        END ;  (* IF Req *)
      END;  (* IF (Kopf *)
  END Schreiben;

  BEGIN
    lDir := ""; sDir := "";
    VKennAlt := "VokDatei" ;
    VKennNeu := "VoDatNeu" ;
    ZGroesse := LONGINT(SIZE(Zeile)) ;
    MGroesse := LONGINT(SIZE(Modus)) ;
    WITH lang DO
      frontPen := 0 ; backPen := 1 ;
      leftEdge := 15 ; topEdge := 15 ; drawMode := jam1 ;
      iTextFont := NIL ;
      iText:= ADR("Anzahl der gelesenen/geschriebenen Bytes ist falsch");
      nextText := NIL ;
    END ;  (* WITH *)
    WITH modus DO
      frontPen := 0 ; backPen := 1 ;
      leftEdge := 15 ; topEdge := 15 ; drawMode := jam1 ;
      iTextFont := NIL ;
      iText := ADR("Modus konnte nicht gelesen werden");
      nextText := NIL ;
    END ;  (* WITH *)
    WITH look DO
      frontPen := 0 ; backPen := 1 ;
      leftEdge := 15 ; topEdge := 15 ; drawMode := jam1 ;
      iTextFont := NIL ;
      iText := ADR("Datei konnte nicht geöffnet werden");
      nextText := NIL ;
    END ;  (* WITH *)
    WITH dateiformat DO
      frontPen := 0 ; backPen := 1 ;
      leftEdge := 15 ; topEdge := 15 ; drawMode := jam1 ;
      iTextFont := NIL ; iText := ADR("Falsches Dateiformat") ;
      nextText := NIL ;
    END ;  (* WITH *)
    WITH schade DO
      frontPen := 2 ; backPen := 3 ;
      leftEdge := 5 ; topEdge := 4 ; drawMode := jam1 ;
      iTextFont := NIL ; iText := ADR("Schade") ;
      nextText := NIL ;
    END ;  (* WITH *)
    WITH ende DO
      frontPen := 2 ; backPen := 3 ;
      leftEdge := 5 ; topEdge := 4 ; drawMode := jam1 ;
      iTextFont := NIL ; iText := ADR("ENDE") ;
      nextText := NIL ;
    END ;  (* WITH *);
    WITH liste DO
      frontPen := 0 ; backPen := 1 ;
      leftEdge := 15 ; topEdge := 15 ; drawMode := jam1 ;
      iTextFont := NIL ; iText := ADR("Konnte keine Liste erstellen") ;
      nextText := NIL ;
    END ;  (* WITH *)
    WITH resp DO
      frontPen := 0 ; backPen := 1 ;
      leftEdge := 15 ; topEdge := 15 ; drawMode := jam1 ;
      iTextFont := NIL ; iText := ADR("Datei noch nicht gespeichert") ;
      nextText := NIL ;
    END ;  (* WITH *)
    FOR m := 0 TO 3 DO
      IF NOT CreateList(Kopf.Gruppe[m]) THEN
         req := AutoRequest(NIL, ADR(liste), NIL, ADR(ende),
                            IDCMPFlagSet{}, IDCMPFlagSet{}, 300, 65) ;
         HALT ;
      END;  (* IF NOT *)
    END;  (* FOR *)
    lTitel := "Bitte alte Datei auswählen";
    sTitel := "Neu Datei speichern als";

    NeueListe;
    WHILE Lesen(dateiOk) DO
      IF dateiOk THEN
        Schreiben;
      END;  (* IF *)
      NeueListe;
    END;  (* WHILE *)

  CLOSE
    FOR m := 0 TO 3 DO
      IF EntriesInList(Kopf.Gruppe[m]) # 0 THEN
        DeleteList(Kopf.Gruppe[m]) ;
      END ;  (* IF *)
    END ;  (* FOR *)


END alt2neu.