Pascal Project Manager & Editor

[jziersch]

Hallo,

ich hatte ja bereits früher nach der Verbesserung der Compiler Funktion gefragt. Denn für mich macht es eine menge Sinn ein Projekt aus Deiner IDE mit einem dafür festgelegten compiler zu kompilieren, ohne dass die IDE gestartet ist.
Das erfordert aber einige Erweiterungen, die über das reine Auswerten der Projekt Datei hinausgehen.

*Wenn* dieses Compilieren dann zuverlässig funktioniert, würde dies auch ermöglichen jede benötigte unit zu finden. Denn die units werden vom Compiler ja in dessen Ausgabe gelistet. Du könntest also diese Ausgabe auswerten und die Units in das Projekt übernehmen.

Schön wäre es, wenn eine BAT Datei geschrieben würde welche alle benötigten units mittels 7zip in eine ZIP Datei packt. Damit könnte man auf Knopfdruck ein Backup machen in dem wirklich alles drin ist.

Viele Grüsse,
Julian

[Harry Stahl]

@ jziersch:

Ich verwende eigentlich immer nur Delphi selber zum compilieren, mit dem händischen Aufruf des externen Compilers habe ich nur wenige Erfahrungen.

Hast Du ein Beispiel, wie ich ein Projekt mit welchen Parametern aufrufen müsste, damit es kompiliert (und dabei z.B. Suchpfade, etc. richtig berücksichtigt)? Und einmal als Release, bzw. einmal als Debug-Version?

By the way: Habe gerade ein neues Video hochgeladen, das einmal zeigt, wie man recht schnell ein einfaches VCL-Formular und die darin enthaltene Programmlogik mit Hilfe des Pascal-Editors nach FMX konvertieren kann:

https://youtu.be/rpN6C9Y1yHg

