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?

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.

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

Gruß

BBB

Hallo,

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

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

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.

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:

zusammenfalten · markieren

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
   }

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.

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.)

zusammenfalten · markieren

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.