# Compilación y gestión de proyectos

Este capítulo trata solo de proyectos compilados, como los de C++, &Java; o Fortran. Los proyectos para lenguajes de guiones, como Python y PHP, funcionan de un modo muy diferente.

Aquí encontrará la siguiente información:

- Sumario de &automanag;, que contiene una introducción a &automanag;,

- Funcionamiento del gestor de automake, que describe de forma básica cómo trabajar con &automanag;,

## Sumario de &automanag;

En el capítulo sobre sistemas de construcción vimos una breve introducción sobre los sistemas de construcción más usados en los entornos &UNIX;. En las siguientes secciones veremos esto con más detalle.

Existe cierta confusión sobre cómo denominar esto. &GNU; los llama «sistemas de construcción» cuando describen Automake, Autoconf y Libtool. QMake se refiere a sí mismo como «una herramienta para escribir Makefiles para diferentes compiladores y plataformas». En &kde; se usa a menudo el término «sistemas de gestión de proyectos». Nosotros usaremos este término en un sentido más amplio para describir los entornos integrados que &tdevelop; utilizará para organizar y construir sus proyectos. De todos modos, en el contexto de esta sección, hablaremos principalmente sobre «sistemas de construcción automatizados».

### La necesidad de un sistema de construcción automatizado

Si tiene un sencillo programa «Hola mundo» escrito en C, puede compilarlo y enlazarlo usando &gcc; `-o hola hola.c` y ejecutarlo usando el comando `./hola`, por lo que no necesitará un archivo `Makefile`.

Si tiene una aplicación en C con varios módulos y archivos de cabecera y solo pretende ejecutarla en su propia máquina (&ie;, se trata de una aplicación doméstica), solo necesitará un sencillo `Makefile`, que es bastante fácil de escribir a mano (use `info make` para ver cómo hacerlo).

Los problemas empiezan cuando:

- Su código fuente, documentación, gráficos, sonidos, traducciones, archivos de datos, &etc;, se encuentran situados en más de una carpeta,

- Tiene una jerarquía de carpetas y subcarpetas,

- Está usando bibliotecas que no son parte del juego tradicional de &UNIX;, como la biblioteca de código objeto de &Qt; o las bibliotecas del escritorio &kde;,

- Está usando un preprocesador para generar parte de su código fuente, como el precompilador MOC de Qt,

- Pretende distribuir su aplicación a todo el mundo, a personas que puede que no tengan el mismo sistema &UNIX;/&Linux;, software o hardware que usted,

- Necesita una utilidad de instalación y desinstalación automática,

- Pretende que su aplicación sea parte del escritorio &kde;.

Si se encuentra en una o varias de las situaciones anteriores, probablemente necesite un sistema de construcción. En el ejemplo anterior hemos usado &gcc; para compilar y construir el programa «Hola mundo», pero no todos los compiladores de C se llaman «&gcc;». De modo que si distribuye su aplicación a alguien que utilice otro compilador de C distinto, su Makefile debe usar de algún modo el nombre del compilador de esta persona, o en caso contrario su aplicación no podrá ser compilada (y esto solo es un sencillo ejemplo de lo que puede ir mal).

Un sistema de construcción se encargará de allanar estas diferencias por usted.

- Comprobará que las bibliotecas que necesita estén presentes en cada máquina de destino,

- recorrerá automáticamente todas las carpetas de su aplicación en busca de archivos para preprocesar, compilar o instalar, y

- también instalará los componentes de su aplicación en las carpetas de destino correctas, asegurándose de que

- las carpetas sean creadas en la máquina de destino cuando sea necesario.

En breve, un sistema de construcción ofrece métodos seguros para que su aplicación pueda ser compilada e instalada correctamente en cualquier máquina de destino. Como hemos mostrado anteriormente en la sección Sistemas de gestión de proyectos, &tdevelop; ofrece tres sistemas de construcción automatizados y la posibilidad de crear su propio Makefile (pulse sobre los nombres de proyecto para obtener más información):

- Proyectos automake que utilizan las herramientas de desarrollo estándar de &GNU;.

