2007-11-22 - Autotools, ah se todos usassem !!!

22 de novembro

Autotools, ah se todos usassem !!!

autotools é um conjunto de ferramentas que simplifica a verificação de dependências e compilação de programas.

É tão usado no mundo opensource que é até um padrão usado e recomendado pelo gnu.
tudo se torna simples quando se tem um projeto usando autotools...
Você apenas descompacta os fontes com:
tar xvf nomedoarquivo.tar.bz2
depois usa:
./configure
make
make install

Se o código depender de outro componente que não exista em seu ambiente, ele vai ser detectado no ./configure ... sendo assim fica fácil descobrir o que está faltando e instalar esta dependência antes de executar o make que é a parte demorada do processo.

O make é a compilação do programa... isto costuma demorar... e muitas vezes tem que executar centenas de subcompilações com linhas de comandos que incluem várias bibliotecas e que seria inviável para um usuário digitá-las na mão, um script para esta compilação poderia ser mantido pelo desenvolvedor do programa, mas daria muito trabalho a ele. É aqui que entra o autotools, ele cria este script automaticamente com um esforço mínimo do desenvolvedor.
Mas infelismente muitos projetos não o usam.

Vou mostrar em um exemplo prático como é fácil e prático usá-lo.

Vamos criar um novo diretório com o nome autotools-example:
$ mkdir autotools-example
$ cd autotools-example

teremos um subdiretório src onde ficaram os fontes:
$ mkdir src

e agora vamos criar um arquivo representando o nosso código:
cat > src/main.c << "EOF"
#include

int main(int argc, char** argv)
{
printf("funciona!!!\n");
return 0;
}

EOF

pronto... já temos um código do programa, hora de usar o autotools pra compilar.
O autotools precisa de um arquivo de referência onde ele vai pesquisar para saber o nome do programa que está sendo compilado e qual é a versão atual, onde estão os arquivos fontes, além de validações obrigatórias ou opcionais, como por exemplo um programa que pode ou não ter suporte a som, dependendo de um parâmetro que o usuário passa para o ./configure... também é no configure.ac que o desenvolvedor personaliza mensagens para o usuário e adiciona verificações adicionais para certificar que o código será compilado.

parece complicado né ? mas na prática é simples... olhe:
Primeiro use o autoscan que varre todos os arquivos do diretório e subdiretórios para detectar os arquivos fontes e criar o configure.ac que é um dos arquivos essenciais do autotools que o programador deve editar.
$ autoscan
agora devem ter sido criados 2 arquivos: autoscan.log e configure.scan.

o arquivo configure.scan é o configure.ac que nós precisamos para o autotools, e que foi criado automaticamente pelo comando autoscan e o autoscan.log registra algum erro ou mensagens ocorridas durante o processo do autoscan.
renomeie o arquivo configure.scan para configure.ac :
$ mv configure.scan configure.ac

vamos olhar o conteúdo do configure.ac e analisar o que precisaremos atualizar:
$ more configure.ac
# -*- Autoconf -*-
# Process this file with autoconf to produce a configure script

AC_PREREQ(2.61)
AC_INIT(FULL-PACKAGE-NAME, VERSION, BUG-REPORT-ADDRESS)
AC_CONFIG_SRCDIR([src/main.c])
AC_CONFIG_HEADER([config.h])

# Checks for programs.
AC_PROG_CC

# Checks for libraries.

# Checks for header files.

# Checks for typedefs, structures, and compiler characteristics.

# Checks for library functions.

AC_OUTPUT

bom... vamos ver...
todas as linhas começando com #(sharp, cerquilha, ou jogo da velha, como preverir) são comentários, e ignorados pelo autotools, então a primeira linha de código é:
AC_PREREQ(2.61)
está dizendo que no ambiente onde será compilado, deve existir instalado o autotools versão 2.61 ou superior.

Logo após vem:
AC_INIT(FULL-PACKAGE-NAME, VERSION, BUG-REPORT-ADDRESS)
aqui temos o lugar onde dizemos ao autotools qual é o nosso programa, a versão do nosso programa, e o endereço de email para onde os usuários devem mandar emails em caso de erros. atualize isto como preferir como no exemplo abaixo:
AC_INIT(autotools-example, 1.0, [seuemail at dominio dot com] )

depois temos:
AC_CONFIG_SRCDIR([src/main.c])
aqui ele detectou corretamente o nosso diretório de códigos fontes.

AC_CONFIG_HEADER([config.h])
este arquivo config.h deve pelo comando autoheader e server para definir variáveis de compilação para o autotools, como o PACKAGE_NAME, opções ativas por padrão... etc...
$ autoheader

agora vamos criar nosso script configure...
$ autoconf

pronto... se tudo deu certo, agora você terá um arquivo configure em seu diretório, execute-o:
$ ./configure

ele vai verificar tudo pela primeira vez e criar o config.h...

mas ainda precisamos cuidar do automake que irá compilar o nosso projeto.
para isto precisamos adicionar um AM_INIT_AUTOMAKE( nomedoprograma, versao ) no configure.ac, então adicione isto logo abaixo de AC_CONFIG_HEADER.
AM_INIT_AUTOMAKE(exemplo, 1.0)

além disto também é necessário informar quais Makefiles precisam ser criados... então no finao do arquivo configure.ac altere a linha AC_OUTPUT para:
AC_OUTPUT([
Makefile
src/Makefile
])

pronto, agora execute um autoreconf para atualizar os arquivos:
$ autoreconf
vamos atualizar o automake agora com o parâmetro --add-missing, para que ele crie os arquivos faltantes:
$ automake --add-missing

agora um ultimo passo é criar o Makefile.am que é bem simples:
cat > Makefile.am << "EOF"
SUBDIRS = src

EXTRA_DIST = NOTES autogen.sh

EOF

e um Makefile.ac no diretório de fontes, onde informaremos quem deve ser compilado:
cat > src/Makefile.am <<"EOF"
bin_PROGRAMS = exemplo
exemplo_SOURCES = main.c

EOF

vamos criar um script pra reconfigurar os arquivos, já fizemos isto, mas precisaremos fazer varias vezes durante o desenvolvimento, um script vai ajudar muito:

cat > autogen.sh <<"EOF"
#!/bin/sh
#
aclocal
automake --add-missing --foreign
autoconf

./configure $*
EOF

agora execute ele:
$ sh autogen.sh

bem... se vc executar o automake:
$ automake
vai receber várias mensagens de erros dizendo q ele não encontrou arquivos necessários... alguns podem ser criados automaticamentes com o parâmetro --add-missing... então vamos criá-los:
$ automake --add-missing
$ touch NEWS README AUTHORS ChangeLog

lembre-se de transformar os links simbólicos possivelmente criados pelo automake --add-missing em arquivos reais antes de compartilhar seu projeto, vc pode fazer isto copiando os arquivos dos links e substituindo-os.

Neste ponto já deve estar tudo pronto, e você já pode executar:
./configure
make

e já deve ter um arquivo executavel com o nome exemplo na pasta src... então execute:
$ src/exemplo
funciona!!!

se apareceu funciona!!! parabéns, vc acaba de criar seu primeiro projeto com autotools...

depois vou mostrar como gerenciar dependências, como o SDL e outros...

Qualquer dúvida usem os comentários.
Abs...
Ton
Postar um comentário

Postagens mais visitadas