28.10.2004

Delphi2Cpp 2.5

Symbolnamen, die mit der Groß- und Kleinschreibung der Deklaration übereinstimmen

Bei der Konvertierung von Delphi nach C++ ist darauf zu achten, dass alle Bezeichner in eine einheitliche Groß- und Kleinschreibung überführt werden. Bisher wurde dies erreicht, indem alle Bezeichner, die sich nur in der Groß- und Kleinschreibung unterschieden, radikal auf eine einheitliche Schreibweise reduziert wurden. Mit Version 2.5.0 gibt es jedoch die Option, für alle Symbole die Schreibweise zu übernehmen, in der sie ursprünglich deklariert wurden. Diese Option ist nun standardmäßig aktiviert, während die alte Methode als veraltet gilt.

In der folgenden Unit werden z.B. eine Konstante, eine Eigenschaft und ein Parameter mit den Namen "name", "Name" und "NAME" verwendet.

unit casesensitivity;

interface

const
  name: string = 'DefaultName';

type
  TPerson = class
  private
    FName: string;
  public
    property Name: string read FName write FName;
    procedure DisplayInfo(NAME: string);
  end;

implementation

procedure TPerson.DisplayInfo(Name: string);
begin
  WriteLn('Parameter Name: ' + Name);
  WriteLn('Property Name: ' + Self.Name);
  WriteLn('Constant Name: ' + casesensitivity.Name);
end;

end.

Mit der veralteten "unify all cases" Option bekamen alle Symbole gleichgeschriebene Namen, wurde die DisplayInfo Prozedur zu:

void __fastcall TPerson::DisplayInfo(String name)
{
  WriteLn(String(L"Parameter Name: ") + name);
  WriteLn(String(L"Property Name: ") + this->name);
  WriteLn(String(L"Constant Name: ") + casesensitivity::name);
}

Mit der neuen Option werden in der Prozedur alle drei Symbolnamen innerhalb von DisplayInfo verwendet. Dies ist möglich, weil sie in verschiedenen Bereichen deklariert sind. Delphi2Cpp konvertiert die prozedur für den C++Builder in:

void __fastcall TPerson::DisplayInfo(String NAME)
{
  WriteLn(String(L"Parameter Name: ") + NAME);
  WriteLn(String(L"Property Name: ") + this->Name);
  WriteLn(String(L"Constant Name: ") + casesensitivity::name);
}

Für andere Kompiler wird die Prozedur zu:

void TPerson::DisplayInfo(String NAME)
{
  WriteLn(String(L"Parameter Name: ") + NAME);
  WriteLn(String(L"Property Name: ") + this->ReadPropertyName());
  WriteLn(String(L"Constant Name: ") + casesensitivity::name);
}

Mit der Option zum Abgleichen mit den Deklarationsnamen werden Probleme vermieden, die auftreten, wenn verschiedene Teile des Codes mit unterschiedlichen Bezeichnerlisten übersetzt werden.

Die C++Builder Version der Synedit-Komponenten:

https://github.com/dm-e/SynEditCb

wurden mit der Option der an die Deklaration angepassten Symbolnamen neu übersetzt.

26.08.2024

Delphi2Cpp 2.4

Das aktuelle Update Delphi2Cpp 2.4.0 ist vor allem den Neuerungen in dem kürzlich erschienenen RAD Studio 12.1 gewidmet, es enthält aber auch viele andere, teils fundamentale, Verbesserungen. Im RAD Studio 12.1 gibt es wieder einen brauchbaren C++Builder mit einem neuen modernen Clang Compiler. Neu in Delphi 12.1 ist auch die Unterstützung von mehrzeiligen Strings: Wie Delphi2Cpp 2.4. sie nach C++ konvertiert, zeigt das Multiline-Beispiel.

Mit Delphi2Cpp 2.4. wurden die bereits zuvor übersetzten Dateien der RTL auf den aktuellen Stand gebracht. Außerdem wurden weitere Verbesserungen an dem übersetzten Code vorgenommen

1. Code in dem der plattformübergreifende Botschafts-Manager "TMessageManager" verwendet wird, wird nun fehlerfrei übersetzt.

2. Code der die atomaren Funktionenenverwendet, bedarf nun keiner manuellen Nachbearbeitung mehr. Das betrifft:

AtomicDecrement
AtomicIncrement
AtomicExchange
AtomicCmpExchange

3. Die Übersetzung von System.System.SyncObjs.pas wurde überarbeitet und für Windows unter Verwendung von CRITICAL_SECTION vervollständigt.

4. es gibt jetzt die zusätzliche Option, den übersetzten Code für den modernen C++Builder-Compiler zu optimieren.

5. Es gibt nun eine zusätzliche Version der für den C++Builder übersetzten Synedit-Komponenten für den modernen Compiler mit 64 bit. Auch die bisherigen Versionen wurden teilweise aktualisisert.

https://github.com/dm-e/SynEditCb

Verbesserte Algoritmen

