Post compile batch starten aus IDE?

[HPW]

Hallo,

Kann man eigentlich aus D7 Pro einen Batch nach dem Compilieren automatisch anstarten?
(Also eine Batch spezifizieren der immer aus diesem Projekt nach dem Compilieren startet)
Ich programmiere eine Plugin-DLL die zum Testen immer in verschiedene Verzeichnisse kopiert werden muss.
Ich weiss das ich den Kommandozeilen Compiler nutzen könnte, aber geht sowas auch aus der IDE?

[Bernhard Geyer]

Nicht per Batch, sondern nur per IDE-Plugin (wie es z.B. das Jedi Debug-Plugin macht).
Erst neuere IDE-Versionen machen es hier einfacher.

[Bomberbb]

Ich selbst mache das per Tools-API: http://www.tempest-sw.com/opentools/

Gruß

BBB

[nahpets]

Hallo,

schau mal, ob Dir das weiterhilft:Before- und Aftercompileexperte

[HPW]

Vielen Dank für alle Antworten.
Werde mir alles mal anschauen.

[HPW]

Hallo,

Der Before- und Aftercompileexperte funktioniert unter D7 wie gewünscht.
Dazu noch eine Frage: Komme ich innerhalb der Events ausser an den Projektnamen auch an den Namen der kompilierten Datei incl. der Extension?
Ich schalte über einen Compiler-Schalter zwischen 2 Extensions um und würde gerne unterschiedliche Batches dafür anstossen.

[Bomberbb]

Ich hab es mit
Project.Filename gemacht, aber da gibt es nur die Endung dpr.
Das könnte evtl. noch gehen... ich hab es noch nicht ausprobiert, aber teste mal:

Project.Projectoptions.Values['CompileName'] hier im übrigen noch ne Liste der Optionen:

Delphi-Quellcode:

{
    Align                         FloatSupport                      MemberPointer                   SrcDir
    Alignment                     ForLoops                          MemberPrecision                 StackChecks
    Ansi                          GenConsoleApp                     MergeDupStrs                    StackFrames
    Assertions                    GenDll                            MFCCompat                       StackSize
    ATLAutoRegisterInproc         GenDRC                            MinEnumSize                     StdStackFrame
    ATLCoinitMultiThreaded        GenDUI                            MinorVersion                    SysDefines
    ATLDebug                      GenPackage                        ModuleAttribs                   Target
    ATLDebugQI                    GenStaticLibrary                  NestedComments                  TasmAllCase
    ATLDebugRefCount              HeapSize                          NoAskLibs                       TasmCaseCheckingOn
    ATLMultiUse                   HintFlag                          ObjDir                          TasmCrossReference
    ATLThreading                  HostApplication                   OpenStrings                     TasmDebugOn
    AutoDep                       IdentLen                          Optimization                    TasmDirective
    AutoIncBuildNum               ImageBase                         OptionsString                   TasmExpanded
    AutoRegVars                   ImageDebugInfo                    OutputDir                       TasmFullDebug
    BoolEval                      ImplicitBuild                     OutputObj                       TasmGenerateListing
    Build                         ImportedData                      OverflowChecks                  TasmHashTable
    CallingConvention             IncludePath                       Packages                        TasmIncludeConditionals
    CaseSensitive                 IncludeVersionInfo                PageSize                        TasmIncludeErrors
    ClearPackageCache             InMemoryExe                       PCH                             TasmPasses
    ClearUnitCache                InstructionSet                    PchPath                         TasmSymbolLength
    CodeModifiers                 IOChecks                          PchStopAfter                    TasmSymbolTables
    CodeOpt                       Keys                              PentiumFloat                    TasmViaCppOpts
    CodePage                      LibPath                           PkgDcpDir                       TasmWarningsLevel1
    CompileName                   LibraryList                       PkgDllDir                       TasmWarningsOn
    CppDebugInfo                  LineNumbers                       PurgeComment                    Templates
    DebugInfo                     LinkDebugVcl                      RangeChecks                     TwoChar
    DebugPath                     LinkGenImportLib                  ReferenceInfo                   TypedAddress
    DebugSourcePath               LinkGenLib                        RegisterVars                    TypeInfo
    Defines                       LinkMaxErrors                     Release                         Underscore
    DesigntimeOnly                LinkNoStateFiles                  ReleasePath                     UnitAliases
    EHDtor                        LinkShowMangle                    RemoteDebug                     UnitDebugInfo
    EHLocalInfo                   LinkSubsysMajor                   RemoteHost                      UnitDir
    EHPrologs                     LinkSubsysMinor                   RemotePath                      UnitOutputDir
    EnableExceptions              Locale                            RemoteSymbols                   UseDynamicRtl
    EnableInLines                 LocalSymbols                      ResDir                          UseIncLinker
    EnableRTTI                    LongStrings                       RunParams                       UsePackages
    ExeDescription                MajorVersion                      RuntimeOnly                     VarStringChecks
    ExtendedDictionary            MapFile                           SafeDivide                      VTables
    ExtendedSyntax                MarkModified                      ShowInfoMsgs                    WarnFlag
    FastFloat                     MaxHeapSize                       ShowLinkerWarnings              WriteableConst
    Float                         MaxStackSize                      ShowWarnings                    ZeroBaseClass
   }

