Compilerversionen?

[himitsu]

Ihr kennt doch bestimmt diese netten Compileroptionen, wie VER110 für Delphi 3.

Kann mir da zufällig die VER's für D8, D9 und Kylix 1


D8 ist ja vermutlich VER160 und D9 dann VER170, da ja D7 die Version 15.0 (VER150) hat, aber sicher kann man sich da ja nie sein ^^


PS: ich hoffe ich hab die Versionen jetzt auch richtig zusammenbekommen -.-''



Ach ja, eine "einfache" Möglichkeit auf die verschiedenen Unterversionen (Standard, Personal, Enterprise ...) zu prüfen gibt es ja nicht?

[shmia]

Kleiner Auszug aus der Datei Jedi.inc

Delphi-Quellcode:

    {$IFDEF VER170}
      {$DEFINE COMPILER9}
      {$DEFINE DELPHI9}
      {$DEFINE DELPHICOMPILER9}
      {$DEFINE RTL170_UP}
    {$ENDIF}

    {$IFDEF VER160}
      {$DEFINE COMPILER8}
      {$DEFINE DELPHI8}
      {$DEFINE DELPHICOMPILER8}
      {$DEFINE RTL160_UP}
    {$ENDIF}

    {$IFDEF VER150}
      {$DEFINE COMPILER7}
      {$IFDEF BCB}
        {$DEFINE BCB7}
      {$ELSE}
        {$DEFINE DELPHI7}
        {$DEFINE DELPHICOMPILER7}
      {$ENDIF}
      {$DEFINE RTL150_UP}
    {$ENDIF}

    {$IFDEF VER140}
      {$DEFINE COMPILER6}
      {$IFDEF BCB}
        {$DEFINE BCB6}
      {$ELSE}
        {$DEFINE DELPHI6}
        {$DEFINE DELPHICOMPILER6}
      {$ENDIF}
      {$DEFINE RTL140_UP}
    {$ENDIF}

    {$IFDEF VER130}
      {$DEFINE COMPILER5}
      {$IFDEF BCB}
        {$DEFINE BCB5}
      {$ELSE}
        {$DEFINE DELPHI5}
        {$DEFINE DELPHICOMPILER5}
      {$ENDIF}
      {$DEFINE RTL130_UP}
    {$ENDIF}

    {$IFDEF VER125}
      {$DEFINE COMPILER4}
      {$DEFINE BCB4}
      {$DEFINE BCB}
      {$DEFINE RTL125_UP}
    {$ENDIF}

    {$IFDEF VER120}
      {$DEFINE COMPILER4}
      {$DEFINE DELPHI4}
      {$DEFINE DELPHICOMPILER4}
      {$DEFINE RTL120_UP}
    {$ENDIF}

    {$IFDEF VER110}
      {$DEFINE COMPILER35}
      {$DEFINE BCB3}
      {$DEFINE RTL110_UP}
    {$ENDIF}

    {$IFDEF VER100}
      {$DEFINE COMPILER3}
      {$DEFINE DELPHI3}
      {$DEFINE DELPHICOMPILER3}
      {$DEFINE RTL100_UP}
    {$ENDIF}

    {$IFDEF VER93}
      {$DEFINE COMPILER2}
      {$DEFINE BCB1}
      {$DEFINE BCB}
      {$DEFINE RTL93_UP}
    {$ENDIF}

    {$IFDEF VER90}
      {$DEFINE COMPILER2}
      {$DEFINE DELPHI2}
      {$DEFINE DELPHICOMPILER2}
      {$DEFINE RTL90_UP}
    {$ENDIF}

    {$IFDEF VER80}
      {$DEFINE COMPILER1}
      {$DEFINE DELPHI1}
      {$DEFINE DELPHICOMPILER1}
      {$DEFINE RTL80_UP}
    {$ENDIF}

[Muetze1]

Moin!

Ansonsten hat Mike Lischke mal wieder was in petto...

MfG
Muetze1

[himitsu]