Dies kann z.B. dann eine Hilfe sein, wenn einem der Mida-Konverter [http://midaconverter.com] nicht (auf einem bestimmten PC oder gar nicht) zur Verfügung steht oder man eine Konvertierung einfach nur Schritt für Schritt durchführen möchte.

Die gezeigte Erweiterung (nun auch Images aus einer FMX-Imagelist einzeln exportieren zu können), ist in der aktualisierten Version 3.22 bereits Online.

Edit: Ach ja: Auch habe ich die Programme schon mal auf die kommende Version Delphi 10.4 soweit wie möglich angepasst, nach den "üblichen Regeln", wie bislang immer Versionsnummern etc. geändert wurden (aus allgemein zugänglichen Quellen, z.B. kein Beta-Test-Wissen oder ähnliches). Da noch nicht bekannt ist, wie Delphi 10.4 mal später genau heißen wird, erscheint derzeit noch ein Delphi 10.4 XXX, das dann später bei Release von Delphi 10.4 durch den richtigen Namen ersetzt wird.

Die Programmteile zur Anzeige von VCL und FMX-Formulare wurden daher mit Delphi 10.3.3 kompiliert und werden spätern mit 10.4 aktualisiert, wenn verfügbar. Der Lazarus-Part wurde auf 2.08 aktualisiert (hier wurden auch eine ganze Reihe von Komponenten für die Anzeige in Formularen hinzugenommen, wie etwa Synedit oder letzte neuere Komponenten).

[jziersch]

Zitat von Harry Stahl:

Ich verwende eigentlich immer nur Delphi selber zum kompilieren, mit dem händischen Aufruf des externen Compilers habe ich nur wenige Erfahrungen.

Natürlich während der Entwicklung läuft das in der IDE, wenn es aber darum geht ein Update heraus zu bringen wird ein script angeworfen, welches z.b. eine Reihe von DLLs erzeugt.

Das kompilieren aus der IDE birgt immer das Risiko, dass durch einer Konfigurationsänderung das Projekt entweder nicht oder falsch kompiliert wird. Durch das kompilieren durch einem direkten Aufruf vermeidet man auch das Problem dass ein vergessenes Compilersymbol im Projekt (z.b. DEBUG) ein unerwünschtes Ergebnis erzeugt. Auch kann ein Projekt mit einem festgelegten Setup von Komponenten gebaut werden, also z.b. einer früheren Version von WPTools also der aktuellen die in der IDE installiert ist.

Zitat von Harry Stahl:

Hast Du ein Beispiel, wie ich ein Projekt mit welchen Parametern aufrufen müsste, damit es kompiliert (und dabei z.B. Suchpfade, etc. richtig berücksichtigt)? Und einmal als Release, bzw. einmal als Debug-Version?

Debug und Release unterscheidet sich bei mir nur durch ein compiler symbol, also z.b. kann -DDEBUG dem Compiler übergeben werden.

Ansonsten funktioniert Deine Methode eigentlich, nur dass eben alle Verzeichnisse eingebunden werden müssen, die man zu einem bestimmten Zeitpunkt aus der IDE ausgelesen hat.
Das auslesen geht ja bereits mittels des Knopf rechts oben, das Ergebnis müsste nur noch abgespeichert und verwendet werden.

Das ist vor allem der jeweilige Bibliothekspfad und der Suchpfad. Es ist für dein Programmes meiner Meinung nach unabdingbar, dass dieser Pfad mit verwaltet wird. Denn es geht doch darum, ein Projekt so genau wie möglich zu erfassen, also alle Abhängigkeiten zu kennen.

Zusätzlich sollte man compiler Symbole angeben können.

Code:

C:\Borland\DX12\Bin\dcc32.exe -DWPDFREGDLL -NSVcl;Vcl.Imaging;Vcl.Touch;Vcl.Samples;Vcl.Shell;Winapi;System.Win;Data.Win;Datasnap.Win;Web.Win;Soap.Win;Xml.Win;Bde;System;Xml;Data;Datasnap;Web;Soap; -DWPDF3 -DWPDF4 -$D- -B+ C:\S\wPDF\Source\
Compile_wPDF_DLL.dpr

Hier wird aus dem Verzeichnis mit allen Compilern (heißt bei mir "Borland" und beinhaltet 19 Delphi Editionen in friedlicher Koexistenz) Delphi 10.2 gestartet um die wPDF DLL zu erzeugen. Dabei wird ein Quellverzeichnis hinzugefügt. Mehr ist eigentlich nicht dabei.

Die Ausgabe des Compilers könnte man (wie ich oben schrieb) dazu verwenden, alle Units zu listen welche wirklich verwendet werden.

[jziersch]

Etwas feedback zu der aktuellen Version:

1) Der Editor ist sehr schön, übersichtlich und nutzbar.

2) Die Formularansicht funktioniert gut. Ich fände es noch toll wenn die Struktur und die Textansicht zusammenarbeiten würden, sodass die Struktur Schachtelungen anzeigt und sowohl Klick (Auswahl) als auch Drag&Drop Operationen (Verschieben) auf der Textansicht anwenden könnte.

3) Beim Öffnen eines Projektes wurden bei einem Projekt alle Dateien unter "Projektdateien" gelistet, ohne Rücksicht darauf ob die verwendet werden. Ist das so gewünscht?

4) Beim Compilieren wird die Ausgabe verkürzt, es wird immer nur der Projektname gelistet. Sinnvoll wäre es die Ausgabe auszuwerten, z.b. nur Fehler zu listen und zusätzlich die verwendeten units anzugeben.

5) Bei DLL Projekten sollte für die Ausführung eine consumer EXE angebbar sein.

[dummzeuch]

[QUOTE=jziersch;1462443]

Zitat von Harry Stahl:

Zitat von Harry Stahl:

Hast Du ein Beispiel, wie ich ein Projekt mit welchen Parametern aufrufen müsste, damit es kompiliert (und dabei z.B. Suchpfade, etc. richtig berücksichtigt)? Und einmal als Release, bzw. einmal als Debug-Version?

Debug und Release unterscheidet sich bei mir nur durch ein compiler symbol, also z.b. kann -DDEBUG dem Compiler übergeben werden.

Edit: Sorry, ich hatte das "bei mir" überlesen. Das ist natürlich legitim, aber unüblich: Gibt es wirklich keine unterschiedlichen Compiler-Einstellungen?

