Boletín Kylix #2
INDICE
1. UNAS PALABRAS DEL EDITOR
2. FREE PASCAL Y LAZARUS
3. INTRODUCCION AL OBJECT PASCAL DE BORLAND (I)
4. CUESTIONES DE PORTABILIDAD: ENSAMBLADOR EN DELPHI
5. ENLACES
6. BIBLIOGRAFIA
7. ¿QUE SIGUE?
________________________________________________________________________
1. UNAS PALABRAS DEL EDITOR
Hace un par de semanas tuvimos un gran éxito cuando comenzamos nuestro
Kylix Newsletter, pero mantenerlo y seguir creciendo en contenido
necesitamos su apoyo para hacerlo crecer en audiencia. Este boletín está
protegido por la propiedad intelectual, pero por favor siéntase libre de
reenviarlo a amigos, conocidos y colegas que pueden estar interesados en
esta publicación, siempre y cuando lo haga en forma completa y sin
modificaciones.
La semana pasada repetimos el éxito con el lanzamiento anticipado de la
primera edición de nuestro Delphi Newsletter, dos semanas antes de lo
planeado!
Nos han sugerido unir los boletines de Kylix y Delphi en un Pascal
Newsletter más grande y genérico que abarque también Free Pascal, Lazarus
y otros proyectos. Creemos que esta propuesta puede ser de interés para
nuestros suscriptores así que la estamos considerando y apreciaríamos
mucho conocer sus opiniones acerca de ello.
Sus contribuciones, comentarios, críticas y preguntas son bienvenidas.
¡Manténgase en contacto!
Atentamente,
Ernesto De Spirito
eds2004 @ latiumsoftware.com
________________________________________________________________________
JfControls Lib. Multilenguaje. Multiapariencia. Skins. Privilegios. Más
de 40 componentes integrados y personalizables. Múltiples problemas de
programación resueltos. Administración centralizada de recursos. Para
Delphi 3-6 y C++ Builder 3-5. http://www.jfactivesoft.com/spindex.htm
________________________________________________________________________
2. FREE PASCAL Y LAZARUS
FREE PASCAL
-----------
Free Pascal (antes llamado FPK-Pascal) es un compilador Pascal open
source de 32 bits compatible con Borland, que se distribuye bajo una
versión modificada de la GNU General Public License.
Free Pascal se encuentra en desarrollo y actualmente sólo hay versiones
de evaluación disponible, pero parecen estar funcionando bien. Las
últimas ediciones son la 0.99.14 (1.0 beta 4) para el chip Intel y la
0.99.5d para el procesador Motorola, y también hay una versión de
desarrollo disponible, así como "instantáneas" de desarrollo publicadas
diariamente. Con suerte la versión 1.0 vería la luz este año.
El compilador mismo está escrito en Pascal y es capaz de compilar sus
propios fuentes (que -a propósito- con sus tan solo 4 Mb son sorpresiva-
mente pequeños), y posee los siguientes requerimientos mínimos:
- Procesador Intel 80386 25 Mhz o Motorola 68020. Se está trabajando
para portarlo al chip Alpha.
- Sistema operativo Linux, DOS, Atari, AmigaOS, OS/2 o Win32. Se está
trabajando para portarlo a otras plataformas (como FreeBSD).
- 2 Mb RAM (16+ Mb recomendados para reconstruir el compilador) para la
versión DOS, y 8 Mb RAM para la versión Linux.
Además del compilador, hay otras herramientas disponibles:
* Herramientas de línea de órdenes (como un formateador de código
fuente, un generador de ficheros make, un traductor de ficheros
cabecera de C y un listador de dependencias de unidades).
* La FCL (Free Component Library - biblioteca gratis de componentes),
que es la alternativa portable y gratuita a parte de la VCL (Visual
Component Library) de Delphi. Se trata de una biblioteca de bajo nivel
(no incluye componentes GUI) pensada para proveer a quienes imple-
menten una GUI (Graphics User Interface - Interfaz Gráfica de Usuario)
con rutinas básicas como listas de cadenas, corrientes, rutinas XML,
acceso a bases de datos y muchas cosas más.
Pretende proveer tantos componentes compatibles con Delphi como sea
posible, para facilitar la portación, pero también presenta componentes
alternativos que ofrecen funcionalidad diferente, no encontrada en los
componentes de Delphi.
* Paquetes: principalmente unidades de importación para bibliotecas
importantes, o algunas herramientas desarrolladas por el equipo Free
Pascal. Hay muchos de esos paquetes que van desde paquetes GUI (como
ser GTK y OpenGL) hasta paquetes de bases de datos (como por ejemplo
Interbase y MySQL).
* El IDE está en una etapa temprana de beta, pero hay IDEs provistos por
terceros como el Bloodshed Dev-Pas.
* Documentación. ¡Es excelente!
La sintaxis del lenguaje es compatible con Borland Turbo Pascal 7.0 y
también soporta algunas extensiones usadas por Delphi 2 y 3 como clases,
RTTI (Run-Time Type Information - Información de Tipos en Tiempo de
Ejecución), excepciones y cadenas ANSI, así como sobrecarga de funciones
y otras características como esas, aunque la compatibilidad total con
Delphi 4 aún no se ha logrado.
El sitio oficial es http://www.freepascal.org y hay muchos otros espejos
(cuidado que no todos están actualizados). Entre otras cosas, allí
encontrará más información acerca de Free Pascal, una comparación entre
Free Pascal y GNU Pascal, las últimas noticias, una lista de correo y un
boletín. Y los ficheros para bajar, por supuesto! Muy completo.
LAZARUS
-------
Lazarus es un conjunto de bibliotecas de clases para Free Pascal que
emulan a Delphi. La idea es permitir a los programadores el desarrollo de
aplicaciones tipo Delphi en todas las plataformas donde corre Free Pascal
sin la necesidad de realizar ninguna recodificación para producir
idénticos productos para diferentes plataformas.
Mientras que la FCL (Free Pascal's Free Component Library) está formada
principalmente por componentes no visuales, la LCL (Lazarus Class
Library) se focaliza en clases y componentes que son visuales y son total
y completamente independientes de la API, queriendo esto decir que se
puede enlazar el código generado con el API widget set de su elección
(Windows, GTK+, GNOME o cualquier otro disponible). En el futuro, la LCL
será añadida a la FCL.
El proyecto Lazarus también involucra la creación de un IDE para Free
Pascal, apuntando a convertirse en una herramienta RAD como Delphi, pero
la verdad es que la versión actual es la 0.5, si sabe lo que significa...
El sitio oficial es http://www.lazarus.freepascal.org Este sitio está
bien diseñado y allí encontrará todo: noticias, información, listas de
correo, documentación, descargas, etc., y hasta tienen una tienda de
regalos. ¡Necesito una de esas tazas de café!
CONCLUSION
----------
En mi opinión personal, la combinación Free Pascal + Lazarus es altamente
recomendable para propósitos académicos, debido a que es una alternativa
gratuita a la gran herramienta profesional que es Delphi, y además corre
en varios SOs, incluyendo Linux (que es gratis y lentamente se va
haciendo popular entre el estudiantado) y los requerimientos de hardware
son bastante modestos. También podría llegar a valer el intento si está
interesado en un lenguaje OOP multi-plataforma con una gran biblioteca de
componentes, dado que Free Pascal y Lazarus son apropiados para progra-
mación tanto de sistema como de bases de datos y son gratis, incluso para
usos comerciales (por supuesto que si modifica el compilador o las
unidades de la FCL o de la LCL debe hacer esos cambios públicamente
disponibles bajo la GPL).
No obstante, para ello tendrá que esperar, puesto que aún se encuentran
en etapa de desarrollo. Al proyecto Lazarus aún le falta mucho, pero ya
pueden ir probando el compilador. Para los típicos programas en línea de
órdenes con propósitos educativos es una buena opción. O tal vez le
gustaría probarlo para ir aprendiendo Pascal mientras espera la
aparición de Kylix.
________________________________________________________________________
3. INTRODUCCION AL OBJECT PASCAL DE BORLAND (I)
Este es el primero de dos artículos que pretenden brindarle una intro-
ducción rápida a la sintaxis de Pascal a aquellos programadores que no
están familiarizados con este lenguaje. Este artículo no les enseñará
Pascal y no es tampoco una referencia completa, sino simplemente una
introducción rápida. En este artículo trataremos de cubrir las bases de
Pascal y dejaremos la programación orientada a objetos para la próxima
edición de este newsletter.
Notas generales
---------------
* Pascal usa "begin" y "end" para encerrar sentencias en bloques, en
lugar de llaves ("{}") como C o Java.
* Las llaves ("{}") encierran comentarios. Se pueden usar "(*" y "*)" en
su lugar (¡sin las comillas!). También se puede comentar hasta el final
de la línea con "//" como en C o Java.
* El punto y coma (";") es un separador de sentencias, no un terminador
de las mismas como en C, de modo que es necesario antes de un "end".
* Se puede dividir una sentencia en muchas líneas como en C o Java dado
que el retorno de carro no es un separador (el punto y coma lo es).
* Los comentarios que comienzan con "$" son directivas del compilador.
* Los valores numéricos hexadecimales se preceden por un "$".
* Un "#" precediendo un valor numérico denota un valor de tipo caracter,
siendo ese caracter el correspondiente a ese valor numérico.
* Los caracteres son compatibles en asignación con las cadenas: son
tratados como cadenas de un caracter.
* Las variables no son automáticamente inicializadas.
* Las sentencias de asignación usan ":=", mientras que "=" es un operador
de a comparación (en C y Java, "=" es el operador de asignación e "=="
es el operador de comparación).
* La sintaxis tipo C a := b := c := 0; no se admite.
* Los operadores And, Or y Not tienen una precedencia más alta que los
operadores de comparación, así que las operaciones de comparación se
suelen encerrar entre paréntesis (a menos que use And, Or o Not como
operadores de bits en vez de operadores booleanos).
* Los identificadores no distinguen mayúsculas de minúsculas.
* Las cadenas y los caracteres se delimitan por comillas simples.
Estructura del código fuente de una aplicación
----------------------------------------------
Normalmente una aplicación se compone de un fichero de programa (.dpr) y
muchos ficheros de "unidades" (.pas). Estas unidades son módulos como los
ficheros .c
Un fichero de un programa mínimo comienza con la palabra "program"
seguida del nombre interno del programa, y un bloque begin...end. Por
ejemplo:
program programa1;
begin
WriteLn('Hola mundo!');
end.
WriteLn es un procedimiento que escribe una cadena en el dispositivo
estándar de salida del sistema (normalmente la consola).
Un programa puede declarar constantes, tipos, variables, procedimientos
y funciones. El siguiente programa no haca nada útil, pero sirve como
ejemplo:
program programa2;
const
MIN: integer = 1;
MAX: integer = 20;
type
RangoValores = 1..20;
ArregloValores = array[RangoValores] of integer;
var
Valor: integer;
Valores: ArregloValores;
function EstaEnRango(n: integer): boolean;
begin
if (n >= MIN) and (n <= MAX) then
Result := True
else
EstaEnRango := False;
end;
procedure IngresarValores();
procedure InicializarValores();
var i: RangoValores;
begin
for i := MIN to MAX do Valores[i] := 0;
end;
begin
InicializarValores;
repeat
WriteLn('Ingrese un valor entre 1 y 20 (0 p/salir): ');
ReadLn(valor);
if Valor <> 0 then
if EstaEnRange(Valor) then
Inc(Valores[Valor])
else
WriteLn('Valor inválido. Por favor intente de nuevo');
until Valor = 0;
end;
function MaxValor(): RangoValores;
var
i: RangoValores;
begin
Result := MIN;
for i := MIN + 1 to MAX do
if Valores[i] > Valores[Result] then
Result := i;
end;
begin
IngresarValores;
WriteLn('El valor más ingresado es: ', MaxValor());
end.
La palabra "const" precede la declaración de constantes. En el ejemplo
se declaran dos constantes enteras llamadas "MIN" y "MAX", representando
los valores 1 y 20 respectivamente.
La palabra "type" precede la declaración de tipos definidos por el
usuario. En el ejemplo declaramos un rango de valores enteros y un
arreglo de 20 enteros indexados del 1 al 20.
La palabra "var" precede la declaración de variables. En el ejemplo
declaramos una variable entera y un arreglo (de 20 enteros indexados del
1 al 20).
Las declaraciones de funciones se preceden por la palabra "function". Las
funciones tienen un nombre, parámetros (opcionales) y un tipo de retorno.
Por ejemplo, la función "EstaEnRango" toma un argumento entero y devuelve
un valor booleano. Para devolver un valor, éste debe asignarse a la
variable implícita "Result" o a la variable implícita llamada igual que
la función de modo que "Result := ..." o "EstaEnRango := ..." tienen el
mismo efecto.
La declaración de procedimientos se precede por la palabra "procedure"
en vez de "function", y no tienen tipo de retorno dado que los procedi-
mientos no devuelven valores.
Para llamar un procedimiento o una función, simplemente escriba su nombre
(seguido de los parámetros reales encerrados entre paréntesis si es que
el procedimiento o función toma parámetros). Por ejemplo,
"EstaEnRango(Valor)" llama a la función EstaEnRango pasando la variable
"Valor" como el argumento. "IngresarValores" en el bloque principal llama
al procedimiento IngresarValores. "Inc(Valores[Valor])" (en C o Java se
escribiría Valores[Valor]++ en su lugar) llama al procedimiento incor-
porado que incrementa su argumento. En realidad no se trata de un
procedimiento dado que el compilador generará el código de máquina INC...
Los procedimientos y funciones pueden tener constantes, tipos y variables
locales, así como también otros procedimientos y funciones. Se declaran
igual que sus contrapartes a nivel de programa, excepto que las declara-
ciones se ponen entre la cabecera del procedimiento o función y el
"begin" de su bloque de código. Por ejemplo la función "MaxValor" declara
una variable local "i" y el procedimiento "IngresarValores" declara un
procedimiento local "InicializarValores" que a su vez declara una
variable local "i".
La ventaja de las funciones y procedimientos locales es que pueden
acceder las variables locales y los parámetros de los procedimientos y/o
funciones que los contienen, de modo que no se necesita pasarlos como
argumentos, permitiendo un código más claro y eficiente.
Los procedimientos usados hasta ahora (ReadLn, que lee de la entrada
estándar, WriteLn e Inc) son declarados en la unidad System que es
"incluida" por el compilador por omisión, de modo que no necesitamos
decirle que lo haga. La unidad System contiene muchas constantes, tipos,
variables, procedimientos y funciones útiles, pero hay muchas más
disponibles en otras unidades que vienen con Delphi. Por ejemplo, la
mayoría de los elementos para trabajar con ficheros vienen en la unidad
SysUtils y la mayoría de las API de Windows vienen en la unidad Windows.
Para "incluir" estas unidades en un programa empleamos la cláusula "uses".
Por ejemplo:
program programa3;
uses
SysUtils, Windows;
...
Y por supuesto, podemos crear nuestras propias unidades. Las unidades
comienzan con la palabra "unit" en vez de "program" y tienen cuatro
secciones:
* interface
La sección interfaz contiene todas las declaraciones públicas (es
decir, constantes, tipos, variables, procedimientos y funciones que
estarán disponibles a programas y otras unidades)
* implementation
La sección implementación contiene todas las declaraciones a nivel de
módulo (unidad) y la definición de los procedimientos y funciones
declaradas en la sección de interfaz.
* initialization
Código para inicializar las variables públicas y modulares.
* finalization
Código para liberar recursos asignados por la unidad.
Por ejemplo:
unit Unidad1;
interface
var globalvar: integer;
procedure IncGlobalVar;
implementation
procedure IncGlobalVar;
begin
Inc(globalvar);
end;
initialization
globalvar := 10;
end.
Esta unidad declara una variable pública llamada globalvar y un procedure
público llamado IncGlobalVar. En la sección de implementación este proce-
dimiento es definido y en la sección de inicialización se establece el
valor inicial de la variable. No hay sección de finalización porque no
hay recursos que liberar.
Este programa usa la unidad declarada arriba:
program programa4;
uses
Unidad1 in 'Unidad1.pas';
begin // La unidad se inicializa aquí
WriteLn(globalvar); // 10
IncGlobalVar;
WriteLn(globalvar); // 11
end.
Sentencias de control de flujo
------------------------------
La sentencia "if":
if <condición> then <sentencia>;
if <condición> then
<sentencia1>
else
<sentencia2>;
if <condición> then begin
<sentencia1>;
<sentencia2>;
<sentencia3>[;]
end else
<sentencia4>;
if <condición> then begin
<sentencia1>;
<sentencia2>;
<sentencia3>[;]
end else begin
<sentencia4>;
<sentencia5>[;]
end;
Note que no hay punto y coma antes de un "else". Necesita usar
"begin...end" cuando las sentencias dentro de la estructura son más de
una. <condición> es una expresión boolean (debe evaluarse como True o
False).
La sentencia "case":
case <selector> of
<listacaso1>: <sentencia1>;
...
<listacasoN>: <sentenciaN>;
[else
<sentencia>;]
end;
<selector> debe ser una expresión ordinal (no puede ser una cadena por
ejemplo). Las listas de casos son listas de calores separados por comas.
Listas de casos válidas son por ejemplo:
1:
5..10:
20, 30..40, 50..60, 67:
Cuando se necesita más de una sentencia en un case, se deben encerrar
mediante un bloque begin...end.
La sentencia "for":
for <variable> := <ini> to/downto <fin> do <sentencia>;
Si usa "to" el incremento (o "step") es 1, y si usa "downto", el incre-
mento es -1. Si necesita más sentencias dentro del bucle for debe
encerrarlas en un bloque begin...end. Tenga cuidado: A la salida de un
bucle for, el valor de la variable de control queda indefinido!
La sentencia "while":
while <condición> do <sentencia>;
<condición> es una expresión booleana y si necesita más sentencias dentro
del bucle while, ya sabe: begin...end.
La sentencia "repeat...until":
repeat
<sentencia1>;
<sentencia2>;
...
<sentenciaN>[;]
until <condición>;
Las sentencias se repiten mientras la condición NO es satisfecha. La
condición es evaluada al final, así que las sentencias de adentro se
ejecutan al menos una vez. No se necesita begin...end.
La sentencia "goto":
Su uso se desaconseja en la programación estructurada. Si embargo es útil
para salir de ciclos (bucles). Antes de usar goto, primero debe declarar
una etiqueta y preceder la sentencia donde desea saltar por esa etiqueta
seguida de dos puntos (":"), como en el siguiente ejemplo:
function EstaCaracterEnCadena(char c, string s): boolean;
var i, n: Integer;
label CaracterEncontrado;
begin
n := Length(s);
for i := 1 to n do
if s[i] = c then goto CaracterEncontrado;
Result := False;
Exit; // Sale de un procedimiento o función
CaracterEncontrado:
Result := True;
end;
Nunca usa goto para saltar hacia adentro de un bucle u otra sentencia
estructurada debido a que puede producir efectos impredecibles. No se
permiten saltos de dentro hacia afuera, o de afuera hacia adentro de
bloques try...except o try...finally. Tampoco se permiten saltos de y
hacia otros procedimientos y funciones.
Siempre intente usar una alternativa estructurada, o por lo menos use el
procedimiento Break:
function EstaCaracterEnCadena(char c, string s): boolean;
var i, n: Integer;
begin
Result := False;
n := Length(s);
for i := 1 to n do
if s[i] = c then begin
Result := True;
break; // Sale del bucle más interno
end;
end;
Tipos básicos
-------------
Los tipos básicos de Object Pascal se pueden clasificar de la siguiente
forma:
simples
ordinales
enteros
Shortint -128..127 8 bits con signo
Smallint -32768..32767 16 bits con signo
Longint -2147483648..2147483647 32 bits con signo
Integer -2147483648..2147483647 32 bits con signo
Int64 -2^63..2^63-1 64 bits con signo
Byte 0..255 8 bits sin signo
Word 0..65535 16 bits sin signo
Longword 0..4294967295 32 bits sin signo
Cardinal 0..4294967295 32 bits sin signo
caracteres
AnsiChar 1-bytes caracter ANSI
WideChar 2-bytes caracter UNICODE
Char AnsiChar
booleanos
Boolean 1-byte (valor booleano de 8 bits)
ByteBool 1-byte (valor booleano de 8 bits)
WordBool 2-byte (valor booleano de 16 bits)
LongBool 4-byte (valor booleano de 32 bits)
enumeraciones
type <tipo> = (valor1, ..., valorn);
Ejemplo: type Palos = (Oro, Espada, Copa, Basto);
subrangos
type <tipo> = valor1..valor2;
Ejemplo: type ExceptoOro = Espada..Basto;
Mayusculas = 'A'..'Z';
Horas = 0..23;
reales
Real48 2.9x10^-39..1.7x10^38 11-12 dígitos 6 bytes
Single 1.5x10^-45..3.4x10^38 7-8 dígitos 4 bytes
Double 5.0x10^-324..1.7x10^308 15-16 dígitos 8 bytes
Extended 3.6x10^-4951..1.1x10^4932 19-20 dígitos 10 bytes
Comp -2^63+1..2^63 -1 19-20 dígitos 8 bytes
Currency -922337203685477.5808
.. 922337203685477.5807 19-20 dígitos 8 bytes
Real Double
cadenas
ShortString 255 caracteres Compatibilidad hacia atrás
AnsiString ~2^31 caracteres caracteres de 8 bits (ANSI)
WideString ~2^30 caracteres Caracteres Unicode
String AnsiString
estructurados
conjuntos
type <tipo> = set of <tipo-ordinal>;
arreglos
estáticos
type <tipo> = array [<tipo-ordinal>] of <tipobase>;
type <tipo> = array [<tipo-ordinal1>,
<tipo-ordinal2>,...] of <tipobase>;
dinámicos
type <tipo> = array of <tipobase>;
registros
type <tipo> = record
<listacampos1>: <tipo1>;
...
<listacamposN>: <tipoN>;
end;
ficheros
type <tipo> = file of <tipobase>;
type <tipo> = file; // Fichero sin tipo
clases
// Las dejamos para el próximo newsletter
referencias a clases
type <tipo> = class of <tipo-class>;
interfaces
// Las dejamos para el próximo newsletter
punteros
type <tipo> = ^<tipobase>;
procedimientos (punteros a procedimientos o funciones)
type <tipo> = <declaración de procedimiento o función>;
type <tipo> = procedure(<parámetros>) of object;
Ejemplos: type TFuncionEntera = function: Integer;
TProcedure = procedure;
TStrProc = procedure(const S: string);
TMathFunc = function(X: Double): Double;
TMethod = procedure of object;
TNotifyEvent = procedure(Sender: TObject) of object;
variantes
Las variables tipo Variant pueden contener un valor de cualquier
tipo, excepto los tipos estructurados, punteros e Int64. Sin embargo,
sí pueden contener arreglos dinámicos y una tipo especial de arreglos
estático llamado arreglo variante. También pueden contener objetos
COM y CORBA.
Esto sería todo por ahora. En la siguiente edición estaremos hablando un
poco acerca de clases y objetos.
________________________________________________________________________
4. CUESTIONES DE PORTABILIDAD: ENSAMBLADOR EN DELPHI
Este artículo solo debería interesarle si codificó en ensamblador para
Windows y luego pretende portar ese código a Linux. Parte de la informa-
ción mostrada aquí ha sido extraída de
http://community.borland.com/article/0,1410,21301,00.html
La mala noticia es que TASM (Turbo Assembler de Borland) no estará
disponible en Kylix, así que si necesita en ensamblador externo porque
escribió ficheros .ASM, entonces deberá considerar una de las siguientes
alternativas para mantener un cierto grado de portabilidad:
* Reescriba sus módulos en un lenguaje de más alto nivel como C o Pascal.
De este modo alcanzaría máxima portabilidad y facilidad de manteni-
miento. Deje el ensamblador (inline) sólo para el código crítico donde
el ensamblador realmente vale la pena.
* Migre el código .ASM externo a bloques de código ensamblador "inline"
en Object Pascal. La desventaja es que se pierden todas las macros y
otros atajos de TASM que haya usado, pero al menos no es una
reescritura completa.
* Use NASM (Netwide Assembler). NASM usa la sintaxis Intel (como TASM) y
tiene soporte limitado de macros, pero ese soporte incluye un subcon-
junto de MASM. Si escribió sus ficheros .ASM en modo TASM, tendrá que
convertir su código a modo MASM. Tendrá que prescindir de las caracte-
rístcas de MASM no soportadas por NASM.
Una cuestión importante a la hora de escribir código ensamblador para
Linux es el Código Independiente de la Posición (Position Independent
Code - PIC) requerido por las bibliotecas de objetos compartidos de Linux
(equivalentes a las DLL de Windows), que significa que su código debe ser
relocalizable en memoria sin modificación.
En el esquema PIC, el registro EBX contiene un puntero a la dirección
base del módulo actual (Global Offset Table, o GOT en la jerga Linux) y
siempre debería preservar este registro entre llamadas dentro de su
código ensamblador. Además, debería restaurar el registro EBX antes de
hacer llamadas a funciones externas.
Todo el código ensamblador que se refiera a variables globales debe
modificarse para usar direccionamiento indirecto vía el registro EBX. Por
ejemplo, si su código es
MOV EAX, GlobalVar
debería cambiarlo por
MOV EAX, [EBX].GlobalVar
Esto sin lugar a dudas significa una pérdida de rendimiento (y código más
grande), así que Borland está usando un símbolo PIC en la RTL (Run-Time
Library) que es definido cuando el código debe seguir las reglas PIC
(Linux shared objects), permitiendo el uso de compilación condicional, y
sería sabio que usted hiciera lo mismo.
________________________________________________________________________
5. ENLACES
He aquí un excelente sitio en español (e inglés) dedicado a Delphi. Les
recomendamos bajarse el programa que descarga y actualiza los trucos de
Delphi en su PC.
* Q3
http://www.q3.nu
* Q3 Trucomanía
http://www.q3.nu/trucomania/
Para quienes aún no están al tanto, hay un proyecto de documentación de
Linux en español. Hay muchos HOWTOs, manuales y otras cosas traducidas
como la General Public License por ejemplo.
* Proyecto Lucas
http://lucas.hispalinux.es/
________________________________________________________________________
6. BIBLIOGRAFIA
Varios de nuestros suscriptores están interesados en libros de progra-
mación que traten específicamente sobre Linux y en español. Nuestra
búsqueda en la red ha sido por demás infructosa. Agradeceríamos mucho si
alguno de los lectores tiene información al respecto que pueda aportar.
Por ahora, para quienes preguntaron, lo más parecido que hemos podido
encontrar es este viejo libro que no sabemos si servirá...
Brian W. Kernighan y Rob Pike. "El entorno de programación UNIX."
Prentice Hall, 1993.
________________________________________________________________________
7. ¿QUE SIGUE?
En la siguiente edición, continuaremos la introducción a Object Pascal y
seguiremos la discusión de cuestiones de portabilidad. ¡Nos vemos!
________________________________________________________________________
Página principal: http://www.latiumsoftware.com/es/pascal/index.php
Página del grupo: http://espanol.groups.yahoo.com/group/boletin-pascal/
Para suscribirse / apuntarse: boletin-pascal-subscribe@gruposyahoo.com
Para cancelar / removerse: boletin-pascal-unsubscribe@gruposyahoo.com
Para reportar problemas con la suscripción: eds2004 @ latiumsoftware.com
________________________________________________________________________
Este boletín se provee "TAL Y COMO ESTA", sin garantía de ninguna clase.
Su uso implica la aceptación de nuestros términos de licencia y de la
ausencia de garantía que puedes leer en nuestro sitio web. Allí también
encontrarás una nota sobre marcas registradas. Te animamos a que redis-
tribuyas este boletín, siempre y cuando lo hagas en forma completa
(incluyendo la información de copyright), sin modificaciones y de manera
gratuita. Los artículos son copyright de sus respectivos autores y se
reproducen aquí con el permiso de los mismos.
________________________________________________________________________
Latium Software http://www.latiumsoftware.com/es/index.php
Copyright (c) 2000 por Ernesto De Spirito. Todos los derechos reservados
________________________________________________________________________
|