[nahpets]

Hallo,

Project.Filename ist der Name des kompilierten Projektes. Mit ExtractFileExt solltest Du an die Dateiendung kommen.

Ansonsten schau Dir mal bitte Project.GetModuleCount und Project.GetModule(i).

GetModule liefert Dir eine IOTAModuleInfo, die Du in der Delphi 7-Hilfe finden kannst. Darüber solltest Du an eine nicht unerhebliche Zahl von Informationen kommen. Im Einzelnen kenne ich das auch nicht, da suche ich mir immer das Passende zusammen.

Bei der IOTAModuleInfo könnte für Dich z. B. der ModuleType interessant sein, da kannst Du erkennen, ob Du ein Formular, eine Unit, ein Datenmodul... im BeforeCompile-Ereignis zur Verfügung hast. Damit kannst Du dann typabhängig über die weiteren Schritte entscheiden.

[HPW]

Mit der Erkennung der Ausgabedatei-Extension bin ich noch nicht weiter gekommen.
Project.Projectoptions.Values['CompileName'] war immer leer.

Ansonsten habe ich es jetzt so zum Laufen gebracht.
Es wird nun eine Batch mit dem selben Namen des Project (mit extension *.bat) gestartet.
(Der ShellExecute funktionierte vorher nicht.)

Delphi-Quellcode:

{$DEFINE Meckermodus}
unit BeforeAfterCompileExperteUnit1;

interface

{$I-}

uses
  ToolsAPI;

Type
  TBeforeCompile = class(TNotifierObject, IOTAIDENotifier, IOTAIDENotifier50, IOTAWizard, IOTAMenuWizard)
  protected
    procedure   AfterCompile(Succeeded: Boolean); overload;
    procedure   AfterCompile(Succeeded: Boolean; IsCodeInsight: Boolean); overload;
    procedure   BeforeCompile(const Project: IOTAProject; var Cancel: Boolean); overload;
    procedure   BeforeCompile(const Project: IOTAProject; IsCodeInsight: Boolean; var Cancel: Boolean); overload;
    procedure   FileNotification(NotifyCode: TOTAFileNotification; const FileName: string; var Cancel: Boolean);
  public
    function    GetMenuText  : string;
    function    GetIDString  : string;
    function    GetName      : string;
    function    GetState     : TWizardState;
    procedure   Execute;
    constructor Create;
    function    AddNotifier(const Notifier: IOTAIDENotifier50) : Integer;
    procedure   RemoveNotifier(Index: Integer);
  end;

procedure Register;

implementation

uses
  Windows,
  SysUtils,
  Dialogs,
  Classes,
  ShellAPI;

Var
  // Die werden nicht alle gebraucht, sind nur hier, um zu sehen,
  // was es so gibt.
  MainServices        : INTAServices;
  ActionServices      : IOTAActionServices;
  CodeInsideServices  : IOTACodeInsightServices;
  DebuggerServices    : IOTADebuggerServices;
  EditorServices      : IOTAEditorServices;
  KeyBindingServices  : IOTAKeyBindingServices;
  KeyboardDiagnostics : IOTAKeyboardDiagnostics;
  KeyboardServices    : IOTAKeyboardServices;
  MessageServices     : IOTAMessageServices;
  ModuleServices      : IOTAModuleServices;
  PackageServices     : IOTAPackageServices;
  Services            : IOTAServices;
  WizardServices      : IOTAWizardServices;
  prjFileName         : String;
  Index : Integer;

procedure Register;
begin
  RegisterPackageWizard(TBeforeCompile.create as IOTAWizard);
end;

procedure InitExpert;
begin
  MainServices        := (BorlandIDEServices as INTAServices);
  ActionServices      := (BorlandIDEServices as IOTAActionServices);
  CodeInsideServices  := (BorlandIDEServices as IOTACodeInsightServices);
  DebuggerServices    := (BorlandIDEServices as IOTADebuggerServices);
  EditorServices      := (BorlandIDEServices as IOTAEditorServices);
  KeyBindingServices  := (BorlandIDEServices as IOTAKeyBindingServices);
  KeyboardDiagnostics := (BorlandIDEServices as IOTAKeyboardDiagnostics);
  KeyboardServices    := (BorlandIDEServices as IOTAKeyboardServices);
  MessageServices     := (BorlandIDEServices as IOTAMessageServices);
  ModuleServices      := (BorlandIDEServices as IOTAModuleServices);
  PackageServices     := (BorlandIDEServices as IOTAPackageServices);
  Services            := (BorlandIDEServices as IOTAServices);
  WizardServices      := (BorlandIDEServices as IOTAWizardServices);
  Index               := (BorlandIDEServices as IOTAServices).AddNotifier(TBeforeCompile.create);
