Delphi-Version ermitteln

[lxo]

Hallo,

gibt es eine Variable/Konstante in Delphi die mir die genaue Delphi Version gibt?

Ich zeige die Version in meinen Versionsinformationen an.
Aktuell verwende ich Compilerversion.
Diese unterscheidet sich aber nicht zwischen 11.2 und 11.3.
Gibt es da was womit ich genau identifizieren könnte, dass die EXE mit Delphi 11.3 erzeugt wurde?

[Uwe Raabe]

Delphi-Quellcode:

{$IF CompilerVersion = 35} 
  {$IF Declared(RTLVersion113)} 
    // Delphi 11.3
  {$ELSEIF Declared(RTLVersion112)} 
    // Delphi 11.2
  {$ELSEIF Declared(RTLVersion111)} 
    // Delphi 11.1
  {$ELSE} 
    // Delphi 11.0
  {$IFEND}
{$IFEND}

[lxo]

Und was ist mit Versionen vor 11?

[TiGü]

Das gleiche in Grün nur halt mit den entsprechenden Werten.
https://delphidabbler.com/notes/version-numbers

[haentschman]

https://delphidabbler.com/notes/version-numbers

[Klaus01]

..da Delphi 11.3 keine neue Hauptversion ist - gibt es nur eine Compilerversion für Delphin 11.

Grüße
Klaus

[himitsu]

Sie "hätten" aber auch einfach CompilerVersionen 35.0 35.1 35.2 35.3 machen können. :freak:

Gab es die RTLVersion nicht auch als Konstante?
[edit] Doch, aber RTLVersion <> RTLVersionXXX und außerdem ebenfalls nur .0

für Delphi 11.3 :

Code:

  CompilerVersion   = 35.0;
  RTLVersion        = 35.00;
  RTLVersion111     = True;
  RTLVersion112     = True;
  RTLVersion113     = True;
  FireMonkeyVersion = 270;

Delphi-Quellcode:

//{$IF (CompilerVersion = 35) and RTLVersion113}  // 11.3  ist zwar ein Boolean, aber die Konstante existiert nicht immer -> True oder nicht existent (nie False)

{$IF (CompilerVersion = 35) and Declared(RTLVersion113)}  // 11.3
{$IF (CompilerVersion = 35) and Declared(RTLVersion112)}  // 11.2
{$IF (CompilerVersion = 35) and Declared(RTLVersion111)}  // 11.1
{$IF (CompilerVersion = 35) and not Declared(RTLVersion111)}  // 11.0
{$IF CompilerVersion = 35}  // 11.x
{$IF CompilerVersion = 34}  // 10.4
{$IF CompilerVersion = 33}  // 10.3
{$IF CompilerVersion = 32}  // 10.2
{$IF CompilerVersion = 31}  // 10.1
{$IF CompilerVersion = 30}  // 10
{$IF CompilerVersion = 29}  // XE8
{$IF CompilerVersion = 28}  // XE7
...
{$IF CompilerVersion = 22}  // XE
...
{$IF CompilerVersion = 20.0}  // 2009
{$IF CompilerVersion = 18.5}  // 2007  (2007 hatte den selben Compiler wie 2006)
{$IF CompilerVersion = 18.0}  // 2006
{$IF CompilerVersion = 17.0}  // 2005

Statt = würde ich aber besser immer nur mit <= oder >= arbeiten.

Delphi-Quellcode:

{$IF CompilerVersion = 22.0}

entspricht

Delphi-Quellcode:

{$IFDEF VER220}

,
aber meisten will man ja nicht genau diese Version wissen, sondern ob es mindestens oder maximal diese Verison ist,
bzw. ein Von-Bis ala

Delphi-Quellcode:

 {$IF (CompilerVersion >= 20) and (CompilerVersion <= 23)}

anstatt

Delphi-Quellcode:

{$IFDEF VER220}{$IFDEF VER220}{$IFDEF VER220}

ähhh

Delphi-Quellcode:

{$IF Defined(VER220) or Defined(VER220) or Defined(VER220)}

