Code Conversion Guide/de

From Lazarus wiki
Jump to navigationJump to search

│ Deutsch (de) │ English (en) │ español (es) │ français (fr) │ 日本語 (ja) │ português (pt) │ русский (ru) │ slovenčina (sk) │

Diese Seite handelt davon, wie man bestehenden Delphi oder Kylix Code konvertiert oder portiert, um ihn mit dem Free Pascal Compiler und der Lazarus IDE zum Laufen zu bringen. Obwohl Lazarus und der Free Pascal Compiler gemeinsame Aspekte mit Delphi und Kylix haben, sind sie keine Klone. Es gibt eine Anzahl von Bibliotheksaufrufen und Konventionsunterschieden... und in einigen Bereichen ist FPC erweitert und kann im Hinblick auf korrekte Syntax anspruchsvoller sein. Bitte schauen Sie im Lazarus für Delphi-Benutzer Handbuch für eine Beschreibung einiger funktioneller Unterschiede nach.

Der Zweck dieses Handbuchs ist es, einige der spezifischen Unterschiede zu dokumentieren, die häufig während des Codekonvertierungsprozesses auftreten, wenn existierender Code von Delphi nach Lazarus übersetzt wird.

Dieses Dokument wurde im Bereich Wissensbasis des Wikis platziert, so dass es einfach von jedem erweitert werden kann, der auf ein einzigartiges Problem gestoßen ist und andere darauf aufmerksam machen möchte.

Auswahl einer Komponente oder Bibliothek für die Konvertierung

Wo Code zum Konvertieren zu finden ist

Im Internet ist eine MENGE Code verfügbar, der für die Verwendung mit FPC und Lazarus konvertiert werden kann. Hier ist eine Seite, die einfach ein Anfang ist. Bitte erweitern Sie die Seite, wenn Sie weitere Stellen kennen. TurboPower Software hat vor kurzem ihr gesamtes kommerzielles Angebot unter der MPL heraus gegeben. Eine Liste der verfügbaren Packages ist hier zu finden.

Um doppelten Aufwand zu vermeiden, sind bereits konvertierte Packages auf der Components and Code examples Seite aufgeführt. Wenn Sie ein Package konvertiert haben oder daran arbeiten, dann fügen Sie bitte eine Notiz auf der Current conversion projects Seite hinzu.

Lizenzierung

Lizenzen für existierenden Code reichen von Freeware/Public Domain bis zu eingeschränkten Versionen, welche Modifizierung, Weiterverteilung und kommerzielle Verwendung verbieten. Bevor Sie irgendein Package konvertieren, ist es eine gute Idee, seine Lizenz zu überprüfen und sicherzustellen, dass sie mit Lazarus und dem Free Pascal Compiler kompatibel ist. Lizenzauswahl ist bei Komponenten besonders wichtig, seit das Ablegen auf einem Formular eine nicht gewollte oder inkompatible Lizenz für die gesamte Anwendung aufbürden kann.

Wenn Sie Komponenten konvertieren, respektieren Sie bitte die Wünsche des Originalautors und belassen alle Copyright- und Lizenz-Header mit Email-Adressen und URl's. Es gehört zum guten Ton und ist oft hilfreich, um den Autor zu informieren, dass seine Komponente konvertiert wurde... besonders wenn sich die Komponente unter einer restriktiven Lizenz befindet. Neues Interesse an einer alten oder vergessenen Komponente kann manchmal die Autoren inspirieren, ihr Original und die allzu restriktive Lizenzierung zu überarbeiten.

Im Allgemeinen sind Public Domain (Freeware) und die LGPL/MPL Komponenten die flexibelsten zum Vertreiben. Für mehr Information ist die Open Source Definition ein guter Platz zum Starten. Dort gibt es auch verschiedene Vergleiche, die verdeutlichen, was die verschiedenen Lizenztypen bedeuten und welchen Einfluss sie auf den Code haben, auf den sie sich beziehen. Suchen Sie nach "open source license comparison"

Abhängigkeiten

Ein anderer Schritt vor einer Konvertierung ist, dass Sie überprüfen, ob der Code verborgene Abhängigkeiten von anderen Packages enthält, die vielleicht nicht verfügbar sind oder einen beträchtlichen Konvertierungsaufwand darstellen. Einige Freeware-Angebote sind gebunden an oder erweitern proprietäre Packages, die häufig nicht mehr erhältlich sind oder mit ungeeigneten Lizenzen versehen sind.

Compiler Probleme

Siehe:

Plattformen und OS Probleme