end;

procedure DoneExpert;
begin
(BorlandIDEServices as IOTAServices).RemoveNotifier(Index);
end;

procedure TBeforeCompile.AfterCompile(Succeeded: Boolean);
begin
{$IFDEF Meckermodus}
  ShowMessage('AfterCompile(Succeeded: Boolean) - AfterCompile(' + BoolToStr(Succeeded) + ')');
{$ENDIF}

end;

procedure TBeforeCompile.AfterCompile(Succeeded: Boolean; IsCodeInsight: Boolean);
var
//   path     : string;
   params   : string;
begin
{$IFDEF Meckermodus}
  ShowMessage('AfterCompile(Succeeded: Boolean; IsCodeInsight: Boolean) - AfterCompile('
  + BoolToStr(Succeeded) + ');(' + BoolToStr(IsCodeInsight) + ')');
{$ENDIF}
  if not IsCodeInsight then
  begin
    // Hier kann man beliebige Aufgaben nach dem Kompilieren ausführen.
//    path := 'cmd.exe'; // Die Konsole oder irgendein Programm aufrufen.
//    params := '/C %temp%\AfterCompile.Bat'; // Die für das Programm erforderlichen Parameter.
    IF FileExists(ChangeFileExt( prjFileName ,'.bat')) THEN
     BEGIN
      params := ChangeFileExt( prjFileName ,'.bat');
//      ShellExecute(0,'open',PChar(path),PChar(params),nil,SW_SHOW);
      ShellExecute(0,nil,PChar(params),PChar(''),nil,SW_SHOW);
     END;
  end;
end;

procedure TBeforeCompile.BeforeCompile(const Project: IOTAProject; var Cancel: Boolean);
begin
{$IFDEF Meckermodus}
  ShowMessage('BeforeCompile(const Project: IOTAProject; var Cancel: Boolean);'
  + #13 + 'BeforeCompile(' + Project.FileName + ' ; ' + BoolToStr(Cancel) + ') ; '+ #13 + Project.Projectoptions.Values['CompileName']);
{$ENDIF}
end;

procedure TBeforeCompile.BeforeCompile(const Project: IOTAProject; IsCodeInsight: Boolean; var Cancel: Boolean);
//Var
//          sl : TStringList;
begin
{$IFDEF Meckermodus}
  ShowMessage('BeforeCompile(const Project: IOTAProject; IsCodeInsight: Boolean; var Cancel: Boolean);'
  + #13 + 'BeforeCompile(' + Project.FileName + '; ' + BoolToStr(IsCodeInsight) + '; ' + BoolToStr(Cancel) + ');');
{$ENDIF}
  prjFileName := Project.FileName;
//  if not IsCodeInsight then begin
//    // Hier kann man beliebige Aufgaben vor dem Kompilieren ausführen.
//    // Zum Beispiel eine Batchdatei erstellen, die von AfterCompile dann ausgeführt wird.
//    sl := TStringList.Create;
//    sl.Add('ECHO OFF');
//    sl.Add('type ' + Project.FileName + ' > %temp%\type.txt');
//    sl.SaveToFile(GetEnvironmentVariable('TEMP') + '\AfterCompile.Bat');
//    sl.Free;
//  End;
end;

procedure TBeforeCompile.FileNotification(NotifyCode: TOTAFileNotification; const FileName: string; var Cancel: Boolean);
begin
  //
end;

function TBeforeCompile.GetMenuText;
begin
  // Caption des Menüeintrages im Hilfemenü der IDE.
  result := 'TBeforeCompile';
end;

function TBeforeCompile.GetName;
begin
  result := 'TBeforeCompile';
end;

function TBeforeCompile.GetState;
begin
  result := [wsEnabled];
end;

function TBeforeCompile.GetIDString;
begin
  result := 'TBeforeCompile';
end;

Constructor TBeforeCompile.Create;
begin
  inherited;
end;

procedure TBeforeCompile.Execute;
begin
  ShowMessage('Das bekommen wir zu sehen, wenn wir im Hilfemenü auf TBeforeCompile klicken.');
end;

function  TBeforeCompile.AddNotifier(const Notifier: IOTAIDENotifier50) : Integer;
begin
  Result := 0;
end;

procedure TBeforeCompile.RemoveNotifier(Index: Integer);
begin
  //
end;

initialization
  InitExpert;

finalization
  DoneExpert;

end.