die Methode nach der die zuvor gefundenen Typen, Variablen etc. bei der Erzeugung der Ausgabe nachgeschlagen werden, wurde grundlegend verbessert. Bisher wurde eine Art "brute force" Methode verwendet, die bisweilen in falschen Alternativen endete. Der neue Algorithmus ist wesentlich intelligenter. Dadurch ist diese Methode nicht nur exakter geworden, sie arbeitet nun auch ca. 25 % schneller (SynEdit example vorher 4:00 min, nun 2:55 min). Auch Redeklarationen von Bezeichnern werden nun anders behandelt als zuvor. Für andere Compiler als den C++Builder werden jetzt Redeklarationen wie z.B. die folgende unterdrückt (bzw. als Kommentar ausgegeben):

dupIgnore = System.Types.TDuplicates.dupIgnore;

Wenn nötig wird nun durch entsprechende Qualifizierung jeweils auf den originalen Typ verwiesen. Im Unterschied zu Delphi ist dies in C++ immer möglich.

Beide Verbesserungen zusammengenommen führen zu einer exakteren Qualifizierung der Bezeichner und führt so letztlich auch zu einer verbeserten Desambiguierung.

Kopierkommentare

wenn das Feature zu automatischen Einfügug von vorbereitetem C++-Code verwendet wird, so wird der entsprechendeAusgabe Code nun durch zwei Kommentarzeichen gekennzeichnet:

//# copied begin
... prepared code
// copied end

Z.B.:

