Bernd
Pol
Ian
Wadham

# Compilação e Gestão de Projectos

Este capítulo lida apenas com os projectos compilados, como os projectos de C++, Java ou Fortran. Os projectos para as linguagens de 'scripting' como o Python ou o PHP funcionam de forma bastante diferente.

Aqui irá encontrar informações acerca de:

- Resumo do &automanag;, que contém uma introdução ao &automanag;,

- A Operação com o Gestor Automake, que descreve as bases sobre como trabalhar com o &automanag;,

## Resumo do &automanag;

No capítulo dos Sistemas de compilação devemos uma vista geral sobre os sistemas de gestão de compilações usados normalmente nos sistemas &UNIX;. Nas secções seguintes iremos olhar para isto com mais detalhe.

Existe alguma confusão sobre o nome a dar estas coisas. A GNU chama-lhes sistemas de compilação quando descreve o Automake, o Autoconf e o Libtool. O QMake chama-se a si próprio uma ferramenta para criar Makefiles para os vários compiladores e plataformas. No &kde;, é usado com frequência o termo sistemas de gestão de projectos. Iremos usar este termo num sentido mais abrangente para descrever os ambientes predefinidos do &kdevelop; que são usados para organizar e construir os seus projectos. No contexto desta secção, contudo, iremos ver mais sobre os sistemas de compilação automatizados.

### A Necessidade de um Sistema de Compilação Automatizado

Se você tiver um programa simples Olá Mundo, feito em C, você poderá compilá-lo e gerar o executável com o comando &gcc; `-o ola ola.c` e executá-lo com o comando `./ola`, por isso você nem irá necessitar de uma `Makefile`.

Se você tiver uma aplicação em C com vários módulos e ficheiros de inclusão e só o vai executar na sua própria máquina (i.e., é uma aplicação caseira), você irá só necessitar de uma única `Makefile`, o que é relativamente simples de criar à mão (use o `info Make` para saber mais sobre o assunto).

As complicações começam quando:

- O seu código, documentação, imagens, sons, traduções, ficheiros de dados, &etc;, estão localizados em mais do que uma directoria,

- Você tem uma hierarquia de directorias e subdirectorias,

- Você está a usar bibliotecas que não fazem parte do conjunto tradicional do &UNIX;, com a biblioteca de Objectos do &Qt; ou as bibliotecas do &kde;,

- Você está a usar um pré-processador para gerar algum do seu código-fonte, como o pré-compilador MOC do Qt,

- Você pretende distribuir a sua aplicação pelo mundo inteiro, para as pessoas que podem não ter o mesmo sistema &UNIX;/&Linux;, o mesmo 'software' e 'hardware' que você,

- Você precisa de uma funcionalidade de Instalação e Desinstalação automática,

- Você pretende tornar a sua aplicação parte do conjunto do Ambiente do &kde;.

Se você tiver alguma ou todas as situações acima, você irá provavelmente necessitar de um sistema de compilações. No exemplo acima usámos o &gcc; para compilar e gerar o executável do programa Olá Mundo, mas nem todos os compiladores de C são chamados &gcc;. Por isso, se você distribuir a sua aplicação para alguém que esteja a usar outro compilador de C, a sua Makefile terá de alguma forma de usar o nome do compilador dessa pessoa, caso contrário a sua aplicação não irá conseguir compilar — e isto é apenas um exemplo simples do que poderá correr mal.

Um sistema de compilações irá limar estas diferenças para si.

- Irá verificar se as bibliotecas que precisa estão presentes em cada máquina recebida,

- irá percorrer automaticamente todas as directorias da sua aplicação à procura dos ficheiros a pré-processar, compilar ou instalar e

- irá instalar os componentes da sua aplicação nas directoria de destino correctas, certificando-se que

- as directorias são criadas na máquina de destino tal como é pedido.

Em resumo, um sistema de compilação oferece métodos seguros para a sua aplicação ser compilada e instalada correctamente em qualquer máquina de destino. Como foi mostrado acima na introdução aos Sistemas de Gestão de Projectos, o &kdevelop; oferece três sistemas de compilação automatizados e a opção para criar a sua própria Makefile (carregue nos nomes dos projectos para obter mais informações):

