(******************************************************************************
*                                                                             *
*    Programmname:  m2MakerRoutines                                           *
*                                                                             *
*    Stand:         29.12.89                            Uhrzeit:  18:16:14    *
*                                                                             *
*    Bearbeitet mit dem MODULETool V1.12        (©) by  Thomas Stolze 1989    *
*                                                                             *
******************************************************************************)

(* $R- *) (* $V- *) (* $S- *) (* $N- *) (* $F- *)
IMPLEMENTATION MODULE m2MakerRoutines;

IMPORT Exec;
IMPORT Intuition;

FROM Arts             IMPORT Assert;
FROM DirectorySupport IMPORT Frame,NewDir;
FROM Dos              IMPORT accessRead,CreateDir,CurrentDir,Delay,DupLock,
                             Execute,FileLockPtr,IoErr,Lock,SetComment,UnLock;
FROM Exec             IMPORT AllocMem,AvailMem,CloseDevice,CopyMem,DoIO,
                             FindPort,FreeMem,IOStdReqPtr,MemReqs,MemReqSet,
                             Message,MsgPort,MsgPortPtr,OpenDevice,PutMsg;
FROM ExecSupport      IMPORT CreatePort,CreateStdIO,DeletePort,DeleteStdIO;
FROM FileSystem       IMPORT Close,File,Lookup,ReadChar,Response,WriteBytes,
                             WriteChar;
FROM Graphics         IMPORT DrawModes,DrawModeSet,jam1,jam2,Move,RastPortPtr,
                             RectFill,SetAPen,SetBPen,SetDrMd,Text;
FROM Input            IMPORT inputName,writeEvent;
FROM InputEvent       IMPORT InputEvent,Class,Qualifiers,QualifierSet;
FROM InputHandler     IMPORT CleanupHandler,Wache;
FROM Intuition        IMPORT ActivateGadget,ActivateWindow,ActivationFlags,
                             ActivationFlagSet,AddGadget,ClearMenuStrip,
                             ClearPointer,GadgetFlags,GadgetFlagSet,GadgetPtr,
                             IDCMPFlags,IDCMPFlagSet,IntuiMessage,
                             IntuitionBasePtr,MenuItemFlags,ModifyIDCMP,
                             MoveWindow,RefreshGList,RemoveGadget,ScreenPtr,
                             SetMenuStrip,SetPointer,SizeWindow,WBenchToBack,
                             WBenchToFront,WindowPtr,WindowToFront;
FROM SYSTEM           IMPORT ADDRESS,ADR,BPTR,INLINE,LONGSET;
FROM Str              IMPORT Concat,Copy,FirstPos,LastPos,Length;
FROM StringSupport    IMPORT DeleteStr,LeftStr,LEQ,LGT,Occurs,ProduceStr,
                             StringStr,ValStr;
FROM TimerSupport     IMPORT MakeDateString,MakeTimeString;
FROM m2Maker          IMPORT BackupFlag,BufferString,DirPtr,F1,F2,fensterBreite,
                             fensterHoehe,GadgetFeldListe,GadgetNamen,
                             MenuItemFeld,menustripPtr,OptionenString,
                             outputChannel,pointer,projectFlag,SystemString,win,
                             window;

CONST lineFeed = 12C;
      actions  = ActivationFlagSet{gadgImmediate,relVerify};

VAR DummyStr  : ARRAY [0..140] OF CHAR;
    altlock   : FileLockPtr;
    bigWindow,
    erfolg    : BOOLEAN;

PROCEDURE Block(rport : RastPortPtr; col,x1,y1,x2,y2 : INTEGER);
BEGIN
  SetAPen(rport,col); SetDrMd(rport,jam2);
  RectFill(rport,x1,y1,x2,y2);
END Block;

PROCEDURE Print(text : ARRAY OF CHAR; rport : RastPortPtr;
                                  fPen,bPen : INTEGER;
                                  drawM     : DrawModeSet;
                                  xpos,ypos : INTEGER);
BEGIN
  SetAPen(rport,fPen); SetBPen(rport,bPen); SetDrMd(rport,drawM);
  Move(rport,xpos,ypos);
  Text(rport,ADR(text),Length(text));
END Print;

PROCEDURE PrintStatus(text : ARRAY OF CHAR);
VAR space : ARRAY [0..40] OF CHAR;
BEGIN
  ProduceStr(space," ",40);
  Print(space,window^.rPort,1,0,jam2,74,117);
  Print(text,window^.rPort,1,0,jam1,74,117);
END PrintStatus;

PROCEDURE PrintDosErr(nr : LONGINT);
VAR  print : ARRAY [0..10] OF CHAR;
     errstr: ARRAY [0..20] OF CHAR;
BEGIN
  IF (nr > 0) AND (nr < 1000) THEN
     errstr:=("DOS Error: "); StringStr(print,nr,5);
     Concat(errstr,print);    PrintStatus(errstr);
  END;
  PrintStatus("OK");