(*#_#include "math.h"_#*)
->
//# copied begin
#include "math.h"
//# copied end

out-Parameter

bisher hat Delphi2Cpp var-Parameter und out-Parameter uterschiedslos behandelt, da es in C++ kein echtes Equivalent zur out-Parametern gibt. Nun wird durch Initialisierung der übergebene out-Parameter zumindest dem Umstand Rechnung getragen, das out-Parameter ihre möglicherweise enthaltenen Werte bei der Übergabe an die Funktion verlieren. Damit wird im übersetzten Code zugleich sichtbar, dass es sich hier nicht um einfache Referenz.Parameter handelt.

Beispiel:

function TryParse(const S: string; out Value: Cardinal): Boolean;
var
  E: Integer;
...
->
bool __fastcall TryParse(const String S, unsigned int& Value)
{
  Value = 0; //# clear out parameter
  bool result = false;
  int E = 0;
...

Zusätzliche Tools

1. ExtractIdentifiers ist ei Werkzeug mit dem man Bezeichnerlisten nun auch außerhlb der Delphi2Cpp IDE erstellen und korrigieren kann.

Amerkung: auch beim Erstellen dieser Listen innerhalb der IDE gibt es nun die Änderug, dass Zahlen in diese Liste nicht mehr eingefügt werden.

2. ExtractReworked ist ein Werkzeug mit dem man die Übernahme von geänderten Übersetzungsergebnissen vereinfachen kann.

19.10.2023

Delphi2Cpp 2.3

Konvertierung von DFM-Dateien nach C++

- Der Code von DFM-Dateien kann nun optional in C++-Code konvertiert werden, der zur Laufzeit beim Erstellen des Formulars oder eines Frames ausgeführt wird. Im Wesentlichen besteht der DFM-Code aus einer Reihe einfacher Zuweisungen von Werten zu Komponenteneigenschaften. Delphi2Cpp gelingt es auch, andere, teilweise komplexe Serialisierungsaktionen auf intuitive und einfache Weise abzubilden. Hierzu werden spezielle Routinen aufgerufen, die den Eigenschaften die Werte nicht direkt zuweisen, sondern diese als Argumente an die Routinen übergeben, in denen dann weitere Aktionen ausgeführt werden können. Speziell für Komponenten von Drittanbietern kann Delphi2Cpp so konfiguriert werden, dass es solche benutzerdefinierten Funktionen aufruft.
Durch die Übersetzung des DFM Codes lassen sich im C++Builder GUI-Anwendungen bauen, die gänzlich ohne DFM Dateien auskommen. Bei anderen Compilern bildet die Konvertierung des DFM-Codes die unerlässliche Brücke zur Verwendung von C++ GUI Bibliotheken.

Mehr Details zur Konvertierung von DFM-Dateien

31.01.2023

Delphi2Cpp 2.2

Übernahme von Änderungen an Delphi2C# zur erleichterten Übersetzung unvollständigen Codes

02.07.2022

Delphi2Cpp 2.1

06.08.2021

DelphiXE2Cpp11 ist jetzt Delphi2Cpp 2.0

Für C++98 werden nun die inneren Funktionen aus verschachtelte Funktionen herausextrahiert, so dass sie zu Klassenfunktionen oder normalen freien Funktionen werden. Parameter und Variablen der äußeren Funktion werden an die extrahierten Funktionen übergeben. Über dieses Feature hatte bereits Delphi2Cpp 1 verfügt, es fehlte bisher aber in Delphi2Cpp 2.x. Mit diesem Feature kann Delphi2Cpp 2.x als legitimer Nachfolger von Delphi2Cpp 1 angesehen werden und wird damit zu Delphi2Cpp 2.0.

31.03.2021

Für rekursiv aufgerufene verschachtelte Funktionen generiert Delphi2Cpp 2.x nun in C++ explizite Vorwärtsdeklarationen anstelle der fehlerverursachenden auto-Routinen. Z.B.:

  function nested : boolean;

    function nested_reflexive(depth :Integer) : boolean;
    begin
      if depth = 2 then
        result := true
       else
        result := nested_reflexive(depth + 1);
    end;

  begin
    result := nested_reflexive(0);
  end;

->

function<bool (int)> nested_reflexive;

bool __fastcall nested()
{
  bool result = false;

  nested_reflexive = [&](int depth) -> bool 
  {
    bool result = false;
    if(depth == 2)
      result = true;
    else
      result = nested_reflexive(depth + 1);
    return result;
  };
  result = nested_reflexive(0);
  return result;
}

Zusätzliche RTL-Dateien wurden übersetzt:

System.ZLib
System.ZLibConst
System.Win.Registry

05.08.2020
Verbesserte Löung für die C++ Nachbildung der modulweiten Sichtbarkeit von Klassenmembern in Delphi.

Die aktualisierte Dokumentation enthält bereits Informationen zum geplanten Programm Delphi2CB. Delphi2CB wird ein kostengünstiges Extrakt aus Delphi2Cpp 2.x für Benutzer des C++Builders sein.

23.06.2020
Angebot des Delphi2Cpp 2.x Übersetzungsservice: kostenlose Übersetzung von 1000 Zeilen ihres Codes

02.04.2020
Dokumentation aktualisiert, beta-Angebot beendet

15.11.2019
Klassenreferenzen

Für andere Compiler als den C++Builder unterstützt Delphi2Cpp 2.x nu ein neues Muster zur Erzeugung von Klassenreferenzen, dass sehr viel eleganter ist als das des alten Delphi2Cpp. Es gibt nun eine Funktion:

template <class Class> TClass class_id()

die Instanzen von Klassenreferenzen in ähnlicher Weise liefert, wie die __classid Funktion des C++Builders. Klasseninnstanzen können durch Aufruf virtueller Konstruktorfunktionen aus solchen Klassenreferenzen erzeugt werden.

16.10.2019
Delphi2Cpp 2.x beta-Angebot

30.01.2012 Version 1.6.3

Klassenelemente werden nun automatisch in den Initialisierungslisten der Konstruktoren mit Default-Werten inititialisiert, wenn es keine expliziten Initialisierungen im Körper des Konstruktors gibt. Gibt es solche expliziten Initialisierungen, so werden sie in die Initialisierungsliste verschoben. Diese Verschiebung geschieht nicht, wenn die Initialisierung von einer Bedingung abhängt. Beispiel:

constructor Base.Create(arg : Integer);    __fastcall Base::Base( int arg )
begin                                       : FI(arg),                     
  FList := TList.Create;                      FList(new TList),            
  FI := arg;                                  FTimeOut(0)                  
  if arg <> $00 then                       {                               
    FTimeOut := arg                          if ( arg != 0x00 )            
  else                                         FTimeOut = arg;             
   FTimeOut := DefaultTimeout;               else                          
end;                                           FTimeOut = DefaultTimeout;
                                           }                  

05.01.2012 Version 1.6.2

31.10.2011 Version 1.6.0

10.10.2011 Version 1.5.2

26.09.2011 Version 1.5.1

22.08.2011 Version 1.5.0

21.06.2011 Version 1.4.9

31.05.2011 Version 1.4.8

08.05.2011 Version 1.4.7

11.04.2011 Version 1.4.5

14.03.2011 Version 1.4.3

21.02.2011 Version 1.4.2

Ein Benutzer von Delphi2Cpp hat eine leistungsfähige Template-Klasse beigesteuert, die Delphi- Sets emuliert. Features:

Vielen Dank an Daniel Flower.

04.02.2011 Version 1.4.1

- Für die Rückgabe statischer Array's aus Funktionen gibt es nun einen Behelf. Da dies in C++ nicht ebenso möglich ist wie in Delphi, wird ein Zeiger auf das erste Element des Array's zurückgegeben und als Argument für "memcpy" verwendet. In Fällen, wo das statische Array lokal innerhalb der Funktion erzeugt wurde, wird vor dessen Zerstörung eine Kopie des Array's in einem Hilfs-Array in der Datei angelegt.

- with-Anweisungen werden nun anders übersetzt als bisher. Anstatt den Ausdruck an allen entsprechenden Stellen einzusetzen, wird nun eine temporäre Variable des resultierenden Typs angelegt. So werden auch Konstruktionen wie die folgende korrekt übersetzt:

  with TmyObject.Create do
    try
      // do something with the object
    finally
      Free;
    end;

->

{
  /*# with TmyObject.Create do */
  TmyObject* tmp2 = new TmyObject;
  try
  {
    // do something with the object
  }
  __finally
  {
    tmp2->Free();
  }
}    

- Die kaum verständliche Fehlermeldung "unit expected" erschien bisher, wenn eine eingeschlossene Datei mit einer UTF8-Kennung (BOM) begann. Diese Kennung wird von neueren Delphi-Versionen erzeugt und wird nun auch von Delphi2Cpp akzeptiert.

- Es gibt nun ein vereinfachendes Makro für "dynamic_cast<>", das für den "is"-Operator steht:

#define ObjectIs(xObj, xIs) dynamic_cast< xIs >( xObj )

Dieses Makro muss in der überschriebenen System.pas enthalten sein. Wenn diese Datei nicht verwendet wird, wird auch das Makro nicht benutzt und diue Übersetzung bleibt die gleiche wie in den bisherigen Versionen von Delphi2Cpp.

- Statt der nicht existierenden Datei "BDE.pas" wird nun die Datei "bde.int" analysiert, wenn der Pfad zu dieser Datei in der Liste der Include-Pfade vorhanden ist. Wenn die Dateien "WinTypes.pas" und "WinProc.pas" nicht vorhanden sind, ersetzt der Präprozessor ihre Verweise durch den auf "Windows.pas".

- Mehr Korrekturen spezieller Fehler.

16.01.2011 Version 1.4.0

- Die professional Version von Delphi2Cpp.exe kann nun auch als Kommandozeilen-Programm ausgeführt werden.

- Die für Delphi besonders wichtige Quellcode-Datei "System.pas" kann nun individuell überschrieben und/oder erweitert werden (nur in der professional Version von Delphi2Cpp).

- Das Skelett einer solchen individuellen "System.pas" wird in das "Source"-Verzeichnis von Delphi2Cpp installiert. In dieser Datei "d2c_system.pas" sind u.a. die wichtigsten Funktionen zum Speichermanagement definiert. Die Übersetzung der Datei mit Delphi2Cpp ergibt funktionierenden C++-Code und kann zusammen mit eigenen übersetzten Dateien kompiliert und gelinkt werden.

- "d2c_system.pas" enthält u.a. auch spezielle Funktionen für "Inc" und "Dec", die auch für enumerierte Typen funktionieren. Für solche Typen werden bei der Übersetzung diese Funktionen nun nicht mehr durch den Inkremtierungs- bzw. Dekrementierungsoperator ersetzt.

- Die Funktion "Fillchar" wird nicht mehr automatisch durch die "memset" Funktion ersetzt. Stattdessen wurde die Definition systematischer Weise in "d2c_system.pas" eingefügt.

- Temporäre Parameter in Funktionsaufrufen werden nun explizit als Variablen diesen Aufrufen vorangestellt. Diese werden zusammen mir dem Funktionsaufruf in einen {...}-Block eingeschlossen,So wird die Lebensdauer der Variablen für den Zeitraum des Funktionsaufrufs sicherstellt. Zugleich wird gewährleistet, dass die beiden Anweisungen auch dann innerhalb eines gemeinsamen Blocks stehen, wenn die ursprüngliche Anweisung innerhalb einer Kontrollstruktur ohne solchen Block auskam. Z.B.:

 if Greet(PChar('hello ' + Name + '!')) then
   Exit;

->

  {
    AnsiString Str__0( "hello " ) + Name + "!";
    if ( Greet( Str__0.c_str( ) ) ) 
      return;;
  }

Neu ist auch die Übersetzung von temporären set's als Werten vom "open array"-Parametern, die ebenfalls auf die eben geschilderte Art erfolgt.

procedure Log(strings : array of String);

Log(['one', 'two', 'three']);

->

void __fastcall Log( const String* strings, int strings_maxidx )

{
  String tmp__0[ 3 ];
  tmp__0[ 0 ] = "one";
  tmp__0[ 1 ] = "two";
  tmp__0[ 2 ] = "three";
  Log( tmp__0, 3 );
}

- Verbesserungen bei der Berechnung von Compilierzeit-Konstanten.

- Die mit dem letzten Update eingeschlagenen Strategie, Typbezeichner weitgehendst unverändert zu lassen wurde ausgebaut/komplettiert. Z.B. "String" wird nicht mehr durch "AnsiString" oder "WideString" ersetzt.

- Bisher wurde "String"-Parameter stets wie Delphi-Strings behandelt, auch bei aktivierter Option zur Übersetzung als Standard-Strings. Ab diesem Update werden die "String"-Parameter konform mit "AnsiString" und "WideString" behandelt.

- Fehlende Namensraumbezeichner bei Konstanten und in den redeklarierten Konstruktoren der Vorgängerklassen, werden nun augegeben.

- Code für den "Cpp" definiert ist wird nicht mehr bezüglich Groß-/Kleinschreibung korrigiert. Zuvor konnte es z.B. passieren dass dabei "#include <io.h>" zu "#Include <io.h>" umgewandelt wurde.

- Ersetzungen werden nun bereits ausgeführt, bevor eine eingeschlossene Unit geöffnet wird, so dass statt der ursprünglich genannten Unit eine andere eingeschlossen werden kann. Eine derartige Ersetzung, nämlich die von "WinProc" durch "Windows", geschah bisher schon automatisch, wenn "WinProc" nicht gefunden wurde. Dies geschieht nun auch für "WinTypes" automatisch.

- Standardmäßig ist nun "MSWINDOWS" definiert. Diese Definition kann selbstverständlich entfernt oder ersetzt werden.

- Die Hilfe zu Delphi2Cpp kann nun zusätzlich auch als PDF-Datei installiert werden.

- Die Qualität der Übersetzung wurde erneut überprüft: das "ATBinHex"-Beispiel dass im Mai letzten Jahres erstmal mit Delphi2Cpp 1.3.0 übersetzt wurde, wurde nun mit Delphi2Cpp 1.4.0 nochmals übersetzt. Die Anzahl der erforderlichen manuellen Korrekturen ist auf weniger als die Hälfte reduziert.

- Es gibt nun einen Übersetzungs-Service für Delphi2Cpp.

- u.v.m.

06.12.2010 Version 1.3.9

- "ShortString" und "String[n]" werden jetzt soweit möglich adäquat übersetzt. D.h. Aufrufe von "Length", "SetLength", "Low" und "High" werden für diese Stringtypen speziell behandelt. Für andere String-Methoden werden "ShortString" und "String[n]" temporär in einen String konvertiert. Bisher wurden ShortString wie normale Strings behandelt.

- Die Methoden zur Ermittlung von Zeigertypen wurden komplett überarbeitet. Dies führt oft zu präziseren Übersetzungsergebnissen als bisher. Dies betrifft insbesondere dynamische Arrays. Bisher wurden häufig Parametertype durch Basistypen ersetzt. Das geschieht jetzt nur noch in wenigen erwünschten Fällen, wie z.B. die Ersetzung von "PChar" durch "char*".

- Die Definition von Konstanten durch andere Konstanten erfolgt in C++ jetzt vollständig durch Einsetzung der Werte der bereits definierten Konstanten, so dass es zu keinen Compilerfehlern mehr kommt.

- Die Umsetzung der Option zur Erzeugung von Namensräumen wurde vervollständigt: die Namensräume von Basisklassen werden eingefügt und forward-Deklarationen werden in den Namensraum geschrieben.

- Fehler mit globalen Variablen im Interface-Teil wurden behoben.

- u.v.m.

09.11.2010 Version 1.3.8

- In der professional Version gibt es jetzt die Option, für jede Unit einen gleichnamigen namespace zu erzeugen. In den C++ Headern werden dann Typen aus anderen Units deren namespace vorangestellt und in den C++ Implementationsdateien werden die entsprechenden using-Klauseln eingefügt. Durch namespace's qualifizierte Bezeichner werden entsprechend aufgelöst.

- Die Delphi Direktiven $HPPEMIT, $EXTERNALVAR, &NODEFINE und $NOINCLUDE werden jetzt von Delphi2Cpp unterstützt.

- Mit dem Update 1.3.6. wurde ein Fehler in den Dialog für die Liste der Include-Verzeichnisse eingebaut. Bei mehrfacher Benutzung des Dialogs wurde die Liste mehrfach kopiert. Dieser Fehler wurde behoben.

- Im File-Manager werden nun schon während der Verarbeitung der Dateien mehr Fehler-Informationen angezeigt.

- Wenn in einer Case-Anweisung für einen "case" eine Menge von mehr als 1000 Elementen definiert ist, werden diese Fälle bei der Übersetzung nicht mehr vollständig aufgelistet. Stattdessen wird ein Hinweistext ausgegeben: "There are too much cases! This section of code has to be converted by hand!". Bisher brauchte Delphi2Cpp viel Zeit, um dieses Listen schreiben, so dass es schien, als stünde das Programm still.

- Fehlerbeseitigung im Päprozessor: "UNDEF" funktionierte nicht für Bezeichner, die nicht bereits in den Delphi2Cpp Optionen als definiert gesetzt sind. Die Direktiven "$I+" und $I-" werden nun ignoriert.

25.10.2010 Version 1.3.7

Viele Detailverbesserungen im Implementationsteil von Units, die im einzelnen oft schwer zu beschreiben sind. Besonder zu nennen sind:

- Bisher war nur der Vorrang der "and" und "or" Operatoren vor den Gleichheitsoperatoren berücksichtigt worden. Nun wird auch die Reihenfolge in der andere Operatoren in Delphi innerhalb von Ausdrücken ausgeführt werden im übersetzten C++ Code reproduziert.

- "not" wird nun zu '~' konvertiert, wenn der folgende Ausdruck nicht vom Typ boolean ist.

- Der Fehler wurde beseitigt, dass Funktionen zur Initialisierung von arrays nicht aufgerufen wurden, wenn die Unit keinen Initialisationsteil enthält.

- Viele weitere Verbesserungen bei Typecasts, Zeigern, verschachtelten Funktionen etc.

03.10.2010 Version 1.3.6

13.09.2010 Version 1.3.5

Wegen dem Umfang der Erweiterungen und Verbesserungen wird die Versionsnummer in diesem Update gleich um zwei Stellen erhöht.

15.08.2010 Version 1.3.3

http://www.texttransformer.de/Videos_ge.html

25.07.2010 Version 1.3.2

      catch(...) 
      { 
        ... // Anweisungen
        throw; 
      }

05.07.2010 Version 1.3.1

      if(...)
      {
        delete p;
        p = NULL;
      }

14.06.2010 Version 1.3.0.1

Nachkommastellen wurden wie Vorkommastellen behandelt. So wurde z.B. 1.2 aus 1.002. Dieser Fehler wurde behoben.

25.05.2010 Version 1.3.0

In Delphi entwickeln, C++ kompilieren:

Der übersetzte C++ Code kann nun mit dem Code synchronisiert werden, der in Delphi weiter entwickelt wird. Zu diesem Zweck können die Teile des Codes, die in C++ einer Nachbearbeitung bedurften, bereits in Delphi so vorformuliert werden, dass sie bei erneuter Übersetzung nicht erneut nachbearbeitet werden müssen. Bei der Präparation des Delphi-Codes kann auf eine vordefinierten Konstante zurückgegriffen werden, so dass mittels bedingter Kompilierung bestimmte Codeabschnitte nur für die Übersetzung nach C++ relevant sind, während andere Abschnitte nur für den Delphi-Compiler sichtbar sind. Darüber hinaus können komplette C++-Codeabschnitte bereits so in den Delphi-Code eingefügt werden, dass sie bei der Übersetzung in die Ausgabe übernommen werden, den Delphi-Compiler aber nicht stören.

Weitere Neuerungen in Delphi2Cpp 1.3.0 sind:

13.05.2010 Version 1.2.9

-In einem Log-Fenster werden nun einzelne Schritte der Übersetzung dokumentiert und Warnungen und Fehlermeldungen ausgegeben.

-Durch exaktere Behandlung von Namensräumen wurde die Qualität der Übersetzung weiter verbessert.

02.05.2010 Version 1.2.8

-Die Reihenfolge von Typdefinitionen wird nun korrigiert. Die Definitionen werden erst dann geschrieben, wenn der definierende Type bekannt ist. Zugleich wird damit die Erkennung der Typen an späteren Stellen im Code verbessert. Siehe in der Hilfe den Abschnitt: "Order of type definitions".

-Botschaftsbehandlungsmethoden werden jetzt unter Verwendung des VCL_MESSAGE_HANDLER-Makros übersetzt.

-goto-Anweisungen werden nun übersetzt und das Update enthält viele weitere kleine Verbesserungen.

-Es gibt mehr und mehr Feedback von Benutzern, was stark zu der Verbesserung von Delphi2Cpp beiträgt. Vielen Dank an sie alle!

25.04.2010 Version 1.2.7

Eine Reihe zusätzlicher Übersetzungsoptionen ist hinzugekommen:

Außerdem gibt es wieder einige Verbesserungen der Übersetzungsqualität und Fehlerbehebungen:

18.04.2010 Version 1.2.6

Stark verbesserte Übersetzungsergebnisse, weil
-die Übergabe von Strukturen an Funktionen in WinProcs jetzt in Übereinstimmung mit der CBuilder VCL als Übergabe von Adressen interpretiert wird
-zwischen boolschen und bitweisen "and" und "or" Operator unterschieden wird
-Default-Parameter in verschachtelten Funktionen berücksichtigt werden
-und es viele weitere Detailverbesserungen gibt.
-Außerdem wird jetzt für den Zugriff auf Elemente die übliche Schreibweise mit dem Zeiger-Operator "a->" ausgegeben statt der bisherigen "(*a).".
-Überflüssige Set-Definitionen werden vermieden.

07.04.2010 Version 1.2.5

-Die Liste der Bezeichner, die vom Präprozessor zur Vereinheitlichung der Schreibweisen erzeugt wird, kann nun gespeichert werden. In einer nachfolgenden Sitzung kann die Liste wieder geladen werden, um in weiteren Übersetzungen die gleichen Schreibweisen beizubehalten.
-In der professional Version von Delphi2Cpp gibt es nun eine zusätzliche Ersetzungstabelle für den Übersetzer ähnlich der schon vorhandenen Tabelle für den Präprozessor.
-Die Behandlung von Arrays wurde überarbeitet. Dabei wurde die Strategie der Indexierung geändert. (Mehr Informationen zu diesem Punkt finden Sie in den Abschnitten der Hilfe: Statische Arrays und Offene Arrays.)

24.03.2010 Version 1.2.4
-Initialisierung und Finalisierung von Units.
-Initialisierungsroutinen für array's.
-Diverse weitere kleine Verbesserungen.

18.03.2010 Version 1.2.3
-Viele kleine spezielle Verbesserungen der Übersetzungsqualität

07.03.2010 Version 1.2.2
-Verschachtelte Delphi Funktionen werden nun in normale Klassenfunktionen entflochten. Alle nötigen Parameter werden an diese Funktionen übergeben.
-Überschriebene "properties" werden nun auch in C++ entsprechend überschrieben.

28.02.2010 Version 1.2.1
-Delphi2CppInstall.exe installiert nun eine dauerhaft nutzbare Demoversion von Delphi2Cpp. Das Demoprogramm liefert Übersetzungen in gleicher Qualität wie das lizensierte Programm. Jedoch ist die Menge des ausgegebenen Codes für den Implementationsteil auf 10000 Zeichen begrenzt und das Laden und Speichern von Code und Optionen ist nicht möglich. Beim Kauf einer Lizenz von Delphi2Cpp wird ein Link auf eine Version von Delphi2Cpp geliefert, in der sich die vollständige Funktionalität des Programms mittels der Lizenz freischalten lässt. Wie bisher gehört der Dateimananger nicht zur Funktionalität der Standardversion sondern ist nur in eder professional Version nutzbar.
-Zusätzliche Option für vorkompilierte Header.
-Verbesserung der Überzetzung von Zeigern auf Zeiger
-Kosmetische Verbesserungen:
a) statt der unüblichen Schreibweise

(*fo).bar , jetzt: fo->bar

b) statt der unüblichen Einrückung der Klammern:

