Delphi Preprocessor und Subprocessor?

[Assarbad]

Hiho,

suche einen Experten (DLL!) oder ähnliches der folgendes macht:

• Vor dem Kompilieren führt er eine Batchdatei oder Befehle meiner Wahl aus
• Nach dem Kompilieren eine andere Batchdatei oder Befehle

Sinn und Zweck: direkt in der IDE die Ressourcen kompilieren (erst ab Delphi 5 kann man RCs einbinden, vorher gehen nur RES) und nach dem kompilieren die Checksumme der EXE setzen. (Und evtl noch per UPX packen)

[jbg]

Das lässt sich doch recht schnell zusammen schreiben, vorausgesetzt man kennt sich mit der OpenTools API aus.

Delphi-Quellcode:

unit PrePostProcessor;
interface
uses
  SysUtils, ToolsAPI;
type
  TCompilerNotifier = class(TNotifierObject, IOTAIDENotifier)
  public
   // IOTAIDENotifier
    procedure FileNotification(NotifyCode: TOTAFileNotification; const FileName: string;
      var Cancel: Boolean); virtual;
    procedure BeforeCompile(const Project: IOTAProject;
      var Cancel: Boolean); overload; virtual;
    procedure AfterCompile(Succeeded: Boolean); overload; virtual;
   // IOTAIDENotifier50
    procedure BeforeCompile(const Project: IOTAProject; IsCodeInsight: Boolean;
      var Cancel: Boolean); overload; virtual;
    procedure AfterCompile(Succeeded: Boolean; IsCodeInsight: Boolean); overload; virtual;
  end;

implementation
{ TCompilerNotifier }

{ veraltete Methoden }
procedure TCompilerNotifier.BeforeCompile(const Project: IOTAProject; var Cancel: Boolean);
begin
end;

procedure TCompilerNotifier.AfterCompile(Succeeded: Boolean);
begin
end;

{ neue Methoden }
procedure TCompilerNotifier.BeforeCompile(const Project: IOTAProject; IsCodeInsight: Boolean; var Cancel: Boolean);
begin
  if SameText(ExtractFileExt(Project.FileName), '.bpg') then Exit; // This should never happen
  if IsCodeInsight then Exit;

// Project.FileName gibt den Dateinamen des Projekts an (.dpr).

{ // save all
  Cancel := not (BorlandIDEServices as IOTAModuleServices).SaveAll; 
  if Cancel then Exit; }

end;

procedure TCompilerNotifier.AfterCompile(Succeeded: Boolean; IsCodeInsight: Boolean);
begin
  if not IsCodeInsight then
  
end;

procedure TCompilerNotifier.FileNotification(NotifyCode: TOTAFileNotification;
  const FileName: string; var Cancel: Boolean);
begin
  Cancel := False;
end;


var
  NotifierIndex: Integer;

{ CompilerNotifier registrieren }
initialization
  NotifierIndex := (BorlandIDEServices as IOTAServices).AddNotifier(TCompilerNotifier.Create);

finalization
  if NotifierIndex >= 0 then
    (BorlandIDEServices as IOTAServices).RemoveNotifier(NotifierIndex);

 // clear all IOTACustomMessages here, else Delphi unloads the dll and then
 // it wants to free the messages -> AccessViolation
  (BorlandIDEServices as IOTAMessageServices).ClearToolMessages;

end.

Das ganze musst du jetzt nur noch in ein DesignTime only Package verpacken, dass designide und rtl requires.

[Assarbad]

Wie ich schon sagte: "vor Delphi 4" ... erst seit Delphi 5 ist die OpenTools API so wie sie jetzt eben ist :-/

Ich schau mir deine Lösung mal an und geb dann Feedback-

[Assarbad]

Okay, habe nicht explizit sondern nur implizit gesagt, daß es Delphi 4 (oder niedriger) sein muß.

Entsprechend geht es hier auch nicht. Ich werd mal nochmal in die Units schauen, vielleicht läßt sich doch was machen. Vielen Dank, einstweilen ;)

[jbg]

Ich hätte auch besser lesen können. :idea:


Für Delphi 3 würde das ungefähr so aussehen:

Delphi-Quellcode:

uses ToolIntf, Exptintf;

type
  TCompilerNotifier = class(TIAddInNotifier)
  public
    procedure FileNotification(NotifyCode: TFileNotification;
      const FileName: string; var Cancel: Boolean); override;
    procedure EventNotification(NotifyCode: TEventNotification;
      var Cancel: Boolean); override;
  end;

procedure TCompilerNotifier.EventNotification(NotifyCode: TEventNotification;
  var Cancel: Boolean);
begin
  if NotifyCode = enBeforeCompile then
  begin
    // ..
  end
  else // if NotifyCode = enAfterCompile then
  begin
    // ...
  end;
end;

var
  CompilerNotifier: TCompilerNotifier;

initialization
  CompilerNotifier := TCompilerNotifier.Create;
  ToolServices.AddNotifierEx(CompilerNotifier);
finalization
  ToolServices.RemoveNotifier(CompilerNotifier);
end.

[Assarbad]