Lazarus und der Free Pascal Compiler sind cross-platform und cross-architecture Entwicklungswerkzeuge. Im Gegensatz dazu wurde der existierende Delphi-Code meistens speziell für einen Intel Prozessor unter Win32 entwickelt. Wenn Ihr Kandidat sehr viel Win32 spezifischen Code enthält, ist es häufig günstiger, nach einer weniger plattformabhängigen Alternative zu suchen. Aber lassen Sie sich davon nicht entmutigen. Es ist erstaunlich, was die LCL unterstützt!

Durchführen der Konvertierung

Einrichten der Lazarus Umgebung für ein Konvertierungs-Projekt

Erstellen eines Testprojekts

  • Kopieren Sie den zu konvertierenden Code in ein Unterverzeichnis (z.B.: convertdir)
  • Starten Sie Lazarus
  • Datei -> Alles speichern in das convertdir Unterverzeichnis. Aussagekräftige Namen für Projekt und Units sind optional.
  • Öffnen Sie die zu konvertierende "main" Unit in convertdir
  • Fügen Sie zum Projekt hinzu: Projekt -> Datei im Editor ins Projekt aufnehmen
  • Starten Sie Werkzeuge -> Schnelle Syntaxüberprüfung oder Start -> Alles neu erstellen um loszulegen.

Grundsätzlich beachten

  • Groß- und Kleinschreibung von Dateinamen werden unter der Version 1.0.x des Compilers unterschieden. Wenn Sie mit dieser Version arbeiten, schreiben Sie alle Dateinamen klein. Sie werden "File not found" Fehler bekommen, wenn Sie es nicht tun.

Delphi VCL, Kylix CLX Quellen in Lazarus

Während der Konvertierung von Delphi/Kylix Quellen ist es oft hilfreich, eine 'find declaration' zu machen, um zu sehen, was eine bestimmte Funktion macht. Die Lazarus IDE kann die Delphi/Kylix Quellen analysieren. Um dies zu tun, werden einige Suchpfade und Compilereinstellungen benötigt. Sie können dies einfach einrichten unter

Einstellungen -> CodeTools Defines Editor -> Vorlage einfügen

Konvertierungsprobleme und Lösungen

Delphi / Kylix Datei-Entsprechungen in Lazarus

Delphi / Kylix Lazarus Beschreibung
.pas

.dfm / .xfm .dcu / .dpu .dpr (main project file) .res .dof / .kof --- --- ---

.pas, .pp

.lfm .o .lpr --- --- .lrs .lpi (main project file) .ppu

Pascal Unit Datei

Formulardaten Datei Compilierte Unit Datei Projektdatei Ressourcendatei Projektoptionen Datei Lazarus Ressourcen Datei Lazarus Projekt Informations Datei FPC Unit Beschreibungsdatei

Konvertierung von Delphi Projekten/Formularen/Units nach Lazarus

Benennen Sie die .dpr Datei in eine .lpr Datei um. Kommentieren Sie die

{$R *.res}

Direktive aus oder entfernen Sie und fügen eine

{$mode delphi}{$H+}

oder

{$mode objfpc}{$H+}

Direktive zur .lpr Datei hinzu. Die Lazarus IDE kann diese Konversion mit dem Tools-Menüpunkt "Convert Delphi Project to Lazarus Project" unterstützen. Sie fragt nach einer .dpr (Delphi Project) Datei und konvertiert sie in eine .lpr; außerdem erzeugt sie die .lpi Datei und konvertiert alle Units.

Viele existierende Delphi Formulare können durch Verwendung des in die IDE eingebauten .dfm to .lfm form Umwandlers konvertiert werden, damit sie mit Lazarus richtig funktionieren. Er ist im Werkzeuge Menü als "Convert DFM file to LFM" zu finden. Öffnen Sie den file Dialog, wählen Sie die dfm Datei aus und der Umwandler wird den Rest erledigen.

Wenn Sie die ganze Unit konvertieren müssen (mit oder ohne ein Formular), enthält Lazarus auch ein eingebautes "Convert Delphi unit to Lazarus unit", welches das folgende für Sie erledigt -

  1. berichtigt die Schreibweise (groß/klein) der include Dateinamen und uses Abschnitte.
  2. konvertiert die .dfm Datei in eine .lfm Datei (gegenwärtig ohne Inhaltsprüfung, nur Formatierung)
  3. erzeugt eine leere .lrs Datei (der Inhalt wird später erzeugt)
  4. fügt die
    {$mode delphi}
    Direktive hinzu
  5. ersetzt die windows Unit durch LCLIntf
  6. fügt die LResources Unit hinzu falls erforderlich (i.e., if unit.lrs is to be used;
    uses LResources
    can be in the implementation part)
  7. entfernt die variants Unit
  8. entfernt die
    {$R *.dfm}
    Direktive
  9. fügt den initialization Abschnitt und die
    {$i unit.lrs}
    Direktive hinzu