if(...)
  {
    ...
  }

jetzt:  

if(...)
{
  ...
}

17.02.2010 Version 1.2.0
- Optional kann nun C++-Code auch für andere Compiler als den CBuilder generiert werde. Für die anderen Compiler werden Delphi-properties eliminiert, indem ihre Vorkommen durch entsprechenden Read- bzw. Write-Methoden ersetzt werden.

- Schreibweisen und Übersetzungen von Bezeichnern können nun durch eine individuelle Übersetzungstabelle gesteuert werden.

- Die Qualität des Übersetzungsergebnisses wurde weiter gesteigert, insbesondere bezüglich der Behandlung von Arrayzeigern, Typecasts, __classid u.v.m

- Der Preis für Delphi2Cpp wurde entsprechend den erweiterten Fähigkeiten des Programms erneut leicht angehoben.

04.02.2010 Version 1.1.9
- An Stellen, wo C++ konstante Ausdrücke erwartet, werden in der Übersetzung nun die Werte von Konstanten ausgegeben, statt der Konstanten selbst.

- Für globale Funktionen wird nun registriert, ob der Rückgabetyp ein Zeiger ist. Bisher wurde das vergessen.

- Die Änderung im letzten Update String-Parameter "(s : string)" als "(const string& s)" zu übersetzen wurden rückgängig gemacht, weil dies zu Konflikten mit der CBuilder VCL führte.