[lxo]

Zitat:

Zitat von Uwe Raabe (Beitrag 1520738)

Delphi-Quellcode:

{$IF CompilerVersion = 35} 
  {$IF Declared(RTLVersion113)} 
    // Delphi 11.3
  {$ELSEIF Declared(RTLVersion112)} 
    // Delphi 11.2
  {$ELSEIF Declared(RTLVersion111)} 
    // Delphi 11.1
  {$ELSE} 
    // Delphi 11.0
  {$IFEND}
{$IFEND}

Ich mach es jetzt einfach so.
Vor Delphi 11 gibt es dann nichts zu sehen.
Muss ich halt für die nächsten Versionen immer pflegen.

[lxo]

Bei Delphi 10.3 z.B. könnte ich das auch anscheinend gar nicht ermitteln oder gab es da noch was anderes?

Delphi-Quellcode:

// Delphi 11.3

  RTLVersion = 35.00;
  RTLVersion111 = True;
  RTLVersion112 = True;
  RTLVersion113 = True;
 {$HPPEMIT '#define RTLVersionC 3500'}
 {$HPPEMIT '#define RTLVersion111C'}
 {$HPPEMIT '#define RTLVersion112C'}
 {$HPPEMIT '#define RTLVersion113C'}

Delphi-Quellcode:

// Delphi 10.3.3

  RTLVersion = 33.00;
 {$HPPEMIT '#define RTLVersionC 3300'}

[Uwe Raabe]

Delphi-Quellcode:

{$IF CompilerVersion = 34} 
  {$IF Declared(RTLVersion113)} 
    // Delphi 11.3
  {$ELSEIF Declared(RTLVersion112)} 
    // Delphi 11.2
  {$ELSEIF Declared(RTLVersion111)} 
    // Delphi 11.1
  {$ELSE} 
    // Delphi 11.0
  {$IFEND}
{$ELSEIF CompilerVersion = 33}
  {$IF Declared(RTLVersion1042)} 
    // Delphi 10.4.2
  {$ELSEIF Declared(RTLVersion1041)} 
    // Delphi 10.4.1
  {$ELSE} 
    // Delphi 10.4
  {$IFEND}
{$ELSEIF CompilerVersion = 32}
usw. 
{$IFEND}

[himitsu]

siehe #7

nee, gibt paktisch nur die drei
System.RTLVersion
System.CompilerVersion
FMX.Types.FireMonkeyVersion

ABER :freak:
https://www.delphipraxis.net/1473778-post5.html

[Uwe Raabe]

Zitat:

Zitat von lxo (Beitrag 1520752)

Bei Delphi 10.3 z.B. könnte ich das auch anscheinend gar nicht ermitteln oder gab es da noch was anderes?

Das ist in der Tat so. Die Konstanten für die Zwischenversionen gibt es noch nicht so lange. Bei den anderen Versionen muss man eventuell nach anderen Kriterien suchen. Leider ist das nicht ganz einfach, da innerhalb eines Hauptrelease ja Änderungen im Interface-Teil bestimmten Restriktionen unterliegen.

[himitsu]

Die HPPEMIT sind ja nur für den C++Builder, nicht für Delphi.

Der C++Builder kann ja Delphi-Units benutzen ... wäre zu geil, wenn man auch im Delphi direkt C++-Header/Code linken könnte. :cry:

Zitat:

Das ist in der Tat so.

Da kann man teilweise mit

Delphi-Quellcode:

{$IF Declared(...)}

und

Delphi-Quellcode:

{$IF Defined(...)} bzw. {$IFDEF ...}

rumpfuschen.

Declared geht z.B. für Konstanten, Variablen, Typen/Klassen und Funktionen, also auf Etwas, was da neu/entfernt/verschoben wurde.

[Uwe Raabe]

Zitat:

Zitat von himitsu (Beitrag 1520758)

Da kann man teilweise mit

Delphi-Quellcode:

{$IF Declared(...)}

und

Delphi-Quellcode:

