Actualizando Lazarus mediante SVN

En este artículo veremos como se configura Lazarus tanto en Windows como en sistemas tipo Unix como Linux, FreeBSD, Etc.  Usar SVN para actualizar nuestra instalación trae consigo algunas interesantes ventajas, como la posibilidad de actualizar a una revisión específica libre de regresiones, o localizar exáctamente en que revisión una función ha dejado de funcionar, también permite modificar el código de Lazarus o FPC permitiendo de una forma muy sencilla volver a la versión original. Se podrian enumerar muchas otras ventajas pero lo omitimos para abreviar.

La principal desventaja que existe al actualizar usando SVN es que en ocasiones los últimos cambios traen consigo también los últimos bugs, estos pueden causar diversos problemas, desde la imposibilidad de compilar, hasta errores más sutiles que sólo aparecen en tiempo de ejecución y bajo ciertas circunstacias.

Se describe entonces un modo de configuración con requerimientos muy específicos: Configurar tanto Lazarus como FPC desde SVN usando un usuario sin privilegios de Root (en sistemas tipo Unix). Con esto se pretende eliminar varios problemas que tienen los usuarios cuando instalan mediante snapshots o paquetes de instalación y que luego desean actualizar su copia del código debido a cambios recientes.

Hay que tener en cuenta que mediante SVN podemos cambiar a cualquiera de la versiones estables o estables corregidas (fixes) tanto de Lazarus como de FPC, con solo averiguar en que revisión ocurrieron los cambios o sabiendo en que branch o tag fue usado para su liberación.

Al momento de escribir éste artículo, estan disponibles la siguientes versiones:

• Lazarus: SVN 0.9.27, última versión estable 0.9.26, fixes a la versión estable 0.9.26.5 (actualmente no mantenida)
• FPC: SVN 2.3.1, última versión estable 2.2.4, fixes a la versión estable 2.2.5

Las herramientas que se necesitan son las siguientes:

1. Binutils y gdb
2. Subversion
3. Compilador estable FPC (únicamente archivo ejecutable)

PASO 1. Planeación de la instalación.

Aquí establecemos como deseamos tener instalado todo, para propósitos de ejemplo he hecho la siguiente especificación:

Windows:

Binutils: c:\binutils
FPC Source: c:\fpcsvn
FPC Compilado: c:\fpc
Lazarus Source y compilado: c:\lazarus

Linux:

Binutils: Instalado en su ubicación estandar
FPC Source: $HOME/fpcsvn
FPC compilado: $HOME/fpc
Lazarus Source y Compilado: $HOME/Lazarus

PASO 2. Obtención de binuils, gdb, Subversion y paquetes adicionales.

En sistemas tipo Unix, estos paquetes probablemente ya estén instalados, principalmente Binutils y gdb, en caso contrario es necesario usar el programa de administración de paquetes de su distribución o su equivalente en la línea de comandos, (si este artículo es leído alguna vez por alguien, solicitar ayuda a los lectores de como lo han hecho en sus respectivos sistemas y adicionarlos en este punto):

• OpenSuse (11.0, x86_64) usando YaST Instalar/Desinstalar Software:paquetes:  gdb, binutils, Subversion, gtk2-devel, etc. (complementar)

En windows, obtenemos binutils descargando los archivos asldw32.zip y makew32.zip desde el sitio FTP de freepascal, extraemos su contenido en c:\binutils y nos debe quedar algo así como c:/binutils/bin/i386-win32 con varios ejecutables dentro.

Con respecto a Subversion, vamos a utilizar la versión de línea de comandos por que se usa de igual forma tanto en Linux como en Windows, por supuesto, quien lo desee puede usar TortoiseSVN o cualquier otro cliente de SVN. Es necesario descargar el archivo de instalación desde el sitio oficial de Subversion y una vez obtenida procedemos a su instalación. Para confirmar que ha quedado instalado correctamente, en una ventana de línea de comandos teclear:

svn (ENTER)

Como resultado debe aparecer un texto como el siguiente:

Tipee 'svn help' para ver el modo de uso.

Para obtener gdb,  descargamos el archivo bz2 disponible en el servidor SourceForge de MingW del cual únicamente estamos interesados en extraer el archivo bin/gdb.exe y lo colocaremos dentro de c:\binutils\bin\i386-win32.

Con el fin de homologar la forma de uso con respecto a Linux, añadiremos el directorio binutils a la variable de entorno PATH, con esto intentamos que al ejecutar el comando "make" o cualquiera de las herramientas de binutils, estos sean localizados sin problemas.

En windows XP esto se hace mediante: INICIO->Clic botón derecho en "Mi PC"->Propiedades->Opciones Avanzadas->Variables de Entorno->Nueva (o Modificar si ya existe) y agregar en la variable PATH el valor c:\binutils\bin\i386-win32.