Nein, die beiden Konfigurationen (und theoretisch weitere, die man anlegen kann) unterscheiden sich potentiell durch jede einzelne mögliche Compiler- und Linker-Option, durch unterschiedliche Suchpfade und ggf. auch noch unterschiedliche Pre-/Post-Scripts. Ach ja, habe ich schon die Versionsinfos erwähnt?

Üblicherweise ist bei mir z.B. im Debug-Modus die Optimierung ausgeschaltet, es werden Debug-DCUs verwendet, es werden diverse Laufzeit-Checks eingeschaltet. Im Release-Modus ist es dann umgekehrt, selbst Assertions sind bei Relesaes manchmal aus.

Es ist aber eigentlich auch recht einfach, diesen Modus an msbuild zu übergeben, der Rest passiert dann genauso wie in der IDE:

Code:

call "%DelphiPath%\bin\rsvars.bat"
msbuild myproject.dproj /target:rebuild /p:config=debug

Dabei muss man %DelphiPath% natürlich passend setzen, so das rsvars.bat gefunden wird.

Edit:
Bei Delphi 2007 ist es ein wenig anders:

Code:

call "%DelphiPath%\bin\rsvars.bat"
msbuild myproject.dproj /target:rebuild /p:Configuration=debug

(also Configuration statt Config).

[Harry Stahl]

OK, vielen Dank Euch beiden für die hilfreichen Hinweise.

Ich bastele gerade ein wenig daran rum, siehe anliegenden Screenshot.

Habe also den Aufruf des Kompilierungsvorgangs in einen eigenen Dialog gelegt, wo man bestimmte Auswahlen treffen kann.

DCC funktioniert wie bisher. Für MSBuild funktioniert bereits die einfache Wahl Release oder Debug. Wie wähle ich hier, ob ein 32-Bit oder 64-Bit Kompilat erzeugt wird?

Und wie, für welche Plattform (Windows, MAC, usw) erzeugt werden soll?

Außerdem werden anscheinend alle Plattformen mit diesem Aufruf erzeugt, oder?

Wenn man den DCC-Compiler verwendet und man dort die Suchpfade angeben will (ist Das der "-I" oder "-U" Parameter?) kann der dann selber solche Angaben auflösen wie:

$(crossvcl)\Lib\$(ProductVersion)\$(Platform)\$(Co nfig)

?

Wo schreibt der DCC-Compiler eigentlich die erzeugten DCU-Units hin, ich kann die hier im Moment gar nicht finden?

[jziersch]

-E<path> = Ausgabeverzeichnis für EXE
-N<path> = DCU-Ausgabeverzeichnis
-O<paths> = Objektverzeichnisse

Hier die Optionen für Delphi 7:

Code:

Syntax: dcc32 [optionen] dateiname [optionen]

  -A<unit>=<alias> = Unit-Alias setzen   -LU<package> = Package verwenden
  -B = Alle Units erzeugen               -M = Modifizierte Units erzeugen
  -CC = Ziel: Konsole                    -N<path> = DCU-Ausgabeverzeichnis
  -CG = Ziel: GUI                        -O<paths> = Objektverzeichnisse
  -D<syms> = Bedingungen definieren      -P = Auch nach 8.3-Dateinamen suchen
  -E<path> = Ausgabeverzeichnis für EXE  -Q = Ohne Meldung compilieren (Quiet)
  -F<offset> = Suchfehler                -R<paths> = Ressourcenverzeichnisse
  -GD = Detaillierte Map-Datei           -U<paths> = Unit-Verzeichnisse
  -GP = Map-Datei mit publics            -V = Debug-Information in EXE
  -GS = Map-Datei mit Segmenten          -VR = Externe Fehlersuche gen.
  -H = Ausgabe von Hinweismeldungen      -W = Ausgabe von Warnungen
  -I<paths> = Include-Verzeichnisse      -Z = Ausgabe nie zu erstellender DCPs
  -J = .obj-Dateien generieren           -$<dir> = Compiler-Direktive
  -JP = C++-.obj-Datei generieren       --help = Diesen Hilfebildschirm anzeigen
  -K<addr> = Image-Basisadresse          --version = Name und Version anzeigen