- Ein Fehler wurde beseitigt, der dafür verantwortlich war, dass häufig falsche Übersetzungsalternativen für spezielle VCL-Funktionen ausgewählt wurden.

01.02.2010 Version 1.1.8
- Die Übersetzung des Implementationsteils der pas-Dateien erfolgt nun um ein mehrfaches schneller als bisher.

- Unterfunktionen verschachtelter Funktionen werden nun korrekt behandelt. Die Verschachtelung bleibt allerdings weiterhin bestehen.

- Verbesserungen bei der Behandlung von Stringadditionen und Stringparametern.

25.01.2010 Version 1.1.7
- Viele with-Anweisungen, die bisher nicht korrekt übersetzt wurden, werden nun korrekt analysiert und übersetzt

- Viele weitere kleine Verbesserungen.

17.01.2010 Version 1.1.6
- Deklarationen von Klassen werden nur noch in den tatsächlich eingeschlossenen Units gesucht.

- Unit-Namensräume werden in qualifizierten Bezeichnern nun korrekt mit zwei Doppelpunkten markiert. Z.B.: Graphics::...

- Die Ermittlung der Liste der Konstruktoren der Vorgängerklassen wurde verbessert.

06.01.2010 Version 1.1.5
- Fehlerpositionen im Fenster des Delphi-Quellcodes wurden bisweilen verschoben angezeigt, weil sie sich auf den vorverarbeiteten Code bezogen. Nun wird nach der Übersetzung in diesem Fenster der vorverarbeitete Code angezeigt.