- Os projectos do Automake que usam as ferramentas de programação normais da &GNU;.

- Os projectos do QMake que usam o gestor de projectos QMake da Trolltech.

- Os projectos do ANT que usam o gestor de projectos ANT do Apache para a programação em &Java;.

- Os projectos personalizados que deixam a seu cargo a manutenção das suas próprias `Makefiles`.

Tem de ser escolhida uma destas quatro alternativas quando você criar um projecto e a escolha é difícil de alterar mais tarde, por isso, você deverá pensar bem antes de começar.

### Tutoriais sobre o Autoconf/Automake/Libtool

Existem vários tutoriais disponíveis sobre o Sistema de Compilações da &GNU; (o `Autoconf`, o `Automake` e a `Libtool`), dos quais o &automanag; tira partido.

- Está disponível um breve tutorial do 'autoconf', feito pelo Christopher W. Curtis na página pessoal do KDevelop. Ele concentra-se em alguns passos básicos para modificar uma `Makefile`.

- Poderá ser encontrado um tutorial mais detalhado em . Este faz parte de um conjunto maior de tutoriais sobre Desenvolver 'software' com a GNU.

- Existe ainda o famoso Livro da Cabra, intitulado Autoconf, Automake, and Libtool. Este é uma introdução fácil de ler mas concisa de todos os aspectos principais das Autotools da &GNU;.

### O Que É Que o &automanag; Faz?

O &appwizard; terá configurado alguns ficheiros `Makefile.am` iniciais quando você criou um Novo Projecto de um tipo que use o Sistema de Compilações da &GNU;, como o C++ KDE Application framework. Durante o desenvolvimento, o &automanag; cria vários outros ficheiros `Makefile.am` para os projectos que usam o Sistema de Compilação da &GNU; e vai fazendo a manutenção dos mesmos, tal como o &appwizard; e o &automanag; os criaram.

Existirá um ficheiro `Makefile.am` por cada directoria do seu projecto que contém os ficheiros a ser compilados ou instalados. Irá conter as suas especificações para compilar, gerar e instalar os ficheiros e uma referência a todas as subdirectorias que também tenham um ficheiro `Makefile.am` e, possivelmente, alguns ficheiros para compilar, gerar e instalar.

As directoria do seu projecto e os ficheiros de código poderão estar estruturados com qualquer profundidade, ou você poderá preferir uma estrutura plana do projecto com todas as subdirectorias no nível de topo.

O objectivo do Sistema de Compilação da &GNU; é produzir estruturas de ficheiros de código que possam ser compilados, gerados e instalados em qualquer sistema &UNIX; ou &Linux; usando os comandos simples:

    ./configure
    make
    make install    # Normalmente como "root".

e possam ser desinstalado com o comando `make uninstall` (normalmente como 'root').

Como é que isto funciona? Bem, o `configure` é um programa que

- lida com os detalhes do sistema em que está a correr, como por exemplo o compilador e as bibliotecas que deve usar e onde é que estas se localizam, e então

- cria ficheiros `Makefile` de forma recursiva, preenchendo as substituições nos respectivos ficheiros `Makefile.in`.

Os `Makefile.in` são ficheiros de input — modelos que fornecem informações básicas para as `Makefile`s a serem produzidas a partir deles, preenchendo alguma informação dependente do sistema. Eles são gerados pelo utilitário `Automake` a partir dos ficheiros `Makefile.am`.

O processo de passar de `Makefile.am` (`.am` significa ficheiros de modelo do Automake) para ficheiros `Makefile` é gerido automaticamente pelo &promanag; do &kdevelop;, usando o utilitário `Autoconf`, algumas macros de `M4` e outras coisas que não merece a pena falar aqui.

Por isso, quando o `make` se executa, ele escolhe os pedaços correctos do ambiente actual, como os compiladores e as bibliotecas. De forma semelhante, o `make install` coloca os componentes da sua aplicação, como os executáveis, a documentação e os ficheiros de dados nos locais correctos para esse ambiente.