END PrintDosErr;

PROCEDURE Executeing(VAR str : ARRAY OF CHAR): INTEGER;
VAR  erg : INTEGER;
BEGIN
  erg:=Execute(ADR(str),NIL,outputChannel);
  IF erg > 0 THEN
     PrintDosErr(IoErr());
  END;
  RETURN erg;
END Executeing;

PROCEDURE Invers(gadgptr : GadgetPtr);
VAR erg : INTEGER;
BEGIN
  erg:=RemoveGadget(window,gadgptr);
  WITH gadgptr^ DO
    IF (selected IN flags) THEN
      Block(window^.rPort,0,leftEdge,topEdge,leftEdge+width-1,topEdge+height-1);
       EXCL(flags,selected);
    END;
  END;
  erg:=AddGadget(window,gadgptr,erg);
  RefreshGList(gadgptr,window,NIL,1);
END Invers;

PROCEDURE Convert(gadgptr : GadgetPtr);
VAR erg : INTEGER;
BEGIN
  erg:=RemoveGadget(window,gadgptr);
  WITH gadgptr^ DO
    IF NOT (selected IN flags) THEN
      Block(window^.rPort,0,leftEdge,topEdge,leftEdge+width-1,topEdge+height-1);
       INCL(flags,selected);
    END;
  END;
  erg:=AddGadget(window,gadgptr,erg);
  RefreshGList(gadgptr,window,NIL,1);
END Convert;

PROCEDURE Prueffile(str : ARRAY OF CHAR; anzeige : BOOLEAN): BOOLEAN;
VAR ioerr  : LONGINT;
    lock   : FileLockPtr;
BEGIN
  lock:=Lock(ADR(str),accessRead);
  IF lock = NIL THEN
     IF anzeige THEN
        PrintDosErr(IoErr());
     END;
     UnLock(lock);
     RETURN FALSE;
  END;
  UnLock(lock);
  RETURN TRUE
END Prueffile;

PROCEDURE EditorTextGadget;
VAR pos : INTEGER;
BEGIN
   pos:=LastPos(BufferString[3],Length(BufferString[3]),".");
     LeftStr(BufferString[1],BufferString[3],pos);
     Copy(BufferString[9],DirPtr^.Pfad);
   RefreshGList(ADR(GadgetFeldListe[fileTextGadget]),window,NIL,2);
END EditorTextGadget;

PROCEDURE ChangePointer(wind : WindowPtr);
BEGIN
  SetPointer(wind,pointer,16,16,-7,-7);
END ChangePointer;

PROCEDURE LadeFehlerListe(wind : WindowPtr; speichern,wb : BOOLEAN): BOOLEAN;
VAR news   : InputEvent;
    port   : MsgPortPtr;
    reqptr : IOStdReqPtr;
    true,
    started: BOOLEAN;

    PROCEDURE SendCommand(command   : CARDINAL;
                          qualifier : QualifierSet;
                          code      : CARDINAL);
    BEGIN

     news.nextEvent:=NIL;
     news.class:=rawkey;
     news.subClass:=null;
     news.qualifier:=qualifier;
     news.code:=code;

      reqptr^.command:=command;
      reqptr^.length:=SIZE(InputEvent);
      reqptr^.data:=ADR(news);

       DoIO(reqptr);
         Assert(reqptr^.error = 0,ADR("I/O Fehler"));
       Delay(5);
    END SendCommand;