{$IF Defined(...)} bzw. {$IFDEF ...}

rumpfuschen.

Das Problem ist hier das teilweise.

Die Frage ist doch eher: Warum will man das wissen?

[lxo]

Zitat:

Zitat von Uwe Raabe (Beitrag 1520760)

Zitat:

Zitat von himitsu (Beitrag 1520758)

Da kann man teilweise mit

Delphi-Quellcode:

{$IF Declared(...)}

und

Delphi-Quellcode:

{$IF Defined(...)} bzw. {$IFDEF ...}

rumpfuschen.

Das Problem ist hier das teilweise.

Die Frage ist doch eher: Warum will man das wissen?

Einfach nur als Information für uns Entwickler damit man genau sehen kann mit welcher Delphi Version diese Anwendung erzeugt wurde.
Auch wenn der Compiler nicht geändert wurde von 11.2 auf 11.3 gibt es ja schon Anpassungen/Änderungen die Auswirkung auf meine Anwendung haben.

Oder war das "Warum will man das wissen?" an himitsu und seinem c++ Thema gerichtet? :-D

[himitsu]

Ja, es wäe schön, wenn es einfach ginge, mit nur einer Compiler/Delphi-VersionsInformationsKonstante, inkl. Version, Subversion/Update und womöglich auch Patch und Hotfix,
aber wenn das nicht geht, dann muß man eben selber auf irgendwas Anderes prüfen.

Es gibt ja für Vieles mehrere Wege:

Delphi-Quellcode:

{$IF CompilerVersion >= 20.0}  // oder so ein perverser {$IFDEF VER123}-Marathon, der aber nur für alte/bekannte Versionen funktioniert und "neue" Delphis noch nicht kennt

{$IF Declared(UnicodeString)}

{$IF SizeOf(Char) = 2}

{$IFDEF UNICODE}

OK, etwas "Lesbares" wäre auch mal zu geil. :cry:

Delphi-Quellcode:

{$IF (DelphiVersion >= 'XE') and (DelphiVersion <= '11.2')}

{$IF (DelphiVersion >= 'XEu2') and (DelphiVersion <= '10.1.2')}

Aber sowas kann eigentlich NIE funktionieren, es sei denn der Compiler würde sich online eine aktuelle Versionsliste besorgen können,
denn ein älterer Compiler kennt neue Delphis noch nicht und weiß z.B. somit nicht dass XE zwar größer als 7 ist, aber kleiner als 10 ist, wenn er die 10 noch nicht kennt.
Wenn Delphi bei den aktuellen Zahlen bleiben würde und Zahlen immer nur größer werden, dann wäre es einfacher, aber wer weiß ob nicht doch irgendwann wieder sowas wie "XE" kommt.

[Uwe Raabe]

Delphi-Quellcode:

unit System.Defines;

interface

const
  RTLVersion11Alexandria = 35.0;
  RTLVersion104Sydney = 34.0;
  RTLVersion103Rio = 33.0;
  RTLVersion102Tokyo = 32.0;
  RTLVersion101Berlin = 31.0;
  RTLVersion10Seattle = 30.0;
  RTLVersionXE8 = 29.0;
  RTLVersionXE7 = 28.0;
  RTLVersionXE6 = 27.0;
  RTLVersionXE5 = 26.0;
  RTLVersionXE4 = 25.0;
  RTLVersionXE3 = 24.0;
  RTLVersionXE2 = 23.0;
  RTLVersionXE = 22.0;
  RTLVersion2010 = 21.0;
  RTLVersion2009 = 20.0;
  RTLVersion2007Net = 19.0;
  RTLVersion2007 = 18.5;
  RTLVersion2006 = 18.0;
  RTLVersion2005 = 17.0;
  RTLVersion8Net = 16.0;
  RTLVersion7 = 15.0;