Auswahl des richtigen Compilermodus

Der Free Pascal Compiler unterstützt 5 unterschiedliche Pascal Modi. Zum Beispiel TP für Turbo Pascal, lässt Sie Turbo Pascal Units kompilieren. Es gibt auch einen DELPHI Kompatibilitäts-Modus, der gesetzt werden kann, um bestehenden Code einfacher zu konvertieren. Lazarus bevorzugt den OBJFPC Modus, welcher fast dem DELPHI Modus gleicht, aber weniger mehrdeutig als die Delphi Syntax ist. Hier sind die wichtigen Punkte:

Der Modus kann auf der Befehlszeile oder beim Start der Quelle gewählt werden. Die Verwendung der Befehlszeile hat den Vorteil, dass Sie die Quelle nicht ändern müssen, aber den Nachteil, dass anderes erzählt werden muss.

Die meisten Delphi Units können mit dem Free Pascal Compiler kompiliert werden, wenn man gleich nach dem Unitnamen folgendes hinzufügt: 

{$IFDEF FPC}
  {$MODE DELPHI}
{$ENDIF}


Für mehr Details über die Free Pascal Modi siehe die Free Pascal Dokumentation. Für Information zu Laufzeitvariablen des Compilers (z.B. aktueller Modus) siehe Free Pascal Dokumentation.

Cross-Plattform Überlegungen

  • Das Verwenden von Inline Assembler ist immer problematisch, weil der Code dann nur auf Intel-Rechnern läuft. Es kommt auch vor, dass Entwickler Code in Pascal schreiben, aber eine optimierte Alternative in Assembler entwickeln, die durch ifdef-Konstrukte nur für Intel-Rechner gilt. Auch TurboPower selbst verwendet diese Technik an verschiedenen Stellen. Wenn das bei einem Package, das Sie übernehmen der Fall ist, schalten Sie auf den Modus Pascal.
  • Verwenden Sie keine spezielle Speicheradressen, wie z. B. aus dem BIOS Datenbereich. Finden Sie heraus, was der Code erreichen will und suchen Sie nach einer Alternative, die für alle Plattformen funktioniert.
  • Verwenden Sie keine Prozessor-spezifischen Tricks (wie z. B. die Intel TSC-Register), ohne dass Sie den Code in einem ifdef-Konstrukt als Plattform spezifisch markieren und entwickeln Sie eine Alternative für die anderen Plattformen.
  • Generell gilt also: Wenn Sie Betriebssystem-spezifischen Code benötigen, dann müssen Sie IFDEFs verwenden. Siehe unten für eine Liste der Makros.

Hilfreiche Compiler Variablen / Defines / Makros

Um Code zu schreiben, der sich auf verschiedenen Systemen unterschiedlich verhält, können Sie die

{$IFDEF Name}

Anweisungen verwenden.

  • {$IfDef LCL}

Diese Variable ist definiert, wenn das LCL Package verwendet wird. Hilfreich, um Code zu schreiben, der mit der LCL und Delphi funktioniert. For compatibility reasons FPC defines the DELPHI makro in mode Delphi. So you can not use {$IFNDEF DELPHI}.

  • {$IfDef LCL}

This variable is defined, when using the LCL package. Useful to write code, that works with the LCL and Delphi.

  • {$IfDef LCLGtk}
    ,
    {$IfDef LCLWin32}
    ,
    {$IfDef LCLQt}
    , ...

Diese Variable ist definiert, wenn das LCL Package verwendet wird und das spezifische Widgetset benutzt wird. Hilfreich um Code zu schreiben, der mit der LCL auf einer spezifischen Plattform funktioniert.

  • {$IfDef FPC}

Diese Variable ist definiert, wenn der FPC Compiler verwendet wird. Hilfreich um Code zu schreiben, der mit FPC und Delphi funktioniert.

  • {$IfDef Unix}
    ,
    {$IfDef Win32}
    , ...

Von FPC für das aktuelle Ziel OS definiert. Delphi definiert "Linux", "Win32" und "MSWindows". Free Pascal läuft auf viel mehr Plattformen und daher wird empfohlen, allgemeinere Begriffe zu verwenden. Zum Beispiel ist "Unix" definiert für Linux, FreeBSD, NetBSD und OpenBSD, wo Lazarus bereits läuft. Verwenden Sie 

{$IfDef Linux}
  {$Define Unix}
{$EndIf}

als "work around" für Kylix.

  • {$IfDef ENDIAN_BIG}

