{ Diese Modul enthaelt verschiedene Transfermacros
  fuer die unterschiedlichen Tools. Die Datei muss
  nach dem Laden übersetzt werden, damit die Macros
  zur Verfügung stehen. }
PROGRAM TransferMacros;

{ globale Variablen bleiben solange bestehen, solange das
  Modul geladen ist. Diese Variablen dienen dazu Daten
  zu speichern, die von einem zum anderen Aufruf erhalten
  bleiben sollen }
var
     TransferString : String;
     ErrorFile      : String;
     ErrorMessage   : String;
     ErrorPosition  : Integer;
     ErrorLine      : Integer;
     Line           : Integer;

(*{{{  procedure TxAll(s:string);*)
{ folgendes Macro gibt alles aus was angegeben wird }
procedure TxAll(s:string);
begin
   {MsgAddMessage('JAVACompile', '', s, 0,0);}
   writeln(s);
end;
(*}}}*)

(*{{{  procedure TxGrepText(s:string);*)
{ Folgendes Macro analysiert die Ausgaben von Grep
  und traegt sie als Message im Messagefenster ein }
procedure TxGrepText(s:string);
var space,line,code : integer;
    msg:String;
begin
   if (pos('File', s) = 1) then begin
      space    := pos(#32, s);
      if (space > 0) THEN begin
         Inc(space);
         TransferString := copy(s, space, length(s)-space);
      end;
   end else if (TransferString <> '') then begin
      { dieser String faengt mit der Zeilennummer an }
      Val(s,line,code);
      swrite(msg, FileNameGetNameExt(TransferString),
             '(', line, ',1):',copy(s,code,255));
      MessageAddMessage('GrepText', TransferString, msg, line,1);
   end else begin
      MessageAddMessage('GrepText', '', s, 0,0);
   end;
end;
(*}}}*)

(*{{{  procedure TxFindString(s:string);*)
{ Folgendes Macro analysiert die Ausgaben von FindString
  aus dem NT- Verzeichnis
  und traegt sie als Message im Messagefenster ein.
  Jede Zeile enthaelt den Dateinamen und die Zeilenummer
  file:zeile:text, wobei Dateiname mit dem Laufwerksbuchstaben
  beginnt, der auch durch einen : begrenzt wird.}
procedure TxFindString(s:string);
var code,p : integer;
    msg,drive : string;
begin
   p := posx(':', s, 3); { erstes Vorkommen, begrenzt Laufwerksbezeichnung }
   if (p > 0) then begin
      ErrorFile := copy(s, 1, p-1); { : nicht mit kopieren }
      delete(s, 1, p);              { Dateiname loeschen}
      { dieser String faengt mit der Zeilennummer an }
      Val(s,ErrorLine,code);
      swrite(msg, FileNameGetNameExt(ErrorFile),
             '(', ErrorLine, ',1):',copy(s,code+1,255));
      MessageAddMessage('FindString', ErrorFile, msg, ErrorLine,1);
   end else begin
      { Evtl. eine andere Fehlermeldung }
      MessageAddMessage('FindString', '', s, 0,0);
   end;
end;
(*}}}*)

(*{{{  procedure TxJavaCompile(s:string);*)
{ folgendes Macro analysiert die Ausgabe des JAVA- Compilers
  dieser gibt Fehlermeldungen in mehreren Zeilen aus. Die
  erste Zeile enthaehlt die fehlerhafte Datei und den
  Fehlertext. Die zweite Zeile enthaelt eine Kopie der
  fehlerhaften Quelltextzeile. Die dritte Zeile letztlich
  gibt durch das Zeichen  ^ an an welcher Position der Fehler
  ist.
}
procedure TxJavaCompile(s:string);
var space : Integer;
    code  : Integer;
begin
   if (pos('Note:', s) > 0) then begin
      { es handelt sich um eine Warnung mit Text in einer Zeile }
      space    := pos(#32, s); TransferString := '';
      if (space > 0) THEN begin
         Inc(space);
         swrite(TransferString, copy(s, space, length(s)-space));
      end;
      MessageAddMessage('JAVACompile', '', TransferString, 0,0);
      Line := 0;
   end else if (Line = 0) then begin
      { DateiName :Zeile: Meldung}
      space := pos(':',s);
      if (space > 0) then begin
         ErrorFile := copy(s, 1, space-1);
         delete(s,1,space);   Val(s,ErrorLine,code);
         space := pos(':',s);
         if (space > 0) then begin
            { FehlerMeldung kopieren }
            ErrorMessage := copy(s, space+1, 255);
         end;
         Line := 1;
      end;
   end else if (Line = 1) then begin
      Line := 2;
   end else if (Line = 2) then begin
      space := pos('^',s); TransferString := '';
      if (space > 0) then begin
         swrite(TransferString,
                FileNameGetNameExt(ErrorFile),
                '(', ErrorLine, ',', space, '):',
                ErrorMessage);
         MessageAddMessage('JAVACompile',
                       ErrorFile, TransferString,
                       ErrorLine, space);
      end;
      Line := 0;
   end;
end;
(*}}}*)

(*{{{  procedure TxCC68K(s : string);*)
{ Transfer Macro fuer cc68k }
procedure TxCC68K(s : string);
var p : integer;
    p2 : integer;
    code  : Integer;
    { Unterprogramm
    }
    (*{{{  procedure make_message(p : integer);*)
    procedure make_message(p : integer);
    begin
      ErrorMessage := copy(s, p, 255);
      { Dateiname extrahieren }
      p  := pos('"', s);
      if (p > 0) then begin
         p2 := posx('"', s, p+1);
         if (p2 > p) then begin
            ErrorFile:= copy(s, p+1, (p2-p)-1);
         end;
      end;
      { Zeile extrahieren }
      p := pos('line', s); ErrorLine := 1;
      if (p > 0) then begin
         p := p+5;
         val(copy(s,p,10), ErrorLine, code);
      end;
      TransferString := '';
      swrite(TransferString,
             FileNameGetNameExt(ErrorFile),
             '(', ErrorLine, '):',
             ErrorMessage);

      MessageAddMessage('cc68k',
                    ErrorFile, TransferString,
                    ErrorLine, 1);
    end;
    (*}}}*)
begin
   p := pos('error', s);  { error kennzeichnet Fehler }
   if (p > 0) then begin
      make_message(p);
      exit;
   end;
   p := pos('info',s);  { info kennzeichnet info's }
   if (p >0) then begin
      make_message(p);
      exit;
   end;
   { string so ausgeben }
   { MessageAddMessage('cc68k', '', s, 1,1); }
end;
(*}}}*)

{ eine Initialisierung ist nicht notwendig }
begin
end.