PASO 3. Obtención del compilador estable FPC

Con respecto a FPC, la situación se complica un poco y es que para compilar FPC se necesita claro, ¡FPC!. Sin embargo a pesar de ser un requisito indispensable, FPC no distribuye sólo el archivo ejecutable del compilador que nosotros necesitamos para usarlo como "compilador de arranque" (ppc386.exe para windows, ppc386 para Linux 32 bits, ppcx64 para Linux 64 bits, para efectos de este artículo llamémosle "el binario"), sino como parte de un paquete gigante de instalación, surge entonces la pregunta ¿Para que queremos todo el paquete completo?,  la respuesta es que no lo necesitamos pero como tenemos una situación especial de instalación lamentablemente es necesario descargar la última versión estable de FPC. Al momento de escribir esto, dicha versión es 2.2.4 y para ello y dependiendo del sistema operativo, seleccionaremos el enlace correspondiente en la página de descargas de FPC.

Pero vamos ¿Es que no hay alternativas? si, he aquí algunas:

• Si ya se tiene instalado FPC extraer el binario.
• Pedirle algún amigo que le comparta el binario de alguna instalación.
• En Linux, descargar el archivo deb para 32 bits  o el de 64 bits según corresponda, es necesario abrirlo con algún administrador de archivos comprimidos y extraer el binario.

Bien, al final nos quedaremos con el binario, copiaremos éste archivo al directorio c:\fpcsvn (el cual no debe estar en el PATH), en Linux lo colocaremos en $HOME/fpcsvn.

Actualización (29-sept-2010) La versión actual de FPC es 2.4.0 y ahora se encuentran disponibles binarios de arranque para varios sistemas operativos y plataformas en esta ubicación: ftp://ftp.freepascal.org/fpc/dist/2.4.0/bootstrap/  

PASO 4. Descargar Lazarus y FPC

Mediante una ventana de línea de comandos, en Windows, nos dirigimos al directorio raíz con

cd C:\ (ENTER)

y en Linux al directorio $HOME mediante

cd (ENTER)

A continuación descargamos el código fuente usando SVN:

svn co http://svn.freepascal.org/svn/lazarus/trunk lazarus
svn co http://svn.freepascal.org/svn/fpc/trunk fpcsvn

PASO 5. Compilación y configuración de FPC

En Windows:

cd c:\fpcsvn
make clean install INSTALL_PREFIX=c:\fpc COPYTREE=echo OPT="-O- -O1 -gl" PP=c:\fpcsvn\ppc386.exe

Se recomienda poner este comando en un archivo BAT, de manera que se facilite la re compilación de FPC. Con esto tendremos FPC compilado e instalado en c:\fpc, para el correcto funcionamiento del compilador, es necesario crear un archivo de configuración fpc.cfg en el directorio c:\fpc\bin\i386-win32, esto lo haremos usando la herramienta fpcmkcfg, la cual ha sido creada en la compilación e instalación  de FPC.

c:\fpc\bin\i386-win32\fpcmkcfg > c:\fpc\bin\i386-win32\fpc.cfg

Abrimos el archivo generado fpc.cfg usando cualquier editor de texto y buscaremos las lineas correspondientes a la opción -Fu, esas lineas deben quedar así:

-Fuc:\fpc\units\$fpctarget\
-Fuc:\fpc\units\$fpctarget\*
-Fuc:\fpc\units\$fpctarget\rtl

En Linux, suponiendo que nuestro $HOME es realmente /home/prog ejecutaremos los siguientes comandos:

cd $HOME/fpcsvn
make clean install INSTALL_PREFIX=/home/prog/fpc OPT="-O- -O1 -gl" PP=/home/prog/fpcsvn/ppc386

La instalación mediante "make", creará una estructura de directorios como ésta:

$HOME/fpc/bin
$HOME/fpc/lib/fpc/2.3.1
$HOME/fpc/lib/fpc/2.3.1/units/i386-linux

por lo tanto para crear el archivo de configuración fpc.cfg, lo haremos mediante:

$HOME/fpc/bin/fpcmkcfg > $HOME/.fpc.cfg

Abriremos el archivo $HOME/.fpc.cfg con algún editor de textos y haremos también los cambios correspondientes a las lineas -Fu, en este caso deben quedar así (teniendo como ejemplo $HOME=/home/prog):

