(* *****************************************************************
** File    : mri_tools.pas
** Created : 02.06.99
** Author  : 
**
** Macro for FoldMaster supporting
**   Microtec 68K Compiler/Assembler/Linker Package
**      tested with Version 4.4 of C- Compiler
**
** **************************************************************-**)
PROGRAM MRI_TOOLS;

(*{{{  const strings*)
const
   c_name       = 'MRI68K-OBJ C-Compiler';
   asm_name     = 'MRI68K-OBJ Assembler';
   lib_name     = 'MRI68K Librarian';
   lnk_name     = 'MRI68K Linker';
   { folgende Tools werden benutzt um Dateien in
     eine Library zu stecken }
   c_name_lib   = 'MRI68K-LIB C-Compiler';
   asm_name_lib = 'MRI68K-LIB Assembler';
(*}}}*)

(*{{{  globale Variablen*)
{ 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;
     LineOffset     : Integer;
     Line           : Integer;
     CPP_InstPath   : String;
     ASM_InstPath   : String;
(*}}}*)

{ Transfer Filter fuer die verschiedenen Werkzeuge }
(*{{{  txcompile*)
{ txcompile
  Transferfilter fuer den Compiler
  Format:
  "D:\FMTEST\mri\SYSLIB\TERMINAL.C", line 72 pos 19; (W) can't open #include file <stdio.h>; directive ignored
  "file", line z pos x; (W) text
}
procedure txcompile(s : string);
var max, p, code : integer;
begin
   if (copy(s,1,1) = '"') then begin
      ErrorLine     := 1;
      ErrorPosition := 1;
      { Fehlermeldung gefunden }
      max := pos(';', s);  { danach beginnt Fehlertext }
      ErrorMessage := copy(s, max+2, 255);
      p := posx ('"', s, 2);
      ErrorFile    := copy(s, 2, p-2);
      p := posx ('line', s, p+2);
      if ((p >0) AND (p < max)) then begin
         val(copy(s, p+5,4), ErrorLine, code);
      end;
      p := posx ('pos', s, p+7);
      if ((p >0) AND (p < max)) then begin
         val(copy(s, p+3,5), ErrorPosition, code);
      end;
      { Message zusammentstellen }
      TransferString := '';
      swrite(TransferString, FileNameGetNameExt(ErrorFile),
             '(', ErrorLine, ',', ErrorPosition, '):',   ErrorMessage);
      MessageAddMessage(c_name,  ErrorFile, TransferString, ErrorLine, ErrorPosition);
   end else begin
      writeln(s);
   end;
end;
(*}}}*)
(*{{{  tx_c_gen*)
{ tx_c_gen
  Transferfilter fuer den C- Compiler
  Format:
  "D:\FMTEST\mri\SYSLIB\TERMINAL.C", line 72 pos 19; (W) can't open #include file <stdio.h>; directive ignored
  "file", line z pos x; (W) text
}
procedure tx_c_gen(s : string);
var max, p, code : integer;
begin
   if (copy(s,1,1) = '"') then begin
      MessageAddGenMessage (c_name, '"%f", line %l pos %p; (%w) %t', s);
   end;
end;
(*}}}*)
(*{{{  tx_asm_gen*)
{ tx_asm_gen
  Transferfilter fuer den Assembler
  Format:
  "test.src", line 109;  ** ERROR:(528) Invalid opcode.
}
procedure tx_asm_gen(s : string);
var max, p, code : integer;
begin
   if (copy(s,1,1) = '"') then begin
      MessageAddGenMessage (asm_name, '"%f", line %l;  ** %t', s);
   end;
end;
(*}}}*)

{ Umgebungsvariablen eintragen, die notwendig sind
  Diese Variablen sind nur gueltig, fuer Aufrufe aus
  dem Editor. Beruecksichtigt die Variable InstPath }
(*{{{  procedure set_env;*)
{ set_env
  wird aufgerufen um die korrekten Umgebungsvariablen fuer den Aufruf
  der verschiedenen Tools und Compiler zu setzen
}
procedure set_env;
var s : string;
begin
   SetEnvValue('MRI_68K_INC', CPP_InstPath);
   SetEnvValue('MRI_68K_LIB', CPP_InstPath);
   SetEnvValue('MRI_68K_TMP', 'C:\TEMP');
   SetEnvValue('MRI_68K_BIN', concat(CPP_InstPath, ';', ASM_InstPath));
end;
(*}}}*)

{ Werkzeuge definieren }
(*{{{  define_c_compiler*)
{ define_c_compiler
  Richtet ein Tool fuer C- Compiler ein
}
procedure define_c_compiler;
begin
   ToolDefine       (c_name, concat(CPP_InstPath, '\Mcc68k.exe'),
                     '$DRIVEDIR($EDNAME)',
                     '$SAVE $(MRI_COPT) $EDNAME');
   ToolDefineType   (c_name, '.c', '.obj', 'C/C++', 2);
   ToolDefineMode   (c_name, '"%f", line %l pos %p; (%w) %t', 6);
   ToolDefineConnect(c_name, '', 0);
   ToolDefineOptions(c_name, 3, 0);
end;
(*}}}*)
(*{{{  define_assembler*)
{ define_assembler
  Definiert das Tool fuer den Assembler
}
procedure define_assembler;
begin
   ToolDefine       (asm_name, concat(ASM_InstPath, '\Asm68k.exe'),
                     '$DRIVEDIR($EDNAME)',
                     '$SAVE $(MRI_ASMOPT) $NAME($EDNAME).src');
   ToolDefineType   (asm_name, '.src', '.obj', 'MOTASM', 2);
   ToolDefineMode   (asm_name, 'tx_asm_gen', 3);
   ToolDefineConnect(asm_name, '', 0);
   ToolDefineOptions(asm_name, 3, 0);
end;
(*}}}*)
(*{{{  define_librarian*)
{ define_librarian
  Definiert das Tool fuer den Librarian
}
procedure define_librarian;
begin
   ToolDefine       (lib_name, concat(ASM_InstPath, '\Lib68k.exe'),
                     '$(OBJPATH)', '$(MRI_LIBOPT)');
   ToolDefineType   (lib_name, '.cmd', '.lib', 'MOTASM', 2);
   ToolDefineMode   (lib_name, '', 2);
   ToolDefineConnect(lib_name, '', 0);
   ToolDefineOptions(lib_name, 3, 0);
end;
(*}}}*)
(*{{{  define_linker*)
{ define_linker
  Definiert das Tool fuer den Linker
}
procedure define_linker;
begin
   (* Definition of MRI68K Linker *)
   ToolDefine       (lnk_name, concat(ASM_InstPath, '\LNK68K.EXE'),
                     '$(OBJPATH)', '$(MRI_LNKOPT)');
   ToolDefineType   (lnk_name, '.cmd', '.abs', 'MOTASM', 2);
   ToolDefineMode   (lnk_name, '', 2);
   ToolDefineConnect(lnk_name, '', 0);
   ToolDefineOptions(lnk_name, 3, 0);

end;
(*}}}*)

{ Syntaxfilter defninieren }
{    Zur genauen UNterscheidung zwischen Kommandodateien fuer den
     Linker und solcher fuer das Lib- Tool werden unterschiedliche
     SyntaxFilter angelegt, die fuer die entsprechende Datei
     eingestellt werden können. }
{ Unterprogramm
     definiert Syntax fuer den Linker }
procedure define_syntax_mri68klnk;
begin
end;

{ Werkzeuge, die verwendet werden um OBJ's gleich in eine Library
  zu stecken. Das Lib- Tool wird automatisch aufgerufen, nachdem
  eine Datei erfolgreich uebersetzt wurde. }
(*{{{  define_c_compiler_lib*)
{ define_c_compiler
  Richtet ein Tool fuer C- Compiler ein
}
procedure define_c_compiler_lib;
begin
   ToolDefine       (c_name_lib, concat(CPP_InstPath, '\Mcc68k.exe'),
                     '$DRIVEDIR($EDNAME)',
                     '$SAVE $(MRI_COPT) $NAMEEXT($EDNAME)');
   ToolDefineType   (c_name_lib, '.c', '.obj', 'C/C++', 2);
   ToolDefineMode   (c_name_lib, '"%f", line %l pos %p; (%w) %t', 6);
   ToolDefineConnect(c_name_lib, lib_name, 0);
   ToolDefineOptions(c_name_lib, 3, 0);
end;
(*}}}*)
(*{{{  define_assembler_lib*)
{ define_assembler
  Definiert das Tool fuer den Assembler
}
procedure define_assembler_lib;
begin
   ToolDefine       (asm_name_lib, concat(ASM_InstPath, '\Asm68k.exe'),
                     '$DRIVEDIR($EDNAME)',
                     '$SAVE $(MRI_ASMOPT) $NAMEEXT($EDNAME)');
   ToolDefineType   (asm_name_lib, '.src', '.obj', 'MOTASM', 2);
   ToolDefineMode   (asm_name_lib, 'tx_asm_gen', 3);
   ToolDefineConnect(asm_name_lib, lib_name, 0);
   ToolDefineOptions(asm_name_lib, 3, 0);
end;
(*}}}*)

{ Hilfsmittel um alle notwendigen Variablen in eine Projektdatei
  einzufügen }
(*{{{  procedure insert_local_variables;*)
{ insert_local_variables
  fügt die beötigten Variablen in die Projektdatei
  an der aktuellen CursorPosition ein
}
procedure insert_local_variables;
begin
   if IsProject then begin
      InsertVariable('OBJEXT',      '.obj');
      InsertVariable('VER',         '114');
      InsertVariable('USE_COMPILER','MRI68K-LIB');
      InsertVariable('MRI_COPT',    '-c -Gf -g -p68340 -S -D_INITDATA -D__DEBUG=0');
      InsertVariable('MRI_ASMOPT',  '-f "case, p=68340, quick"');
      InsertVariable('MRI_LIBOPT',  '-r $NAME($EDNAME)$(OBJEXT) $TARGET.lib');
      InsertVariable('MRI_LNKOPT',  '-c $NAMEEXT($EDNAME) -M -o $TARGET$(VER)p.abs');
   end;
end;
(*}}}*)
(*{{{  procedure insert_librarian_call;*)
{ Unterprogramm
}
procedure insert_librarian_call;
begin
   ToolInsert('MRI68K Librarian');  { tool einfuegen }
end;
(*}}}*)

BEGIN
   LineOffset := 0;

   (*{{{  Installationspfade bestimmen*)
   { ----------------------------------------------------- }
   { Installationspfad bestimmen }
   { ----------------------------------------------------- }
   { pruefen ob variable MRI_CPP_INSTPATH vorhanden ist wenn nich,
     dann nach dem Instalations verzeichnis suchen lassen }
   CPP_InstPath := GetVarValue('MRI_CPP_INSTPATH');
   FileNameMakeShort(CPP_InstPath); { benoetigt kurze Namen }
   if (CPP_InstPath = '') then begin
      { Nach Pfad suchen }
      Beep;
      if (DirectoryInput ('CPP- Installations Pfad', CPP_InstPath)) then begin
         SetGlobalVar('MRI_CPP_INSTPATH', CPP_InstPath);
      end;
   end;

   { pruefen ob variable MRI_CPP_INSTPATH vorhanden ist wenn nich,
     dann nach dem Instalations verzeichnis suchen lassen }
   ASM_InstPath := GetVarValue('MRI_ASM_INSTPATH');
   FileNameMakeShort(ASM_InstPath); { benoetigt kurze Namen }
   if (ASM_InstPath = '') then begin
      { Nach Pfad suchen }
      Beep;
      if (DirectoryInput ('ASM- Installations Pfad', ASM_InstPath)) then begin
         SetGlobalVar('MRI_ASM_INSTPATH', ASM_InstPath);
      end;
   end;
   (*}}}*)

   { ----------------------------------------------------- }
   { Umgebungsvariablen einrichten }
   { ----------------------------------------------------- }
   set_env;

   { ----------------------------------------------------- }
   { Compiler- Tools definieren }
   { ----------------------------------------------------- }
   if (NOT ToolAvail(c_name_lib))   then define_c_compiler_lib;
   if (NOT ToolAvail(asm_name_lib)) then define_assembler_lib;

   if (NOT ToolAvail(c_name))   then define_c_compiler;
   if (NOT ToolAvail(asm_name)) then define_assembler;
   if (NOT ToolAvail(lib_name)) then define_librarian;
   if (NOT ToolAvail(lnk_name)) then define_linker;

   { ----------------------------------------------------- }
   { Funktionen in das Menue eintragen }
   { ----------------------------------------------------- }
   MacroMenuAdd ('insert_local_variables');
   MacroMenuAdd ('insert_librarian_call');

END.