BEGIN
  IF wb THEN
   true:=WBenchToBack();
  END;
  ActivateWindow(wind); started:=FALSE;
  port:=CreatePort(NIL,0);
    Assert(port # NIL,ADR("MsgPort nicht geöffnet"));
  reqptr:=CreateStdIO(port);
  OpenDevice(ADR(inputName),0,reqptr,LONGSET{});

    IF speichern THEN
       IF (checked IN MenuItemFeld[26].flags) THEN
          SendCommand(writeEvent,QualifierSet{control},0DH);
          started:=TRUE;
       ELSE;
          SendCommand(writeEvent,QualifierSet{lShift},F1);
       END;
    ELSE
       SendCommand(writeEvent,QualifierSet{lShift},F2);
       SendCommand(writeEvent,QualifierSet{},F2);
    END;

  CloseDevice(reqptr);
  DeleteStdIO(reqptr); reqptr:=NIL;
  DeletePort(port);      port:=NIL;
  RETURN started;
END LadeFehlerListe;

PROCEDURE FindEditor(VAR wind : WindowPtr): BOOLEAN;
VAR base   : IntuitionBasePtr;
    screen : ScreenPtr;
    name   : ARRAY [0..23] OF CHAR;
BEGIN
  base:=ADR(Intuition);
  screen:=base^.firstScreen; wind:=NIL;
  WHILE (screen # NIL) DO
    CopyMem(screen^.title,ADR(name),22); name[22]:=00C;
    IF LEQ("Amiga Modula-2 Editor,",name) THEN
       wind:=screen^.firstWindow;
       RETURN TRUE;
    ELSE
       screen:=screen^.nextScreen;
    END;
  END;
  RETURN FALSE;
END FindEditor;

PROCEDURE Editor(run : BOOLEAN);
VAR llock,lock,
    oldlock    : FileLockPtr;
    wwind      : WindowPtr;
    true       : BOOLEAN;
BEGIN
  IF FindEditor(wwind) THEN
     PrintStatus("Editor bereits gestartet!");
     Invers(ADR(GadgetFeldListe[editorGadget]));
     true:=WBenchToBack(); ActivateWindow(wwind);
  ELSE
     PrintStatus('Editor aktiviert');
     IF (checked IN MenuItemFeld[21].flags) THEN
        DummyStr:=("run ");
     ELSE
        DummyStr:=("");
     END;

     llock:=NIL; lock:=Lock(ADR(SystemString[4]),accessRead);
                   llock:=DupLock(lock);
                 UnLock(lock);
     IF (llock # NIL) THEN
        oldlock:=CurrentDir(llock);

        Concat(DummyStr,SystemString[0]);
        Concat(DummyStr," "); Concat(DummyStr,OptionenString[0]);
        Concat(DummyStr," ");
        Concat(DummyStr,BufferString[9]);
        Concat(DummyStr,BufferString[3]);
          PrintDosErr(Executeing(DummyStr));
        Invers(ADR(GadgetFeldListe[editorGadget]));
        llock:=CurrentDir(oldlock);
     ELSE
        PrintStatus("Kann Editor nicht ansprechen !!!");
     END;
  END;
END Editor;

PROCEDURE Compiler(): BOOLEAN;
VAR str     : ARRAY [0..79] OF CHAR;
    windd   : WindowPtr;
  PROCEDURE SetCompilerComment;
  VAR infoString : ARRAY [0..40] OF CHAR;
      string     : ARRAY [0..20] OF CHAR;
      dummy      : ARRAY [0..79] OF CHAR;
      bool       : BOOLEAN;
      pos        : INTEGER;
  BEGIN
    MakeDateString(string); Copy(infoString,string); Concat(infoString," ");
    MakeTimeString(string); Concat(infoString,string);
       Copy(DummyStr,BufferString[7]); Concat(DummyStr,"/obj/");
       pos:=LastPos(BufferString[3],Length(BufferString[3]),".");
       Copy(dummy,BufferString[3]);
       IF (pos # -1) THEN
           LeftStr(dummy,BufferString[3],pos);
            Concat(dummy,".obj");
            Concat(DummyStr,dummy);
           bool:=SetComment(ADR(DummyStr),ADR(infoString));
       END;
  END SetCompilerComment;

BEGIN
  PrintStatus('Compiler aktiviert'); str:=(""); DummyStr:=("");
  IF (checked IN MenuItemFeld[22].flags) THEN
     DummyStr:=("");
  ELSE
     Copy(DummyStr,SystemString[4]);
  END;
  Concat(DummyStr,SystemString[1]);
  Concat(DummyStr," "); Concat(DummyStr,OptionenString[2]);
  Concat(DummyStr," ");
    IF projectFlag THEN
       Copy(str,BufferString[7]); Concat(str,"/txt/");
    ELSE
       Concat(str,BufferString[9]);
    END;
  Concat(str,BufferString[3]); Concat(DummyStr,str);

  IF FindEditor(windd) THEN
     ChangePointer(windd);
     erfolg:=LadeFehlerListe(windd,TRUE,FALSE);
  END;
  PrintDosErr(Executeing(DummyStr));

  IF projectFlag THEN SetCompilerComment END;

  Invers(ADR(GadgetFeldListe[compilerGadget]));
  Concat(str,"E");
    IF Prueffile(str,FALSE) THEN
       IF FindEditor(windd) THEN
          erfolg:=LadeFehlerListe(windd,FALSE,TRUE);
          ClearPointer(windd);
          RETURN FALSE;
       ELSE
          Convert(ADR(GadgetFeldListe[editorGadget]));
          Editor(FALSE);
          RETURN FALSE;
       END;
    ELSE
      IF FindEditor(windd) THEN
         erfolg:=LadeFehlerListe(windd,FALSE,FALSE);
      END;
    END;
  ClearPointer(windd);
  RETURN TRUE;
END Compiler;

PROCEDURE CompileProject(start : ARRAY OF CHAR; all : BOOLEAN);
VAR Dateiname : ARRAY [0..80] OF CHAR;
    input     : File;
    bool      : BOOLEAN;

  PROCEDURE LeseZeile(VAR name : ARRAY OF CHAR);
  VAR  pos : INTEGER;
     anzahl: LONGINT;
       str : ARRAY [0..80] OF CHAR;
       ch  : CHAR;
  BEGIN
    pos:=0; ch:=00C;
    REPEAT
      ReadChar(input,ch);
       str[pos]:=ch; INC(pos);
    UNTIL (ch = lineFeed) OR (input.eof);
       str[pos-1]:=00C;
    Copy(name,str);
  END LeseZeile;

  PROCEDURE Proceed(read : BOOLEAN);
  BEGIN
    WHILE ((input.res = done) AND ((NOT input.eof) AND bool)) DO
      IF read THEN LeseZeile(Dateiname) END;
         IF LGT("                                  ",Dateiname) THEN
            Copy(BufferString[3],Dateiname);
            EditorTextGadget;
            Convert(ADR(GadgetFeldListe[compilerGadget]));
            bool:=Compiler();
         END;
      read:=TRUE;
    END;
  END Proceed;

BEGIN
  PrintStatus("Compiliere Projekt"); bool:=TRUE;
  Copy(DummyStr,BufferString[9]); Concat(DummyStr,"/m2maker.mke");
  Lookup(input,DummyStr,512,FALSE);
    IF (input.res = done) THEN
       IF all THEN
          Proceed(TRUE);
       ELSE
         LeseZeile(Dateiname);
         WHILE (NOT LEQ(Dateiname,start) AND (NOT input.eof)) DO
           LeseZeile(Dateiname);
         END;
         IF NOT input.eof THEN
            Proceed(FALSE);
         ELSE
            PrintStatus("StartDatei nicht gefunden!");
         END;
      END;
    ELSE
      PrintStatus("m2Maker.mke Datei nicht gefunden!");
    END;
 Close(input);
END CompileProject;

PROCEDURE Linker;
VAR windd : WindowPtr;
BEGIN
  PrintStatus('Linker aktiviert');
  IF FindEditor(windd) THEN
     ChangePointer(windd);
  END;
  IF (checked IN MenuItemFeld[22].flags) THEN
     DummyStr:=("");
  ELSE
     Copy(DummyStr,SystemString[4]);
  END;
  Concat(DummyStr,SystemString[2]);
  Concat(DummyStr," "); Concat(DummyStr,OptionenString[4]);
  Concat(DummyStr," ");
    IF projectFlag THEN
       Concat(DummyStr,BufferString[7]);
       Concat(DummyStr,"/obj/");
    ELSE
       Concat(DummyStr,BufferString[9]);
    END;
   Concat(DummyStr,BufferString[1]);
   Concat(DummyStr,".obj");
     PrintDosErr(Executeing(DummyStr));
   ClearPointer(windd);
   Invers(ADR(GadgetFeldListe[linkerGadget]));
END Linker;

PROCEDURE Run;
VAR bool : BOOLEAN;
    wind : WindowPtr;
BEGIN
  PrintStatus('Programm gestartet');
  IF projectFlag THEN
     Copy(DummyStr,BufferString[7]); Concat(DummyStr,"/");
     IF (FirstPos(OptionenString[6],0,"b") = -1) THEN
        Concat(DummyStr,"bin/");
     END;
  ELSE
     Copy(DummyStr,BufferString[9]);
  END;
  Concat(DummyStr,BufferString[1]);
  IF FindEditor(wind) THEN
     bool:=WBenchToFront();
  END;
    PrintDosErr(Executeing(DummyStr));
  Invers(ADR(GadgetFeldListe[runGadget]));
END Run;

PROCEDURE Backup;
VAR true : INTEGER;
    str,
    check,
    pruef: ARRAY [0..79] OF CHAR;
BEGIN
  PrintStatus('Backup-Kopie wird gespeichert'); str:=("");
  DummyStr:="sys:c/copy ";
  IF projectFlag THEN
     Copy(str,BufferString[7]);
     Concat(str,"/txt/");
  ELSE
      Concat(str,BufferString[9]);
  END;
  Concat(str,BufferString[3]);
  Concat(DummyStr,str);
  Concat(DummyStr," TO ");
  IF projectFlag THEN
     Copy(str,BufferString[7]);
     true:=FirstPos(str,0,":"); DeleteStr(str,0,true+1);

     Copy(pruef,SystemString[4]); Concat(pruef,SystemString[3]);
     Concat(pruef," "); Concat(pruef,OptionenString[6]);
     Concat(pruef," ");
     Concat(pruef,BufferString[5]); Concat(pruef,str);
     Copy(check,BufferString[5]);   Concat(check,str);
     IF NOT Prueffile(check,FALSE) THEN
        PrintDosErr(Executeing(pruef));
     END;

     Concat(str,"/txt/");
     Concat(DummyStr,BufferString[5]);
  ELSE
     Copy(str,BufferString[5]);
  END;
  Concat(DummyStr,str);
    PrintDosErr(Executeing(DummyStr));
  Invers(ADR(GadgetFeldListe[copyGadget]));
END Backup;

PROCEDURE Make;
VAR  str    : ARRAY [0..80] OF CHAR;
     dummy  : ARRAY [0..31] OF CHAR;
     erfolg : BOOLEAN;
     pos    : INTEGER;
BEGIN
  Convert(ADR(GadgetFeldListe[compilerGadget]));
  erfolg:=Compiler();
    IF erfolg THEN
       IF (checked IN MenuItemFeld[17].flags) THEN
          Copy(dummy,BufferString[1]);
          pos:=LastPos(SystemString[5],Length(SystemString[5]),".");
          IF (pos # -1) THEN
             LeftStr(SystemString[5],SystemString[5],pos);
          END;
          Copy(BufferString[1],SystemString[5]);
          RefreshGList(ADR(GadgetFeldListe[fileTextGadget]),window,NIL,1);
       END;

       Convert(ADR(GadgetFeldListe[linkerGadget]));
       Linker;
       IF BackupFlag=TRUE THEN
          Convert(ADR(GadgetFeldListe[copyGadget]));
          Backup;
       END;

       Convert(ADR(GadgetFeldListe[runGadget]));
       Run;

       IF (checked IN MenuItemFeld[17].flags) THEN
          Copy(BufferString[1],dummy);
          RefreshGList(ADR(GadgetFeldListe[fileTextGadget]),window,NIL,1);
       END;

    END;
  Invers(ADR(GadgetFeldListe[makeGadget]));
END Make;

PROCEDURE Resident;
BEGIN
   IF (checked IN MenuItemFeld[22].flags) THEN
      DummyStr:=("sys:c/Resident m2:m2c pure");
       PrintDosErr(Executeing(DummyStr));
      DummyStr:=("sys:c/Resident m2:m2l pure");
       PrintDosErr(Executeing(DummyStr));
   ELSE
      DummyStr:=("sys:c/Resident m2:m2c remove");
       PrintDosErr(Executeing(DummyStr));
      DummyStr:=("sys:c/Resident m2:m2l remove");
       PrintDosErr(Executeing(DummyStr));
   END;
END Resident;

PROCEDURE SaveOpts;
VAR     anzahl : LONGINT;
             i : INTEGER;
        output : File;
        dummy  : ARRAY [0..10] OF CHAR;

  PROCEDURE SchreibeZeile(str : ARRAY OF CHAR);
  VAR pos : INTEGER;
  BEGIN
      pos:=Length(str);
         WriteBytes(output,ADR(str),pos,anzahl);
         WriteChar (output,lineFeed);
  END SchreibeZeile;

  PROCEDURE MenuItemSave(par : CARDINAL);
  BEGIN
    IF (checked IN MenuItemFeld[par].flags) THEN
        SchreibeZeile("TRUE");
    ELSE
        SchreibeZeile("FALSE");
    END;
  END MenuItemSave;

  PROCEDURE SichereParameter(path : ARRAY OF CHAR);
  BEGIN
    i:=0;
    Lookup(output,path,512,TRUE);
    IF (output.res = done) THEN
       FOR i:=0 TO 6 BY 2 DO
         SchreibeZeile(OptionenString[i]);
         SchreibeZeile(BufferString[i+1]);
       END;
       SchreibeZeile(BufferString[9]);
       SchreibeZeile(DirPtr^.Pfad);
       SchreibeZeile(BufferString[11]);
         StringStr(dummy,DirPtr^.info.vertPot,9);
       SchreibeZeile(dummy);
       FOR i:=0 TO 5 DO
         SchreibeZeile(SystemString[i]);
       END;
       MenuItemSave(1);
       MenuItemSave(17);
       MenuItemSave(21);
       MenuItemSave(22);
    END;
    Close(output);
    PrintDosErr(IoErr());
  END SichereParameter;
BEGIN
  PrintStatus('Optionen Speichern');
    Copy(DummyStr,SystemString[4]); Concat(DummyStr,"m2Maker.par");
    SichereParameter(DummyStr);
    Copy(DummyStr,BufferString[7]);
      Concat(DummyStr,"/m2Maker.par");
    SichereParameter(DummyStr);
END SaveOpts;

PROCEDURE LoadOpts;
VAR input : File;
    i     : INTEGER;
    dummy : ARRAY [0..10] OF CHAR;
    wahr,
    bool  : BOOLEAN;

  PROCEDURE LeseZeile(VAR zeile : ARRAY OF CHAR);
  VAR  pos : INTEGER;
     anzahl: LONGINT;
       str : ARRAY [0..80] OF CHAR;
       ch  : CHAR;
  BEGIN
    pos:=0; ch:=00C;
    REPEAT
      ReadChar(input,ch);
       str[pos]:=ch; INC(pos);
    UNTIL (ch = lineFeed) OR (input.eof);
       str[pos-1]:=00C;
    Copy(zeile,str);
  END LeseZeile;

  PROCEDURE MenuItemLoad(par : CARDINAL);
  VAR dummy  : ARRAY [0..10] OF CHAR;
  BEGIN
    LeseZeile(dummy);
    IF LEQ(dummy,"TRUE") THEN
       INCL(MenuItemFeld[par].flags,checked);
    ELSE
       EXCL(MenuItemFeld[par].flags,checked);
    END;
  END MenuItemLoad;

BEGIN
  Copy(DummyStr,SystemString[4]); Concat(DummyStr,"m2Maker.par");
  PrintStatus('Optionen Laden');
  bool:=FALSE; IF (checked IN MenuItemFeld[22].flags) THEN bool:=TRUE END;
  Lookup(input,DummyStr,512,FALSE);
  IF (input.res = done) THEN
     DirPtr^.listFile:=0;
     FOR i:=0 TO 6 BY 2 DO
       LeseZeile(OptionenString[i]);
       LeseZeile(BufferString[i+1]);
     END;
     LeseZeile(BufferString[9]);
     LeseZeile(DirPtr^.Pfad);
     LeseZeile(BufferString[11]);
     LeseZeile(dummy);
     DirPtr^.info.vertPot:=ValStr(dummy);
     FOR i:=0 TO 5 DO
         LeseZeile(SystemString[i]);
     END;
     ClearMenuStrip(window);
       MenuItemLoad(1);
       MenuItemLoad(17);
       MenuItemLoad(21);
       MenuItemLoad(22);
     wahr:=SetMenuStrip(window,menustripPtr);
  END;
  Close(input);
  PrintDosErr(IoErr());
  IF (checked IN MenuItemFeld[21].flags) THEN
     CleanupHandler; Wache;
  END;
  IF (checked IN MenuItemFeld[22].flags) THEN
     IF NOT bool THEN
        Resident;
     END;
  END;
  RefreshGList(ADR(GadgetFeldListe[fileTextGadget]),window,NIL,7);
END LoadOpts;

PROCEDURE Saver;
BEGIN
  IF BackupFlag=FALSE THEN
     BackupFlag:=TRUE;
  ELSE
     BackupFlag:=FALSE;
  END;
END Saver;

PROCEDURE ProjektSpeichern(txt : BOOLEAN);
VAR save    : BOOLEAN;
    nr      : LONGINT;
    str,
    makedir : ARRAY [0..79] OF CHAR;
    lock    : FileLockPtr;
BEGIN
  IF (Length(BufferString[7]) # 0) THEN
     Copy(DummyStr,"sys:c/Copy ");
     Concat(DummyStr,BufferString[7]);
       IF txt THEN Concat(DummyStr,"/txt/") END;
     Concat(DummyStr," TO ");
     Copy(str,BufferString[7]);
      nr:=LastPos(str,Length(str),"/");
      IF nr < 0 THEN nr:=FirstPos(str,0,":") END;
     DeleteStr(str,0,nr+1); Concat(DummyStr,BufferString[5]);
     Concat(DummyStr,str);
       IF txt THEN Concat(DummyStr,"/txt") END;
     Concat(DummyStr," ALL QUIET");
      Copy(makedir,BufferString[5]); Concat(makedir,str);

       IF projectFlag THEN UnLock(altlock) END;
          lock:=CreateDir(ADR(makedir));
          nr:=IoErr(); UnLock(lock);

          PrintStatus("Sichere Projekt.");
          Convert(ADR(GadgetFeldListe[copyGadget]));
       nr:=Executeing(DummyStr);

     Copy(DummyStr,BufferString[5]); Concat(DummyStr,str);
     Concat(DummyStr,".info");
     IF NOT Prueffile(DummyStr,FALSE) THEN
        Copy(str,BufferString[7]); Concat(str,".info");
        IF Prueffile(str,FALSE) THEN
           Copy(DummyStr,"sys:c/Copy ");
           Concat(DummyStr,str); Concat(DummyStr," TO ");
           Concat(DummyStr,BufferString[5]);
           nr:=Executeing(DummyStr);
        END;
     END;
     Invers(ADR(GadgetFeldListe[copyGadget]));

     IF projectFlag THEN
        lock:=Lock(ADR(BufferString[7]),accessRead);
        altlock:=CurrentDir(lock);
     END;
  END;
END ProjektSpeichern;

PROCEDURE StartProject():BOOLEAN;
VAR erg  : INTEGER;
    lock : FileLockPtr;
BEGIN
  Copy(DummyStr,SystemString[4]); Concat(DummyStr,SystemString[3]);
  Concat(DummyStr," ");
  Concat(DummyStr,OptionenString[6]); Concat(DummyStr," ");

  IF (Length(BufferString[7]) # 0) THEN
        IF (NOT Prueffile(BufferString[7],TRUE)) THEN
           Concat(DummyStr,BufferString[7]);
           erg:=Executeing(DummyStr);
        END;
        Copy(DummyStr,BufferString[7]);
        Concat(DummyStr,"/m2Maker.par");
        IF (Prueffile(DummyStr,TRUE)) THEN
           Copy(DummyStr,"sys:c/Copy ");
           Concat(DummyStr,BufferString[7]);
           Concat(DummyStr,"/m2Maker.par TO ");
           Concat(DummyStr,SystemString[4]);
           erg:=Executeing(DummyStr);
           LoadOpts; NewDir(FALSE);
        ELSE
           Copy(DirPtr^.Pfad,BufferString[7]); Concat(DirPtr^.Pfad,"/");
           DirPtr^.info.vertPot:=0;
           NewDir(TRUE);
        END;
        PrintStatus('Projekt initialisiert');
         lock:=Lock(ADR(BufferString[7]),accessRead);
         altlock:=CurrentDir(lock);
     RETURN TRUE;
  ELSE
     PrintStatus('Kein Projekt definiert !!!');
  END;
  RETURN FALSE;
END StartProject;

PROCEDURE Project;
VAR lock : FileLockPtr;
    wahr : BOOLEAN;
BEGIN
  IF (projectFlag = FALSE) THEN
     PrintStatus("Projektverzeichnis erstellt");
     IF StartProject() THEN
        projectFlag:=TRUE;
        ClearMenuStrip(window);
          INCL(MenuItemFeld[2].flags,itemEnabled);
          INCL(MenuItemFeld[15].flags,itemEnabled);
          INCL(MenuItemFeld[17].flags,itemEnabled);
        wahr:=SetMenuStrip(window,menustripPtr);
     ELSE
        Invers(ADR(GadgetFeldListe[projectGadget]))
     END;
  ELSE
     projectFlag:=FALSE;
     ClearMenuStrip(window);
       EXCL(MenuItemFeld[2].flags,itemEnabled);
       EXCL(MenuItemFeld[15].flags,itemEnabled);
       EXCL(MenuItemFeld[17].flags,itemEnabled);
       EXCL(MenuItemFeld[17].flags,checked);
     wahr:=SetMenuStrip(window,menustripPtr);
     PrintStatus('Projekt beendet');
     lock:=CurrentDir(altlock); UnLock(lock);
  END;
END Project;

PROCEDURE SelectedFile;
VAR pos : INTEGER;
BEGIN
  IF DirPtr^.newProjekt THEN
     IF projectFlag THEN
        Project;
          Copy(BufferString[7],DirPtr^.Pfad);
          Concat(BufferString[7],DirPtr^.Projekt);
          RefreshGList(ADR(GadgetFeldListe[nameGadget]),window,NIL,1);
        Project;
        PrintStatus("Wechsel des Projekts !!!");
     ELSE
        Concat(DirPtr^.Pfad,DirPtr^.Projekt);
        NewDir(TRUE);
     END;
  ELSE
     Copy(BufferString[9],DirPtr^.Pfad);
     Copy(BufferString[3],DirPtr^.Auswahl);
     pos:=LastPos(BufferString[3],Length(BufferString[3]),".");
     IF (pos # -1) THEN
       LeftStr(BufferString[1],DirPtr^.Auswahl,pos);
     ELSE
       Copy(BufferString[1],DirPtr^.Auswahl);
     END;
     RefreshGList(ADR(GadgetFeldListe[fileTextGadget]),window,NIL,2);
  END;
END SelectedFile;

PROCEDURE NewCli;
VAR str : ARRAY [0..15] OF CHAR;
BEGIN
  str:=("sys:c/NewShell"); PrintDosErr(Executeing(str));
END NewCli;

PROCEDURE SmallWindow;
VAR gadgptr : GadgetPtr;
    erfolg  : BOOLEAN;
BEGIN
  IF (NOT bigWindow) THEN
     bigWindow:=TRUE;
     MoveWindow(window,-1 * window^.leftEdge,-1 * window^.topEdge);
     SizeWindow(window,-365,29-fensterHoehe); Delay(5);
     ModifyIDCMP(window,IDCMPFlagSet{closeWindow,gadgetUp,rawKey,menuPick,
                                     activeWindow,inactiveWindow});
     WindowToFront(window); Delay(5);
  ELSE
     bigWindow:=FALSE;
     MoveWindow(window,-1 * window^.leftEdge,-1 * window^.topEdge);
     SizeWindow(window,365,fensterHoehe-29); Delay(5);
     ModifyIDCMP(window,IDCMPFlagSet{closeWindow,gadgetUp,rawKey,activeWindow,
                                     inactiveWindow,mouseButtons,menuPick});
     Frame(window^.rPort,1,0,0,fensterBreite-1,fensterHoehe-1,1);
     IF projectFlag THEN Convert(ADR(GadgetFeldListe[projectGadget])) END;
     WindowToFront(win); Delay(5);
  END;
END SmallWindow;

PROCEDURE FastLister;
VAR  name : ARRAY [0..50] OF CHAR;
BEGIN
  Copy(name,SystemString[4]); Concat(name,"FastLister ");
  IF NOT Prueffile(name,FALSE) THEN
     PrintStatus("FastLister installiert.");
     DummyStr:=("sys:c/Run "); Concat(DummyStr,name);
     Concat(DummyStr,BufferString[11]);
     PrintDosErr(Executeing(DummyStr));
  END;
END FastLister;

PROCEDURE ExecuteBatch;
VAR  name : ARRAY [0..50] OF CHAR;
BEGIN
  Copy(DummyStr,SystemString[4]); Concat(DummyStr,"m2Maker.exec");
  IF Prueffile(DummyStr,FALSE) THEN
     name:=("sys:c/Execute "); Concat(name,DummyStr);
     PrintStatus("Arbeite Batchdatei ab.");
     PrintDosErr(Executeing(name));
  END;
  FastLister;
END ExecuteBatch;

PROCEDURE NewFile;
VAR bool : BOOLEAN;
BEGIN
  BufferString[3]:=(""); BufferString[1]:=("");
    Copy(BufferString[9],DirPtr^.Pfad);
    RefreshGList(ADR(GadgetFeldListe[fileTextGadget]),window,NIL,2);
  bool:=ActivateGadget(ADR(GadgetFeldListe[editTextGadget]),window,NIL);
END NewFile;

PROCEDURE ProjektPfad;
BEGIN
  IF (BufferString[7,Length(BufferString[7])-1] = CHAR(47)) THEN
     BufferString[7,Length(BufferString[7])-1]:=00C;
  END;
  IF (Occurs(BufferString[7],0,".Projekt",FALSE) = -1 ) THEN
     Concat(BufferString[7],".Projekt");
  END;
  RefreshGList(ADR(GadgetFeldListe[nameGadget]),window,NIL,1);
END ProjektPfad;

PROCEDURE BackupPfad;
VAR len : INTEGER;
BEGIN
  len:=Length(BufferString[5]);
  IF ((BufferString[5,len-1] # CHR(47)) AND
                              (BufferString[5,len-1] # CHR(58))) THEN
     BufferString[5,len]:=CHR(47);
     BufferString[5,len+1]:=00C;
  END;
  RefreshGList(ADR(GadgetFeldListe[pathTextGadget]),window,NIL,1);
END BackupPfad;

PROCEDURE Clear;
BEGIN
  IF projectFlag THEN
     Invers(ADR(GadgetFeldListe[projectGadget]));
     Project;
  END;

  OptionenString[4]:=("-qx");        BufferString[3]:=("");
  OptionenString[2]:=("-dfnqrsv");   BufferString[1]:=("");
  BufferString[5]:=("df1:");         OptionenString[6]:=("-br");
  BufferString[7]:=("");             OptionenString[0]:=("-b");
  BufferString[9]:=("");
  SystemString[0]:=("m2emacs"); SystemString[1]:=("m2c");
  SystemString[2]:=("m2l");     SystemString[3]:=("m2project");
  SystemString[4]:=("m2:");
  RefreshGList(ADR(GadgetFeldListe[fileTextGadget]),window,NIL,8);
  NewDir(TRUE);
END Clear;

PROCEDURE StartDefMaker;
BEGIN
  PrintStatus("Aktiviere DefMaker !");
    Copy(DummyStr,"run "); Concat(DummyStr,SystemString[4]);
    Concat(DummyStr,"ModuleTool ");
    Concat(DummyStr,BufferString[9]); Concat(DummyStr,BufferString[3]);
  PrintDosErr(Executeing(DummyStr));
END StartDefMaker;

PROCEDURE EditSysCompiler;
BEGIN
  Copy(DummyStr,SystemString[4]); Concat(DummyStr,SystemString[0]);
  Concat(DummyStr," "); Concat(DummyStr,OptionenString[0]);
  Concat(DummyStr," ");  Concat(DummyStr,BufferString[7]);
  Concat(DummyStr,"/m2maker.mke");
  PrintDosErr(Executeing(DummyStr));
END EditSysCompiler;

(* $E- *)
PROCEDURE Daten;
BEGIN
  INLINE( 00000H,00000H,
          08003H,0C001H,04006H,06002H,0200CH,03004H,01018H,01808H,
          00830H,00C10H,00460H,00620H,002C0H,00340H,00180H,00180H,
          00380H,001C0H,00640H,00260H,00C20H,00430H,01810H,00818H,
          03008H,0100CH,06004H,04006H,0C002H,04003H,08001H,08001H,
          00000H,00000H);
END Daten;

BEGIN
  IF (AvailMem(MemReqSet{chip}) >= 72) THEN
      pointer:=AllocMem(72,MemReqSet{chip});
      CopyMem(ADR(Daten),pointer,72);
  END;
END m2MakerRoutines.