Code Conversion Guide/de: what changed

Revision 1 to 2. Removed lines have a minus sign; added lines have a plus sign.

Old	New		Line
1	1		Diese Seite handelt davon, wie man bestehenden Delphi oder Kylix Code konvertiert oder portiert, um ihn mit dem [[Free Pascal/de\|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 For Delphi Users/de\|Lazarus für Delphi-Benutzer]] Handbuch für eine Beschreibung einiger funktioneller Unterschiede nach.
2	2
3	3		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.
4	4
5	5		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.
6	6
7	7		## Auswahl einer Komponente oder Bibliothek für die Konvertierung
8	8
9	9		### Wo Code zum Konvertieren zu finden ist
10	10
11	11		Im Internet ist eine MENGE Code verfügbar, der für die Verwendung mit FPC und Lazarus konvertiert werden kann. Hier ist eine [[Page Of Code Sites\|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](http://sourceforge.net/users/tpsfadmin/) zu finden.
12	12
13	13		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.
14	14
15	15		### Lizenzierung
16	16
17	17		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.
18	18
19	19		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.
20	20
21	21		Im Allgemeinen sind Public Domain (Freeware) und die LGPL/MPL Komponenten die flexibelsten zum Vertreiben. Für mehr Information ist die [Open Source Definition](http://www.opensource.org/docs/definition.php) 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"
22	22
23	23		### Abhängigkeiten
24	24
25	25		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.
26	26
27	27		### Compiler Probleme
28	28
29	29		Siehe:
30	30
31	31		- [bekannte Probleme](http://www.freepascal.org/probs.html)
32	32		- [Nichtbereinigte Bugs](http://www.freepascal.org/bugs/db.php3?statusfield=Unfixed)
33	33
34	34		### Plattformen und OS Probleme
35	35
36	36		Lazarus und der Free Pascal Compiler sind [[Glossary\|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!
37	37
38	38		## Durchführen der Konvertierung
39	39
40	40		### Einrichten der Lazarus Umgebung für ein Konvertierungs-Projekt
41	41
42	42		#### Erstellen eines Testprojekts
43	43
44	44		- Kopieren Sie den zu konvertierenden Code in ein Unterverzeichnis (z.B.: convertdir)
45	45		- Starten Sie Lazarus
46	46		- Datei -\> Alles speichern in das convertdir Unterverzeichnis. Aussagekräftige Namen für Projekt und Units sind optional.
47	47		- Öffnen Sie die zu konvertierende "main" Unit in convertdir
48	48		- Fügen Sie zum Projekt hinzu: Projekt -\> Datei im Editor ins Projekt aufnehmen
49	49		- Starten Sie Werkzeuge -\> Schnelle Syntaxüberprüfung oder Start -\> Alles neu erstellen um loszulegen.
50	50
51	51		#### Grundsätzlich beachten
52	52
53	53		- 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.
54	54
55	55		#### Delphi VCL, Kylix CLX Quellen in Lazarus
56	56
57	57		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
58	58
59	59		Einstellungen -\> CodeTools Defines Editor -\> Vorlage einfügen
60	60
61	61		### Konvertierungsprobleme und Lösungen
62	62
63	63		#### Delphi / Kylix Datei-Entsprechungen in Lazarus
64	64
65	65		\| \| \| \|
66	66		\|----\|----\|----\|
67	67		\| Delphi / Kylix \| Lazarus \| Beschreibung \|
68	68		\| .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 \|
69	69
70	70		#### Konvertierung von Delphi Projekten/Formularen/Units nach Lazarus
71	71
72	72		Benennen Sie die .dpr Datei in eine .lpr Datei um. Kommentieren Sie die
73	73
74		-	~~<div class="dir">~~
75		-
76	74		{\$R *.res}
77	75
78		-	~~</div>~~
79		-
80	76		Direktive aus oder entfernen Sie und fügen eine
81	77
82		-	~~<div class="dir">~~
83		-
84	78		{\$mode delphi}{\$H+}
85	79
86		-	~~</div>~~
87		-
88	80		oder
89	81
90		-	~~<div class="dir">~~
91		-
92	82		{\$mode objfpc}{\$H+}
93	83
94		-	~~</div>~~
95		-
96	84		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.
97	85
98	86		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.
99	87
100	88		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 -
101	89
102	90		1. berichtigt die Schreibweise (groß/klein) der include Dateinamen und uses Abschnitte.
103	91		2. konvertiert die .dfm Datei in eine .lfm Datei (gegenwärtig ohne Inhaltsprüfung, nur Formatierung)
104	92		3. erzeugt eine leere .lrs Datei (der Inhalt wird später erzeugt)
105	93		4. fügt die
106		-	~~<div class="dir">~~
107		-
108	94		{\$mode delphi}
109	95
110		-	~~</div>~~
111		-
112	96		Direktive hinzu
113	97		5. ersetzt die windows Unit durch LCLIntf
114	98		6. fügt die LResources Unit hinzu falls erforderlich (i.e., if unit.lrs is to be used;
115		-	~~<div class="dir">~~
116		-
117	99		uses LResources
118	100
119		-	~~</div>~~
120		-
121	101		can be in the implementation part)
122	102		7. entfernt die variants Unit
123	103		8. entfernt die
124		-	~~<div class="dir">~~
125		-
126	104		{\$R *.dfm}
127	105
128		-	~~</div>~~
129		-
130	106		Direktive
131	107		9. fügt den initialization Abschnitt und die
132		-	~~<div class="dir">~~
133		-
134	108		{\$i unit.lrs}
135	109
136		-	~~</div>~~
137		-
138	110		Direktive hinzu
139	111
140	112		#### Auswahl des richtigen Compilermodus
141	113
142	114		Der [[Free Pascal/de\|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:
143	115
144	116		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.
145	117
146	118		Die meisten Delphi Units können mit dem [[Free Pascal/de\|Free Pascal]] Compiler kompiliert werden, wenn man gleich nach dem Unitnamen folgendes hinzufügt:
147	119
148	120		`{$IFDEF FPC}`\
149	121		` {$MODE DELPHI}`\
150	122		`{$ENDIF}`
151	123
152	124		Für mehr Details über die [[Free Pascal/de\|Free Pascal]] Modi siehe die [Free Pascal Dokumentation](http://www.freepascal.org/docs-html/prog/progap4.html#progse62.html). Für Information zu Laufzeitvariablen des Compilers (z.B. aktueller Modus) siehe [Free Pascal Dokumentation](http://www.freepascal.org/docs-html/prog/progap7.html#x310-311000G).
153	125
154	126		#### Cross-Plattform Überlegungen
155	127
156	128		- 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.
157	129		- 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.
158	130		- 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.
159	131		- Generell gilt also: Wenn Sie Betriebssystem-spezifischen Code benötigen, dann müssen Sie IFDEFs verwenden. Siehe unten für eine Liste der Makros.
160	132
161	133		#### Hilfreiche Compiler Variablen / Defines / Makros
162	134
163	135		Um Code zu schreiben, der sich auf verschiedenen Systemen unterschiedlich verhält, können Sie die
164	136
165		-	~~<div class="dir">~~
166		-
167	137		{\$IFDEF Name}
168	138
169		-	~~</div>~~
170		-
171	139		Anweisungen verwenden.
172	140
173		-	~~- <div class="dir">~~
174		-
175		-	~~{\$IfDef LCL}~~
176		-
177		-	~~</div>~~
	141	+	- {\$IfDef LCL}
178	142
179	143		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}.
180	144
181		-	~~- <div class="dir">~~
182		-
183		-	~~{\$IfDef LCL}~~
184		-
185		-	~~</div>~~
	145	+	- {\$IfDef LCL}
186	146
187	147		This variable is defined, when using the LCL package. Useful to write code, that works with the LCL and Delphi.
188	148
189		-	~~- <div class="dir">~~
190		-
191		-	~~{\$IfDef LCLGtk}~~
192		-
193		-	~~</div>~~
	149	+	- {\$IfDef LCLGtk}
194	150
195	151		,
196	152
197		-	~~<div class="dir">~~
198		-
199	153		{\$IfDef LCLWin32}
200	154
201		-	~~</div>~~
202		-
203	155		,
204	156
205		-	~~<div class="dir">~~
206		-
207	157		{\$IfDef LCLQt}
208	158
209		-	~~</div>~~
210		-
211	159		, ...
212	160
213	161		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.
214	162
215		-	~~- <div class="dir">~~
216		-
217		-	~~{\$IfDef FPC}~~
218		-
219		-	~~</div>~~
	163	+	- {\$IfDef FPC}
220	164
221	165		Diese Variable ist definiert, wenn der FPC Compiler verwendet wird. Hilfreich um Code zu schreiben, der mit FPC und Delphi funktioniert.
222	166
223		-	~~- <div class="dir">~~
224		-
225		-	~~{\$IfDef Unix}~~
226		-
227		-	~~</div>~~
	167	+	- {\$IfDef Unix}
228	168
229	169		,
230	170
231		-	~~<div class="dir">~~
232		-
233	171		{\$IfDef Win32}
234	172
235		-	~~</div>~~
236		-
237	173		, ...
238	174
239	175		Von FPC für das aktuelle Ziel OS definiert. Delphi definiert "Linux", "Win32" und "MSWindows". [[Free Pascal/de\|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
240	176
241	177		`{$IfDef Linux}`\
242	178		` {$Define Unix}`\
243	179		`{$EndIf}`
244	180
245	181		als "work around" für Kylix.
246	182
247		-	~~- <div class="dir">~~
248		-
249		-	~~{\$IfDef ENDIAN_BIG}~~
250		-
251		-	~~</div>~~
	183	+	- {\$IfDef ENDIAN_BIG}
252	184
253	185		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.
254	186
255		-	~~- <div class="dir">~~
256		-
257		-	~~{\$IfDef ENDIAN_BIG}~~
258		-
259		-	~~</div>~~
	187	+	- {\$IfDef ENDIAN_BIG}
260	188
261	189		Für mehr Details siehe die [Free Pascal Dokumentation](http://www.freepascal.org/docs-html/prog/prog.html#QQ2-23-21).
262	190
263	191		#### 32 bit / 64 bit Unterstützung
264	192
265	193		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:
266	194
267	195		` {$IFNDEF FPC}`\
268	196		` type`\
269	197		` PtrInt = integer;`\
270	198		` PtrUInt = cardinal;`\
271	199		` {$ENDIF}`
272	200
273	201		Ersetzen Sie alle integer(SomePointerOrObject) mit PtrInt(SomePointerOrObject).
274	202
275	203		#### Finden eines fehlenden Bezeichners
276	204
277	205		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.
278	206
279	207		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):
280	208
281	209		` grep -in ' tbutton =' lcl/*`
282	210
283	211		#### Wichtige Unit Unterschiede zwischen Lazarus und Delphi
284	212
285	213		Bitte ergänzen Sie diesen Abschnitt!
286	214
287	215		- Windows-\>Interfaces, LCLIntf, LCLType, LCLProc, VCLGlobals, ...)
288	216
289	217		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.
290	218
291	219		- Messages-\>LMessages
292	220
293	221		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.
294	222
295	223		- Graphics, Controls-\>GraphTypes, GraphMath, Graphics, Controls
296	224
297	225		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 ...
298	226
299	227		- Mask-\>MaskEdit
300	228
301	229		Aus Überlegungen für eine bessere Benennung wurde die Unit für TMaskEdit \[MaskEdit \\|\] anstelle des leicht unklareren Mask wie in vielen Delphi Versionen.
302	230
303	231		- StdCtrls-\>StdCtrls,Buttons
304	232
305	233		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.
306	234
307	235		#### Eigenschaften und Methoden Unterschiede Delphi -\> FPC/LCL
308	236
309	237		- TBitmap verfügt über eine Kanvas in der LCL
310	238
311	239		#### Semantische Unterschiede
312	240
313	241		##### Reihenfolge der Parameter-Auswertung
314	242
315	243		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.
316	244
317	245		##### Verschachtelte Prozeduren/Funktionen als Prozedurvariablen
318	246
319	247		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.
320	248
321	249		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.
322	250
323	251		Kurz gesagt: Vermeiden Sie es, prozedurale Variablen an andere Prozeduren zu übergeben.
324	252
325	253		#### Syntax Unterschiede
326	254
327	255		Bitte fügen Sie weitere Informationen zu diesem Thema hinzu!
328	256
329	257		Wegen der inhärenten Striktheit des FPC sind manche Syntaxänderungen notwendig, obwohl
330	258
331		-	~~<div class="dir">~~
332		-
333	259		{\$Mode Delphi}
334	260
335		-	~~</div>~~
336		-
337	261		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
338	262
339		-	~~<div class="dir">~~
340		-
341	263		{\$Mode ObjFPC}
342	264
343		-	~~</div>~~
344		-
345	265		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:
346	266
347	267		##### Bei der Zuweisung eines Ereignis-Handler-Einstiegspunkts ist diesem ein "@" voranstellen
348	268
349	269		Zum Beispiel, wenn Sie einen Button-Callback manuell zuweisen
350	270
351		-	~~<table>~~
352		-	~~<tbody>~~
353		-	~~<tr>~~
354		-	~~<td class="header"><p>Delphi</p></td>~~
355		-	~~<td class="header"><p>FPC</p></td>~~
356		-	~~</tr>~~
357		-	~~<tr>~~
358		-	~~<td class="code"><div class="key">~~
359		-	~~<p>begin</p>~~
360		-	~~</div>~~
361		-	~~<div class="key">~~
362		-	~~<p>if not</p>~~
363		-	~~</div>~~
364		-	~~<p>Assigned(MyButton.OnClick)</p>~~
365		-	~~<div class="key">~~
366		-	~~<p>then</p>~~
367		-	~~</div>~~
368		-	~~<p><code> MyButton.OnClick:= SomeFunction; </code></p>~~
369		-	~~<div class="cmt">~~
370		-	~~<p>//@ wird nicht benötigt</p>~~
371		-	~~</div>~~
372		-	~~<div class="cmt">~~
373		-	~~<p>//weiterer Code...</p>~~
374		-	~~</div>~~
375		-	~~<div class="key">~~
376		-	~~<p>end</p>~~
377		-	~~</div>~~
378		-	~~<p>;</p></td>~~
379		-	~~<td data-clag="code"><div class="key">~~
380		-	~~<p>begin</p>~~
381		-	~~</div>~~
382		-	~~<div class="key">~~
383		-	~~<p>if not</p>~~
384		-	~~</div>~~
385		-	~~<p>Assigned(MyButton.OnClick)</p>~~
386		-	~~<div class="key">~~
387		-	~~<p>then</p>~~
388		-	~~</div>~~
389		-	~~<p><code> MyButton.OnClick:= @SomeFunction; </code></p>~~
390		-	~~<div class="cmt">~~
391		-	~~<p>//@ wird benötigt</p>~~
392		-	~~</div>~~
393		-	~~<div class="cmt">~~
394		-	~~<p>//weiterer Code...</p>~~
395		-	~~</div>~~
396		-	~~<div class="key">~~
397		-	~~<p>end</p>~~
398		-	~~</div>~~
399		-	~~<p>;</p></td>~~
400		-	~~</tr>~~
401		-	~~</tbody>~~
402		-	~~</table>~~
	271	+	Delphi
403	272
	273	+	FPC
	274	+
	275	+	begin
	276	+
	277	+	if not
	278	+
	279	+	Assigned(MyButton.OnClick)
	280	+
	281	+	then
	282	+
	283	+	` MyButton.OnClick:= SomeFunction; `
	284	+
	285	+	//@ wird nicht benötigt
	286	+
	287	+	//weiterer Code...
	288	+
	289	+	end
	290	+
	291	+	;
	292	+
	293	+	begin
	294	+
	295	+	if not
	296	+
	297	+	Assigned(MyButton.OnClick)
	298	+
	299	+	then
	300	+
	301	+	` MyButton.OnClick:= @SomeFunction; `
	302	+
	303	+	//@ wird benötigt
	304	+
	305	+	//weiterer Code...
	306	+
	307	+	end
	308	+
	309	+	;
	310	+
404	311		Hinweis: Bei Fehlern gibt der Compiler einen Typ-Fehler aus (siehe Hinweis im nächsten Abschnitt).
405	312
406	313		##### Wenn Sie eine Prozedurenvariable aufrufen, verwenden Sie diese Syntax: theprocname()
407	314
408	315		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 -
409	316
410		-	~~<table>~~
411		-	~~<tbody>~~
412		-	~~<tr>~~
413		-	~~<td class="header"><p>Delphi</p></td>~~
414		-	~~<td class="header"><p>FPC</p></td>~~
415		-	~~</tr>~~
416		-	~~<tr>~~
417		-	~~<td class="code"><div class="key">~~
418		-	~~<p>With</p>~~
419		-	~~</div>~~
420		-	~~<p>(SomeObject)</p>~~
421		-	~~<div class="key">~~
422		-	~~<p>do begin</p>~~
423		-	~~</div>~~
424		-	~~<div class="key">~~
425		-	~~<p>If</p>~~
426		-	~~</div>~~
427		-	~~<p>Assigned(OnMyCallback)</p>~~
428		-	~~<div class="key">~~
429		-	~~<p>then</p>~~
430		-	~~</div>~~
431		-	~~<p><code> OnMyCallback; </code></p>~~
432		-	~~<div class="cmt">~~
433		-	~~<p>//runde Klammer nicht benötigt</p>~~
434		-	~~</div>~~
435		-	~~<div class="key">~~
436		-	~~<p>end</p>~~
437		-	~~</div>~~
438		-	~~<p>;</p></td>~~
439		-	~~<td class="code"><div class="key">~~
440		-	~~<p>With</p>~~
441		-	~~</div>~~
442		-	~~<p>(SomeObject)</p>~~
443		-	~~<div class="key">~~
444		-	~~<p>do begin</p>~~
445		-	~~</div>~~
446		-	~~<div class="key">~~
447		-	~~<p>If</p>~~
448		-	~~</div>~~
449		-	~~<p>Assigned(OnMyCallback)</p>~~
450		-	~~<div class="key">~~
451		-	~~<p>then</p>~~
452		-	~~</div>~~
453		-	~~<p><code> OnMyCallback(); </code></p>~~
454		-	~~<div class="cmt">~~
455		-	~~<p>//runde Klammer benötigt</p>~~
456		-	~~</div>~~
457		-	~~<div class="key">~~
458		-	~~<p>end</p>~~
459		-	~~</div>~~
460		-	~~<p>;</p></td>~~
461		-	~~</tr>~~
462		-	~~</tbody>~~
463		-	~~</table>~~
	317	+	Delphi
464	318
	319	+	FPC
	320	+
	321	+	With
	322	+
	323	+	(SomeObject)
	324	+
	325	+	do begin
	326	+
	327	+	If
	328	+
	329	+	Assigned(OnMyCallback)
	330	+
	331	+	then
	332	+
	333	+	` OnMyCallback; `
	334	+
	335	+	//runde Klammer nicht benötigt
	336	+
	337	+	end
	338	+
	339	+	;
	340	+
	341	+	With
	342	+
	343	+	(SomeObject)
	344	+
	345	+	do begin
	346	+
	347	+	If
	348	+
	349	+	Assigned(OnMyCallback)
	350	+
	351	+	then
	352	+
	353	+	` OnMyCallback(); `
	354	+
	355	+	//runde Klammer benötigt
	356	+
	357	+	end
	358	+
	359	+	;
	360	+
465	361		Hinweis: Falls nicht im Delphi oder TP Modus, und die Klammern werden vergessen, so gibt der Compiler einen Typ-Fehler aus. Zum Beispiel
466	362
467	363		Error: Incompatible types: got "\<procedure variable type of function:SmallInt;Register\>" expected "SmallInt"
468	364
469	365		Diese Fehlermeldung ist hier zwar wenig aussagekräftig aber logisch.
470	366
471	367		##### Beim Zugriff auf den Wert eines Record mittels eines Zeigers muss dieser zuerst dereferenziert werden
472	368
473	369		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:
474	370
475		-	~~<table>~~
476		-	~~<tbody>~~
477		-	~~<tr>~~
478		-	~~<td class="header"><p>Delphi</p></td>~~
479		-	~~<td class="header"><p>FPC</p></td>~~
480		-	~~</tr>~~
481		-	~~<tr>~~
482		-	~~<td class="code"><div class="key">~~
483		-	~~<p>Function</p>~~
484		-	~~</div>~~
485		-	~~<p>GetSomeValue(ARecord: PMyRecord)</p>~~
486		-	~~<div class="symbol">~~
487		-	~~<dl>~~
488		-	~~<dt></dt>~~
489		-	~~<dd>~~
490		-	~~</div>~~
491		-	~~<p>Integer;</p>~~
492		-	~~</dd>~~
493		-	~~</dl>~~
494		-	~~<div class="key">~~
495		-	~~<p>begin</p>~~
496		-	~~</div>~~
497		-	~~<div class="key">~~
498		-	~~<p>If</p>~~
499		-	~~</div>~~
500		-	~~<p>Assigned(ARecord)</p>~~
501		-	~~<div class="key">~~
502		-	~~<p>then</p>~~
503		-	~~</div>~~
504		-	~~<p><code> Result</code></p>~~
505		-	~~<div class="symbol">~~
506		-	~~<dl>~~
507		-	~~<dt></dt>~~
508		-	~~<dd>~~
	371	+	Delphi
	372	+
	373	+	FPC
	374	+
	375	+	Function
	376	+
	377	+	GetSomeValue(ARecord: PMyRecord)
	378	+
	379	+
	380	+	Integer;
	381	+
	382	+	begin
	383	+
	384	+	If
	385	+
	386	+	Assigned(ARecord)
	387	+
	388	+	then
	389	+
	390	+	` Result`
	391	+
	392	+
509	393		=
510		-	~~</div>~~
511		-	~~<p>ARecord.SomeValue</p>~~
512		-	~~</dd>~~
513		-	~~</dl>~~
514		-	~~<div class="key">~~
515		-	~~<p>else</p>~~
516		-	~~</div>~~
517		-	~~<p><code> Result:= </code></p>~~
518		-	~~<div class="int">~~
519		-	~~<p>0</p>~~
520		-	~~</div>~~
521		-	~~<p>;</p>~~
522		-	~~<div class="key">~~
523		-	~~<p>end</p>~~
524		-	~~</div>~~
525		-	~~<p>;</p></td>~~
526		-	~~<td class="code"><div class="key">~~
527		-	~~<p>Function</p>~~
528		-	~~</div>~~
529		-	~~<p>GetSomeValue(ARecord: PMyRecord)</p>~~
530		-	~~<div class="symbol">~~
531		-	~~<dl>~~
532		-	~~<dt></dt>~~
533		-	~~<dd>~~
534		-	~~</div>~~
535		-	~~<p>Integer;</p>~~
536		-	~~</dd>~~
537		-	~~</dl>~~
538		-	~~<div class="key">~~
539		-	~~<p>begin</p>~~
540		-	~~</div>~~
541		-	~~<div class="key">~~
542		-	~~<p>If</p>~~
543		-	~~</div>~~
544		-	~~<p>Assigned(ARecord)</p>~~
545		-	~~<div class="key">~~
546		-	~~<p>then</p>~~
547		-	~~</div>~~
548		-	~~<p><code> Result</code></p>~~
549		-	~~<div class="symbol">~~
550		-	~~<dl>~~
551		-	~~<dt></dt>~~
552		-	~~<dd>~~
	394	+
	395	+	ARecord.SomeValue
	396	+
	397	+	else
	398	+
	399	+	` Result:= `
	400	+
	401	+	0
	402	+
	403	+	;
	404	+
	405	+	end
	406	+
	407	+	;
	408	+
	409	+	Function
	410	+
	411	+	GetSomeValue(ARecord: PMyRecord)
	412	+
	413	+
	414	+	Integer;
	415	+
	416	+	begin
	417	+
	418	+	If
	419	+
	420	+	Assigned(ARecord)
	421	+
	422	+	then
	423	+
	424	+	` Result`
	425	+
	426	+
553	427		=
554		-	~~</div>~~
555		-	~~<p>ARecord^.SomeValue</p>~~
556		-	~~</dd>~~
557		-	~~</dl>~~
558		-	~~<div class="key">~~
559		-	~~<p>else</p>~~
560		-	~~</div>~~
561		-	~~<p><code> Result:= </code></p>~~
562		-	~~<div class="int">~~
563		-	~~<p>0</p>~~
564		-	~~</div>~~
565		-	~~<p>;</p>~~
566		-	~~<div class="key">~~
567		-	~~<p>end</p>~~
568		-	~~</div>~~
569		-	~~<p>;</p></td>~~
570		-	~~</tr>~~
571		-	~~</tbody>~~
572		-	~~</table>~~
573	428
	429	+	ARecord^.SomeValue
	430	+
	431	+	else
	432	+
	433	+	` Result:= `
	434	+
	435	+	0
	436	+
	437	+	;
	438	+
	439	+	end
	440	+
	441	+	;
	442	+
574	443		##### Beim Zugriff auf Zeichen einer indizierten Zeichenketten-Eigenschaft eines Objektes muss dieses in runden Klammern stehen
575	444
576	445		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:
577	446
578		-	~~<table>~~
579		-	~~<tbody>~~
580		-	~~<tr>~~
581		-	~~<td class="header"><p>Delphi</p></td>~~
582		-	~~<td class="header"><p>FPC</p></td>~~
583		-	~~</tr>~~
584		-	~~<tr>~~
585		-	~~<td class="code"><div class="key">~~
586		-	~~<p>Type</p>~~
587		-	~~</div>~~
588		-	~~<p>TSomeComponent=</p>~~
589		-	~~<div class="key">~~
590		-	~~<p>class</p>~~
591		-	~~</div>~~
592		-	~~<p>(TComponent)</p>~~
593		-	~~<div class="cmt">~~
594		-	~~<p>//weiterer Code...</p>~~
595		-	~~</div>~~
596		-	~~<div class="key">~~
597		-	~~<p>Published</p>~~
598		-	~~</div>~~
599		-	~~<div class="key">~~
600		-	~~<p>Property</p>~~
601		-	~~</div>~~
602		-	~~<p>MyString:</p>~~
603		-	~~<div class="key">~~
604		-	~~<p>String</p>~~
605		-	~~</div>~~
606		-	~~<div class="key">~~
607		-	~~<p>index</p>~~
608		-	~~</div>~~
609		-	~~<div class="int">~~
610		-	~~<p>3</p>~~
611		-	~~</div>~~
612		-	~~<div class="key">~~
613		-	~~<p>read</p>~~
614		-	~~</div>~~
615		-	~~<p>GetMyString;</p>~~
616		-	~~<div class="cmt">~~
617		-	~~<p>//weiterer Code...</p>~~
618		-	~~</div>~~
619		-	~~<div class="key">~~
620		-	~~<p>End</p>~~
621		-	~~</div>~~
622		-	~~<p>;</p>~~
623		-	~~<div>~~
624		-	~~</div>~~
625		-	~~<div class="key">~~
626		-	~~<p>var</p>~~
627		-	~~</div>~~
628		-	~~<p><code> MyChar</code></p>~~
629		-	~~<div class="symbol">~~
630		-	~~<dl>~~
631		-	~~<dt></dt>~~
632		-	~~<dd>~~
633		-	~~</div>~~
634		-	~~<p>char;</p>~~
635		-	~~</dd>~~
636		-	~~</dl>~~
637		-	~~<div class="key">~~
638		-	~~<p>begin</p>~~
639		-	~~</div>~~
640		-	~~<div class="key">~~
641		-	~~<p>If</p>~~
642		-	~~</div>~~
643		-	~~<p>Length(MyString)></p>~~
644		-	~~<div class="int">~~
645		-	~~<p>2</p>~~
646		-	~~</div>~~
647		-	~~<div class="key">~~
648		-	~~<p>then</p>~~
649		-	~~</div>~~
650		-	~~<div class="cmt">~~
651		-	~~<p>//no parenthesis needed</p>~~
652		-	~~</div>~~
653		-	~~<p><code> MyChar:= MyString[</code></p>~~
654		-	~~<div class="int">~~
655		-	~~<p>3</p>~~
656		-	~~</div>~~
657		-	~~<p>];</p>~~
658		-	~~<div class="cmt">~~
659		-	~~<p>//weiterer Code...</p>~~
660		-	~~</div>~~
661		-	~~<div class="key">~~
662		-	~~<p>end</p>~~
663		-	~~</div>~~
664		-	~~<p>;</p></td>~~
665		-	~~<td class="code"><div class="key">~~
666		-	~~<p>Type</p>~~
667		-	~~</div>~~
668		-	~~<p>TSomeComponent=</p>~~
669		-	~~<div class="key">~~
670		-	~~<p>class</p>~~
671		-	~~</div>~~
672		-	~~<p>(TComponent)</p>~~
673		-	~~<div class="cmt">~~
674		-	~~<p>//weiterer Code...</p>~~
675		-	~~</div>~~
676		-	~~<div class="key">~~
677		-	~~<p>Published</p>~~
678		-	~~</div>~~
679		-	~~<div class="key">~~
680		-	~~<p>Property</p>~~
681		-	~~</div>~~
682		-	~~<p>MyString:</p>~~
683		-	~~<div class="key">~~
684		-	~~<p>String</p>~~
685		-	~~</div>~~
686		-	~~<div class="key">~~
687		-	~~<p>index</p>~~
688		-	~~</div>~~
689		-	~~<div class="int">~~
690		-	~~<p>3</p>~~
691		-	~~</div>~~
692		-	~~<div class="key">~~
693		-	~~<p>read</p>~~
694		-	~~</div>~~
695		-	~~<p>GetMyString;</p>~~
696		-	~~<div class="cmt">~~
697		-	~~<p>//weiterer Code...</p>~~
698		-	~~</div>~~
699		-	~~<div class="key">~~
700		-	~~<p>End</p>~~
701		-	~~</div>~~
702		-	~~<p>;</p>~~
703		-	~~<div>~~
704		-	~~</div>~~
705		-	~~<div class="key">~~
706		-	~~<p>var</p>~~
707		-	~~</div>~~
708		-	~~<p><code> MyChar</code></p>~~
709		-	~~<div class="symbol">~~
710		-	~~<dl>~~
711		-	~~<dt></dt>~~
712		-	~~<dd>~~
713		-	~~</div>~~
714		-	~~<p>char;</p>~~
715		-	~~</dd>~~
716		-	~~</dl>~~
717		-	~~<div class="key">~~
718		-	~~<p>begin</p>~~
719		-	~~</div>~~
720		-	~~<div class="key">~~
721		-	~~<p>If</p>~~
722		-	~~</div>~~
723		-	~~<p>Length(MyString)></p>~~
724		-	~~<div class="int">~~
725		-	~~<p>2</p>~~
726		-	~~</div>~~
727		-	~~<div class="key">~~
728		-	~~<p>then</p>~~
729		-	~~</div>~~
730		-	~~<div class="cmt">~~
731		-	~~<p>//parenthesis sometimes needed</p>~~
732		-	~~</div>~~
733		-	~~<p><code> MyChar:= (MyString)[</code></p>~~
734		-	~~<div class="int">~~
735		-	~~<p>3</p>~~
736		-	~~</div>~~
737		-	~~<p>];</p>~~
738		-	~~<div class="cmt">~~
739		-	~~<p>//weiterer Code...</p>~~
740		-	~~</div>~~
741		-	~~<div class="key">~~
742		-	~~<p>end</p>~~
743		-	~~</div>~~
744		-	~~<p>;</p></td>~~
745		-	~~</tr>~~
746		-	~~</tbody>~~
747		-	~~</table>~~
	447	+	Delphi
748	448
	449	+	FPC
	450	+
	451	+	Type
	452	+
	453	+	TSomeComponent=
	454	+
	455	+	class
	456	+
	457	+	(TComponent)
	458	+
	459	+	//weiterer Code...
	460	+
	461	+	Published
	462	+
	463	+	Property
	464	+
	465	+	MyString:
	466	+
	467	+	String
	468	+
	469	+	index
	470	+
	471	+	3
	472	+
	473	+	read
	474	+
	475	+	GetMyString;
	476	+
	477	+	//weiterer Code...
	478	+
	479	+	End
	480	+
	481	+	;
	482	+
	483	+	var
	484	+
	485	+	` MyChar`
	486	+
	487	+
	488	+	char;
	489	+
	490	+	begin
	491	+
	492	+	If
	493	+
	494	+	Length(MyString)\>
	495	+
	496	+	2
	497	+
	498	+	then
	499	+
	500	+	//no parenthesis needed
	501	+
	502	+	` MyChar:= MyString[`
	503	+
	504	+	3
	505	+
	506	+	\];
	507	+
	508	+	//weiterer Code...
	509	+
	510	+	end
	511	+
	512	+	;
	513	+
	514	+	Type
	515	+
	516	+	TSomeComponent=
	517	+
	518	+	class
	519	+
	520	+	(TComponent)
	521	+
	522	+	//weiterer Code...
	523	+
	524	+	Published
	525	+
	526	+	Property
	527	+
	528	+	MyString:
	529	+
	530	+	String
	531	+
	532	+	index
	533	+
	534	+	3
	535	+
	536	+	read
	537	+
	538	+	GetMyString;
	539	+
	540	+	//weiterer Code...
	541	+
	542	+	End
	543	+
	544	+	;
	545	+
	546	+	var
	547	+
	548	+	` MyChar`
	549	+
	550	+
	551	+	char;
	552	+
	553	+	begin
	554	+
	555	+	If
	556	+
	557	+	Length(MyString)\>
	558	+
	559	+	2
	560	+
	561	+	then
	562	+
	563	+	//parenthesis sometimes needed
	564	+
	565	+	` MyChar:= (MyString)[`
	566	+
	567	+	3
	568	+
	569	+	\];
	570	+
	571	+	//weiterer Code...
	572	+
	573	+	end
	574	+
	575	+	;
	576	+
749	577		##### Sie müssen eine Typumwandlung von Zeigern in den tatsächlichen Typ vornehmen, wird dieser Zeiger mit einer Variablen oder Funktion dieses Typs benutzt
750	578
751	579		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
752	580
753	581		Zum Beispiel -
754	582
755		-	~~<table>~~
756		-	~~<tbody>~~
757		-	~~<tr>~~
758		-	~~<td class="header"><p>Delphi</p></td>~~
759		-	~~<td class="header"><p>FPC</p></td>~~
760		-	~~</tr>~~
761		-	~~<tr>~~
762		-	~~<td class="code"><p>Unit 1</p>~~
763		-	~~<div class="key">~~
764		-	~~<p>Type</p>~~
765		-	~~</div>~~
766		-	~~<p>TSomeObject=</p>~~
767		-	~~<div class="key">~~
768		-	~~<p>class</p>~~
769		-	~~</div>~~
770		-	~~<p>(TComponent)</p>~~
771		-	~~<div class="cmt">~~
772		-	~~<p>//weiterer Code...</p>~~
773		-	~~</div>~~
774		-	~~<div class="key">~~
775		-	~~<p>End</p>~~
776		-	~~</div>~~
777		-	~~<p>;</p>~~
778		-	~~<div>~~
779		-	~~</div>~~
780		-	~~<div class="key">~~
781		-	~~<p>Procedure</p>~~
782		-	~~</div>~~
783		-	~~<p>DoSomething(Value: TSomeObject);</p>~~
784		-	~~<div class="key">~~
785		-	~~<p>Function</p>~~
786		-	~~</div>~~
787		-	~~<p>GetSomeObject: TSomeObject;</p>~~
788		-	~~<div>~~
789		-	~~</div>~~
790		-	~~<div class="symbol">~~
791		-	~~<p>Unit 2</p>~~
792		-	~~</div>~~
793		-	~~<div class="key">~~
794		-	~~<p>Type</p>~~
795		-	~~</div>~~
796		-	~~<p>TSomeComponent=</p>~~
797		-	~~<div class="key">~~
798		-	~~<p>class</p>~~
799		-	~~</div>~~
800		-	~~<p>(TComponent)</p>~~
801		-	~~<div class="cmt">~~
802		-	~~<p>//weiterer Code...</p>~~
803		-	~~</div>~~
804		-	~~<div class="key">~~
805		-	~~<p>Published</p>~~
806		-	~~</div>~~
807		-	~~<p><code> SomeObject: Pointer</code></p>~~
808		-	~~<div class="symbol">~~
809		-	~~<p>;</p>~~
810		-	~~</div>~~
811		-	~~<div class="cmt">~~
812		-	~~<p>//weiterer Code...</p>~~
813		-	~~</div>~~
814		-	~~<div class="key">~~
815		-	~~<p>End</p>~~
816		-	~~</div>~~
817		-	~~<p>;</p>~~
818		-	~~<div>~~
819		-	~~</div>~~
820		-	~~<div class="symbol">~~
821		-	~~<p>Application</p>~~
822		-	~~</div>~~
823		-	~~<div class="key">~~
824		-	~~<p>var</p>~~
825		-	~~</div>~~
826		-	~~<p><code> MyComponent: TSomeComponent</code></p>~~
827		-	~~<div class="symbol">~~
828		-	~~<p>;</p>~~
829		-	~~</div>~~
830		-	~~<div class="key">~~
831		-	~~<p>begin</p>~~
832		-	~~</div>~~
833		-	~~<p><code> MyComponent.SomeObject</code></p>~~
834		-	~~<div class="symbol">~~
835		-	~~<dl>~~
836		-	~~<dt></dt>~~
837		-	~~<dd>~~
	583	+	Delphi
	584	+
	585	+	FPC
	586	+
	587	+	Unit 1
	588	+
	589	+	Type
	590	+
	591	+	TSomeObject=
	592	+
	593	+	class
	594	+
	595	+	(TComponent)
	596	+
	597	+	//weiterer Code...
	598	+
	599	+	End
	600	+
	601	+	;
	602	+
	603	+	Procedure
	604	+
	605	+	DoSomething(Value: TSomeObject);
	606	+
	607	+	Function
	608	+
	609	+	GetSomeObject: TSomeObject;
	610	+
	611	+	Unit 2
	612	+
	613	+	Type
	614	+
	615	+	TSomeComponent=
	616	+
	617	+	class
	618	+
	619	+	(TComponent)
	620	+
	621	+	//weiterer Code...
	622	+
	623	+	Published
	624	+
	625	+	` SomeObject: Pointer`
	626	+
	627	+	;
	628	+
	629	+	//weiterer Code...
	630	+
	631	+	End
	632	+
	633	+	;
	634	+
	635	+	Application
	636	+
	637	+	var
	638	+
	639	+	` MyComponent: TSomeComponent`
	640	+
	641	+	;
	642	+
	643	+	begin
	644	+
	645	+	` MyComponent.SomeObject`
	646	+
	647	+
838	648		=
839		-	~~</div>~~
840		-	~~<p>GetSomeObject;</p>~~
841		-	~~</dd>~~
842		-	~~</dl>~~
843		-	~~<div class="cmt">~~
844		-	~~<p>//weiterer Code...</p>~~
845		-	~~</div>~~
846		-	~~<p><code> DoSomething(MyComponent.SomeObject)</code></p>~~
847		-	~~<div class="symbol">~~
848		-	~~<p>;</p>~~
849		-	~~</div>~~
850		-	~~<div class="key">~~
851		-	~~<p>end</p>~~
852		-	~~</div>~~
853		-	~~<p>;</p></td>~~
854		-	~~<td class="code"><p>Unit 1</p>~~
855		-	~~<div class="key">~~
856		-	~~<p>Type</p>~~
857		-	~~</div>~~
858		-	~~<p>TSomeObject=</p>~~
859		-	~~<div class="key">~~
860		-	~~<p>class</p>~~
861		-	~~</div>~~
862		-	~~<p>(TComponent)</p>~~
863		-	~~<div class="cmt">~~
864		-	~~<p>//weiterer Code...</p>~~
865		-	~~</div>~~
866		-	~~<div class="key">~~
867		-	~~<p>End</p>~~
868		-	~~</div>~~
869		-	~~<p>;</p>~~
870		-	~~<div>~~
871		-	~~</div>~~
872		-	~~<div class="key">~~
873		-	~~<p>Procedure</p>~~
874		-	~~</div>~~
875		-	~~<p>DoSomething(Value: TSomeObject);</p>~~
876		-	~~<div class="key">~~
877		-	~~<p>Function</p>~~
878		-	~~</div>~~
879		-	~~<p>GetSomeObject: TSomeObject;</p>~~
880		-	~~<div>~~
881		-	~~</div>~~
882		-	~~<div class="symbol">~~
883		-	~~<p>Unit 2</p>~~
884		-	~~</div>~~
885		-	~~<div class="key">~~
886		-	~~<p>Type</p>~~
887		-	~~</div>~~
888		-	~~<p>TSomeComponent=</p>~~
889		-	~~<div class="key">~~
890		-	~~<p>class</p>~~
891		-	~~</div>~~
892		-	~~<p>(TComponent)</p>~~
893		-	~~<div class="cmt">~~
894		-	~~<p>//weiterer Code...</p>~~
895		-	~~</div>~~
896		-	~~<div class="key">~~
897		-	~~<p>Published</p>~~
898		-	~~</div>~~
899		-	~~<p><code> SomeObject: Pointer</code></p>~~
900		-	~~<div class="symbol">~~
901		-	~~<p>;</p>~~
902		-	~~</div>~~
903		-	~~<div class="cmt">~~
904		-	~~<p>//weiterer Code...</p>~~
905		-	~~</div>~~
906		-	~~<div class="key">~~
907		-	~~<p>End</p>~~
908		-	~~</div>~~
909		-	~~<p>;</p>~~
910		-	~~<div>~~
911		-	~~</div>~~
912		-	~~<div class="symbol">~~
913		-	~~<p>Application</p>~~
914		-	~~</div>~~
915		-	~~<div class="key">~~
916		-	~~<p>var</p>~~
917		-	~~</div>~~
918		-	~~<p><code> MyComponent: TSomeComponent</code></p>~~
919		-	~~<div class="symbol">~~
920		-	~~<p>;</p>~~
921		-	~~</div>~~
922		-	~~<div class="key">~~
923		-	~~<p>begin</p>~~
924		-	~~</div>~~
925		-	~~<p><code> MyComponent.SomeObject</code></p>~~
926		-	~~<div class="symbol">~~
927		-	~~<dl>~~
928		-	~~<dt></dt>~~
929		-	~~<dd>~~
	649	+
	650	+	GetSomeObject;
	651	+
	652	+	//weiterer Code...
	653	+
	654	+	` DoSomething(MyComponent.SomeObject)`
	655	+
	656	+	;
	657	+
	658	+	end
	659	+
	660	+	;
	661	+
	662	+	Unit 1
	663	+
	664	+	Type
	665	+
	666	+	TSomeObject=
	667	+
	668	+	class
	669	+
	670	+	(TComponent)
	671	+
	672	+	//weiterer Code...
	673	+
	674	+	End
	675	+
	676	+	;
	677	+
	678	+	Procedure
	679	+
	680	+	DoSomething(Value: TSomeObject);
	681	+
	682	+	Function
	683	+
	684	+	GetSomeObject: TSomeObject;
	685	+
	686	+	Unit 2
	687	+
	688	+	Type
	689	+
	690	+	TSomeComponent=
	691	+
	692	+	class
	693	+
	694	+	(TComponent)
	695	+
	696	+	//weiterer Code...
	697	+
	698	+	Published
	699	+
	700	+	` SomeObject: Pointer`
	701	+
	702	+	;
	703	+
	704	+	//weiterer Code...
	705	+
	706	+	End
	707	+
	708	+	;
	709	+
	710	+	Application
	711	+
	712	+	var
	713	+
	714	+	` MyComponent: TSomeComponent`
	715	+
	716	+	;
	717	+
	718	+	begin
	719	+
	720	+	` MyComponent.SomeObject`
	721	+
	722	+
930	723		=
931		-	~~</div>~~
932		-	~~<p>Pointer(GetSomeObject);</p>~~
933		-	~~</dd>~~
934		-	~~</dl>~~
935		-	~~<div class="cmt">~~
936		-	~~<p>//weiterer Code...</p>~~
937		-	~~</div>~~
938		-	~~<p><code> DoSomething(TSomeObject(MyComponent.SomeObject))</code></p>~~
939		-	~~<div class="symbol">~~
940		-	~~<p>;</p>~~
941		-	~~</div>~~
942		-	~~<div class="key">~~
943		-	~~<p>end</p>~~
944		-	~~</div>~~
945		-	~~<p>;</p></td>~~
946		-	~~</tr>~~
947		-	~~</tbody>~~
948		-	~~</table>~~
949	724
	725	+	Pointer(GetSomeObject);
	726	+
	727	+	//weiterer Code...
	728	+
	729	+	` DoSomething(TSomeObject(MyComponent.SomeObject))`
	730	+
	731	+	;
	732	+
	733	+	end
	734	+
	735	+	;
	736	+
950	737		#### Ressourcen
951	738
952	739		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.
953	740
954	741		- cd lazarus/tools
955	742		- make install
956	743
957	744		Um eine Ressource zu Ihrer Anwendung hinzuzufügen:
958	745
959	746		- lazres myresource.lrs mypix.xpm anotherpix.xpm
960	747		- Fügen Sie die LResources Unit zu Ihrem Uses Abschnitt hinzu
961	748		- Nehmen Sie die von Ihnen erstellte .lrs Datei unter dem initialization Abschnitt auf
962	749
963	750		Beispiel:
964	751
965		-	~~<table>~~
966		-	~~<tbody>~~
967		-	~~<tr>~~
968		-	~~<td class="code"><div class="key">~~
969		-	~~<p>function</p>~~
970		-	~~</div>~~
971		-	~~<p>TForm1.LoadGlyph(</p>~~
972		-	~~<div class="key">~~
973		-	~~<p>const</p>~~
974		-	~~</div>~~
975		-	~~<p>GlyphName:</p>~~
976		-	~~<div class="key">~~
977		-	~~<p>String</p>~~
978		-	~~</div>~~
979		-	~~<p>): TBitMap;</p>~~
980		-	~~<div class="key">~~
981		-	~~<p>begin</p>~~
982		-	~~</div>~~
983		-	~~<p><code> Result:= TPixmap.Create</code></p>~~
984		-	~~<div class="symbol">~~
985		-	~~<p>;</p>~~
986		-	~~</div>~~
987		-	~~<p><code> Result.LoadFromLazarusResource(GlyphName)</code></p>~~
988		-	~~<div class="symbol">~~
989		-	~~<p>;</p>~~
990		-	~~</div>~~
991		-	~~<div class="key">~~
992		-	~~<p>end</p>~~
993		-	~~</div>~~
994		-	~~<p>;</p>~~
995		-	~~<div class="cmt">~~
996		-	~~<p>//weiterer Code...</p>~~
997		-	~~</div>~~
998		-	~~<div class="key">~~
999		-	~~<p>begin</p>~~
1000		-	~~</div>~~
1001		-	~~<p><code> Speedbutton1.glyph:= LoadGlyph('mypix')</code></p>~~
1002		-	~~<div class="symbol">~~
1003		-	~~<p>;</p>~~
1004		-	~~</div>~~
1005		-	~~<div class="cmt">~~
1006		-	~~<p>//weiterer Code...</p>~~
1007		-	~~</div>~~
1008		-	~~<div class="key">~~
1009		-	~~<p>end</p>~~
1010		-	~~</div>~~
1011		-	~~<p>;</p>~~
1012		-	~~<div>~~
1013		-	~~</div>~~
1014		-	~~<div class="key">~~
1015		-	~~<p>initialization</p>~~
1016		-	~~</div>~~
1017		-	~~<div class="dir">~~
1018		-	~~<p>{$I unit1.lrs}</p>~~
1019		-	~~</div>~~
1020		-	~~<div class="dir">~~
1021		-	~~<p>{$I myresource.lrs}</p>~~
1022		-	~~</div>~~
1023		-	~~<div class="key">~~
1024		-	~~<p>end</p>~~
1025		-	~~</div>~~
1026		-	~~<p>.</p></td>~~
1027		-	~~</tr>~~
1028		-	~~</tbody>~~
1029		-	~~</table>~~
	752	+	function
	753	+
	754	+	TForm1.LoadGlyph(
	755	+
	756	+	const
	757	+
	758	+	GlyphName:
	759	+
	760	+	String
	761	+
	762	+	): TBitMap;
	763	+
	764	+	begin
	765	+
	766	+	` Result:= TPixmap.Create`
	767	+
	768	+	;
	769	+
	770	+	` Result.LoadFromLazarusResource(GlyphName)`
	771	+
	772	+	;
	773	+
	774	+	end
	775	+
	776	+	;
	777	+
	778	+	//weiterer Code...
	779	+
	780	+	begin
	781	+
	782	+	` Speedbutton1.glyph:= LoadGlyph('mypix')`
	783	+
	784	+	;
	785	+
	786	+	//weiterer Code...
	787	+
	788	+	end
	789	+
	790	+	;
	791	+
	792	+	initialization
	793	+
	794	+	{\$I unit1.lrs}
	795	+
	796	+	{\$I myresource.lrs}
	797	+
	798	+	end
	799	+
	800	+	.
1030	801
1031	802		### Eine andere Methode um ein Delphi- oder Kylix-Projekt nach Lazarus zu konvertieren
1032	803
1033	804		- 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.)
1034	805		- Benennen Sie die .dpr Datei in .lpr um.
1035	806		- Nehmen Sie notwendige Änderungen in der .lpr Datei vor:
1036	807
1037	808		1. Fügen Sie {\$mode delphi}{\$H+} oder {\$mode objfpc}{H+} Direktiven hinzu.
1038	809		2. Fügen Sie 'Interfaces' zum uses Abschnitt hinzu.
1039	810		3. Kommentieren Sie die {\$R *.res} Direktive aus oder löschen Sie diese.
1040	811
1041	812		- Nehmen Sie notwendige Änderungen in allen .pas Unit Dateien vor:
1042	813
1043	814		1. Fügen sie die {\$mode delphi}{\$H+} oder {\$mode objfpc}{H+} Direktiven hinzu.
1044	815		2. Fügen Sie 'LResources', und wenn das Formular Buttons hat, 'Buttons' zum uses Abschnitt hinzu.
1045	816		3. Kommentieren Sie die {\$R .dfm} oder {\$R .xfm} Direktive aus oder löschen Sie diese.
1046	817		4. Fügen Sie einen 'Initialization' Abschnitt am Ende jeder Datei hinzu, und fügen die {\$I unitname.lrs} Direktive darin hinzu.
1047	818
1048	819		- Wählen Sie Projekt -\> Neues Projekt von Datei
1049	820		- Wählen Sie die .lpr Datei
1050	821		- Im 'Erzeuge neues Projekt' Fenster wählen Sie 'Anwendung'
1051	822		- 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.
1052	823		- Speichern Sie alles und Sie haben ein Lazarus Projekt :-)
1053	824
1054	825		## Hilfe erhalten
1055	826
1056	827		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:
1057	828
1058	829		### Dokumentation
1059	830
1060	831		Für reine Object Pascal und FPC Probleme, ist der beste Ort zu beginnen die Free Pascal [Dokumentation](http://www.freepascal.org/docs-html/)von Michaël Van Canneyt und Florian Klämpfl.
1061	832
1062	833		Für mehr Lazarus orientierte Probleme ist die Lazarus Projekt Dokumentation in der [[Main Page/de\|Lazarus-CCR Knowledgebase]] der nächste Ort zum Nachschauen. Schließlich können Sie eine Frage posten in einer der [Mailing Listen](http://www.freepascal.org/maillist.html)für den Free Pascal Compiler oder den [FPC Foren](http://community.freepascal.org:10000/bboard/), wo eine Menge Experten eingeschrieben sind.
1063	834
1064	835		### Unterstützung durch andere User
1065	836
1066	837		Mailing-Listen: Man kann eine Frage stellen unter einer der [Mailing-Listen für den Freien Pascal Compiler](http://www.freepascal.org/maillist.html) oder das [FPC/Lazarus forums](http://forum.lazarus.freepascal.org/index.php?action=forum) wo eine Reihe von Experten antworten.
1067	838
1068	839		Bei Zugriff auf IRC: bei irc.freenode.net: [\#fpc](irc://irc.freenode.net/fpc) for FPC, oder [\#lazarus-ide](irc://irc.freenode.net/lazarus-ide) für Lazarus
1069	840
1070	841		### Wissensbasis
1071	842
1072	843		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:
1073	844
1074	845		- Tamarack Associates enthält eine schnelle \[ <http://codenewsfast.com/> search\] Suche speziell für das Borland usenet Archiv.
1075	846		- Mer Systems Inc. liefert eine ähnliche Suchseite [engine](http://www.mers.com/searchsite.html).
1076	847		- Eine weitere herausragende Informationsquelle sowie eine standortübergreifende [search](http://www.efg2.com/Lab/search.htm)Möglichkeit ist Earl F. Glynn's Computer Lab and Reference [Library](http://www.efg2.com/).
1077	848
1078	849		## Erstellen eines Packages und Veröffentlichung Ihrer Komponente
1079	850
1080	851		### Erstellen eines Lazarus Packages für Ihre Komponente(n)
1081	852
1082	853		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/de\|Lazarus Packages]] geschrieben, die Sie lesen sollten bevor Sie mit diesem Prozess beginnen.
1083	854
1084	855		### Dokumentation
1085	856
1086	857		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.
1087	858
1088	859		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.
1089	860
1090	861		### Erzeugen einer Code Release Page
1091	862
1092	863		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.
1093	864
1094	865		Die folgende Prozedur lässt Sie eine Code Release Seite mit Ihrem Browser erzeugen:
1095	866
1096	867		- Gehen Sie zu [[Release new component]]
1097	868		- Tippen Sie den Namen Ihrer Komponente in die Textbox und klicken auf Create Article
1098	869		- Füllen Sie die Vorlage aus und vergessen Sie nicht zu speichern.
1099	870		- 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.
1100	871
1101	872		### Einreichen der Komponente
1102	873
1103	874		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.
1104	875
1105	876		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]].
1106	877
1107	878		## Mitwirkende und Änderungen
1108	879
1109	880		Diese Seite wurde von der epikwiki [Version](http://lazarus-ccr.sourceforge.net/index.php?wiki=CodeConversionGuide) konvertiert.
1110	881
1111	882		- Anfangsversion von Tom Lisjac und Mattias Gärtner - 9/22/2003 VlxAdmin
1112	883		- Moved Getting help from the main page. T. Lisjac - 9/24/2003 VlxAdmin
1113	884		- Added documentation templates, procedure and links. 9/25/2003 VlxAdmin
1114	885		- LCLLinux wurde in LCLIntf umbenannt, Jesus Reyes, 9/27/2003
1115	886		- added more information on Unit changes, [AndrewJohnson](http://lazarus-ccr.sourceforge.net/index.php?wiki=AndrewJohnson) 9/27/2003
1116	887		- Updated Syntax differences, including some examples, [AndrewJohnson](http://lazarus-ccr.sourceforge.net/index.php?wiki=AndrewJohnson) 9/27/2003
1117	888		- FPC 1.0.x doesn't support interfaces, Vincent Snijders 9/28/2003
1118	889		- Fixed some of the examples per new WikiWord definition, 9/28/2003 VlxAdmin
1119	890		- Made code more consistant to remove last accidental Pascal WikiWord definitions, [AndrewJohnson](http://lazarus-ccr.sourceforge.net/index.php?wiki=AndrewJohnson) 9/27/2003
1120	891		- Use tables for code examples for nice blocks, and easy side by side view of Delphi-\>FPC differences, [AndrewJohnson](http://lazarus-ccr.sourceforge.net/index.php?wiki=AndrewJohnson) 10/17/2003
1121	892		- Use pascal stylesheet to make example code more readable, [AndrewJohnson](http://lazarus-ccr.sourceforge.net/index.php?wiki=AndrewJohnson) 10/18/2003
1122	893		- Abschnitt 'Another method to convert a Delphi or Kylix project to Lazarus' hinzugefügt , George Lober, 2/17/2006
1123	894
1124	895		---
1125	896		From the Free Pascal wiki, page "Code Conversion Guide/de", as it stood on 2023-03-15 after a change by Kornelius, out of the wiki's dump of 2024-05-26. Copyright stays with the author who wrote it, according to the old wiki's [[Licensing]] page. If you have concerns about this material, [message the admin](/wiki-contact).

Back to history