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


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


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

[himitsu]

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


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

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?

[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


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

[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 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