- Proyectos QMake que utilizan el gestor de proyectos QMake de Trolltech.

- Proyectos ANT que utilizan el gestor de proyectos ANT de Apache para desarrollos en &Java;.

- Proyectos personalizados que necesitan que usted mantenga sus propios `Makefiles`.

Debe seleccionar una de estas cuatro alternativas cuando cree un proyecto, pero esta elección es difícil de cambiar después, por lo que debería tenerlo en cuenta antes de comenzar.

### Manuales sobre Autoconf/Automake/Libtool

Existen varios manuales disponibles sobre el sistema de construcción de &GNU; (`Autoconf`, `Automake` y `Libtool`) que utiliza &automanag;.

- Un corto manual de autoconf escrito por Christopher W. Curtis se encuentra disponible en la página web de &tdevelop;. Se concentra en algunos pasos básicos para modificar un `Makefile`.

- Un manual más detallado se puede encontrar en la extensa colección de manuales existente en «Desarrollo de software con GNU».

- Y también existe el famoso «libro para novatos» titulado «Autoconf, Automake, y Libtool». Se trata de una introducción concisa y fácil de leer sobre todos los puntos principales de las herramientas &GNU;.

### ¿Qué hace &automanag;?

El &appwizard; habrá preparado algunos archivos `Makefile.am` iniciales tras crear un Nuevo proyecto que utilice el sistema de construcción de &GNU;, como C++ KDE Infraestructura de aplicación. Durante el desarrollo, &automanag; crea el resto de archivos `Makefile.am` en los proyectos que usan el sistema de construcción de &GNU;, y los mantiene de modo parecido a como los creó el &appwizard; y &automanag;.

Solo habrá un `Makefile.am` en cada carpeta de su proyecto, y contendrá los archivos que se van a compilar o a instalar. También contendrá sus opciones de compilación, creación e instalación de archivos, y una referencia a cualquier subcarpeta que también contenga otro `Makefile.am` y, posiblemente, más archivos para compilar, construir e instalar.

Las carpetas de su proyecto y los archivos de código fuente pueden estar contenidos en una estructura de cualquier profundidad, o tal vez prefiera una estructura de proyecto plana, con todas las subcarpetas en el nivel superior.

El propósito del sistema de construcción de &GNU; es la generación de estructuras de archivos de código fuente que puedan ser compilados, construidos e instalados en cualquier sistema &UNIX; o &Linux; mediante el uso de los sencillos comandos:

    ./configure
    make
    make install    # normalmente como «root».

y que puedan ser desinstalados posteriormente mediante el uso del comando `make uninstall` (normalmente como «root»).

¿Cómo funciona esto? Bien, `configure` es un guión que

- decide los detalles de cualquier sistema en el que se ejecuta, como qué compilador y bibliotecas se deben usar y dónde están situados, y luego

- crea archivos `Makefile` recursivos rellenando los campos a sustituir en los correspondientes archivos `Makefile.in`.

Los `Makefile.in` son archivos de «entrada» (plantillas que proporcionan información básica para los `Makefile`s que se deben obtener de ellos rellenando cierta información dependiente del sistema). Son generados por la utilidad `automake` a partir de los archivos `Makefile.am`.

El proceso de ir desde `Makefile.am` (`.am` indica que se trata de archivos de plantilla para «automake») hasta los archivos `Makefile` se gestiona automáticamente por el &promanag; de &tdevelop;, usando la utilidad `autoconf`, macros `M4` y otros procesos arcanos que no necesitamos conocer aquí.

De modo que, cuando se ejecuta `make`, se recogen automáticamente las piezas necesarias del entorno actual, como compiladores y bibliotecas. Del mismo modo, `make install` sitúa los componentes de su aplicación (como ejecutables, documentación y archivos de datos) en los lugares correctos de ese entorno.

Si distribuye su aplicación como un «tarball» (un único archivo comprimido que &tdevelop; puede crear por usted), se incluirán los archivos `Makefile.in` y el guión `configure`, de modo que el receptor pueda compilar, construir e instalar su aplicación sin necesidad de tener `automake`, `autoconf` ni &tdevelop; en su máquina. Los archivos `Makefile.am` también se incluyen, pero solo para el caso de que el receptor necesite realizar alguna modificación en el código fuente.

