Make e Makefile
Você que utiliza algum *nix da vida já deve ter passado pelo momento mágico de ter executado o comando make em algum código fonte, não?
O make (GNU make) é uma ferramenta que executa os comandos inclusos dentro de um arquivo. É normalmente utilizado na compilação e instalação de programas.
Uma das vantagens do make é que ele identifica quais partes do programa devem ser recompiladas de acordo com as mudanças efetuadas desde a última compilação.
Dependendo do tamanho do programa pode-se economizar minutos ou horas entre as recompilações, pois não será necessário recompilar o programa inteiro.
Exemplo de uso:
$ make -f arquivo_com_os_comandos
Se você chamar o comando make sem passar nenhum parâmetro ele tentará utilizar o arquivo com nome de Makefile do diretório atual.
É o que normalmente acontece quando você precisa compilar e instalar um programa pelo código fonte.
- Descompactar o código fonte (se for um "*.tar.gz").
- Entrar na pasta descompactada. Haverá um arquivo Makefile dentro.
- Executar o comando "make" para compilar.
- Executar o comando "make install" como root para instalar.
Makefile
Se você quiser utilizar o comando make só é necessário criar um arquivo Makefile e dentro dele colocar as instruções que o make deve executar.
Formato do Makefile:
regra: dependências... comandos ...
Os comandos são comandos normais do shell (bash). Pode-se colocar vários comandos, porém devem estar identados com tabulações. Isto é importante, não utilize espaços pois não irá funcionar.
A regra é só um nome para identificar um bloco de comandos. Fazendo uma analogia com programação, a "regra" seria semelhante a uma função.
As dependências são os arquivos necessários para a execução dos comandos da regra, o make irá fazer a verificação deles. Também podem ser outras regras que serão chamadas antes da execução dos comandos. Se houver mais de uma dependência elas devem ser separadas com espaços.
Aqui vai um exemplo de um Makefile que compila um programa em C:
program: gcc -o meuprograma meuprograma.c
Um exemplo com dependências:
program: cod1.c cod2.c lib1.a gcc -c cod1.c cod2.c gcc cod1.o cod2.o lib1.a -o program lib1.a: lib1.c cod3.c gcc -c lib1.c cod3.c ar rcs lib1.a lib1.o cod3.o ranlib lib1.a
Pode-se utilizar variáveis também. A declaração é simples, mas devem ser chamados com a notação "$(variável)". Repare também que elas podem ser concatenadas:
CC=gcc CFLAGS=-O2 CFLAGS=$(CFLAGS) -Wall program: $(CC) $(CFLAGS) -o program program.c
Olha que legal no Makefile a seguir, advinha o que acontece ao executar o comando `make clean' no terminal?
program: program.c
gcc -o program program.c
clean:
rm *.o
rm program
O que aconteceria também se houvesse um arquivo no diretório atual que se chamasse "clean"? O `make clean' não iria executar a lista de comandos da regra. Para evitar este tipo de conflito utilize a regra ".PHONY":
program: program.c
gcc -o program program.c
.PHONY: clean
clean:
rm *.o
rm program
Agora a regra "clean" será executada mesmo se houver um arquivo no diretório atual com mesmo nome.
.
