Code Conversion Guide/es: what changed

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

Old	New		Line
1	1		### Guía de conversión de código
2	2
3	3		Esta página trata sobre cómo trasladar o convertir código existente en Delphi o Kylix para que trabaje con el compilador [[Free Pascal]] (FPC) y el IDE Lazarus. Aunque Lazarus y el Free Pascal Compiler tienen aspectos en común con Delphi y Kylix, no son clones. Hay numerosas diferencias en las llamadas a librerías y en las convenciones utilizadas... y en muchas otras áreas, FPC es más rico y puede ser más exigente sobre la corrección de la sintaxis. Por favor lee [[Lazarus For Delphi Users\|Lazarus para usuarios de Delphi]] una guía descriptiva de muchas de las diferencias de funcionamiento.
4	4
5	5		El propósito de esta guía es documentar algunas diferencias específicas que son frecuentes encontrar en el proceso de conversión de código al trasladar código existente desde Delphi a FPF/Lazarus.
6	6
7	7		Este documento se ha ubicado en la zona de 'wiki base de conocimientos' por lo que puede ser fácilmente ampliado por cualquiera que se haya tropezado con un problema singular y quiera poner su experiencia en común con otras personas.
8	8
9	9		## Seleccionar un componente o librería para convertir
10	10
11	11		### Dónde encontrar código para convertir
12	12
13	13		Existe una gran cantidad de código disponible en la red que puede ser convertido para el uso con FPC y Lazarus. Esta página [[Page Of Code Sites]] es sólo un comienzo. Por favor, añada cualquier ubicación buena que conozca. TurboPower Software ha publicado recientemente la totalidad de su oferta comercial bajo la licencia MPL. Una lista de los paquetes disponibles se encuentra [aquí](http://sourceforge.net/users/tpsfadmin/).
14	14
15	15		Para evitar duplicar esfuerzos, los paquetes que ya han sido convertidos están listados en la página [[Components and Code examples\|Componentes y código de ejemplo]]. Si has convertido un paquete o estás trabajando en ello, haz una reseña en la página [[Current conversion projects\|Proyecto actualmente en conversión]].
16	16
17	17		### Licencias
18	18
19	19		Las licencias del código existente varían desde libre/dominio público hasta versiones restrictivas que prohiben modificar, redistribuir y el uso comercial. Antes de convertir un un paquete, es conveniente examinar los téminos de su licencia y asegurarse de que es compatible con Lazarus y FPC. La selección de la licencia es especialmente importante con componentes, cuya mera ubicación en un formulario puede imponer una licencia no deseada o incompatible para toda la aplicación.
20	20
21	21		Cuando conviertas componentes, respeta los términos del autor original y mantén todos los derechos de autor y los encabezados de licencia con sus direcciones de correo y url. Es cortés y a veces muy útil informar al autor de que sus componente va a ser convertido... especialmente si el componente está bajo una licencia restrictiva. Un interés renovado sobre un componente antiguo u olvidado a menudo incita al autor a revisar las restricciones de la licencia original.
22	22
23	23		En general, Dominio Público ([software](http://buscon.rae.es/draeI/SrvltGUIBusUsual?TIPO_HTML=2&TIPO_BUS=3&LEMA=software) libre), y LGPL/MPL son las más flexibles para distribuir componentes. Para más información, [Definición de Fuentas Abiertas (Open Source)](http://www.opensource.org/docs/definition.php) es un buen sitio para empezar. Asimismo hay varias comparaciones disponibles para ayudar a clarificar el impacto que los diversos tipos de licencias de obra pueden tener sobre el código que está relacionado con el mismo. Busca sobre los términos "licencia de fuente abierta comparación"
24	24
25	25		### Dependencias
26	26
27	27		Otro punto previo al comienzo del trabajo de conversión, es verificar que el código no tiene una profunda dependencia de otros paquetes que podrían no estar disponibles o representan un reto considerable de conversión. Algunos desarrollos de código libre son extensiones de paquetes propietarios/cerrados, que a menudo ya no están disponibles o lo están bajo licencias inapropiadas.
28	28
29	29		### Acerca del compilador
30	30
31	31		Ver:
32	32
33	33		- [Problemas conocidos](http://www.freepascal.org/probs.html)
34	34		- [Fallos no corregidos](http://www.freepascal.org/bugs/db.php3?statusfield=Unfixed) (parece que no funciona)
35	35
36	36		### Acerca de Sistemas Operativos y Plataformas
37	37
38	38		Lazarus y el Compilador Libre de Pascal son herramientas multiplataforma y multiarquitectura de desarrollo cruzado, es decir lo escrito en una plataforma puede compilarse ¡y funcionar! en otra. Por contra mucho código Delphi existente ha sido diseñado específicamente para correr sobre la plataforma Intel+Win32. Si el componente candidato tiene mucho código específico win32, tal vez sea más conveniente buscar otra alternativa menos dependiente de la plataforma. Pero no te detengas por ello... ¡es verdaderamente sorprendente lo que el LCL soporta!
39	39
40	40		## Convirtiendo
41	41
42	42		### Configurando el entorno de Lazarus para un proyecto de conversión
43	43
44	44		#### Crear un proyecto de prueba
45	45
46	46		- Poner el código a convertir en un subdirectorio (convertdir, por ejemplo)
47	47		- Desde Lazarus crear un proyecto nuevo.
48	48		- Guardar (Archivo-\>Guardar Todo) en el subdirectorio convertdir. Poner nombres significativos a este proyecto y a su unidad principal es optativo.
49	49		- Abrir la unidad principal del proyecto a convertir.
50	50		- Añadirla al proyecto: Proyecto-\>Añadir archivo del Editor al Proyecto
51	51		- Utilice Herramientas-\>Chequeo Rápido de la sintaxis o bien Ejecutar-\>Construir todo para empezar.
52	52
53	53		#### Cuestiones iniciales a tener en cuenta
54	54
55	55		- Las series 1.0.x del compilador distinguen en los nombres de fichero mayúsculas y minúsculas. Si se trabaja con esta versión, es conveniente poner todos los nombres en minúsculas. En caso contrario se producirá el error "Archivo no encontrado"
56	56
57	57		#### Código fuente Delphi VCL y Kylix CLX en Lazarus
58	58
59	59		Al convertir código fuente Delphi / Kylix, a menudo es útil mirar la declaración para comprobar lo que hace una función concreta. El IDE de Lazarus puede analizar el código Delphi / Kylix. Para ello es necesario configurar las opciones del compilador y las rutas de búqueda. Esto hace más fácilmente utilizando plantillas de proyecto: Entorno-\>Definir editor de CodeTools-\>Insertar plantilla.
60	60
61	61		### Problemas de conversión y soluciones
62	62
63	63		#### Equivalencia de archivos entre Delphi / Kylix y Lazarus
64	64
65	65		Delphi / Kylix
66	66
67	67		Descripción
68	68
69	69		Lazarus
70	70
71	71		Descripción
72	72
73	73		.pas
74	74
75	75		.dfm/.xfm,
76	76
77	77		.dcu/.dpu,
78	78
79	79		.dpr(main project file),
80	80
81	81		.res,
82	82
83	83		.dof/.kof
84	84
85	85		---
86	86
87	87		---
88	88
89	89		---
90	90
91	91		Delphi Source File, Delphi Form,
92	92
93	93		Delphi Compiled Unit,
94	94
95	95		Delphi Project,
96	96
97	97		Windows Resource File,
98	98
99	99		Delphi Option File
100	100
101	101		.pas, .pp .lfm,
102	102
103	103		.o,
104	104
105	105		.lpr
106	106
107	107		---
108	108
109	109		---
110	110
111	111		.lrs,
112	112
113	113		.lpi(main project file),
114	114
115	115		.ppu
116	116
117	117		Pascal unit file,
118	118
119	119		Form data file,
120	120
121	121		Compiled unit file,
122	122
123	123		Project file,
124	124
125	125		Resource file,
126	126
127	127		Project options file,
128	128
129	129		Lazarus resource file,
130	130
131	131		Lazarus project information file,
132	132
133	133		FPC unit description file
134	134
135	135		Así pués un archivo .dcu de Delphi contiene, más o menos, la información de los archivos .o y .ppu de FPC. Un .ppu es principalmente la cabecera (interfaz), y el .o la parte de la implementación. Las funciones "en línea" (inline) que residen en el .ppu, son la principal excepción a esta regla.
136	136
137	137		#### Convirtiendo proyectos/formularios/unidades de Delphi a Lazarus
138	138
139	139		Utiliza la herramienta de conversión de las nuevas versiones de Lazarus para la conversión automática. La mayoría de las funciones se explican más adelante en esta página. Más información aquí:
140	140
141		-	~~` `[`http://wiki.lazarus.freepascal.org/Delphi_Converter_in_Lazarus`](http://wiki.lazarus.freepascal.org/Delphi_Converter_in_Lazarus)~~
	141	+	```
	142	+	http://wiki.lazarus.freepascal.org/Delphi_Converter_in_Lazarus
	143	+	```
142	144
143	145		El siguiente texto explica las diferencias entre Delphi y Lazarus y cómo convertir manualmente.
144	146
145	147		Cambia el nombre o copia el archivo .dpr a un .lpr. Comenta o elimina la directiva
146	148
147	149		{\$R *.res}
148	150
149	151		y añade la directiva
150	152
151	153		{\$mode delphi}{\$H+}
152	154
153	155		o bien esta otra
154	156
155	157		{\$mode objfpc}{\$H+}
156	158
157	159		en el .lpr. El IDE de Lazarus ayuda en esta cuestión en la opción del menú Herramientas "Convertir proyecto de DElphi a proyecto de Lazarus...". En ella se pide un .dpr (proyecto Delphi) y lo convierte en un .lpr; además, crea el archivo. lpi archivo y convierte todas las demás unidades.
158	160
159	161		Muchos formularios de Delphi se pueden convertir para trabajar en Lazarus utilizando el asistente del IDE, que se encuentra en el menú Herramientas como tema "Convertir archivo DFM a LFM". Utilice el diálogo, seleccione el dfm y el convertidor hará el resto.
160	162
161	163		Si necesitas convertir una unidad (con o sin formulario), Lazarus incluye una opción "Convertir unidad de Delphi a unidada de Lazarus" que haá por tí lo siguiente:
162	164
163	165		1. poner en minúsculas los nombre de archivo de inclusiones y de la sección uses.
164	166		2. convierte el .dfm a .lfm (normalmente sin comprobar el contenido, únicamente el formato)
165	167		3. crea un .lrs vacío (el contenido se creará después)
166	168		4. añade la directiva
167	169		{\$mode delphi}
168	170		5. sustituye la referencia a la unidad windows por LCLIntf
169	171		6. añade la unidad LResources si es preciso (si se usa .lrs se pondrá
170	172		uses LResources
171	173
172	174		en la sección de implementación)
173	175		7. elimina las unidades variants
174	176		8. elimina la directiva
175	177		{\$R *.dfm}
176	178		9. crea la sección de iniciación y añade en ella la directiva
177	179		{\$i unit.lrs}
178	180
179	181		Esto permite una rápida y fácil conversión de la mayoría de las unidades de Delphi a Lazarus. No se realiza ninguna validación ni cambios automáticos de sintaxis, por lo que cualquier cambio en la sintaxis se hará manualmente, así como de unidades referenciadas, sustitución de algunos componentes,..., aunque hay asistentes de ayuda disponibles para facilitar esta tarea, especialmente en el caso de la reparación de formularios (.lfm)
180	182
181	183		#### Seleccionar el modo correcto de compilación
182	184
183	185		El compilador FPC soporta 5 modos diferentes de pascal. Por ejemplo, TP para turbo pascal, que permite compilar unidades turbo pascal. Está también el modo de compatibilidad DELPHI, cuya utilización permite una fácil conversión del código existente. El modo preferido en Lazarus es OBJFPC, muy parecido a DELPHI pero menos ambiguo en la sintaxis. Estos son puntos importantes:
184	186
185	187		El modo se puede seleccionar en la línea de ordenes o al principio del código fuente. Utillizar la línea de ordenes tien la ventaja de que no hay que cambiar el código fuente, pero la desventaja de que hay que documentarlo para los demás.
186	188
187	189		Muchas unidades DELPHI compilan con FPC añadiendo a las mismas
188	190
189		-	~~`{$IFDEF FPC}`\~~
190		-	~~` {$MODE DELPHI}`\~~
191		-	~~`{$ENDIF}`~~
	191	+	```
	192	+	{$IFDEF FPC}
	193	+	{$MODE DELPHI}
	194	+	{$ENDIF}
	195	+	```
192	196
193	197		inmediatamente a continuación del nombre de la unidad.
194	198
195	199		Para más detalles acerca de los modos de [[Free Pascal]] FPC ver [Documentación de Free Pascal](http://www.freepascal.org/docs-html/prog/progap4.html#progse62.html)
196	200
197	201		#### Consideraciones sobre codificación para Multiplataforma
198	202
199	203		- El código Ensamblador en línea (inline assembler) es problemático, dado que es específico para la arquitectura Intel. Muchos desarrolladores hacen el prototipo en Pascal y después utilizan su equivalente ensamblador optimizado. Por suerte TurboPower hizo esta operación dejando también el código Pascal. Si este es el caso del paquete que estás convirtiendo, repón el código pascal.
200	204		- No hagas referencias a direcciones concretas de memoria, como el área de BIOS. Averigua lo que el código necesita y busca una alternativa portable entre plataformas.
201	205		- No utilices trucos específicos de procesador (por ejemplo, Intel TSC) sin encerrar ese código en un selector (IFDEF) para esa plataforma... y provee una alternativa para entornos que no tienen esa máquina concreta.
202	206		- Si es necesario código específico para un SO, haz uso de bloques selectores (IFDEF). Ver más abajo una lista de macros.
203	207
204	208		#### Variables, "defines" y macros útiles del compilador
205	209
206	210		Para escribir código que se adapte, y se comporte de forma distinta según el sistema, se utiliza la directiva
207	211
208	212		{\$IFDEF identificador}.
209	213
210	214		- {\$IFDEF FPC}
211	215
212	216		Esta se define cuando se utiliza el compilador FPC. Es útil para escribir código válido tanto para Delphi como para FPC. Por razones de compatibilidad en FPC se define la macro DELPHI en modo Delphi, por lo tanto no se puede usar {\$IFNDEF DELPHI}.
213	217
214	218		- {\$IFDEF LCL}
215	219
216	220		Esta se define para utilizar el paquete LCL. Es útil para escribir código que funcione con LCL y Delphi.
217	221
218	222		- {\$IFDEF LCLGtk}
219	223
220	224		,
221	225
222	226		{\$IFDEF LCLWin32}
223	227
224	228		,
225	229
226	230		{\$IFDEF LCLQt}
227	231
228	232		, ...
229	233
230	234		Esta varible se define para utilizar el LCL en una determinada plataforma, usando los componentes visuales (widgetset).
231	235
232	236		- {\$IFDEF Unix} // para Linux, BSD, Mac OS X, Solaris
233	237
234	238		,
235	239
236	240		{\$IFDEF Win32}
237	241
238	242		,
239	243
240	244		{\$IFDEF Linux}
241	245
242	246		// para Linux,
243	247
244	248		{\$IFDEF Darwin}
245	249
246	250		// para OS X,
247	251
248	252		{\$IFDEF WinCE}
249	253
250	254		// para WinCE,...
251	255
252	256		Determina la utilización de FPC para un deteminado SO como destino. Delphi define "Linux", "Win32" y "MSWindows". [[Free Pascal]] funciona en muchas más plataformas y por tanto se recomienda utilizar especificaciones más generales. Por ejemplo "Unix" está definido para Linux, FreeBSD, NetBSD y OpenBSD, en los que Lazarus ya funciona. Para código que corra tanto en FPC cómo en Delphi utilice:
253	257
254	258		``` pascal
255	259		{$IFDEF Linux}
256	260		{$DEFINES Unix}
257	261		{$ENDIF}
258	262		```
259	263
260	264		para que funcione en Kilix.
261	265
262	266		- {\$IFDEF ENDIAN_BIG}
263	267
264	268		Esta variable se definirá para procesadores como el powerpc (ordenadores Apple, hasta el MacOSX 10.2, por ejemplo) que tienen la disposisicón del byte invertida respecto de los procesadores compatibles intel.
265	269
266	270		- {\$IFDEF ENDIAN_BIG}
267	271
268	272		Para más detalles ver [Documentación de FPC](http://www.freepascal.org/docs-html/prog/prog.html#QQ2-23-21).
269	273
270	274		#### Soporte para 32bit / 64 bit
271	275
272	276		Los punteros para 64bit requieren 8 octetos en vez de los 4 de 32bit. El tipo entero (integer) permanece de 32bit por compatibilidad. Esto supone que ya no es posible transformar enteros en punteros y viceversa mediante "typecast". FPC define dos nuevos tipos: PtrInt y PtrUInt. PtrInt es un entero con signo de 32bit en plataformas 32 bit y de 64 bit en plataformas 64bit. PtrUInt funciona igual, excepto que es un entero sin signo. Por tanto, para código que funcione tanto en FPC cómo en Delphi hay que escribir esto:
273	277
274	278		``` pascal
275	279		{$IFNDEF FPC}
276	280		type
277	281		PtrInt = integer;
278	282		PtrUInt = cardinal;
279	283		{$ENDIF}
280	284		```
281	285
282	286		Sustituya todas las ocurrencias de integer(SomePointerOrObject) por PtrInt(SomePointerOrObject).
283	287
284	288		Para más información ver Guía de programación para multiples plataformas [[Multiplatform Programming Guide]]
285	289
286	290		#### Buscando un identificador perdido
287	291
288	292		La organización de la LCL y de la VCL son diferentes. Cuándo tenemos un error de compilación "no encontrado" sobre una clase o un identificador, lo más probable es que la definición de los mismos se encuentre en una unidad distinta de la esperada. Una completa referencia cruzada se puede encontrar buscando en lazarus/docs/xml o en el directorio lcl.
289	293
290	294		Por ejemplo, el común tbutton, dará error en Delphi, ya que se encuentra en una unidad llamada buttons.pp. El siguiente mandato encuentra la unidad correcta rápidamente (en el directorio fuente lazarus):
291	295
292	296		``` bash
293	297		grep -in ' tbutton =' lcl/*
294	298		```
295	299
296	300		(Nota del traductor: esta sintaxis de grep no da resultados en windows. Yo en windows utilizo el 'buscar' del SO en el ámbito del directorio en que está instalado lazarus, para archivos .pas o .pp que contienen referencias al término deseado. Incluso funciona, a veces, la utilidad del IDE de buscar la declaración)
297	301
298	302		#### Diferencias mayores entre las unidades de Lazarus y las de Delphi
299	303
300	304		¡Por favor, añada lo que sepa sobre este tema!
301	305
302	306		- Windows -\> Interfaces, LCLIntf, LCLType, LCLProc, VCLGlobals, ...)
303	307
304	308		Dado que la LCL no es específica de windows, el código para acceder la API win32 está condensada en interfaces separadas que son accedidas desde la unidad LCLIntf. Hay que tener en cuenta que Lazarus no intenta emular win32, por lo que muchas funciones no están incluidas y otras no funcionan exactamente como sus homólogas win32. Estas funciones existen únicamente para dar compatibilidad con Delphi y deben ser utilizadas únicamente para una migración rápida y "sucia". Las definiciones tipos están fragmentadas, por lo que es necesaria la unidad LCLType, y a veces también VCLGlobals. La unidad LCLProc también contiene algunas funciones que pueden ser útiles para manipulaciones a bajo nivel como "FreeThenNil" tal como se hace en Delphi 5 y superiores o "DeleteAmpersands" para eliminar los "&" sobrantes de una cadena de control (vs & & & etc). Hay que incluir la unidad Interfaces en la cláusula uses del archivo .lpr para iniciar adecuadamente el conjunto de controles apropiado (widgetset).
305	309
306	310		- Messages -\> LMessages
307	311
308	312		Los mensajes de control (TControl Messages) para los eventos de retrollamada de win32 en el formato WM_CALLBACK y sus estructuras asociadas se encuentran en la unidad Delphi Messages. En la LCL estos tipos de mensajes y sus estructuras están usualmente en LMessages, normalmente con un cambio en el nombre, de WM a LM, así, por ejemplo, WM_MOUSEENTER se transforma en LM_MOUSEENTER, y TWMMouse en TLMMouse.
309	313
310	314		- Graphics, Controls -\> GraphType, GraphMath, Graphics, Controls
311	315
312	316		Para simplificar las cosas y romper la complejidad de las referencias entre unidades, muchos tipos han sido abstraidos en una unidad común llamada GraphType, que incluye lo que en Deplhi se encuentra en las unidades Graphics o Controls. Así que tendrá que ser incluida. Otra unidad igualmente incompatible con Delphi es GraphMath, que añade el tipo TFloatPoint para precisión, rutinas para trabajar con curvas de Bézier, líneas y arcos, sobrecarga de algunos operadores para trabajar con TPoints y TRect, como, por ejemplo, punto1: = punto2 + punto3, y comparar dos Trect así if (rect1 = rect2) then ...such as for instance Point1 := Point2 + Point3, and comparing two rects like if (rect1 = rect2) then ...
313	317
314	318		- Mask -\> MaskEdit
315	319
316	320		Para racionalizar las convenciones sobre nombres, la unidad para la clase TMaskEdit se llama MaskEdit y no el confuso Mask de muchas versiones Delphi.
317	321
318	322		- StdCtrls-\>StdCtrls,Buttons
319	323
320	324		En muchas versiones de Delphi TButton se encuentra en StdCtrls, mientras que TSpeedButton y TBitBtn están en Buttons. Por consistencia y simplicidad la LCL ubica todos los tipos de botones en la unidad Buttons, es por tanto una buena idea incluirla para evitar problemas de conversión.
321	325
322	326		#### Diferencias entre Delphi y FPC/LCL sobre propiedades y métodos
323	327
324	328		- EL TBitmap de la LCL tiene una propiedad lienzo (canvas)
325	329		- En la LCL las propiedades de las dimensiones de la ventana (TForm.ClientWidth/ClientHeight) y las proiedades de las dimensiones de su área cliente (TForm.Width/Height)tienen el mismo valor. Esto es así porque los valores de las dimensiones de la ventana no incluyen las dimensiones de su marco. Ver: [[Lazarus Faq\|Preguntas sobre Lazarus]]
326	330
327	331		#### Diferencias semánticas
328	332
329	333		##### Orden de evaluación de los parámetros
330	334
331	335
332	336		Delphi garantiza que los parámetros se evalúan siempre de izquierda a derecha. FPC no garantiza esto, y evaluará los parámetros en el orden que produzca un código más optimo.
333	337
334	338		##### Procedimientos y funciones anidadas como variables de procedimiento
335	339
336	340
337	341		Delphi pasa el puntero al marco (framepointer) del procedimiento padre siempre en la pila, y es quién llama el que debe quitarlo. Esto significa que no puede acceder a las variables del padre, y sin embargo puede pasar la dirección de una función anidada a otra función que podrá usarla como cualquier variable de procedimiento.
338	342
339	343
340	344		FPC, por otro lado pasa el puntero al marco del procedimiento padre cómo el primer parámetro oculto de acuerdo a las convenciones actuales de llamada, esto significa que si se llama a un procedimiento anidado como si fuese una variable de procedimiento ordinaria todos los parámetros pasados se moverán una posición.
341	345
342	346
343	347		En resumen, no llames a procedimientos anidados a través de variables de procedimiento.
344	348
345	349		#### Diferencias de sintaxis
346	350
347	351		##### ¡Por favor, añada lo que sepa sobre este tema!
348	352
349	353
350	354		Debido al rigor inherente a FPC, algunos cambios en la sintaxis son necesarios, aunque con la directiva {\$Mode Delphi} podemos relajarnos al estilo Delphi. No obstante lo cual, es recomendable cumplir con las reglas de sintaxis del modo {\$Mode ObjFPC}, incluso cuando el código va a ser compartido entre Delphi y la LCL. Algunos son simples buenas prácticas de escritura de código, y otras porque el modo Delphi no es completamente exacto, o porque el código aceptable en Delphi no funciona como debe con FPC, incluso aunque compila. Para ello, aunque no todo es estrictamente necesario, los siguientes cambios deben considerarse obligatorios:
351	355
352	356		##### Al asignar una función de manejo de un evento, antepon un "@" a su nombre
353	357
354	358
355	359		Por ejemplo, se puede asignar la llamada a un botón manualmente
356	360
357	361		Delphi
358	362
359	363		OBJFPC
360	364
361	365		``` pascal
362	366		begin
363	367		if not Assigned(MiBoton.OnClick) then
364	368		MiBoton.OnClick:= UnaFuncion;
365	369		//@ no necesario
366	370		//más código...
367	371		end;
368	372		```
369	373
370	374		``` pascal
371	375		begin
372	376		if not Assigned(MiBoton.OnClick) then
373	377		MiBoton.OnClick:= @UnaFuncion;
374	378		//@ Es necesario
375	379		//más código...
376	380		end;
377	381		```
378	382
379	383		##### Al llamar a una variable procedural usar esta sintaxis: ProcNombre()
380	384
381	385
382	386		En Delphi no existen diferencias entre el resultado de una función y una variable, en cambio en FPC, la llamada a una función debe llevar los paréntesis, incluso si no hay argumentos. Por ejemplo:
383	387
384	388		Delphi
385	389
386	390		OBJFPC
387	391
388	392		``` pascal
389	393		With (UnObjeto) do
390	394		begin
391	395		If Assigned(OnMiLlamada) then
392	396		OnMiLlamada;
393	397		//paréntesis no necesarios
394	398		end;
395	399		```
396	400
397	401		``` pascal
398	402		With (UnObjeto) do
399	403		begin
400	404		If Assigned(OnMiLlamada) then
401	405		OnMiLlamada();
402	406		//los paréntesis son necesarios
403	407		end;
404	408		```
405	409
406	410		##### Al obtener los valores de un puntero a registro hay que deshacer antes la referencia
407	411
408	412
409	413		En Delphi no es necesario deshacer la referencia a un puntero de registro para acceder a sus valores, se trata, de hecho, cómo si fuese un registro, o culaquier otro objeto. En FPC es necesario deshacer la referencia antes. Un ejemplo,
410	414
411	415		Delphi
412	416
413	417		OBJFPC
414	418
415	419		``` pascal
416	420		Function DameValores(UnRegistro: PMiRegistro):Integer;
417	421		begin
418	422		If Assigned(UnRegistro) then
419	423		Result:=UnRegistro.UnValor
420	424		else
421	425		Result:=0;
422	426		end;
423	427		```
424	428
425	429		``` pascal
426	430		Function DameValores(UnRegistro: PMiRegistro):Integer;
427	431		begin
428	432		If Assigned(UnRegistro) then
429	433		Result:=UnRegistro^.UnValor
430	434		else
431	435		Result:=0;
432	436		end;
433	437		```
434	438
435	439		##### Para acceder a caracteres de la cadena que es una propiedad de un objeto, esta debe ser encerrada entre paréntesis
436	440
437	441
438	442		Con Delphi las porpiedades de los objetos se tratan como cualquier otra constante o variable, incluso para acceder directamente a los caracteres individuales de una cadena, pero esto no es posible en FPC, específicamente para propiedades indexadas. PAra hacerlo hay que encerrar la propiedad etnre paréntesis, para diferenciar. Aunque no es necesario en todos los casos, es buena práctica hacerlo así siempre. Por ejemplo,
439	443
440	444		Delphi
441	445
442	446		OBJFPC
443	447
444	448		``` pascal
445	449		Type TUnComponente=class(TComponent)
446	450		//Más código......
447	451		Published
448	452		Property MiCadena:String index 3 read GetMiCadena;
449	453		//Más código....
450	454		End;
451	455
452	456		var
453	457		MiLetra:char;
454	458		begin
455	459		If Length(MiCadena)>2 then
456	460		//paréntesis no necesarios
457	461		MiLetra:= MiCadena[3];
458	462		//Más código......
459	463		end;
460	464		```
461	465
462	466		``` pascal
463	467		Type TUnComponente=class(TComponent)
464	468		//Más código...
465	469		Published
466	470		Property MiCadena:String index 3 read GetMiCadena;
467	471		//Más código...
468	472		End;
469	473
470	474		var
471	475		MiLetra:char;
472	476		begin
473	477		If Length(MiCadena)>2 then
474	478		//paréntesis necesarios
475	479		MiLetra:= (MiCadena)[3];
476	480		//Más código......
477	481		end;
478	482		```
479	483
480	484		##### Hay que convertir los punteros al tipo real que espera la función con que se utiliza
481	485
482	486
483	487		En Delphi se puede tener un puntero nulo representando a un objeto. Aunque puede parecer extraño, es corriente que se de especialmente en paquetes de muchos componentes, cómo forma de evitar referencias circulares entre objetos de unidades distintas. En Delphi es posible pasar el puntero nulo a una función que espera un objeto de ese tipo, sin realizar la conversión al tipo real, en FPC hay que realizar la conversión de forma explícita. Por ejemplo:
484	488
	489	+	```
	490	+	cellpadding="2" cellspacing="2">
	491	+	```
	492	+
485	493		Delphi / ObjFPC
486	494
487	495		``` pascal
488	496		Unit Unidad1
489	497		Type TUnObjeto=class(TComponent)
490	498		//Más código...
491	499		End;
492	500		Procedure HacerAlgo(Value: TSomeObject);
493	501		Function GetUnObjeto: TUnObjeto;
494	502
495	503		Unit Unidad2
496	504		Type TUnComponente=class(TComponent)
497	505		//Más código...
498	506		Published UnObjeto: Pointer;
499	507		//Más código...
500	508		End;
501	509		```
502	510
503	511		Delphi
504	512
505	513		OBJFPC
506	514
507	515		-- Aplicación ----------
508	516
509	517		``` pascal
510	518		var
511	519		MiComponente: TUnComponente;
512	520		begin
513	521		MiComponente.UnObjeto:=GetUnObjeto
514	522		//Más código...
515	523		HacerAlgo(MiComponente.UnObjeto);
516	524		end;
517	525		```
518	526
519	527		-- Aplicación ----------
520	528
521	529		``` pascal
522	530		var
523	531		MiComponente: TUnComponente;
524	532		begin
525	533		MiComponente.UnObjeto:=Pointer(GetUnObjeto);
526	534		//Más código...
527	535		HacerAlgo(TUnObjeto(MiComponente.UnObjeto));
528	536		end;
529	537		```
530	538
531	539		#### Recursos
532	540
533	541
534	542		Los recursos (iconos, imágenes, cursores, etc.) Delphi son específicos de win32 y no son compatibles con Lazarus, hay que rehacerlos y compilarlos con la utilidad lazres, que se puede encontrar en el directorio dir_de_lazarus/tools. Deberás compilar tú mismo esta utilidad.
535	543
536	544		:linux y nix
537	545
538		-	~~` cd dir_de_lazarus/lazarus/tools`\~~
539		-	~~` make install`~~
	546	+	```
	547	+	cd dir_de_lazarus/lazarus/tools
	548	+	make install
	549	+	```
540	550
541	551		:*windows
542	552
543	553		:** Abrir una consola con CMD y escribir lo siguiente:
544	554
545		-	~~` cd dir_de_lazarus\tools`\~~
546		-	~~` dir_de_lazarus\fpc\2.2.0\bin\i386-win32\make install`~~
	555	+	```
	556	+	cd dir_de_lazarus\tools
	557	+	dir_de_lazarus\fpc\2.2.0\bin\i386-win32\make install
	558	+	```
547	559
548	560
549	561		(nota del traductor: esto en realidad construye todas las utilidades que hay en tools)
550	562
551	563
552	564		Para añadir rucursos a tu aplicación:
553	565
554	566		- lazres mirecurso.lrs mi_dibujo.xpm otro_dibujo.xpm.
555	567		- Añade la unidad LResources en ls cláusula Uses de la unidad.
556	568		- Incluye la referencia al archivo .lrs creado dentro de bloque de iniciación.
557	569
558	570		Ejemplo:
559	571
560	572		``` pascal
561	573		Unit Unidad1
562	574		function TForm1.LoadGlyph(const NombreGrafico: String): TBitMap;
563	575		begin
564	576		Result:= TPixmap.Create; //¿no debería ser Result:= TBitMap.Create;?
565	577		Result.LoadFromLazarusResource(NombreGrafico);
566	578		end;
567	579		//Más código...
568	580		begin
569	581		BotonRapido.glyph:= LoadGlyph('mi_dibujo');
570	582		//Más código...
571	583		end;
572	584
573	585		initialization
574	586		{$I Unidad1.lrs}
575	587		{$I mirecurso.lrs}
576	588		end.
577	589		```
578	590
579	591
580	592		Desde la versión 2.2 del FPC, incluso los ejecutables ELF de Linux admiten recursos binarios, por lo que lo que se pueden utilizar los típicos recursos .res que se utilizan en Delphi
581	593
582	594		Ejemplo:
583	595
584	596		``` pascal
585	597		//hasta aquí todo igual
586	598
587	599		initialization
588	600		{$I Unidad1.lrs}
589	601		{$R mirecurso.res}
590	602		end.
591	603		```
592	604
593	605		### Otro método para convertir proyectos Delphi o Kylix a Lazarus
594	606
595	607		- Renombra o copia todos los archivos .dfm o .xfm como .lfm. Las primeras versiones (hasta la 3 por lo menos) de Delphi no generaban los archivos .dfm como texto. Si este es el caso habrá que usar previamente la utilidad de conversión del IDE del menú Herramientas-\>Convertir archivo DFM a LFM...
596	608		- Renombra o copia el archivo .dpr como .lpr.
597	609		- Haz los cambios necesarios al archivo .lpr:
598	610
599	611		:# Añade las directivas {\$mode delphi}{\$H+} o {\$mode objfpc}{H+}
600	612
601	613		:# Añade la unidad Interfaces a la clausula uses
602	614
603	615		:# Comenta o borra la directiva {\$R .res}* (esto no es necesario a partir de la versión 2.2 del FPC)
604	616
605	617		- Haz los cambios necesarios a todas la unidades .pas:
606	618
607	619		:# Añade las directivas {\$mode delphi}{\$H+} o {\$mode objfpc}{H+}
608	620
609	621		:# Añade la unidad LResources, y si el formulario tiene botones la unidad Buttons a la clausula uses
610	622
611	623		:# Comenta o borra las directivas {\$R .dfm}* o {\$R .xfm}*
612	624
613	625		:# Añade la sección Initialization al final de cada unidad, y añade una directiva {\$I unitname.lrs} en su interior.
614	626
615	627		- Crea un nuevo proyecto: Proyecto -\> Nuevo proyecto desde archivo...
616	628		- Selecciona el archivo .lpr que acabas de preparar
617	629		- En la ventana Crear un proyecto nuevo selecciona Aplicación
618	630		- Construye el proyecto y efectúa las correcciones necesarias para que compile correctamente, en este punto el archivo .lpi se crea automáticamente. Si aparecen errores de Error leyendo formulario dale al botón Continuar cargando
619	631		- Guárdalo todo, y ya tienes un proyecto Lazarus :-)
620	632
621	633		## Obtener ayuda
622	634
623	635		Si encuentras un problema durante la conversión que no puedes resolver, hay una gran variedad de lugares donde obtener ayuda.
624	636
625	637		### Documentación
626	638
627	639		Sobre Object Pascal y FPC
628	640
629	641		El mejor sitio para empezar es [la Documentación de Free Pascal](http://www.freepascal.org/docs-html/) de Michaël Van Canneyt y Florian Klämpfl.
630	642
631	643		Para cuestiones más enfocadas en Lazarus
632	644
633	645		El proyecto de documentación de Lazarus [[Main Page\|Base de conocimientos Lazarus-CCR]] es el siguiente sitio donde buscar.
634	646
635	647		### Soporte directo
636	648
637	649		Lista de correo
638	650
639	651		Puedes enviar cuestiones a la [lista de correo de Free Pascal Compiler](http://www.freepascal.org/maillist.html) o en los [FPC foros](http://community.freepascal.org:10000/bboard/), a los que un montón de espertos están suscritos.
640	652
641	653		Si tienes acceso a IRC:
642	654
643	655		On irc.freenode.net: [\#fpc](irc://irc.freenode.net/fpc) para FPC, o [\#lazarus-ide](irc://irc.freenode.net/lazarus-ide) para Lazarus
644	656
645	657		### Bases de conocimientos
646	658
647	659		Hay algunas bases de conocimientos y buscadores en línea que también pueden ser de gran ayuda para aprender nuevas técnicas y encontrar soluciones a problemas:
648	660
649	661		- Tamarack Associates opera un rápido \[ <http://codenewsfast.com/> buscador\] específico para los archivos usenet de Borland.
650	662		- Mer Systems Inc. provee un [motor de búsqueda](http://www.mers.com/searchsite.html) similar .
651	663		- Otra fuente de información, junto con un amplio y [capaz buscador](http://www.efg2.com/Lab/search.htm) es Earl F. Glynn's Computer Lab y el [Archivo de referencia](http://www.efg2.com/).
652	664
653	665		## Empaquetando y distribuyendo componentes
654	666
655	667		### Creando un paquete Larazus para tu(s) componente(s)
656	668
657	669		Crear un paquete hace que instalar el código convertido sea un proceso más fácil... especialmente si se está facilitando más de un componente. Mattias Gärtner ha escrito una descripción general sobre [[Lazarus Packages\|paquetes Lazarus]] que deben leerse antes de comenzar este proceso.
658	670
659	671		### Documentación
660	672
661	673		El propósito de este sitio y el formato wiki es hacer de la generación de documentación profesional un proceso fácil y rápido. El wiki también permite ver inmediatamente los resultados de lo publicación y hacer modificaciones al instante.
662	674
663	675		Usar el Lazarus-CCR wiki para crear documentación bien presentada es muy fácil. Si nunca has utilizado antes las marcas wiki, puede familiarizarse con ellas en el [[Sand Box\|área de práctica]].
664	676
665	677		### Creando una página de lanzamiento de código
666	678
667	679		La página de lanzamiento de código contiene la información importante sobre sus componentes que un potencial usuario debe conocer, cómo la licencia, plataformas de destino, estado (alfa, beta, estable...), dónde está para descargarlo, quién lo ha escrito, si hay soporte... etc.
668	680
669	681		El siguiente procedimiento permite crear el código de una página de lanzamiento de código con su navegador:
670	682
671	683		- Acceda a [[Release new component\|lanzamiento de nuevos componentes]]
672	684		- Escriba el nobre de su paquete o componente el la caja de texto y pulsa en Create Article
673	685		- Cumplimenta la plantilla que aparecerá y guárdala.
674	686		- Edita la página [[Components and Code examples\|Componentes y código de ejemplo]] y añade el enlace a la nueva página creada en la sección de Componentes liberados (Released Components). Guarda la página modificada.
675	687
676	688		### Envío del componente
677	689
678	690		Si eres el responsable de lanzamiento de tu proyecto, pon el proyecto en el sistema de liberación de archivos de SourceForge y añádelo a la lista de paquetes liberados. En otro caso envíalo a uno de los administradores del proyecto (Tom Lisjac o Vincent Snijders) para que lo añadan al repositorio. Antes de subir a SourceForge, hay que crear la Página de lanzamiento de código para describir el componente. Se puede utilizar la página [[Release new component\|lanzamiento de nuevos componentes]], para comenzar a crear la página.
679	691
680	692		Si crees que será necesario para continuar desarrollando el componente, también puedes poner el código en SVN para seguir teniendo acceso al mismo. Si te cansas de enviar sus parches, le daremos acceso de escritura al CVS, para que puedas hacer las modificaciones tú mismo. Para detalles ver [[Using the Lazarus-ccr SVN repository\|Usando el repositorio SVN de Lazarus-ccr]].
681	693
682	694		## Contribuciones y cambios
683	695
684	696		Esta página ha sido convertida desde la [versión epikwiki](http://lazarus-ccr.sourceforge.net/index.php?wiki=CodeConversionGuide).
685	697
686	698		- Versión incial por Tom Lisjac y Mattias Gärtner - 9/22/2003 VlxAdmin
687	699		- Movido Cómo conseguir ayuda de la página principal. T. Lisjac - 9/24/2003 VlxAdmin
688	700		- Añadida platillas de documentos, procedimientos y enlaces. 9/25/2003 VlxAdmin
689	701		- LCLLinux renombrada como LCLIntf, Jesus Reyes, 9/27/2003
690	702		- Añadida más información en los cambios de Unidad, [AndrewJohnson](http://lazarus-ccr.sourceforge.net/index.php?wiki=AndrewJohnson) 9/27/2003
691	703		- Actualizadas las diferencias de sintaxis, incluyendo ejemplos, [AndrewJohnson](http://lazarus-ccr.sourceforge.net/index.php?wiki=AndrewJohnson) 9/27/2003
692	704		- FPC 1.0.x no soporta interfaces, Vincent Snijders 9/28/2003
693	705		- Nuevos ejemplos para la nueva definición de WikiWord, 9/28/2003 VlxAdmin
694	706		- Mayor consistencia del Código para eliminar definiciones accidentales WikiWord, [AndrewJohnson](http://lazarus-ccr.sourceforge.net/index.php?wiki=AndrewJohnson) 9/27/2003
695	707		- Utilización de tablas para los ejemplos de código y así mejorar la visualización al confrontar las diferencias entre Delphi y FPC, [AndrewJohnson](http://lazarus-ccr.sourceforge.net/index.php?wiki=AndrewJohnson) 10/17/2003
696	708		- Utilización de estilo pascal para hacer los ejemplos más legibles, [AndrewJohnson](http://lazarus-ccr.sourceforge.net/index.php?wiki=AndrewJohnson) 10/18/2003
697	709		- Adición de la sección 'Otro método para convertir proyectos Delphi o Kylix a Lazarus', George Lober, 2/17/2006
698	710		- Versión en castellano (español) iskraelectrica (jldc) / mayo de 2008.
699	711
700	712		---
701	713		From the Free Pascal wiki, page "Code Conversion Guide/es", as it stood on 2020-02-10 after a change by Trev, 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