Las reglas son algo distintas si decide distribuir su código fuente mediante un repositorio basado en la web, como &cvs;.

### Sumario de lo que hace el gestor Automake

- Genera archivos `Makefile.am` en subcarpetas que se conocen como «subproyectos».

- Actualiza los archivos `Makefile.am` cuando cambia la estructura del proyecto.

- Actualiza los archivos `Makefile.am` cuando se añaden o eliminan archivos del proyecto.

- Acepta definiciones sobre cómo se deben construir o instalar los diferentes archivos y modifica los archivos `Makefile.am` de acuerdo con esta información.

- Acepta parámetros usados durante la construcción o instalación (⪚, nombres de bibliotecas), y se asegura de que sean usados durante los procesos de compilación y construcción.

### Contenido de los archivos de automake

Un archivo `Makefile.am` contiene líneas con nombres de variables seguidas por un signo de igualdad y una lista de archivos o parámetros. Los nombres de las «variables» constan de dos partes, como `bin_PROGRAMS`, `myapp_SOURCES` o `kdelnk_DATA`. La segunda parte es la principal, y representa algo de donde se debe construir o instalar. La primera parte se conoce como prefijo y representa:

- Una carpeta donde realizar la instalación (⪚, `bin`),

- Un calificador primario (⪚, `myapp`, para `SOURCES`, que indica que los archivos de código fuente listados a continuación de `myapp_SOURCES` sirven para construir `myapp`),

- Un prefijo especial `noinst` (de «no instalar»), que se usa normalmente para listar los archivos de cabecera del programa (`.h`),

- O el prefijo especial `EXTRA`, para cosas dependientes de la configuración.

Para más información sobre `Automake` y los archivos `Makefile.am`, consulte `info Automake`.

Básicamente, &automanag; crea y actualiza los nombres de variable y las listas de archivos y de parámetros. Observe el siguiente ejemplo de un `Makefile.am` de una aplicación típica, llamada `myapp`.

    ## Makefile.am para myapp

    # este es el programa que se instala; su nombre se usa en las variables
    # del resto de archivos Makefile.am
    bin_PROGRAMS = myapp

    # ruta de inclusión para X, qt y KDE
    INCLUDES = $(all_includes)

    # ruta donde buscar las bibliotecas
    myapp_LDFLAGS = $(KDE_RPATH) $(all_libraries)

    # las bibliotecas con las que enlazar
    myapp_LDADD   = $(LIB_KFILE) $(LIB_TDEPRINT)

    # archivos de código fuente que se van a compilar para myapp
    myapp_SOURCES = main.cpp myapp.cpp myappview.cpp

    # estas son las cabeceras de su proyecto
    noinst_HEADERS = myapp.h myappview.h

    # dejar que automoc se haga cargo de los archivos de metadatos (moc)
    METASOURCES = AUTO

    KDE_ICON = myapp

    # aquí es donde irá el archivo de enlace para KDE
    kdelnkdir = $(kde_appsdir)/Utilities
    kdelnk_DATA = myapp.desktop

    # aquí es donde irá el archivo de recursos XML para la interfaz gráfica
    rcdir = $(kde_datadir)/myapp
    rc_DATA = myappui.rc

    AM_CXXFLAGS = -DMY_C++_PREPROCESSOR_OPTION

Como puede ver, muchos de los elementos de la parte de la derecha son símbolos con el formato `$(xxx)`. Se trata de variables de entorno que están definidas en el entorno real de &kde; y que se sustituyen por sus valores reales cuando `./configure` genera los archivos `Makefile` finales en la máquina de destino.

Además, tras trabajar durante algún tiempo con &tdevelop;, es una buena idea ejecutar el comando `./configure --help`, que le mostrará la cantidad de cosas que puede cambiar durante los procesos de construcción e instalación, como para disponer de un entorno de pruebas. En particular, el comando:

    ./configure --prefix=/donde/usted/quiera