Also bei D8 und D9 lag ich also doch richtig (aber Borland hatte ja schonmal einige "komische Sprünge in den Versionsnummer ... also hab'sch lieber nochmal gefragt ^^)

Kylix 1 ... kein Wunder, das ich die Version nicht feststellen konnte, denn Kylix 1 schein keine VERxxx zu haben, aber dort konnte mir Mike ja weiterhelfeen :love:


Im Anhang hab ich mal meine Datei hinterlegt ... könnte ja mal reinschauen und eventuell mal testen und/oder eure Meinung dazu sagen :angel2:


PS: Also der Mike gefällt mir ... hat ja fast den gleichen Stil, wie ich (120 Spalten, die Namen sind auch ähnlich ...)

[add]
so jetzt mal ohne FW, da geht die passende Demo auch mit raus :roll:

[himitsu]

So, inzwischen gab es noch einige kleine Veränderungen.


Nun hänge ich da aber am nächsten Problem :wall:

Und zwar wollte ich gern irgenwie mit aufnehmen, welche Component Library(s) verwendet werden.
(wenn das überhaupt über Compiler-Direktiven möglich ist)

Die 3 großen Bibliotheken hab ich mir schonmal zusammengesucht, aber ich konnte noch nirgends entdecken, wie/wo man auslesen kann, was nun verwendet wird?

Code:

VCL     Compiled with Borland Visual Component Library
CLX     Compiled with Component Library for  Cross-Platform-Development
FCL     Compiled with Microsoft Framework Component Library

Bei der JCL/JVCL von JEDI wäre es einfach, da dort entsprechende Schalter vorhanden sind.



OK, in den JEDI's gibt es zwar die Compiler-Direktiven CLX, VisualCLX und VCL,
aber dort wird zwischen CLX und VCL unterschiedenm indem geprüft wird, ob es sich um Delphi, oder Kylix handelt.
Aber wie ich es sehe, kann man die CLX ja auch in Delphi verwenden, demnach wärre die Prüfung in den JEDI's falsch ... außerdem fehlt dort ja auch noch die FCL -.-''



Ach ja, was heißt FCL nun genau?
"Framework Component Library" so hatte ich es irgendwo bei Borland, im INet und (ich glaub) auch in der OH gesehn,
oder "Frame Class Library", wie es in den DP-Akronymen heißt, was mir jetzt auch irgendwie sinnvoll vorkommt, das es sich doch um die Bibliothek der Framework-Klassen handelt? :gruebel:

[Robert Marquardt]

jedi.inc forciert nur VisualCLX fuer Kylix aber nicht VCL fuer Delphi.
Nur bei Kylix ist klar das es keine VCL gibt.
Die FCL lohnt nicht, da es kaum Komponenten gibt die unter VCL, VisualCLX und FCL aus einer Source kommen koennten.
Die JCL laueft auch teilweise unter FPC.

[himitsu]

Daß es, wenn Kylix detektiert wird, einfach ist, war mir klar ... aber wie du auch nochmal sagtest ist es ansonsten nicht aus dem ompiler abzuleiten was gerade verwendet wird - in D2005 kann es ja CLX, VCL, oder FCL sein ... aber irgendwie muß man doch rausbekommen können was gerade für ein Projekt erstellt wird?
OK, bei .Net kann es ja nur noch FCL sein, aber anscheinend kann man in eine .Net-Anwendung ja auch etwas VCL mit reinbringen, jedenfalls wenn es nach dem Delphi 8 Kochbuch geht, was ich derzeit bei mir rumliegen hab :wall:


Im grunde genommen wollte ich ja nur eine Möglichkeit, um herauszufinden, was für Bibliotheken verwendet werden,
um dann eventuell, jeweilig was vorhanden ist, passend reagieren zu können.

z.B. eine VCL-Funktion verwenden, wenn VCL vorhanden ist und bei der CLX dann die entsprechende CLX-Funktion...



Einfacher wäre es ja, wenn man in sein Projekt die Schalter selber definiert (also was verwendet werden soll) und dann darüber die entsprechenden Units einzubinden und die Funktionen auszuwählen :gruebel:

[Robert Marquardt]

Die CLX-Version der JVCL funktioniert im Augenblick sowieso nicht, aber wenn sie funktioniert, dann generieren wir aus den Sourcen
separate Files fuer CLX und dann werden die Komponenten parallel in VCL und CLX installiert.
Delphi serviert einem dann ja die korrekte Palette zum Auswaehlen.
Die VisualCLX Eintraege in den JVCL Sourcen sind also garnicht zum direkten Komilieren gedacht.

[jbg]

Zitat:

Zitat von himitsu

in D2005 kann es ja CLX, VCL, oder FCL sein

VCL.NET nicht vergessen.

Im Grund kann man ja "alles" mischen.
Man kann ein VCL Programm schreiben und dabei die CLX einsetzen. Ich habe da so ein Programm, dass zum einen VCL ist, aber zum anderen Formulare für die CLX erzeugt, weil CLX Plugins eingebunden werden.
Welche Schalter würdest du hierfür definieren?

Man kann WinForms und VCL.NET Anwendungen mischen.
Welche Schalter würdest du hierfür definieren?

Im Prinzip kann der Compiler nicht erraten, welche Frameworks du nun einsetzt, oder gar mischt. Was ist, wenn du ein weiteres, neues, alle anderen in den Schatten stellendes Framework einbindest? Woher soll der Compiler denn nun wissen, welches Framework du einsetzen willst?
Es ist schlicht weg nicht möglich für den Compiler. Also muss man es ihm sagen. Und das geht bekanntlicherweise über die Projekt-Optionen->Bedingungen

Zitat:

OK, bei .Net kann es ja nur noch FCL sein

Auch die VCL.NET nutzt die FCL. FCL <> WinForms.

Zitat:

z.B. eine VCL-Funktion verwenden, wenn VCL vorhanden ist und bei der CLX dann die entsprechende CLX-Funktion...

Da musst du wohl oder übel entweder so vorgehen, wie die JVCL und Qxxx Dateien (bzw. JvQxxx) generieren. Die JVCL hat da ein Tool dafür. ODER du machst es über Include-Dateien, die du in jede Unit einbindest. Dann musst du nur noch den Bibliothekspfad für jedes Projekt ändern und die passende Include-Datei wird eingebunden. ODER du machst es über die Projekt-Optionen (einfachste Variante)

[himitsu]

Na OK, ihr habt mich überredet ... hab ja nur gehoft, daß es eventuell einen einfachen und "automatischen" Weg geben könnte :cry:

[himitsu]

So, nun hab ich hier mal meine aktuelle (Single-Unit-)Version.

Diese ist jetzt (hofentlich) auch für Delphi 2006 geeignet.



Nur gibt es da jetzt noch 'ne Kleinigkeit, welche ich gern ändern/ergenzen würde.
Und zwar ist D2006 ja in Wirklichkeit ein Päckchen von Delphi, C#...

Nun bin ich aber mit dem ganzen C-Kram ja "überhaupt" nicht vertraut und würde ein wenig Hilfe benötigen. :)