Dank dir vielmals, derzeit mäkelt er noch bei einem Typen aber ich schau mal, ob ich das ausbügeln kann. Ich melde mich dann nochmal ;)

[Assarbad]

Funktioniert wunderbar:

Delphi-Quellcode:

unit PrePostProcessor;
interface
uses ToolIntf, Exptintf;

type
  TCompilerNotifier = class(TIAddInNotifier)
  public
    procedure EventNotification(NotifyCode: TEventNotification; var Cancel: Boolean); override;
  end;

implementation
var
  CompilerNotifier: TCompilerNotifier;

procedure TCompilerNotifier.EventNotification(NotifyCode: TEventNotification; var Cancel: Boolean);
begin
  case NotifyCode of
    enBeforeCompile:
      begin
      end;
    enAfterCompile:
      begin
      end;
  end;
end;

initialization
  CompilerNotifier := TCompilerNotifier.Create;
  ToolServices.AddNotifierEx(CompilerNotifier);
finalization
  ToolServices.RemoveNotifier(CompilerNotifier);
end.

Du hast damit ein lange bestehendes Problem bei mir aus dem Wege geräumt!
Top!

[Assarbad]

Hiho,

auch mit Delphi 4 geht es ... man muß nur TNotifierObject durch TInterfacedObject ersetzen und ein paar Methoden implementieren. Ich werde das nochmal umschreiben. Wenn du erlaubst, würde ich es dann als OpenSource hier ins Forum stellen. Schreib mir doch mal ne PN was du drinstehen haben möchtest, jbg ;)

Delphi-Quellcode:

unit ...
interface
uses
  SysUtils, ToolsAPI;

type
  TCompilerNotifier = class(TInterfacedObject, IOTAIDENotifier)
  public
// IOTAIDENotifier
    procedure FileNotification(NotifyCode: TOTAFileNotification; const FileName: string; var Cancel: Boolean); virtual;
    procedure BeforeCompile(const Project: IOTAProject; var Cancel: Boolean); overload; virtual;
    procedure AfterCompile(Succeeded: Boolean); overload; virtual;
// IOTANotifier
    procedure AfterSave;
    procedure BeforeSave;
    procedure Modified;
    procedure Destroyed;
// IOTAIDENotifier50
    procedure BeforeCompile(const Project: IOTAProject; IsCodeInsight: Boolean;
      var Cancel: Boolean); overload; virtual;
    procedure AfterCompile(Succeeded: Boolean; IsCodeInsight: Boolean); overload; virtual;
  end;


implementation
{ TCompilerNotifier }

procedure TCompilerNotifier.AfterSave;
begin
end;

procedure TCompilerNotifier.BeforeSave;
begin
end;

procedure TCompilerNotifier.Modified;
begin
end;

procedure TCompilerNotifier.Destroyed;
begin
end;

{ veraltete Methoden }

procedure TCompilerNotifier.BeforeCompile(const Project: IOTAProject; var Cancel: Boolean);
begin
end;

procedure TCompilerNotifier.AfterCompile(Succeeded: Boolean);
begin
end;

{ neue Methoden }

procedure TCompilerNotifier.BeforeCompile(const Project: IOTAProject; IsCodeInsight: Boolean; var Cancel: Boolean);
begin
  if not IsCodeInsight then
  begin
    if not (BorlandIDEServices as IOTAModuleServices).SaveAll then
      Exit;
  end;
end;

procedure TCompilerNotifier.AfterCompile(Succeeded: Boolean; IsCodeInsight: Boolean);
begin
  if not IsCodeInsight then
  begin
  end;
end;

procedure TCompilerNotifier.FileNotification(NotifyCode: TOTAFileNotification; const FileName: string; var Cancel: Boolean);
begin
  Cancel := False;
end;

var
  NotifierIndex: Integer;

{ CompilerNotifier registrieren }
initialization
  NotifierIndex := (BorlandIDEServices as IOTAServices).AddNotifier(TCompilerNotifier.Create);

finalization
  if NotifierIndex >= 0 then
    (BorlandIDEServices as IOTAServices).RemoveNotifier(NotifierIndex);
// clear all IOTACustomMessages here, else Delphi unloads the dll and then
// it wants to free the messages -> AccessViolation
  (BorlandIDEServices as IOTAMessageServices).ClearToolMessages;

end.

[Bomberbb]

Also, ich habe das mit dem pre und subprocessor hinbekommen. Was ich vorhabe: Ich will mit einem Project, abhängig von den compilieroptionen verschiedene Dateien erstellen (die Datei nach dem kompilieren umbenennen und eventuell gleich packen). nun will ich die Kompilieroptionen meiner Projekte im Postprocessor nutzen. Ich habe gesehen es gibt im Quelltext die Konstante Project:IOTAProject. Ich denke, dass das was ich brauche hier drin steckt. Es Gibt ja auch Project.Filename aber wie bekomme ich raus, was in der Konstanten noch drinsteckt. Wie gesagt, am wichtigsten wären die Kompilieroptionen. Habe nun den halben Tag im Internet gesucht, aber keine Lösung gefunden.
Kann mir hier jemand helfen???

[mschaefer]

Gibt es sowas eigentlich inzwischen als fertiger Experte für die IDE ? // Grüße Martin