Se você distribuir a sua aplicação como um TAR (um único pacote comprimido que o &kdevelop; poderá criar para si), ele irá incluir os ficheiros `Makefile.in` e o programa `configure`, de modo a que o destinatário possa compilar, construir e instalar a sua aplicação sem terem o `Automake`, o `Autoconf` ou o &kdevelop; na máquina deles. Os ficheiros `Makefile.am` são também incluídos, para o caso de o destinatário precisar de fazer algumas modificações ao código-fonte.

As regras são ligeiramente diferentes se você distribuir o código através de um repositório da Web como o &cvs; do &kde;.

### Resumo do que o Gestor do Automake Faz

- Gera ficheiros `Makefile.am` nas subdirectorias que conhece como subprojectos.

- Actualiza os ficheiros `Makefile.am` à medida que a estrutura do projecto se altera.

- Actualiza os ficheiros `Makefile.am` à medida que os ficheiros são adicionados ou removidos do projecto.

- Aceita as definições de como os vários ficheiros deverão ser compilados ou instalados e modifica o `Makefile.am` de acordo com isso.

- Aceita os parâmetros usados na compilação e na instalação (&eg;, nomes de bibliotecas) e garante que eles são usados nos passos de compilação e geração de binários.

### Conteúdo dos Ficheiros do Automake

Um ficheiro `Makefile.am` tem linhas que contêm nomes de variáveis seguidos de um sinal de igualdade (=) e uma lista de ficheiros ou valores de parâmetros. As variáveis têm nomes com duas partes, como por exemplo `bin_PROGRAMS`, `aplicacao_SOURCES` ou `kdelnk_DATA`. A segunda parte é chamada de primária e representa algo a partir do qual compilar ou instalar. A primeira parte é chamada de prefixo e representa:

- Uma directoria na qual fazer a instalação (p.ex., a `bin`),

- Um qualificador para o primário (p.ex. `novaaplicacao` para `SOURCES`, indicando que os ficheiros de código indicados a seguir ao `novaaplicacao_SOURCES` vão gerar o `novaaplicacao`),

- Um prefixo especial `noinst` (abreviatura de no installation ou sem instalação), é normalmente usado para listar os ficheiros de inclusão (`.h`),

- Ou o prefixo especial `EXTRA`, para os elementos dependentes da configuração.

Para mais informações sobre o `Automake` e os ficheiros `Makefile.am`, vá a `info Automake`.

Basicamente, o &automanag; cria e actualiza os nomes das variáveis e as listas de ficheiros ou parâmetros. Veja o exemplo seguinte de um `Makefile.am` para uma aplicação típica, chamada `aplicacao`.

    ## Makefile.am da 'aplicacao'

    # este é o programa que é instalado. O nome dele é usado para todas as
    # outras variáveis do Makefile.am
    bin_PROGRAMS = aplicacao

    # define os locais dos ficheiros de inclusão do X, qt e KDE
    INCLUDES = $(all_includes)

    # as localizações onde procurar as bibliotecas
    novaaplicacao_LDFLAGS = $(KDE_RPATH) $(all_libraries)

    # as bibliotecas com as quais compilar
    novaaplicacao_LDADD   = $(LIB_KFILE) $(LIB_KDEPRINT)

    # quais os ficheiros que devem ser compilados para a 'novaaplicacao'
    novaaplicacao_SOURCES = main.cpp novaaplicacao.cpp novaaplicacaoview.cpp

    # estes são os ficheiros de inclusão do seu projecto
    noinst_HEADERS = novaaplicacao.h novaaplicacaoview.h

    # deixe que o 'automoc' faça a gestão de todos os ficheiros de meta-código (moc)
    METASOURCES = AUTO

    KDE_ICON = novaaplicacao

    # aqui é para onde irá o ficheiro 'kdelnk'
    kdelnkdir = $(kde_appsdir)/Utilities
    kdelnk_DATA = novaaplicacao.desktop

    # aqui é para onde irá o ficheiro de recursos da XML-GUI
    rcdir = $(kde_datadir)/novaaplicacao
    rc_DATA = novaaplicacaoui.rc

    AM_CXXFLAGS = -DA_MINHA_OPCAO_DO_PREPROCESSADOR_DE_C++

Como poderá ver, muitos dos itens do lado direito são símbolos no formato `$(xxxx)`. Estas são variáveis de ambiente que são definidas no ambiente actual do &kde; e que são substituídas pelos valores reais quando o `./configure` gerar os ficheiros `Makefile` finais na máquina de destino.