Diese Variable wird auf Prozessoren wie dem PowerPC definiert (zum Beispiel ältere Apple Computer, bis MacOSX 10.2), die eine im Vergleich zu Intel-Prozessoren umgekehrte Byte Order haben.

  • {$IfDef ENDIAN_BIG}

Für mehr Details siehe die Free Pascal Dokumentation.

32 bit / 64 bit Unterstützung

Pointers under 64bit need 8 bytes instead of 4 on 32bit. The 'Integer' type remains for compatibility 32bit. This means you can no longer typecast pointers into integers and back. FPC defines two new types: PtrInt and PtrUInt. PtrInt is a 32bit signed integer on 32 bit platforms and a 64bit signed integer on 64bit platforms. The same for PtrUInt, but unsigned integer instead. Use for code that should work with Delphi and FPC: 

 {$IFNDEF FPC}
 type
   PtrInt = integer;
   PtrUInt = cardinal;
 {$ENDIF}

Ersetzen Sie alle integer(SomePointerOrObject) mit PtrInt(SomePointerOrObject).

Finden eines fehlenden Bezeichners

Es gibt Unterschiede darin, wie die LCL organisiert ist im Vergleich zur Delphi VCL. Wenn Sie einen "not found" Compilerfehler erhalten über eine wichtige Klasse oder Bezeichner, stehen die Chancen gut, dass Sie die Klasse oder den Bezeichner in einer anderen Unit finden könne. Eine komplette Cross-Reference können Sie finden, indem Sie grep auf das Verzeichnis lazarus/docs/xml oder das Unterverzeichnis lcl anwenden.