- Kommentare aus dem Interfaceteil wurden nur lückenhaft reproduziert. Dies wurde verbessert.

- Konstanten des Interfaceteils wurden bisher als statische Konstanten in den C++-Headern übersetzt. Das konnte zu vielen Warnmeldungen des Compilers führen, wenn der Header in mehreren Dateien eingeschlossen wurde. Nun werden die Konstanten als extern deklariert und in der zugehörigen Implementationsdatei mit ihrem Wert instantiiert. Das kann in selteneren Fällen Fehler nach sich ziehen, wenn die Werte der Konstanten bereits im Header benötigt werden.

- Bisher wurden Arraydimensionen in C++ als Differenzen der oberen und unteren Begrenzung von Bereichen angegeben. Nun wird die obere Grenze als Dimension angegeben, damit sicher gestellt ist, dass Index-Zugriffe auf das Array dessen Begrenzung nicht übersteigen.

- Viele andere Verbesserungen an verschiedenen Übersetzungsdetails.

21.12.2009 Version 1.1.0
- Im übersetzten Code werden nun Instanzen von Strukturen als automatische Variablen angelegt und als Referenzen an Funktionen übergeben. Im Gegensatz dazu werden Klassen-Instanzen weiterhin über Zeiger manipuliert.

- "array of type"-Parameter werden nun standardmäßig als Referenzen auf dynamische Arrays interpretiert.