hará que toda la instalación se realice en una estructura de carpetas de su elección, cambiando para ello la variable interna `$(prefix)` al valor `/donde/usted/quiera`.

## Operación del gestor de Automake

En este capítulo encontrará una descripción básica sobre los elementos de &automanag; y sobre cómo usarlos. Esto cubre:

- La ventana de &automanag; describe la estructura básica de la ventana principal de &automanag;.

- La ventana de vista general describe los elementos de la ventana de la parte superior.

- La ventana de vista detallada describe los elementos de la ventana de la parte inferior.

- Navegación a través de &automanag; lista algunas operaciones básicas que puede realizar en el &automanag;.

- Menús desplegables del &automanag; describe las ventanas que aparecerán cuando seleccione una acción en el &automanag;.

### La ventana de &automanag;

| &automanag; se ejecuta en una ventana dividida en dos partes: la parte superior se llama vista general, y la inferior vista detallada. Entre ambas existe una estrecha barra que se puede arrastrar con el ratón para ajustar el tamaño de las vistas. En el modo IDEAl también puede arrastrar el borde de la ventana para ajustar su anchura. En la parte superior de cada vista existe una barra de herramientas, los botones que se activarán cuando seleccione un elemento de su vista. Esto proporciona un modo de acceder a las acciones ofrecidas para dicho elemento de la vista. El resto son los menús de contexto, que aparecerán cuando pulse con el botón derecho del ratón, como se describirá a continuación. En el modo IDEAl existen dos pequeños botones adicionales en la parte izquierda de la barra de título de la ventana de &automanag;: una flecha hacia la derecha de forma triangular y un botón en forma de punto. El botón de la flecha se usa para cerrar la ventana. El botón del punto, por el contrario, mantendrá la ventana abierta incluso si se selecciona otra ventana de &tdevelop; (de otro modo, la ventana de &automanag; se cerrará automáticamente cuando otra ventana pase al primer plano).

### La ventana de vista general

La ventana de vista general contiene una lista en forma de árbol con todas las carpetas de su proyecto que contengan archivos del programa, documentación o datos. Cada subcarpeta contiene un archivo `Makefile.am` y se conoce en &automanag; como un subproyecto. Típicamente existen tres subproyectos en un proyecto de &kde;, como se muestra en la ilustración:

- `src` – los archivos de código fuente de su aplicación,

- `doc` – su manual de usuario,

- `po` – las cadenas de texto de su código fuente que necesitan traducción a otros idiomas (⪚, títulos de ventanas, opciones de menú, etiquetas de botones, textos de diálogos y mensajes de varios tipos).

Observe que el subproyecto `doc` siempre contiene un subproyecto `en`, que podrá ver si pulsa sobre el símbolo + que hay junto a la palabra `doc`. Esto se debe a que el idioma básico para toda la documentación de &kde; es el inglés de los Estados Unidos («en»). Si su aplicación se convierte en parte de &kde;, los equipos de traducción de &kde; podrán traducir su documentación en inglés de los Estados Unidos a otros idiomas, que acabarán residiendo en otros subproyectos, como `es` (para el español) o `fr` (para el francés). Las cadenas de texto del subproyecto `po` permiten que su aplicación pueda ser manejada por personas que no conozcan el idioma inglés.

Los subproyectos `doc` y `po` sirven para diferentes propósitos: `doc` contiene documentación (como el manual del usuario), mientras que `po` contiene cadenas de texto para traducir procedentes de la interfaz de usuario, que está integrada en el código fuente de la aplicación.

La ventana de vista general sirve (entre otras cosas) como herramienta de navegación. Si selecciona un subproyecto en la ventana de vista general, se mostrarán sus detalles correspondienes en la ventana de vista detallada.

### La ventana de vista detallada

La vista detallada contiene una lista en forma de árbol de todos los archivos del subproyecto actualmente seleccionado en la ventana de vista general, además de las reglas de compilación, construcción e instalación para este subproyecto. De este modo, ambas vistas le proporcionan acceso a todos los componentes de su aplicación y a toda la información sobre cómo compilarla, construirla e instalarla.