Zum Beispiel erzeugt der häufig verwendete TButton üblicherweise einen Fehler im Delphi Code, weil er sich in der Unit buttons.pp befindet. Das folgende Kommando findet die richtige Unit sehr schnell (im Lazarus Quellenverzeichnis): 

 grep -in ' tbutton =' lcl/*

Wichtige Unit Unterschiede zwischen Lazarus und Delphi

Bitte ergänzen Sie diesen Abschnitt!

  • Windows->Interfaces, LCLIntf, LCLType, LCLProc, VCLGlobals, ...)

Da die LCL nicht Windows-spezifisch ist, ist der Code, der sich in der Delphi Windows Unit für den direkten Zugriff auf das Win32 API befindet, abstrahiert in separate Schnittstellen, auf welche mit der LCLIntf Unit Zugriff genommen werden kann. Beachten Sie, dass Lazarus nicht win32 emuliert, so dass mehrere Funktionen fehlen und einige nicht wie ihre win32-Gegenstücke funktionieren. Diese Funktionen existieren nur für die Delphi-Kompatibilität und sollten nur für Quick&Dirty-Portierungen benutzt werden. LCL beinhaltet auch viele Typen nicht, so dass oftmals LCLType und manchmal VCLGlobals benötigt werden. LCLProc enthält auch ein paar Funktionen, die hilfreich sein können für maschinennahere Bearbeitung wie "FreeThenNil" wie in Delphi 5 und höher, "DeleteAmpersands" um zusätzliche Et-Zeichen aus Zeichenketten für Kontrollen zu entfernen (vs && etc). Die Interfaces-Unit muss in der .lpr Datei enthalten sein, um das passende Widgetset zu initialisieren.

  • Messages->LMessages

TControl-Messages für win32-Ereignis-Callbacks vom Format WM_CALLBACK und die Structs, die dazugehören, finden sich oftmals in der Messages-Unit in Delphi. In LCL befinden diese sich meistens in LMessages, üblicherweise mit einer Namensänderung von WM zu LM, zum Beispiel WM_MOUSEENTER wird LM_MOUSEENTER, und TWMMouse wird TLMMouse.

  • Graphics, Controls->GraphTypes, GraphMath, Graphics, Controls

Um einige Sachen zu vereinfachen und die Komplexität von Kreisabhängigkeiten zwischen Units zu verringern, wurden einige Typen in einer gemeinsamen Unit namens GraphType abstrahiert, die sich in Delphi in Graphics oder Controls befinden, bspw. das bvNone usw. von Panels. Deswegen müssen Sie diese Unit gelegentlich einbinden. Eine weitere Unit, leider inkompatibel zu Delphi, liefert zusätzliche Funktionalität, GraphMath. Sie ermöglicht TFloatPoints für präzise Berechnungen, verschiedene Routinen für den Umgang mit Beziers, Linien und Kreisbögen, sowie überladene Operatoren zur Benutzung mit TPoints und TRect, um Punkte derart zu addieren Point1 := Point2 + Point3 oder Rechtecke zu vergleichen if(rect1 = rect2) then ...

  • Mask->MaskEdit

Aus Überlegungen für eine bessere Benennung wurde die Unit für TMaskEdit [MaskEdit |] anstelle des leicht unklareren Mask wie in vielen Delphi Versionen.

  • StdCtrls->StdCtrls,Buttons

In vielen Delphi Versionen befindet sich TButton in StdCtrls, während TSpeedButton und TBitBtn sich in Buttons befinden. Für eine Stetigkeit und Einfachheit steckt die LCL alle Buttontypen in Buttons, was gelegentlich die Code-Konvertierung ins Leere laufen lassen kann -- es ist also eine gute Idee, diese einzubinden.

Eigenschaften und Methoden Unterschiede Delphi -> FPC/LCL

  • TBitmap verfügt über eine Kanvas in der LCL

Semantische Unterschiede

Reihenfolge der Parameter-Auswertung

Delphi stellt sicher, dass alle Parameter von links nach rechts ausgewertet werden. FPC macht dies nicht so, sondern wertet alle Parameter so aus, dass der Code optimal schnell läuft.

Verschachtelte Prozeduren/Funktionen als Prozedurvariablen

Delphi übergibt einen Pointer des aufrufenden Prozesses immer an den Stack, dieser entfernt ihn später auch wieder. Das bedeutet, dass es möglich ist, diesen Pointer auch an eine andere Funktion zu übergeben, die dann das rufenden Programm aufruft, wie jede andere Funktion auch. Das geht natürlich nur, solange man die Variablen der Prozedur nicht benötigt.

Im Gegensatz dazu übergibt in FPC das rufende Programm den Pointer als ein verstecktes Argument entsprechend der jeweiligen Calling-Konvention. Das bedeutet, dass bei der Übergabe dieses Stacks an ein anderes Programm alle Parameter um eine Position verschoben sind.

Kurz gesagt: Vermeiden Sie es, prozedurale Variablen an andere Prozeduren zu übergeben.

Syntax Unterschiede

Bitte fügen Sie weitere Informationen zu diesem Thema hinzu!

Wegen der inhärenten Striktheit des FPC sind manche Syntaxänderungen notwendig, obwohl

{$Mode Delphi}

mehr Nachlässigkeit als in Delphi erlaubt. Aus diesem Grund ist es in höchstem Maße empfehlenswert, soweit wie möglich den Syntaxregeln von

{$Mode ObjFPC}

zu entsprechen, auch wenn die Codebasis weiterhin von Delphi und LCL gemeinsam benutzt wird. Einiges davon entspricht einfach besserer Code-Praxis, anderes liegt an dem gelegentlich inakuraten Delphi-Modus und manchmal funktioniert Code von Delphi mit FPC nicht so wie erwartet, auch wenn er sich kompilieren lässt. Letztlich sollte die folgende Liste als verbindlich betrachtet werden, auch wenn nicht alle Änderungen zwingend notwendig sind:


Bei der Zuweisung eines Ereignis-Handler-Einstiegspunkts ist diesem ein "@" voranstellen

Zum Beispiel, wenn Sie einen Button-Callback manuell zuweisen

Delphi FPC
begin
if not
Assigned(MyButton.OnClick)
then
MyButton.OnClick:= SomeFunction;
//@ wird nicht benötigt
//weiterer Code...
end
;
begin
if not
Assigned(MyButton.OnClick)
then
MyButton.OnClick:= @SomeFunction;
//@ wird benötigt
//weiterer Code...
end
;

Hinweis: Bei Fehlern gibt der Compiler einen Typ-Fehler aus (siehe Hinweis im nächsten Abschnitt).

Wenn Sie eine Prozedurenvariable aufrufen, verwenden Sie diese Syntax: theprocname()

In Delphi gibt es keinen Unterschied zwischen dem Ergebnis einer Funktion und einer Variablen, jedoch gibt es in FPC einen. Um eine Funktion aufzurufen, selbst wenn sie keine Parameter hat, müssen Sie eine runde Klammer anhängen. Zum Beispiel -

Delphi FPC
With
(SomeObject)
do begin
If
Assigned(OnMyCallback)
then
OnMyCallback;
//runde Klammer nicht benötigt
end
;
With
(SomeObject)
do begin
If
Assigned(OnMyCallback)
then
OnMyCallback();
//runde Klammer benötigt
end
;

Hinweis: Falls nicht im Delphi oder TP Modus, und die Klammern werden vergessen, so gibt der Compiler einen Typ-Fehler aus. Zum Beispiel

Error: Incompatible types: got "<procedure variable type of function:SmallInt;Register>" expected "SmallInt"

Diese Fehlermeldung ist hier zwar wenig aussagekräftig aber logisch.

Beim Zugriff auf den Wert eines Record mittels eines Zeigers muss dieser zuerst dereferenziert werden

In Delphi ist es nicht nötig, einen Zeiger auf einen Record zu dereferenzieren, um auf einen Wert darin zuzugreifen. Tatsächlich kann ein Zeiger wie der Record selbst oder wie jedes andere Objekt behandelt werden. In FPC muss er zuerst dereferenziert werden. Beispiel:

Delphi FPC
Function
GetSomeValue(ARecord: PMyRecord)
:
Integer;
begin
If
Assigned(ARecord)
then
Result
:=
ARecord.SomeValue
else
Result:=
0
;
end
;
Function
GetSomeValue(ARecord: PMyRecord)
:
Integer;
begin
If
Assigned(ARecord)
then
Result
:=
ARecord^.SomeValue
else
Result:=
0
;
end
;
Beim Zugriff auf Zeichen einer indizierten Zeichenketten-Eigenschaft eines Objektes muss dieses in runden Klammern stehen

Mit Delphi ist es möglich, eine Eigenschaft genauso zu behandeln wie andere Konstanten oder Variablen, z.B. beim direkten Zugriff auf einzelne Zeichen einer Zeichenkette, wogegen das mit FPC nicht immer möglich ist, speziell bei indizierten Eigenschaften. Stattdessen muss die entsprechende Eigenschaft zur besseren Unterscheidung in runden Klammer stehen. Dies mag zwar nicht immer nötig sein, es ist dennoch eine gute Praxis, das so zu machen. Beispiel:

Delphi FPC
Type
TSomeComponent=
class
(TComponent)
//weiterer Code...
Published
Property
MyString:
String
index
3
read
GetMyString;
//weiterer Code...
End
;
var
MyChar
:
char;
begin
If
Length(MyString)>
2
then
//no parenthesis needed
MyChar:= MyString[
3
];
//weiterer Code...
end
;
Type
TSomeComponent=
class
(TComponent)
//weiterer Code...
Published
Property
MyString:
String
index
3
read
GetMyString;
//weiterer Code...
End
;
var
MyChar
:
char;
begin
If
Length(MyString)>
2
then
//parenthesis sometimes needed
MyChar:= (MyString)[
3
];
//weiterer Code...
end
;
Sie müssen eine Typumwandlung von Zeigern in den tatsächlichen Typ vornehmen, wird dieser Zeiger mit einer Variablen oder Funktion dieses Typs benutzt

In Delphi haben Sie manchmal einen Null-Zeiger-Variable, die ein Objekt repräsentiert. Auch wenn es nach einer gestellten Situation aussieht, ist es gängige Praxis gerade in großen Komponenten-Paketen, um zu viele Kreisreferenzen zwischen Objekten verschiedener Units zu vermeiden. In Delphi ist es möglich, diesen Null-Zeiger einer Funktion zu schicken, die ein Objekt dieses Typs erwartet, ohne sich mit einer Typenumwandlung beschäftigen zu müssen. In FPC muss eine solche Typenumwandlung stattfinden

Zum Beispiel -

Delphi FPC
Unit 1
Type
TSomeObject=
class
(TComponent)
//weiterer Code...
End
;
Procedure
DoSomething(Value: TSomeObject);
Function
GetSomeObject: TSomeObject;
Unit 2
Type
TSomeComponent=
class
(TComponent)
//weiterer Code...
Published
SomeObject: Pointer
;
//weiterer Code...
End
;
Application
var
MyComponent: TSomeComponent
;
begin
MyComponent.SomeObject
:=
GetSomeObject;
//weiterer Code...
DoSomething(MyComponent.SomeObject)
;
end
; 		Unit 1
Type
TSomeObject=
class
(TComponent)
//weiterer Code...
End
;
Procedure
DoSomething(Value: TSomeObject);
Function
GetSomeObject: TSomeObject;
Unit 2
Type
TSomeComponent=
class
(TComponent)
//weiterer Code...
Published
SomeObject: Pointer
;
//weiterer Code...
End
;
Application
var
MyComponent: TSomeComponent
;
begin
MyComponent.SomeObject
:=
Pointer(GetSomeObject);
//weiterer Code...
DoSomething(TSomeObject(MyComponent.SomeObject))
;
end
;

Ressourcen

Delphi Ressourcendateien sind Win32-spezifisch und nicht kompatibel mit Lazarus, so dass Sie sie neu erstellen und mit Lazres kompilieren müssen. Lazres ist im lazarus/tools Unterverzeichnis zu finden. Wenn Sie die Lazarus Quellen heruntergeladen haben, müssen sie es erst kompilieren.

  • cd lazarus/tools
  • make install

Um eine Ressource zu Ihrer Anwendung hinzuzufügen:

  • lazres myresource.lrs mypix.xpm anotherpix.xpm
  • Fügen Sie die LResources Unit zu Ihrem Uses Abschnitt hinzu
  • Nehmen Sie die von Ihnen erstellte .lrs Datei unter dem initialization Abschnitt auf

Beispiel:

function
TForm1.LoadGlyph(
const
GlyphName:
String
): TBitMap;
begin
Result:= TPixmap.Create
;
Result.LoadFromLazarusResource(GlyphName)
;
end
;
//weiterer Code...
begin
Speedbutton1.glyph:= LoadGlyph('mypix')
;
//weiterer Code...
end
;
initialization
{$I unit1.lrs}
{$I myresource.lrs}
end
.

Eine andere Methode um ein Delphi- oder Kylix-Projekt nach Lazarus zu konvertieren

  • Benennen Sie alle .dfm oder .xfm Dateien in .lfm um. (Dies funktioniert nicht mit frühen Delphi Versionen da sie keine textbasierte .dfm Datei erstellen.)
  • Benennen Sie die .dpr Datei in .lpr um.
  • Nehmen Sie notwendige Änderungen in der .lpr Datei vor:
  1. Fügen Sie {$mode delphi}{$H+} oder {$mode objfpc}{H+} Direktiven hinzu.
  2. Fügen Sie 'Interfaces' zum uses Abschnitt hinzu.
  3. Kommentieren Sie die {$R *.res} Direktive aus oder löschen Sie diese.
  • Nehmen Sie notwendige Änderungen in allen .pas Unit Dateien vor:
  1. Fügen sie die {$mode delphi}{$H+} oder {$mode objfpc}{H+} Direktiven hinzu.
  2. Fügen Sie 'LResources', und wenn das Formular Buttons hat, 'Buttons' zum uses Abschnitt hinzu.
  3. Kommentieren Sie die {$R *.dfm} oder {$R *.xfm} Direktive aus oder löschen Sie diese.
  4. Fügen Sie einen 'Initialization' Abschnitt am Ende jeder Datei hinzu, und fügen die {$I unitname.lrs} Direktive darin hinzu.
  • Wählen Sie Projekt -> Neues Projekt von Datei
  • Wählen Sie die .lpr Datei
  • Im 'Erzeuge neues Projekt' Fenster wählen Sie 'Anwendung'
  • Erzeugen Sie das Projekt und nehmen Sie weitere notwendige Korrekturen vor um eine ordentliche Kompilierung zu erhalten, an diesem Punkt wird die .lpi Datei automatisch generiert. Sie erhalten vielleicht 'Error reading Form' Meldungen. Klicken Sie auf 'Continue Loading' falls dem so ist.
  • Speichern Sie alles und Sie haben ein Lazarus Projekt :-)

Hilfe erhalten

Wenn Sie während der Konvertierung auf ein Problem stoßen, das Sie gerade nicht lösen können, gibt es eine große Auswahl von Orten, um Hilfe zu erhalten:

Dokumentation

Für reine Object Pascal und FPC Probleme, ist der beste Ort zu beginnen die Free Pascal Dokumentationvon Michaël Van Canneyt und Florian Klämpfl.

Für mehr Lazarus orientierte Probleme ist die Lazarus Projekt Dokumentation in der Lazarus-CCR Knowledgebase der nächste Ort zum Nachschauen. Schließlich können Sie eine Frage posten in einer der Mailing Listenfür den Free Pascal Compiler oder den FPC Foren, wo eine Menge Experten eingeschrieben sind.

Unterstützung durch andere User

Mailing-Listen: Man kann eine Frage stellen unter einer der Mailing-Listen für den Freien Pascal Compiler oder das FPC/Lazarus forums wo eine Reihe von Experten antworten.

Bei Zugriff auf IRC: bei irc.freenode.net: #fpc for FPC, oder #lazarus-ide für Lazarus

Wissensbasis

Es gibt einige hervorragende Such- und Wissensdatenbanken im Internet, die ebenfalls eine große Hilfe beim Erlernen neuer Techniken und beim Lösen von Problemen sein können:

  • Tamarack Associates enthält eine schnelle search Suche speziell für das Borland usenet Archiv.
  • Mer Systems Inc. liefert eine ähnliche Suchseite engine.
  • Eine weitere herausragende Informationsquelle sowie eine standortübergreifende searchMöglichkeit ist Earl F. Glynn's Computer Lab and Reference Library.

Erstellen eines Packages und Veröffentlichung Ihrer Komponente

Erstellen eines Lazarus Packages für Ihre Komponente(n)

Das Erstellen eines Packages macht die Installation Ihres konvertierten Codes viel einfacher - besonders wenn Sie mehr als eine Komponente anbieten. Mattias Gärtner hat eine Übersicht über Lazarus Packages geschrieben, die Sie lesen sollten bevor Sie mit diesem Prozess beginnen.

Dokumentation

Der Zweck dieser Seite und des Wiki-Formats ist, die Generierung einer professionellen Dokumentation zu einem einfachen und schnellen Vorgang zu machen. Das Wiki erlaubt es auch, die Resultate Ihrer Posting unverzüglich zu sehen und erlaubt Ihnen, Änderungen in Echtzeit zu machen.

Die Verwendung des Lazarus-CCR Wiki um eine schön anzuschauende Dokumentation zu erstellen ist sehr einfach. Wenn Sie noch nie zuvor die Wiki Sprache verwendet haben, können Sie sich in dem Sand Box Übungsbereich damit vertraut machen.

Erzeugen einer Code Release Page

Die Code Release Page enthält grundlegende Informationen über Ihre Komponente, die ein potenzieller Nutzer wird wissen wollen, wie Lizenz, vorgesehene Plattform, Status (alpha, beta, stable...), wo sie herunterzuladen ist, wer sie geschrieben hat, ob Support verfügbar ist... etc.

Die folgende Prozedur lässt Sie eine Code Release Seite mit Ihrem Browser erzeugen:

  • Gehen Sie zu Release new component
  • Tippen Sie den Namen Ihrer Komponente in die Textbox und klicken auf Create Article
  • Füllen Sie die Vorlage aus und vergessen Sie nicht zu speichern.
  • Bearbeiten Sie die Components and Code examples Seite und fügen Sie einen Link zu Ihrer gerade erzeugten Seite hinzu im "Released Components" Abschnitt. Speichern Sie die geänderte Seite.

Einreichen der Komponente

Wenn Sie die Rechte eines Lazarus-Release-Verwalters besitzen, laden Sie ihre Komponente in das SourceForge File Release System hoch und fügen Sie sie zur Liste der Release-Packages hinzu. Andernfalls senden Sie die Komponente an einen der Projektadministratoren (Tom Lisjac oder Vincent Snijders) und wir werden sie zum Repository hinzufügen. Bevor wir sie zu SourceForge hochladen, müssen Sie eine Code Release Page erstellen, um Ihre Komponente zu beschreiben. Sie können die Release new component Seite verwenden, um mit der Erzeugung einer solchen Seite zu beginnen.

Falls Sie vorhaben, dass Sie die Entwicklung der Komponente fortsetzen, dann können wir sie auch in SVN einstellen, sodass Sie auch weiterhin Zugriff auf Ihre Komponente haben. Wenn wir es leid sind, immer Ihre Patches zu übermitteln, werden wir Ihnen die Schreibrechte zum SVN einräumen, damit Sie Ihre Patches dann selbst betreuen können. Für Details siehe Using the Lazarus-ccr SVN repository.

Mitwirkende und Änderungen

Diese Seite wurde von der epikwiki Version konvertiert.

  • Anfangsversion von Tom Lisjac und Mattias Gärtner - 9/22/2003 VlxAdmin
  • Moved Getting help from the main page. T. Lisjac - 9/24/2003 VlxAdmin
  • Added documentation templates, procedure and links. 9/25/2003 VlxAdmin
  • LCLLinux wurde in LCLIntf umbenannt, Jesus Reyes, 9/27/2003
  • added more information on Unit changes, AndrewJohnson 9/27/2003
  • Updated Syntax differences, including some examples, AndrewJohnson 9/27/2003
  • FPC 1.0.x doesn't support interfaces, Vincent Snijders 9/28/2003
  • Fixed some of the examples per new WikiWord definition, 9/28/2003 VlxAdmin
  • Made code more consistant to remove last accidental Pascal WikiWord definitions, AndrewJohnson 9/27/2003
  • Use tables for code examples for nice blocks, and easy side by side view of Delphi->FPC differences, AndrewJohnson 10/17/2003
  • Use pascal stylesheet to make example code more readable, AndrewJohnson 10/18/2003
  • Abschnitt 'Another method to convert a Delphi or Kylix project to Lazarus' hinzugefügt , George Lober, 2/17/2006
Retrieved from "https://wiki.freepascal.org/index.php?title=Code_Conversion_Guide/de&oldid=156013"