- Die Schreibweisen der TObject-Elemente sind jetzt im Präprozessor vorgegeben. So werden die Element auf jeden Fall erkannt.

- Globale Funktionen Und prozeduren werden jetzt erkannt.

- "String" wird nun korrekt als "String" übersetzt, nicht als "AnsiString".

- In Anbetracht eines weiteren Monats Arbeit zur Verbesserung der Übersetzungsqualität wurde der Preis für Delphi2Cpp angehoben. In der Testversion wird die Übersetzung nun nach 10000 Zeichen abgeschnitten.

14.12.2009 Version 1.0.9
- Die überschriebenen Konstruktoren einer Klasse werden nun automatisch um die vollständige Liste der nicht überschriebenen Konstruktoren ergänzt.

- Eine Funktion wird nun auch korrekt übersetzt, wenn der Funktionsname selbst anstelle der vordefinierten Variable "Result" benutzt wird.

- In Aufrufen wie "foo(['hello', 'world'])" unterscheidet Delphi2Cpp nun anhand des erwarteten Parametertyps zwischen der Übergabe eines Sets und eines array of const.

- Eine Menge anderer kleiner Ergänzungen und Verbesserungen.

08.12.2009 Version 1.0.8
- Die Typerkennung von Variablen in with-Anweisungen wurde verbessert.