Compiler-Schalter: $<buchst><status> (Vorgabewerte siehe unten)
  A8  Ausgerichtete Record-Felder         P+  Offene String-Parameter
  B-  Vollst.  boolesche Auswertung       Q-  Integer-Überlaufprüfung
  C+  Zur Laufzeit Bedingungen auswerten  R-  Bereichsüberprüfung
  D+  Debug-Information                   T-  Typisierter @-Operator
  G+  Importierte Datenreferenzen verw.   U-  Pentium(tm)-sichere Division
  H+  Standardmäßig lange Strings verw.   V+  Strenge Prüfung von var-Strings
  I+  Ein-/Ausgabeprüfung                 W-  Stack-Frames erzeugen
  J-  Strukt. Consts (Schreibzugriff)     X+  Erweiterte Syntax
  L+  Lokale Debug-Symbole                Y+  Symbolinformation
  M-  Laufzeit-Typinfo (RTTI)             Z1  Mindestgröße für Enum-Typen
  O+  Optimierung

Für Delphi 10.3 - 64 bit

Code:

Syntax: dcc64 [Optionen] Dateiname [Optionen]

  -A<unit>=<alias> = Unit-Alias setzen
  -B = Alle Units erzeugen
  -CC = Ziel: Konsole
  -CG = Ziel: GUI
  -D<syms> = Bedingungen definieren
  -E<path> = EXE/DLL-Ausgabeverzeichnis
  -F<offset> = Fehlersuche
  -GD = Detaillierte Map-Datei
  -GP = Map-Datei mit publics
  -GS = Map-Datei mit Segmenten
  -H = Ausgabe von Hinweismeldungen
  -I<paths> = Include-Verzeichnisse
  -J = .obj-Dateien generieren
  -JPHNE = C++ .obj-Datei, .hpp-Datei, im Namespace erzeugen, alles exportieren
  -JL = Package-.lib, -.bpi und alle .hpp-Dateien für C++ erzeugen
  -K<addr> = Image-Basisadresse
  -LE<path> = Package .bpl-Ausgabeverzeichnis
  -LN<path> = Package .dcp-Ausgabeverzeichnis
  -LU<package> = Package verwenden
  -M = Modifizierte Units erzeugen
  -NU<Pfad> = Unit-DCU-Ausgabeverzeichnis
  -NH<path> = Unit .hpp-Ausgabeverzeichnis
  -NO<path> = Unit .obj-Ausgabeverzeichnis
  -NB<path> = Unit .bpi-Ausgabeverzeichnis
  -NX<Pfad> = Unit-XML-Ausgabeverzeichnis
  -NS<namespaces> = Namespace-Suchpfad
  -O<paths> = Objektverzeichnisse
  -P = Auch nach 8.3-Dateinamen suchen
  -Q = Ohne Meldung compilieren (Quiet)
  -R<paths> = Ressourcenverzeichnisse
  -TX<Erw.> = Erweiterung des Ausgabenamens
  -U<paths> = Unit-Verzeichnisse
  -V = Debug-Information in EXE
  -VR = Externe Fehlersuche gen.
  -VT = Debug-Informationen in TDS
  -VN = TDS-Symbole im Namespace
  -W[+|-|^][warn_id] = Ausgabe von Warnmeldungen
  -Z = Ausgabe nie zu erstellender DCPs
  -$<dir> = Compiler-Direktive
  --help = Diesen Hilfebildschirm anzeigen
  --version = Name und Version anzeigen
  --codepage:<cp> = Codierung für Quelltextdatei festlegen
  --default-namespace:<namespace> = Namespace setzen
  --depends = Unit-Abhängigkeitsinformationen ausgeben
  --doc = XML-Ausgabedokumentation
  --drc = Ausgabe-Ressourcenstring .drc-Datei
  --no-config = Standard-dcc64.cfg-Datei nicht laden
  --description:<String> = Beschreibung für ausführbare Datei festlegen
  --inline:{on|off|auto} = Inlining von Funktionen steuern
  --legacy-ifend = Alte $IFEND-Direktive zulassen
  --zero-based-strings[+|-] = Indizierung der Strings beginnt mit 0
  --peflags:<Flags> = Zusätzliches Flags-Feld für PE-Header setzen
  --peoptflags:<Flags> = Zusätzliches Feld für optionale Flags für PE-Header setzen
  --peosversion:<Haupt>.<Neben> = BS-Versionsfelder in PE-Header setzen (Vorgabe: 5.0)
  --pesubsysversion:<Haupt>.<Neben> = Untersystem-Versionsfelder in PE-Header setzen (Vorgabe: 5.0)
  --peuserversion:<Haupt>.<Neben> = Benutzer-Versionsfelder in PE-Header setzen (Vorgabe: 0.0)
  --lib-version:<Version> = Version des Ausgabe-Package-Namens
  --lib-suffix:<Suffix> = Suffix des Ausgabe-Package-Namens