-Fu/home/prog/fpc/lib/$fpcversion/units/$fpctarget
-Fu/home/prog/fpc/lib/$fpcversion/units/$fpctarget/*
-Fu/home/prog/fpc/lib/$fpcversion/units/$fpctarget/rtl

De esta forma se tiene configurado FPC para que funcione bien independientemente de la versión que venga en el repositorio SVN, ya que las variables $fpcversion y $fpctarget son reconocidas por el compilador y significan: la versión (en este caso 2.3.1) y el sistema formado por el CPU y el OS (i386-linux).

Una vez terminada la edición del archivo fpc.cfg, crearemos un par de enlaces simbólicos para facilitar el trabajo posterior en caso que deseemos usar las facilidades de compilación cruzada de FPC y Lazarus.

ln -s /home/prog/fpc/bin/fpc /home/prog/fpc/lib/fpc/2.3.1/fpc
ln -s /home/prog/fpc/bin/fpcmake /home/prog/fpc/lib/fpc/2.3.1/fpcmake

Es importante señalar que tanto en Windows como en Linux estamos compilando FPC con información de depuración, esto es importante para una instalación dedicada al desarrollo. Si deseamos omitir la información de depuración se debe excluir del comando la sección correspondiente a OPT="-O- -O1 -gl", la compilación procederá entonces con las opciones predeterminadas de FPC.

PASO 6. Compilación y Configuración de Lazarus.

Ahora compilemos nuestro Lazarus base:

cd c:\lazarus (windows) o cd $HOME/lazarus (Linux)

make clean all PP=c:\fpc\bin\i386-win32\ppc386.exe (windows)
make clean all PP=$HOME/fpc/lib/fpc/2.3.1/ppc386 (Linux, usando FPC 2.3.1 como ejemplo)

Con el paso anterior se ha compilado Lazarus usando una selección de componentes base que nos sirve para arrancar Lazarus y posteriormente comenzar a añadir componentes según vayamos necesitando. Nótese que no incluimos comando de "install" por que en éste método de instalación el Lazarus compilado y el código fuente comparten la misma ubicación.

Junto con la compilación de Lazarus se han creado, adicionalmente, un par de programas: StartLazarus y LazBuild. LazBuild es el método de compilación de proyectos mediante la línea de comandos, muy útil si por ejemplo estamos accediendo a la PC de desarrollo mediante un enlace SSH remoto y deseamos compilar algún programa en dicho sistema.

El propósito de StartLazarus es como su nombre lo indica, arrancar Lazarus, esto es importante por dos motivos, en Windows no es posible reemplazar un programa mientras éste se encuentra en ejecución tal como será el caso de Lazarus cuando se han añadido componentes, ya que por omisión, Lazarus se re compilará y reiniciará automáticamente. La otra funcionalidad de StartLazarus es en sistemas tipo Unix donde se ha instalado Lazarus usando privilegios de Root, en estas circunstancias cuando un usuario normal añade componentes a Lazarus, los binarios generados van a parar a un directorio donde el usuario normal tiene privilegios de escritura, al reiniciar Lazarus, StartLazarus arranca la versión correcta del ejecutable desde el directorio del usuario y no desde la instalación de Root. Nótese que si se arranca Lazarus usando "lazarus", se estaría arrancando  nuevamente la versión instalada por Root y los usuario se llevan la sorpresa de que los componentes que recien han instalado no estan en la paleta de componentes :).

En nuestro caso, bajo Linux, y como estamos instalando Lazarus en nuestro propio directorio sin privilegios de Root, no es necesario usar StartLazarus, pues ¡ya contamos con privilegios de escritura!, y como Linux permite el reemplazo de programas aun cuando estan en ejecución,  podemos usar directamente "lazarus". Posteriormente, si se desea, se puede crear un enlace al binario lazarus y colocarlo en el Escritorio o en nuestra barra de tareas según nuestra preferencia personal, o simplemente arrancarlo en una ventana de consola desde el directorio $HOME/lazarus.

En Windows, si necesitamos usar el programa startlazarus, para ello creamos un acceso directo a StartLazarus y lo colocamos en el Escritorio, editamos las propiedades del acceso directo y en el campo "destino" complementaremos el comando de esta manera:

c:\lazarus\startlazarus.exe --pcp=c:\lazarus

Nada mas arrancar Lazarus nos salta un mensaje que dice que no ha encontrado el código fuente de FPC, Lazarus usa el código fuente para propósitos de encontrar donde están definidas las variables y funciones de FPC mas no lo usa para re-compilar FPC.

El primer paso después de que Lazarus ha sido iniciado, es configurar donde se encuentra el compilador y sus fuentes así como el "make" de binutils y el depurador. Esto lo hacemos mediante el Menú Entorno->Options->Environment->Archivos y pondremos los siguientes datos:

En Windows:

• "Ruta del compilador (fpc)"  c:\fpc\bin\i386-win32\fpc
• "Directorio de las fuente de FPC"  c:\fpcsvn
• "Ruta de Make"  c:\binutils\bin\i386-win32\make.exe

En Linux:

• "Ruta del compilador (fpc)"  /home/prog/fpc/lib/fpc/2.3.1/fpc
• "Directorio de las fuente de FPC"  /home/prog/fpcsvn
• "Ruta de Make"  se puede quedar vacia.

El depurador se configura en: Entorno->Options->Environment->debugger. Pondremos los siguientes datos:

"Tipo de depurador " seleccionar "GNU Debugger (gdb)"

En Ruta (siguiente componente edit) poner /usr/bin/gdb para Linux y c:\binutils\bin\i386-win32\gdb.exe para Windows.

PASO 7. Manteniendo actualizados FPC y Lazarus.

Seguir de cerca el desarrollo de FPC y Lazarus puede ser muy útil e incluso indispensable cuando necesitamos en nuestros proyectos los últimos cambios, pero también es un arma de dos filos pues en ocasiones y sin previo aviso se introducen modificación que provocan que FPC o Lazarus no compilen mas. Usualmente, los errores de compilación se solucionan rápidamente, en ocasiones en minutos una vez que han sido detectados por los desarrolladores de Lazarus o FPC, pero la ventaja de usar SVN es que igualmente rápido podemos actualizar nuestra instalación y continuar con nuestro trabajo. Pero el hecho de usar SVN no quiere decir que tengamos que estar actualizando cada n horas o minutos, si encontramos una revisión que nos complace lo usual es mantenerse en una revisión estable y solo actualizar en caso de necesidad, también podríamos regresar a una revisión en el pasado de manera que podemos comprobar regresiones, etc.

Para actualizar Lazarus o FPC a la revisión actual en el repositorio SVN, entramos al directorio de lazarus o fpcsvn y tecleamos:

svn update

Para actualizar a una revisión específica:

svn update -r10200 (para actualizar a la revisión 10200)

Cuando tenemos cambios en nuestra copia local podemos visualizar la diferencia con respecto a la última revisión de esta forma:

svn diff (todos los cambios, incluso en subdirectorios) 

o

svn diff lcl/grids.pas (solo cambios en lcl/grids.pas)

Si deseamos contribuir nuestras modificaciones al proyecto Lazarus (o FPC) podemos hacerlo con:

svn diff > cambios.diff

Y enviar el archivo generado cambios.diff a quien corresponda.

Si por algún motivo no deseamos conservar los cambios que hemos hecho a nuestra copia local y queremos regresar a la última revisión que actualizamos, se puede hacer usando:

svn revert -R *

Lo cual desecha todos los cambios ocurridos en el directorio actual o en cualquier subdirectorio incluido, el * significa en cualquier archivo, los comandos también se pueden efectuar sobre un grupo de archivos por ejemplo:

svn diff lcl/grids.pas lcl/include/dbcheckbox.inc

Cuando nuevos cambios han sido introducidos en nuestra instalación, en el caso de FPC, basta con volver a ejecutar el comando ''make'' del paso 5.

Si se tiene que re compilar Lazarus debido a un cambio en FPC o a cambios en el mismo código de Lazarus o en alguno de sus componentes,  esto lo haremos mediante el menú "Herramientas" -> Configurar "Construir Lazarus" -> Opciones Avanzadas de configuración". Ahí seleccionaremos todas las opciones en "Limpiar+Construir" a excepción de "ejemplos" que se debe dejar fuera.

Hay muchas situaciones que no requieren una "Limpieza" completa y por consiguiente la re  compilación de Lazarus sería mas rápida si omitimos la etapa de "Limpiar", sólo hay que tener en cuenta que en ocasiones la opción de "Limpiar" también es de ayuda cuando la compilación falla debido a que el compilador ha encontrado archivos *.o y *.ppu olvidados de compilaciones anteriores.

Las actualizaciones sucesivas de Lazarus mediante SVN permiten mantener intacta nuestra selección previa de componentes instalados, por ejemplo, si al actualizar Lazarus vemos cambios en algunas de las units de LCL lo primero que deberiamos hacer es recompilar LCL mediante el diálogo "Configurar Reconstruir Lazarus" y seleccionando la opción correspondiente a LCL de manera que indique "Construir",  si han habido muchos cambios o si algunos de los archivos de LCL han desaparecido o si "Construir" solo no funciona,  es buena idea seleccionar "Limpiar+Construir" y re intentarlo. Como siguiente paso, es buena idea re compilar nuestras aplicaciones, al hacer esto, los componenes usados seran automáticamente recompilados debido al nuevo código en la LCL. Como siguiente paso si todo ha resultado bien, comprobar que aquellos componentes que nuestras aplicaciones no usan pero que estan instalados en Lazarus compilan correctamente, hay dos formas de hacerlo, una es abriendo cada paquete y tratar de compilarlo y la otra es recompilar la IDE o sea Lazarus mismo.

Se agradece su colaboración para la mejora continua de este artículo detectando los muchas fallas de ortografía así como para completar la lista de paquetes necesarios en cada distribución y en general para mejorar la precisión de los comandos o enlaces proporcionados.