- Deklarationen von friend-Klassen wurden nur in Klassen mit Vorgängern eingefügt. Nun werden sie für alle Klassen innerhalb einer Unit deklariert.

06.12.2009 Version 1.0.7
- Der Fehler wurde behoben, dass der Parser die Namen der speziell behandelten VCL Funktionen nicht erkennen konnte, wenn diese auf "inherited" folgen, z.B. "inherited delete".

- Zahlen, die mit '0' beginnen, wie z.B. '0943' wurden unverändert in der C++ Code geschrieben. C++ interpretiert solche Zahlen aber oktal. Jetzt werden die führenden '0'-Zeichen entfernt.

- Der Fehler wurde behoben, dass in Exponentialzahlen Exponenten durch ein Leerzeichen getrennt wurden.

- Spezielle Parameterdeklarationen wurden verbessert:
const Args: array of const -> const TVarRec * Args, const int Args_Size
const Value -> const int Value

03.12.2009 Version 1.0.6
- Wenn bei der Deklarierung einer neuen Klasse kein Vorgängertyp angegeben wird, verwendet Delphi automatisch TObject als Vorgänger. Dies wurde nun in C++ explizit gemacht.

- An den Stellen, wo Resource-strings verwendet werden, werden sie nun durch das entsprechende Makro zum Laden der Resource ersetzt.

- Ein Fehler wurde behoben, der manchmal die Erkennung des Typs von Variablen im aktuellen Bereich verhinderte.

02.12.2009 Version 1.0.5
- Konstruktoren ohne Parameter werden nicht mehr eingefügt.
- Aufrufe von Konstruktoren der Basisklasse ohne Parameter werden im Konstruktor des abgeleiteten Klasse auskommentiert, z.B.

// inherited::Create;

- Typinformationen von überschriebenen properties werden nun ausgewertet.

- Wird die Größe eines Arrays durch einen enumerierten Typ spezifiziert, so wird sie in C++ aus dem kleinsten und dem größten der enumerierten Werte berechnet.

01.12.2009 Version 1.0.4
- Verbesserung: forward-Deklarationen von VCL-Klassen in eingeschlossenen Units wurden nicht zur Ermittlung von Zeigertypen herangezogen
- Fehlende Konstruktoren in abgeleiteten Klassen werden automatisch eingefügt, z.B.

inline __fastcall virtual TDerivedComponent(TComponent* Owner) : inherited(Owner) { }

29.11.2009 Version 1.0.3
- Behandlung von Sets weiter verbessert.
Z.B. type TIntSet = set of 1..250; -> typedef System::Set < int/* range 1..250*/, 1, 250 > TIntSet;
- Variablen werden nun in den C++-Headern als extern qualifiziert und ihre Instanzen werden in den Implementations cpp-Dateien eingefügt.

26.11.2009 Version 1.0.2
- verdoppelte pseudo forward Deklaration der Art "class classname{}" wird nicht mehr generiert
- Zuweisungen von Sets wurden verbessert.

var 
  MySet: set of 'a'..'z';  
begin 
  MySet := ['a','b','c'];
->   

typedef System::Set < char, 97, 122 > test__0;
#define test__1 ( test__0 ()
<< char ( 97 ) << char ( 98 ) << char ( 99 ) )
System::Set < char, 97, 122 > MySet;
MySet = test__1;

25.11.2009 Version 1.0.1
- Der Präprozessor führt nun Include-Directiven aus
- Un/Defines in nicht definierten Bereichen werden nicht mehr ausgeführt

17.11.2009 Version 1.0.0 veröffentlicht, Frühkäufer-Preis 58,- €