const
  CompilerVersion11Alexandria = 35.0;
  CompilerVersion104Sydney = 34.0;
  CompilerVersion103Rio = 33.0;
  CompilerVersion102Tokyo = 32.0;
  CompilerVersion101Berlin = 31.0;
  CompilerVersion10Seattle = 30.0;
  CompilerVersionXE8 = 29.0;
  CompilerVersionXE7 = 28.0;
  CompilerVersionXE6 = 27.0;
  CompilerVersionXE5 = 26.0;
  CompilerVersionXE4 = 25.0;
  CompilerVersionXE3 = 24.0;
  CompilerVersionXE2 = 23.0;
  CompilerVersionXE = 22.0;
  CompilerVersion2010 = 21.0;
  CompilerVersion2009 = 20.0;
  CompilerVersion2007 = 18.5;
  CompilerVersion2006 = 18.0;
  CompilerVersion2005 = 17.0;
  CompilerVersion8Net = 16.0;
  CompilerVersion7 = 15.0;

implementation

end.

[himitsu]

Alten Code mit alter DefinesUnit/INC/Sonstwas in zu neuem Delphi/Compiler und schon knallt es gern mal. (siehe das Beispiel mit der JEDI-INC)

OK, wenn diese Defines zum Code passt, dann isses schon OK.
Man darf beim Rumschreiben für ein neues Delphi nur nicht vergessen diese Unit zu aktialisieren.



Aber gerade sowas war ja das Problem, z.B. mit der Versions-INC von den JEDI.
Ein neues Delphi und schon war sowas wie

Delphi-Quellcode:

{$IFDEF DelphiXEorGreater}

plötzlich undefiniert, weil das Gerödel mit

Delphi-Quellcode:

{$IFDEF VER132}

plötzlich endete und es das neue VER789 nicht kannte.

Ähnlich wie beim RTLVersion113, wo die RTLVersion112, RTLVersion112 und RTLVersion111 weiter existieren, hätte der Compiler sowas wie die VERxxx-Defines auch aufheben können (also Delphi 11 hat die Define vom 10 und allen Vorhängern drin) ... aber egal, dank CompilerVersion und z.B. >= geht es auch ohne.
Es wäre nur einfacher, wenn es eben "eine" Konstante gäbe, anstatt den vielen RTLVersionXXX.

Willst du einen Bugfix für genau 11.3 schreiben, dann

Zitat:

{$IF Declared(RTLVersion113) and not Declared(RTLVersion114)}

und hoffen der nächste Bugfix heißt wirklich Declared(RTLVersion114) oder es wird ein Delphi 12,
aber wehe es wird eine RTLVersion113b oder RTLVersion1132 oder ... (Delphi 11.3.2)




Mit

Delphi-Quellcode:

{$IF CompilerVersion > 123}

wurde es dann besser, seit den ConditionalDefines, gegenüber dem alten

Delphi-Quellcode:

{$IFDEF VER132}

,
aber jetzt mit RTLVersion112 wurde es wieder schlimmer. (und da das RTLVersion112 ja eigentlich vom Compiler kommen könnte, hätte man es auch als DEFINE deklarieren können, aber als CONST wird es wenigstens über UnitGrenzen durchgereicht)

[Uwe Raabe]

Zitat:

Zitat von himitsu (Beitrag 1520768)

Man darf beim Rumschreiben für ein neues Delphi nur nicht vergessen diese Unit zu aktialisieren.

Man kann ja die obige Unit auch um so etwas ergänzen:

Delphi-Quellcode:

{$IF CompilerVersion > 35}
Du musst diese Unit anpassen!
{$IFEND}

[himitsu]

Drum meinte ich ja, dass es mit CompilerVersion schon besser wurde, da man damit auch auf zukünftige Delphis prüfen kann (nicht direkt auf eine bestimmte noch unbekannte Version, aber auf Alles >= dem letzten Aktuellen),
ohne ALLE bereits bekannten Versionen prüfen zu müssen (sonst weiß man ja nicht, ob älter oder neue, bzw. vergessen zu prüfen).

Aber mit solchem Mist wie RTLVersion113 wurde das alles wieder zur Minna gemacht und rutsch logisch zurück ins Grauen der alten VERxxx-Defines.