Também, logo depois de você ter iniciado o KDevelop, é uma boa ideia correr o comando `./configure --help`, que lhe irá mostrar o conjunto de coisas que você poderá alterar na altura da compilação ou da instalação, como por exemplo, para um ambiente de testes. Em particular, o comando:

    ./configure --prefix=/onde/voce/desejar

irá redireccionar a instalação por completo para uma estrutura de directorias à sua escolha, alterando a variável interna `$(prefix)` para o valor `/onde/voce/desejar`.

## Operação do Gestor do Automake

Neste capítulo você irá encontrar uma descrição básica dos elementos do &automanag; e como usá-los. Isto cobre:

- A Janela do &automanag; que descreve a estrutura básica da janela principal do &automanag;.

- A Janela Introdutória que descreve os elementos da sub-janela superior.

- A Janela de Detalhes que descreve os elementos da sub-janela inferior.

- O Navegar no &automanag; lista algumas operações básicas que você poderá efectuar no &automanag;.

- Os Menus de Contexto no &automanag; descreve as janelas que irão aparecer quando você seleccionar uma acção no &automanag;.

### A Janela do &automanag;

- O &automanag; corre numa janela dividida. A parte superior é chamada de Introdução e a parte inferior de Detalhes. Entre elas existe uma barra fina que poderá ser arrastada com o rato para ajustar o tamanho das janelas. No modo IDEAl, você poderá também arrastar o lado da janela dividida para alterar a largura.

- No topo de cada área existe uma barra de ferramentas, em que os botões de cada uma ficarão activos de cada vez que um elemento da respectiva área for seleccionada. Isto possibilita uma forma de você aceder às acções oferecidas por esse elemento. A outra são os menus de contexto que aparecem quando você carrega com o &RMB;, como será discutido em baixo.

- No modo IDEAl existem dois pequenos botões adicionais na barra de título da janela do &automanag;, do lado esquerdo – uma seta triangular para a direita e um ponto. O botão da seta é usado para fechar a janela. O botão do ponto, por outro lado, irá manter a janela aberta, mesmo que outra janela do &kdevelop; tenha sido seleccionada. (Caso contrário, a janela do &automanag; irá fechar automaticamente sempre que outra janela ficar em primeiro plano.)

### A Janela de Introdução

A janela de Introdução contém uma árvore de todas as directorias no seu projecto que contêm ficheiros de programas, documentação ou dados. Cada uma destas directorias contém um ficheiro `Makefile.am` e é reconhecida pelo &automanag; como um subprojecto. Existem três subprojectos típicos num projecto baseado no &kde;, tal como é mostrado na ilustração acima:

- `src` – ficheiros com código-fonte para a sua aplicação,

- `doc` – o se manual do utilizador,

- `po` – extracções das cadeias de caracteres dos seus ficheiros de código que necessitem de ser traduzidas para outras línguas (p.ex., os títulos das janelas, os nomes dos menus, os textos dos botões, das janelas e as mensagens de vários tipos).

Repare que o subprojecto `doc` tem sempre um subprojecto `en`, o qual você poderá ver se carregar no símbolo + ao lado da palavra `doc`. Isto acontece porque a língua de base para toda a documentação do KDE é o Inglês (en). Se a sua aplicação fizer parte do KDE, as equipas de tradução do KDE poderão traduzir a sua documentação a partir do Inglês para outras línguas e as traduções irão para outros subprojectos como o `pt` (Português) ou para `fr` (Francês). Os textos do subprojecto `po` também poderão ser traduzidos e gravados noutros ficheiros do `po`, permitindo desta forma que a sua aplicação seja utilizada por pessoas que não percebam Inglês.

Os subprojectos `doc` e `po` servem para diferentes fins. O `doc` contém a documentação, como os manuais do utilizador, enquanto que o `po` contém o texto traduzido da interface do utilizador que está integrado no código-fonte desta aplicação.

A janela de Introdução serve — entre outras coisas — como uma ferramenta de navegação. Se você seleccionar um subprojecto na janela da Introdução, os detalhes correspondentes serão mostrados na área de Detalhes.