Je nach Platform gibt es ja verschiedene compiler, also auch OSX...

Ich halte es für wichtig wahlweise den compiler direkt anzusprechen (und nicht MSBuild), da man dadurch Projekt unabhängig kompilieren kann. Also alles was man im Projekt (*.dproj) oder den Pfaden evtl. verstellt hat spielt keine Rolle, und man erhält wirklich das Ergebnis so, wie es im Projekt Manager hinterlegt ist. Auch funktioniert DCxx sehr zuverlässig.

[dummzeuch]

Zitat von Harry Stahl:

Für MSBuild funktioniert bereits die einfache Wahl Release oder Debug. Wie wähle ich hier, ob ein 32-Bit oder 64-Bit Kompilat erzeugt wird?

Und wie, für welche Plattform (Windows, MAC, usw) erzeugt werden soll?

Du kannst Dir von der IDE den Aufruf für's compilieren anzeigen lassen. Ich weiß nur gerade nicht mehr, wo man das einstellt.

twm

[ringli]

Zitat von Harry Stahl:

Für MSBuild funktioniert bereits die einfache Wahl Release oder Debug. Wie wähle ich hier, ob ein 32-Bit oder 64-Bit Kompilat erzeugt wird?

Ich hoffe das beantwortet deine Frage:

Code:

msbuild.exe "Project.dproj" /target:Clean;Build /p:Platform=Win32 /p:config=Release
msbuild.exe "Project.dproj" /target:Clean;Build /p:Platform=Win64 /p:config=Release

[jziersch]

@Harry

Grossartig, es läuft viel weiter. Jetzt kommen auch lesbare Fehlermeldungen.

Mein grosses FMX Projekt konnte msbuild kompilieren und es wurde die Ausgabe Datei erstellt. Allerdings zeigt sich der Naschteil hier, da eben die Einstellungen des Projektes komplett verwendet werden und die EXE in dem dort eingestellten Verzeichnis erstellt wird. Das ist zwar oft gewünscht, aber nicht immer, gerade bei einem Projekt welches man schon ewig nicht mehr angefasst hat. Mir geht es darum ein Projekt so in PPM zu erfassen, dass es immer kompilierbar ist, mit den gespeicherten Pfaden etc, unabhängig von der IDE die evtl. bereits andere Komponenten verwendet. Es sieht so aus, als ob genau das kommt. Toll!

DCC, was mich daher insbesondere interessier lief auch ganz gut. Besonders zeigt sich dass hier alle units gelistet werden. Es ist die method um die Abhängigkeiten zu finden. Könnten die direkt so in das Projekt in PPM eingetragen werden? Ganz wichtig ist die DCC Pfade auch im Projekt abzuspeichern, also für später.

In meinem Fall kommt:

C:\....\unitname.pas(42) Schwerwiegend: F2613 Unit 'SysUtils' nicht gefunden.

Das problem war ein fehlender namespace. Keine grosse Sache.

Ich habe auch ein paar Symbole mit -D... als parameter hinzugefügt. Funktioniert insgesamt sehr gut.

Kannst Du bitte vielleicht einen Knopf auf deinem neuen Formular anbringen "Parameter in Projekt merken", sodass die Einstellungen, parameter und(!) Pfade genau wie verwendet für den nächsten Aufruf gespeichert werden. Dann wäre es perfekt, denke ich.