#### Objetivos

La lista de árbol de la ventana detallada posee dos niveles. El nivel superior contiene lo que se denomina objetivos de &automanag;, y el siguiente nivel contiene listas de archivos que definen cada objetivo.

Este concepto de un objetivo en &automanag; difiere algo de lo que se entiende por un objetivo en un `Makefile`. En breve:

- La definición sobre cómo un conjunto de archivos se debe compilar, construir o instalar se conoce como objetivo en &automanag;, aunque en `automake` se denomina variable.

- Un objetivo de `make` es normalmente algo bastante distinto, como por ejemplo el parámetro de un comando `make` (por ejemplo, `make install` o `make clean`).

  No obstante, algunas variables de `Makefile.am` representan a un subobjetivo subyacente en `make`.

### Navegación en &automanag;

Tanto en la ventana de vista general como en la detallada, puede pulsar sobre los símbolos + o - que hay junto al nombre de un subproyecto o de un objetivo para desplegar o plegar su vista en árbol. Si hace esto con un subproyecto en la ventana de vista general, se mostrarán u ocultarán los subproyectos del siguiente nivel (si existen). Si lo hace sobre un objetivo en la vista detallada, se mostrará u ocultará la lista de archivos de dicho objetivo.

Abrir un archivo para editarlo

- Si pulsa con el botón izquierdo del ratón sobre el nombre de un archivo en la vista detallada, se abrirá su correspondiente archivo en la ventana de edición de &tdevelop;.

Activación de los botones de la barra de herramientas de &automanag;

- Si pulsa con el botón izquierdo del ratón sobre el nombre de un subproyecto en la ventana de vista general, se resaltará su nombre y se activarán algunos botones en la barra de herramientas que hay en la parte superior de la vista.

  Se le recomienda que utilice el botón derecho del ratón y los menús de contexto en lugar de los botones de la barra de herramientas, ya que así le resultará mucho más fácil ver y comprender lo que está haciendo.

  Las operaciones realizadas sobre los subproyectos y sobre los objetivos producen efectos sobre la estructura, compilación, construcción e instalación de su aplicación.

Selección de acciones/menús desplegables

- Si pulsa con el botón derecho del ratón sobre el nombre de un subproyecto, objetivo o archivo, se le mostrará un menú desplegable donde podrá seleccionar las acciones a realizar sobre el subproyecto, objetivo o archivo, como añadir un objetivo al subproyecto, añadir un archivo al objetivo, o eliminar el archivo seleccionado de su objetivo.

### Menús desplegables de &automanag;

Las siguientes secciones explican brevemente qué operaciones permiten los menús que se mostrarán al pulsar con el botón derecho en la ventana del &automanag;. Se refieren únicamente a la ventana de vista general. Encontrará descripciones más detalladas de la mayor parte de las operaciones posibles en un capítulo posterior.

#### El menú desplegable para un archivo

Cuando pulse con el botón derecho del ratón sobre un nombre de archivo en la vista detallada se le mostrará el siguiente menú, que le permitirá seleccionar una de entre varias operaciones a realizar sobre dicho archivo. En la ilustración inferior el icono del archivo `hi-16app-myapp.png` ha sido seleccionado en el objetivo Datos de icono de myapp perteneciente al subproyecto myapp/src.

| El principal elemento del menú desplegable para este archivo es Eliminar el archivo de su objetivo (es decir, que no vuelva a utilizarse para compilar, construir o instalar su objetivo). El elemento CVS ofrece varias operaciones CVS sobre el archivo. El elemento Abrir con le permite abrir el archivo con una variedad de editores o con cualquier otra aplicación (por ejemplo, puede abrir el archivo de icono de nuestro ejemplo con TDEIcon). El elemento Perforce se utiliza para operaciones similares a las de CVS, pero utilizando en su lugar el sistema de control de versiones comercial «Perforce».

#### El menú desplegable para un objetivo