### A Janela de Vista de Detalhes

A janela de Detalhes contém uma árvore com todos os ficheiros no subprojecto seleccionado de momento na Introdução, assim como as regras de compilação, geração e instalação para este subprojecto. Como tal, as duas áreas em conjunto poder-lhe-ão dar o acesso a todos os componentes da sua aplicação e a todas as informações sobre como compilar, gerar e instalar os itens.

#### Alvos

A lista em árvore nos Detalhes tem dois níveis. O nível de topo consiste nos alvos do &automanag; e o próximo nível contém as listas dos ficheiros que irão compor cada alvo.

Este conceito de um alvo para o &automanag; difere de certa forma do que é um alvo nas `Makefile`s. Em resumo:

- A definição de como deverá ser compilado, gerado ou instalado um conjunto de ficheiros é conhecido como um alvo no &automanag;, mas apenas como uma variável no `Automake` em si.

- Um alvo no `make` é normalmente algo de muito diferente, sendo o parâmetro de um comando `make` (p.ex. `make install`, `make clean`).

  Contudo, algumas variáveis do `Makefile.am` representam, de facto, um sub-alvo subjacente no `make`.

### Navegar no &automanag;

Tanto na janela de Introdução como na de Detalhes, você poderá carregar com o botão esquerdo nos símbolos + ou -, juntos a um subprojecto ou nome de alvo para expandir ou contrair a árvore. Se fizer isso com um subprojecto na Introdução, ele irá mostrar ou esconder os subprojectos no próximo nível abaixo (se existir). Se o fizer com um alvo na janela de Detalhes, ele mostra ou esconde a lista de ficheiros que vão para esse alvo.

#### Abrir um Ficheiro para Edição

Se você carregar com o botão esquerdo do rato no nome de um ficheiro na janela de Detalhes, o ficheiro correspondente irá abrir na janela de edição do &kdevelop;.

#### Activar os Botões da Barra de Ferramentas do &automanag;

Se você carregar com o botão esquerdo no nome de um subprojecto na área de Introdução ou num alvo da janela de Detalhes, esse nome fica realçado e alguns botões da barra de ferramentas ficam activos na parte superior dessa janela.

Recomenda-se que você use o botão direito do rato e os menus de contexto, em vez dos botões das barras de ferramentas, porque é muito mais fácil de ver e perceber o que é que eles fazem.

As operações nos subprojectos e nos alvos têm efeitos de larga escala na estrutura, compilação, geração e instalação da sua aplicação.

#### Seleccionar Acções/Menus de Contexto

Se você carregar com o botão direito no nome de um subprojecto, alvo ou ficheiro, irá aparecer um menu, onde nele poderá seleccionar as acções a efectuar sobre o item em questão, como adicionar um alvo ao subprojecto, adicionar um ficheiro a um alvo ou remover logicamente o ficheiro seleccionado do seu alvo.

### Menus de Contexto no &automanag;

As seguintes acções explicam de forma resumida quais as operações que os menus disponibilizam e que irão aparecer, quando o botão direito do rato é carregado na janela do &automanag;. Elas pretendem ser meramente introdutórias. Você irá obter descrições mais detalhadas para a maioria das operações num capítulo posterior.

#### O Menu de Contexto de um Ficheiro

Quando você carregar com o botão direito no nome de um ficheiro na janela de Detalhes, irá aparecer o seguinte menu que lhe permite seleccionar uma de várias operações nesse ficheiro. Na ilustração por baixo, o ícone `hi-16app-novaaplicacao.png` foi seleccionado a partir do alvo Dados de ícone no 'novaaplicacao' do subprojecto novaaplicacao/src.

- O item principal do menu para um ficheiro é o Remover, para retirar o ficheiro do seu alvo (i.e., não será mais usado para compilar, gerar ou instalar esse alvo).

- O item CVS oferece um conjunto de operações do CVS sobre o ficheiro.

- O item Abrir Com permite-lhe abrir o ficheiro com uma variedade de editores ou com qualquer aplicação que desejar (p.ex., você poderá abrir o ficheiro do ícone do nosso exemplo com o KIcon).

- O item Perforce é usado para as operações semelhantes às do CVS, mas usando o sistema comericial de controlo de versões Perforce.