Als ich Angefangen hab diese Unit zusammenzustellen, da war überall von den C++-Versionen 1 und 3 bis 7 die Rede.
Aber als ich jetzt mal bei Borland vorbei schaute, da stand dort nur was von der 6er und beim Compiler ging es nur bis Version 5.5 :gruebel:

Zitat:

Zitat von Borland

C++BuilderX 6.1
C++Builder 6
C++Builder Compiler 5.5

Und wenn jetzt D2006 rauskommt, dann ist dort ja wiederum C++/C# drin, welches dann aber bestimmt auf 'nem Compiler der 10. Generation aufbaut?


Und dann hab'sch da ja noch 'ne Liste der verschiedenen Delphi/Kylix-Versionen ... und naja, wie gesagt, mir fehlen nun die C-Versionen :roll:
(allerdings ist dieses nich unbedingt daß Wichtigste ... wir sind ja schließlich nur'n Delphi-Forum ^^)
z.B für Delphi:

Code:

Delphi 1                         -               -
Delphi   2                       Desktop         Desk
Delphi     3 4 5                 Standard        Std
Delphi           6 7   2005 2006 Personal        Pers
Delphi   2                       Developer       Dev
Delphi     3 4 5 6 7 8 2005 2006 Professional    Pro/Prof
Delphi   2 3 4                   Client/Server   Serv/CS
Delphi         5 6 7 8 2005 2006 Enterprise      Ent
Delphi             7 8 2005 2006 Architect       Arch

[NicoDE]

Zitat:

Zitat von himitsu

Und wenn jetzt D2006 rauskommt, dann ist dort ja wiederum C++/C# drin, welches dann aber bestimmt auf 'nem Compiler der 10. Generation aufbaut?

Für Pascal dürfte das doch relativ uninteressant sein, oder?
Im BCB wurde/wird zum Generieren der .hpp der Delphi Compiler/Linker (dcc32) mit speziellen Parametern gestartet (-JPHNE).
Insofern dürfte ebenfalls VER180 definiert sein, da es sich um den selben Compiler/Linker handelt.

[himitsu]

Im Grunde genommen ist das ja mein "Problem", denn ich hab ja schließlich schon die Vermutung, daß es ich um einen/den Compiler der 10. Genereation handelt, also das überall VER180 vorhanden sein wird. ^^

Die Unterscheidung wird dann wohl "vermutlich" genauso wie ab den 5er Compilern sein, also es wird das BCB-Symbol definiert sein.

Code:

(************************************************************************ )
(                                                                         )
(  Definitions for Compiler Versions:                                     )
(  **********************************                                     )
(                                                                         )
(  MSWINDOWS + VER80            DELPHI_1         COMPILER_1               )
(  MSWINDOWS + VER90            DELPHI_2         COMPILER_2               )
(  [color=#00ffff]MSWINDOWS + VER93            CPPBUILDER_1     COMPILER_2[/color]               )
(  MSWINDOWS + VER100           DELPHI_3         COMPILER_3               )
(  [color=#00ffff]MSWINDOWS + VER110           CPPBUILDER_3     COMPILER_35[/color]              )
(  MSWINDOWS + VER120           DELPHI_4         COMPILER_4               )
(  [color=#00ffff]MSWINDOWS + VER125           CPPBUILDER_4     COMPILER_4[/color]               )
(  MSWINDOWS + VER130           DELPHI_5         COMPILER_5               )
(  [color=#00ffff]MSWINDOWS + VER130 + BCB     CPPBUILDER_5     COMPILER_5[/color]               )
(  MSWINDOWS + VER140           DELPHI_6         COMPILER_6               )
(  [color=#00ffff]MSWINDOWS + VER140 + BCB     CPPBUILDER_6     COMPILER_6[/color]               )
(  [color=#00ff00]LINUX     + VER140           KYLIX_2          COMPILER_6[/color]               )
(  MSWINDOWS + VER150           DELPHI_7         COMPILER_7               )
(  [color=#00ffff]MSWINDOWS + VER150 + BCB     CPPBUILDER_7     COMPILER_7[/color]               )
(  [color=#00ff00]LINUX     + VER150           KYLIX_3          COMPILER_7[/color]               )
(  MSWINDOWS + VER160           DELPHI_8         COMPILER_8               )
(  [color=#ff0000]MSWINDOWS + VER160 + CLR     DELPHI_8NET      COMPILER_8NET[/color]            )
(  MSWINDOWS + VER170           DELPHI_9         COMPILER_9               )
(  [color=#ff0000]MSWINDOWS + VER170 + CLR     DELPHI_9NET      COMPILER_9NET[/color]            )
(  MSWINDOWS + VER180           DELPHI_10        COMPILER_10              )
(  [color=#ff0000]MSWINDOWS + VER180 + CLR     DELPHI_10NET     COMPILER_10NET[/color]           )
(  [color=#00ffff]MSWINDOWS + VER180 + BCB     CPPBUILDER_10    COMPILER_10[/color]              )
(                                                                         )
(************************************************************************ )

Aber wie gesagt, ich hab keine Ahnung was mit dem 7er los ist, denn in vielen Quellen wird der 7er mit unterschieden, aber auf der Borland-Website ist nur was bis zum 6er vorhanden?
Und was ist vorallem mit den Compilern 8 und 9 ... jetzt scheint es ja schließlich den 10er zu geben? :gruebel:

[add]
hab vorläufig den CPPBUILDER_10 mit in diesem Beitrag eingefügt.

[NicoDE]

Zitat:

Zitat von himitsu

Die Unterscheidung wird dann wohl "vermutlich" genauso wie ab den 5er Compilern sein, also es wird das BCB-Symbol definiert sein.

Jupp.

Zitat:

Zitat von himitsu

Aber wie gesagt, ich hab keine Ahnung was mit dem 7er los ist, denn in vielen Quellen wird der 7er mit unterschieden, aber auf der Borland-Website ist nur was bis zum 6er vorhanden?

Vielleicht hat es der "BCB7" einfach nie in die Läden geschafft... wer weiß :)

[himitsu]

Zitat:

Zitat von NicoDE

Vielleicht hat es der "BCB7" einfach nie in die Läden geschafft... wer weiß :)

hmmm :gruebel: ich könnte ja einfach die 7 bis 9 mit aufnehmen, aber wenn es diese nicht gibt, dann würde ich ja doch lieber nicht drin haben wollen :angel2: