Code Conversion Guide/es: what changed

Revision 3 to 4. 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		-	~~```~~
	141	+	```text
142	142		http://wiki.lazarus.freepascal.org/Delphi_Converter_in_Lazarus
143	143		```
144	144
145	145		El siguiente texto explica las diferencias entre Delphi y Lazarus y cómo convertir manualmente.
146	146
147	147		Cambia el nombre o copia el archivo .dpr a un .lpr. Comenta o elimina la directiva
148	148
149	149		{\$R *.res}
150	150
151	151		y añade la directiva
152	152
153	153		{\$mode delphi}{\$H+}
154	154
155	155		o bien esta otra
156	156
157	157		{\$mode objfpc}{\$H+}
158	158
159	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.
160	160
161	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.
162	162
163	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:
164	164
165	165		1. poner en minúsculas los nombre de archivo de inclusiones y de la sección uses.
166	166		2. convierte el .dfm a .lfm (normalmente sin comprobar el contenido, únicamente el formato)
167	167		3. crea un .lrs vacío (el contenido se creará después)
168	168		4. añade la directiva
169	169		{\$mode delphi}
170	170		5. sustituye la referencia a la unidad windows por LCLIntf
171	171		6. añade la unidad LResources si es preciso (si se usa .lrs se pondrá
172	172		uses LResources
173	173
174	174		en la sección de implementación)
175	175		7. elimina las unidades variants
176	176		8. elimina la directiva
177	177		{\$R *.dfm}
178	178		9. crea la sección de iniciación y añade en ella la directiva
179	179		{\$i unit.lrs}
180	180
181	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)
182	182
183	183		#### Seleccionar el modo correcto de compilación
184	184
185	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:
186	186
187	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.
188	188
189	189		Muchas unidades DELPHI compilan con FPC añadiendo a las mismas
190	190
191		-	~~```~~
	191	+	```text
192	192		{$IFDEF FPC}
193	193		{$MODE DELPHI}
194	194		{$ENDIF}
195	195		```
196	196
197	197		inmediatamente a continuación del nombre de la unidad.
198	198
199	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)
200	200
201	201		#### Consideraciones sobre codificación para Multiplataforma
202	202
203	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.
204	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.
205	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.
206	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.
207	207
208	208		#### Variables, "defines" y macros útiles del compilador
209	209
210	210		Para escribir código que se adapte, y se comporte de forma distinta según el sistema, se utiliza la directiva
211	211
212	212		{\$IFDEF identificador}.
213	213
214	214		- {\$IFDEF FPC}
215	215
216	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}.
217	217
218	218		- {\$IFDEF LCL}
219	219
220	220		Esta se define para utilizar el paquete LCL. Es útil para escribir código que funcione con LCL y Delphi.
221	221
222	222		- {\$IFDEF LCLGtk}
223	223
224	224		,
225	225
226	226		{\$IFDEF LCLWin32}
227	227
228	228		,
229	229
230	230		{\$IFDEF LCLQt}
231	231
232	232		, ...
233	233
234	234		Esta varible se define para utilizar el LCL en una determinada plataforma, usando los componentes visuales (widgetset).
235	235
236	236		- {\$IFDEF Unix} // para Linux, BSD, Mac OS X, Solaris
237	237
238	238		,
239	239
240	240		{\$IFDEF Win32}
241	241
242	242		,
243	243
244	244		{\$IFDEF Linux}
245	245
246	246		// para Linux,
247	247
248	248		{\$IFDEF Darwin}
249	249
250	250		// para OS X,
251	251
252	252		{\$IFDEF WinCE}
253	253
254	254		// para WinCE,...
255	255
256	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:
257	257
258	258		``` pascal
259	259		{$IFDEF Linux}
260	260		{$DEFINES Unix}
261	261		{$ENDIF}
262	262		```
263	263
264	264		para que funcione en Kilix.
265	265
266	266		- {\$IFDEF ENDIAN_BIG}
267	267
268	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.
269	269
270	270		- {\$IFDEF ENDIAN_BIG}
271	271
272	272		Para más detalles ver [Documentación de FPC](http://www.freepascal.org/docs-html/prog/prog.html#QQ2-23-21).
273	273
274	274		#### Soporte para 32bit / 64 bit
275	275
276	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:
277	277
278	278		``` pascal
279	279		{$IFNDEF FPC}
280	280		type
281	281		PtrInt = integer;
282	282		PtrUInt = cardinal;
283	283		{$ENDIF}
284	284		```
285	285
286	286		Sustituya todas las ocurrencias de integer(SomePointerOrObject) por PtrInt(SomePointerOrObject).
287	287
288	288		Para más información ver Guía de programación para multiples plataformas [[Multiplatform Programming Guide]]
289	289
290	290		#### Buscando un identificador perdido
291	291
292	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.
293	293
294	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):
295	295
296	296		``` bash
297	297		grep -in ' tbutton =' lcl/*
298	298		```
299	299
300	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)
301	301
302	302		#### Diferencias mayores entre las unidades de Lazarus y las de Delphi
303	303
304	304		¡Por favor, añada lo que sepa sobre este tema!
305	305
306	306		- Windows -\> Interfaces, LCLIntf, LCLType, LCLProc, VCLGlobals, ...)
307	307
308	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).
309	309
310	310		- Messages -\> LMessages
311	311
312	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.
313	313
314	314		- Graphics, Controls -\> GraphType, GraphMath, Graphics, Controls
315	315
316	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 ...
317	317
318	318		- Mask -\> MaskEdit
319	319
320	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.
321	321
322	322		- StdCtrls-\>StdCtrls,Buttons
323	323
324	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.
325	325
326	326		#### Diferencias entre Delphi y FPC/LCL sobre propiedades y métodos
327	327
328	328		- EL TBitmap de la LCL tiene una propiedad lienzo (canvas)
329	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]]
330	330
331	331		#### Diferencias semánticas
332	332
333	333		##### Orden de evaluación de los parámetros
334	334
335	335
336	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.
337	337
338	338		##### Procedimientos y funciones anidadas como variables de procedimiento
339	339
340	340
341	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.
342	342
343	343
344	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.
345	345
346	346
347	347		En resumen, no llames a procedimientos anidados a través de variables de procedimiento.
348	348
349	349		#### Diferencias de sintaxis
350	350
351	351		##### ¡Por favor, añada lo que sepa sobre este tema!
352	352
353	353
354	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:
355	355
356	356		##### Al asignar una función de manejo de un evento, antepon un "@" a su nombre
357	357
358	358
359	359		Por ejemplo, se puede asignar la llamada a un botón manualmente
360	360
361	361		Delphi
362	362
363	363		OBJFPC
364	364
365	365		``` pascal
366	366		begin
367	367		if not Assigned(MiBoton.OnClick) then
368	368		MiBoton.OnClick:= UnaFuncion;
369	369		//@ no necesario
370	370		//más código...
371	371		end;
372	372		```
373	373
374	374		``` pascal
375	375		begin
376	376		if not Assigned(MiBoton.OnClick) then
377	377		MiBoton.OnClick:= @UnaFuncion;
378	378		//@ Es necesario
379	379		//más código...
380	380		end;
381	381		```
382	382
383	383		##### Al llamar a una variable procedural usar esta sintaxis: ProcNombre()
384	384
385	385
386	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:
387	387
388	388		Delphi
389	389
390	390		OBJFPC
391	391
392	392		``` pascal
393	393		With (UnObjeto) do
394	394		begin
395	395		If Assigned(OnMiLlamada) then
396	396		OnMiLlamada;
397	397		//paréntesis no necesarios
398	398		end;
399	399		```
400	400
401	401		``` pascal
402	402		With (UnObjeto) do
403	403		begin
404	404		If Assigned(OnMiLlamada) then
405	405		OnMiLlamada();
406	406		//los paréntesis son necesarios
407	407		end;
408	408		```
409	409
410	410		##### Al obtener los valores de un puntero a registro hay que deshacer antes la referencia
411	411
412	412
413	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,
414	414
415	415		Delphi
416	416
417	417		OBJFPC
418	418
419	419		``` pascal
420	420		Function DameValores(UnRegistro: PMiRegistro):Integer;
421	421		begin
422	422		If Assigned(UnRegistro) then
423	423		Result:=UnRegistro.UnValor
424	424		else
425	425		Result:=0;
426	426		end;
427	427		```
428	428
429	429		``` pascal
430	430		Function DameValores(UnRegistro: PMiRegistro):Integer;
431	431		begin
432	432		If Assigned(UnRegistro) then
433	433		Result:=UnRegistro^.UnValor
434	434		else
435	435		Result:=0;
436	436		end;
437	437		```
438	438
439	439		##### Para acceder a caracteres de la cadena que es una propiedad de un objeto, esta debe ser encerrada entre paréntesis
440	440
441	441
442	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,
443	443
444	444		Delphi
445	445
446	446		OBJFPC
447	447
448	448		``` pascal
449	449		Type TUnComponente=class(TComponent)
450	450		//Más código......
451	451		Published
452	452		Property MiCadena:String index 3 read GetMiCadena;
453	453		//Más código....
454	454		End;
455	455
456	456		var
457	457		MiLetra:char;
458	458		begin
459	459		If Length(MiCadena)>2 then
460	460		//paréntesis no necesarios
461	461		MiLetra:= MiCadena[3];
462	462		//Más código......
463	463		end;
464	464		```
465	465
466	466		``` pascal
467	467		Type TUnComponente=class(TComponent)
468	468		//Más código...
469	469		Published
470	470		Property MiCadena:String index 3 read GetMiCadena;
471	471		//Más código...
472	472		End;
473	473
474	474		var
475	475		MiLetra:char;
476	476		begin
477	477		If Length(MiCadena)>2 then
478	478		//paréntesis necesarios
479	479		MiLetra:= (MiCadena)[3];
480	480		//Más código......
481	481		end;
482	482		```
483	483
484	484		##### Hay que convertir los punteros al tipo real que espera la función con que se utiliza
485	485
486	486
487	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:
488	488
489		-	~~```~~
	489	+	```text
490	490		cellpadding="2" cellspacing="2">
491	491		```
492	492
493	493		Delphi / ObjFPC
494	494
495	495		``` pascal
496	496		Unit Unidad1
497	497		Type TUnObjeto=class(TComponent)
498	498		//Más código...
499	499		End;
500	500		Procedure HacerAlgo(Value: TSomeObject);
501	501		Function GetUnObjeto: TUnObjeto;
502	502
503	503		Unit Unidad2
504	504		Type TUnComponente=class(TComponent)
505	505		//Más código...
506	506		Published UnObjeto: Pointer;
507	507		//Más código...
508	508		End;
509	509		```
510	510
511	511		Delphi
512	512
513	513		OBJFPC
514	514
515	515		-- Aplicación ----------
516	516
517	517		``` pascal
518	518		var
519	519		MiComponente: TUnComponente;
520	520		begin
521	521		MiComponente.UnObjeto:=GetUnObjeto
522	522		//Más código...
523	523		HacerAlgo(MiComponente.UnObjeto);
524	524		end;
525	525		```
526	526
527	527		-- Aplicación ----------
528	528
529	529		``` pascal
530	530		var
531	531		MiComponente: TUnComponente;
532	532		begin
533	533		MiComponente.UnObjeto:=Pointer(GetUnObjeto);
534	534		//Más código...
535	535		HacerAlgo(TUnObjeto(MiComponente.UnObjeto));
536	536		end;
537	537		```
538	538
539	539		#### Recursos
540	540
541	541
542	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.
543	543
544	544		:linux y nix
545	545
546		-	~~```~~
	546	+	```text
547	547		cd dir_de_lazarus/lazarus/tools
548	548		make install
549	549		```
550	550
551	551		:*windows
552	552
553	553		:** Abrir una consola con CMD y escribir lo siguiente:
554	554
555		-	~~```~~
	555	+	```text
556	556		cd dir_de_lazarus\tools
557	557		dir_de_lazarus\fpc\2.2.0\bin\i386-win32\make install
558	558		```
559	559
560	560
561	561		(nota del traductor: esto en realidad construye todas las utilidades que hay en tools)
562	562
563	563
564	564		Para añadir rucursos a tu aplicación:
565	565
566	566		- lazres mirecurso.lrs mi_dibujo.xpm otro_dibujo.xpm.
567	567		- Añade la unidad LResources en ls cláusula Uses de la unidad.
568	568		- Incluye la referencia al archivo .lrs creado dentro de bloque de iniciación.
569	569
570	570		Ejemplo:
571	571
572	572		``` pascal
573	573		Unit Unidad1
574	574		function TForm1.LoadGlyph(const NombreGrafico: String): TBitMap;
575	575		begin
576	576		Result:= TPixmap.Create; //¿no debería ser Result:= TBitMap.Create;?
577	577		Result.LoadFromLazarusResource(NombreGrafico);
578	578		end;
579	579		//Más código...
580	580		begin
581	581		BotonRapido.glyph:= LoadGlyph('mi_dibujo');
582	582		//Más código...
583	583		end;
584	584
585	585		initialization
586	586		{$I Unidad1.lrs}
587	587		{$I mirecurso.lrs}
588	588		end.
589	589		```
590	590
591	591
592	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
593	593
594	594		Ejemplo:
595	595
596	596		``` pascal
597	597		//hasta aquí todo igual
598	598
599	599		initialization
600	600		{$I Unidad1.lrs}
601	601		{$R mirecurso.res}
602	602		end.
603	603		```
604	604
605	605		### Otro método para convertir proyectos Delphi o Kylix a Lazarus
606	606
607	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...
608	608		- Renombra o copia el archivo .dpr como .lpr.
609	609		- Haz los cambios necesarios al archivo .lpr:
610	610
611	611		:# Añade las directivas {\$mode delphi}{\$H+} o {\$mode objfpc}{H+}
612	612
613	613		:# Añade la unidad Interfaces a la clausula uses
614	614
615	615		:# Comenta o borra la directiva {\$R .res}* (esto no es necesario a partir de la versión 2.2 del FPC)
616	616
617	617		- Haz los cambios necesarios a todas la unidades .pas:
618	618
619	619		:# Añade las directivas {\$mode delphi}{\$H+} o {\$mode objfpc}{H+}
620	620
621	621		:# Añade la unidad LResources, y si el formulario tiene botones la unidad Buttons a la clausula uses
622	622
623	623		:# Comenta o borra las directivas {\$R .dfm}* o {\$R .xfm}*
624	624
625	625		:# Añade la sección Initialization al final de cada unidad, y añade una directiva {\$I unitname.lrs} en su interior.
626	626
627	627		- Crea un nuevo proyecto: Proyecto -\> Nuevo proyecto desde archivo...
628	628		- Selecciona el archivo .lpr que acabas de preparar
629	629		- En la ventana Crear un proyecto nuevo selecciona Aplicación
630	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
631	631		- Guárdalo todo, y ya tienes un proyecto Lazarus :-)
632	632
633	633		## Obtener ayuda
634	634
635	635		Si encuentras un problema durante la conversión que no puedes resolver, hay una gran variedad de lugares donde obtener ayuda.
636	636
637	637		### Documentación
638	638
639	639		Sobre Object Pascal y FPC
640	640
641	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.
642	642
643	643		Para cuestiones más enfocadas en Lazarus
644	644
645	645		El proyecto de documentación de Lazarus [[Main Page\|Base de conocimientos Lazarus-CCR]] es el siguiente sitio donde buscar.
646	646
647	647		### Soporte directo
648	648
649	649		Lista de correo
650	650
651	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.
652	652
653	653		Si tienes acceso a IRC:
654	654
655	655		On irc.freenode.net: [\#fpc](irc://irc.freenode.net/fpc) para FPC, o [\#lazarus-ide](irc://irc.freenode.net/lazarus-ide) para Lazarus
656	656
657	657		### Bases de conocimientos
658	658
659	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:
660	660
661	661		- Tamarack Associates opera un rápido \[ <http://codenewsfast.com/> buscador\] específico para los archivos usenet de Borland.
662	662		- Mer Systems Inc. provee un [motor de búsqueda](http://www.mers.com/searchsite.html) similar .
663	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/).
664	664
665	665		## Empaquetando y distribuyendo componentes
666	666
667	667		### Creando un paquete Larazus para tu(s) componente(s)
668	668
669	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.
670	670
671	671		### Documentación
672	672
673	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.
674	674
675	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]].
676	676
677	677		### Creando una página de lanzamiento de código
678	678
679	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.
680	680
681	681		El siguiente procedimiento permite crear el código de una página de lanzamiento de código con su navegador:
682	682
683	683		- Acceda a [[Release new component\|lanzamiento de nuevos componentes]]
684	684		- Escriba el nobre de su paquete o componente el la caja de texto y pulsa en Create Article
685	685		- Cumplimenta la plantilla que aparecerá y guárdala.
686	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.
687	687
688	688		### Envío del componente
689	689
690	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.
691	691
692	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]].
693	693
694	694		## Contribuciones y cambios
695	695
696	696		Esta página ha sido convertida desde la [versión epikwiki](http://lazarus-ccr.sourceforge.net/index.php?wiki=CodeConversionGuide).
697	697
698	698		- Versión incial por Tom Lisjac y Mattias Gärtner - 9/22/2003 VlxAdmin
699	699		- Movido Cómo conseguir ayuda de la página principal. T. Lisjac - 9/24/2003 VlxAdmin
700	700		- Añadida platillas de documentos, procedimientos y enlaces. 9/25/2003 VlxAdmin
701	701		- LCLLinux renombrada como LCLIntf, Jesus Reyes, 9/27/2003
702	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
703	703		- Actualizadas las diferencias de sintaxis, incluyendo ejemplos, [AndrewJohnson](http://lazarus-ccr.sourceforge.net/index.php?wiki=AndrewJohnson) 9/27/2003
704	704		- FPC 1.0.x no soporta interfaces, Vincent Snijders 9/28/2003
705	705		- Nuevos ejemplos para la nueva definición de WikiWord, 9/28/2003 VlxAdmin
706	706		- Mayor consistencia del Código para eliminar definiciones accidentales WikiWord, [AndrewJohnson](http://lazarus-ccr.sourceforge.net/index.php?wiki=AndrewJohnson) 9/27/2003
707	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
708	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
709	709		- Adición de la sección 'Otro método para convertir proyectos Delphi o Kylix a Lazarus', George Lober, 2/17/2006
710	710		- Versión en castellano (español) iskraelectrica (jldc) / mayo de 2008.
711	711
712	712		---
713	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