Cuando pulse con el botón derecho sobre un objetivo de la vista detallada se le mostrará el siguiente menú emergente, que le permite seleccionar una de entre varias operaciones a realizar sobre él. En la imagen inferior se ha seleccionado el objetivo myapp (Programa en bin) del subproyecto myapp/src.

| El elemento Opciones de un objetivo sólo es aplicable a los archivos de código fuente. El el diálogo correspondiente puede especificar los modificadores para el enlazador, las rutas donde encontrar bibliotecas e incluso proporcionar una lista de las bibliotecas reales que se deben enlazar con su aplicación. El elemento Crear nuevo archivo muestra un diálogo en el que puede introducir el nombre del archivo que se generará y su tipo (de entre los disponibles en una lista desplegable). El elemento Añadir archivos existentes muestra un diálogo mediante el que puede añadir un archivo existente a este objetivo. El elemento Eliminar de un objetivo le permite eliminar de manera virtual dicho objetivo y todos sus archivos de la estructura del proyecto. El elemento Convertir en objetivo activo sólo es aplicable a los objetivos que contengan archivos de código fuente. Los archivos nuevos siempre se añadirán al objetivo activo. El elemento Construir objetivo se encarga de llamar a todas las operaciones de compilación necesarias para construir el código del objetivo seleccionado.

#### El menú desplegable para un subproyecto

Cuando pulsa con el &RMB; sobre un subproyecto en la ventana de vista general se le muestra el siguiente menú, que le permite realizar cambios importantes en la estructura de su proyecto y en el modo en que se compila, construye o instala. Puede utilizarlo para expandir o modificar la estructura básica de proyecto que ha creado el &appwizard;.

| Para un subproyecto, el elemento Opciones controla el modo en que dicho subproyecto será compilado, construido e instalado. El diálogo que se muestra contiene las pestañas: «Compilador», «Inclusiones», «Prefijos» y «Orden de construcción». El elemento Añadir subproyecto crea una nueva carpeta y el archivo de esqueleto Makefile.am. El elemento Añadir objetivo muestra un diálogo en el que puede establecer las reglas de compilación, construcción e instalación para un grupo de archivos pertenecientes a su subproyecto. Añadir servicio (pendiente de escribir...) Añadir aplicación (pendiente de escribir...) Añadir subproyectos existentes (pendiente de escribir...) El elemento Eliminar subproyecto del menú desplegable de un subproyecto es el modo adecuado para eliminar dicho subproyecto, ya que ajustará los archivos `Makefile.am` automáticamente. También se le ofrecerá la opción de eliminar todos los archivos (o enlaces a ellos) existentes en la subcarperta correspondiente. Obviamente, esta característica se debe usar con precaución. El elemento Construir llama a las operaciones necesarias de compilación para construir el código del subproyecto seleccionado. Forzar reedición (pendiente de escribir...) Limpiar (pendiente de escribir...) Instalar (pendiente de escribir...) Instalar (como usuario «root») (pendiente de escribir...)

## Proyectos automake

(... pendiente de escribir ...)

### Autoconf

`Makefile.in` en `Makefile`

    prefix = @prefix@
    INSTALL = @INSTALL@
    build_triplet = @build@
    CXX = @CXX@

    prefix = /home/bernd/kde3
    INSTALL = /usr/bin/ginstall -c -p
    build_triplet = i686-pc-linux-gnu
    CXX = g++

`config.h.in` en `config.h`

    /* Definir si tiene instalado libz */
    #undef HAVE_LIBZ
    /* El tamaño de un número entero, calculado por sizeof */
    #undef SIZEOF_INT

    /* Definir si tiene instalado libz */
    #define HAVE_LIBZ 1
    /* El tamaño de un número entero, calculado por sizeof */
    #define SIZEOF_INT 4

### Automake

(... pendiente de escribir ...)

### &automanag; de &tdevelop;

#### Una captura de pantalla del gestor de automake

### Construir e instalar bibliotecas

- -rpath

- PIC

- static

- plugins: no-undefined

## Makefiles personalizados y guiones de construcción

(... pendiente de escribir ...)

## Opciones del compilador

(... pendiente de escribir ...)

## Opciones de make

(... pendiente de escribir ...)