#### O Menu de Contexto de um Alvo

Quando você carregar com o botão direito num alvo da janela de Detalhes, irá aparecer o seguinte menu que lhe permitirá seleccionar uma de várias operações sobre ele. Na imagem em baixo, o alvo novaaplicacao (Programa em bin) do subprojecto novaaplicacao/src estava seleccionado.

- O item Opções de um alvo só se aplica aos ficheiros de código-fonte. Na janela correspondente você poderá indicar as opções do editor de ligações e os locais onde procurar as bibliotecas e onde você poderá também indicar uma lista com as bibliotecas que irão ser efectivamente associadas à sua aplicação.

- O item Criar um Novo Ficheiro mostra uma janela, na qual você poderá indicar o nome e o tipo do ficheiro a ser gerado (a partir de uma lista).

- O item Adicionar Ficheiros Existentes mostra uma janela, na qual você poderá adicionar um ou mais ficheiros existentes a este alvo.

- O item Remover para um alvo, permite-lhe remover logicamente o alvo e todos os seus ficheiros da estrutura do projecto.

- O item Tornar o Alvo Activo só se aplica aos alvos que contenham ficheiros de código. Os ficheiros novos serão sempre adicionados a um desses alvos activos.

- O item Construir o Alvo invoca todas as operações de compilação e geração de binários necessárias para compilar o código apenas para este alvo.

#### O Menu de Contexto de um Sub-Projecto

Quando você carregar com o botão direito num subprojecto da janela de Introdução, irá aparecer o seguinte menu que lhe permite fazer as alterações mais abrangentes à estrutura do seu projecto e à forma como é compilado, gerado e instalado. Você poderá usá-lo para expandir ou modificar a estrutura básica do projecto que o &appwizard; criou.

- O item Opções de um subprojecto controla a forma como o subprojecto será compilado, gerado e instalado. A janela que aparece terá páginas para o Compilador, Inclusões, Prefixos e Ordem de Construção.

- O item Adicionar um Sub-projecto cria uma nova directoria e um ficheiro-esqueleto do Makefile.am.

- O item Adicionar um Alvo faz aparecer uma janela, na qual você poderá definir as regras para compilar, gerar ou instalar um grupo de ficheiros dentro do seu subprojecto.

- Adicionar um Serviço (... a ser escrito ...)

- Adicionar uma Aplicação (... a ser escrito ...)

- Adicionar um Sub-Projecto Existente (... a ser escrito ...)

- O item Remover o Sub-projecto do menu de contexto de um subprojecto é a forma correcta de remover um subprojecto. Ela irá ajustar os ficheiros `Makefile.am` de acordo com isso. Você também terá a opção de remover todos os ficheiros (ou ligações) da subdirectoria correspondente. Obviamente, esta funcionalidade deverá ser usada com cuidado.

- O item Construir invoca todas as operações de compilação e geração necessárias para compilar o código apenas deste subprojecto.

- Forçar a Reedição (... a ser escrito ...)

- Limpar (... a ser escrito ...)

- Instalar (... a ser escrito ...)

- Instalar (como utilizador 'root') (... a ser escrito ...)

## Projectos Automake

(... ainda não escrito ...)

### Autoconf

#### Efeito do Programa 'Configure'

`Makefile.in` em `Makefile`

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

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

`config.h.in` em `config.h`

    /* Defina se você tiver a 'libz' */
    #undef HAVE_LIBZ
    /* O tamanho de um `int', tal como indicado pelo 'sizeof'. */
    #undef SIZEOF_INT

    /* Defina se tiver a 'libz' */
    #define HAVE_LIBZ 1
    /* O tamanho de um `int', tal como indicado pelo 'sizeof'. */
    #define SIZEOF_INT 4

### Automake

(... ainda não escrito ...)

### &automanag; do &kdevelop;

#### Uma imagem do gestor de automake

### Compilar e Instalar as Bibliotecas

- -rpath

- PIC

- static

- 'plugins': no-undefined

## 'Makefiles' e Programas de Compilação Personalizados

(... ainda não escrito ...)

## Opções do Compilador

(... ainda não escrito ...)

## Opções do Make

(... ainda não escrito ...)