Compilazione Automatizzata con Make

Le potenzialità offerte dal compilatore GCC fornito nelle varie distribuzioni Linux sono davvero numerose e permettono di coprire le esigenze di programmazione più svariate, tuttavia gestire interi progetti, costituiti magari da diversi file sorgenti ed header, risulta molto scomodo. Un valido strumento che può aiutare in questi problemi è senza dubbio il make, che si occupa di gestire le regole di compilazione scritte, che provvedono ad automatizzare il processo di compilazione.
Make si occupa di analizzare un file di testo che contiene una serie di regole per il raggiungimento di un target, che avrà quindi bisogno di una serie di comandi da eseguire e dei file che rappresentano le dipendenze. Tutti i comandi che vengono inseriti nel file di make devono essere preceduti da un carattere di tabulazione, altrimenti non verranno eseguiti. La prima operazione svolta da make è quella di controllare se tutti i file di dipendenza esistano, quindi, in caso positivo, vengono eseguiti i comandi per raggiungere il target. Facciamo un semplice esempio per spiegare il funzionamento di make; supponiamo che il nostro eseguibile finale si chiamerà hello, e che per realizzarlo occorrano due file: hello.c e ciao.c; un possibile file make potrebbe essere:

hello : hello.o ciao.o
gcc -o hello hello.o ciao.o

hello.o : hello.c hello.h
gcc -c hello.c

ciao.o : ciao.c ciao.h
gcc -c ciao.c

La prima riga rappresenta la regola principale che viene eseguita da make e significa che il nostro eseguibile finale deve essere creato con i file compilati hello.o e ciao.o; nel caso in cui i due file esistano viene lanciato il comando per il link e la creazione dell’eseguibile finale, ma se uno dei due manca allora viene effettuata l’operazione associata al file da creare.
L’avere un file che ci permette di configurare la compilazione e creazione della nostra applicazione è importante per una buona manutenzione, ma make consente di fare molto di più. Tra le caratteristiche più utilizzate, abbiamo l’uso delle variabili, permettendo così di scrivere le regole in una maniera molto più flessibile e semplificando al tempo stesso la manutenzione di queste ultime. Le variabili vengono definite utilizzando questa sintassi:

VARIABILE = testo

make sostituirà testo con il valore della ($VARIABILE), così come avviene per gli script della shell di Linux. Un ottimo uso delle variabili è per definire le opzioni di compilazione. Oltre alle variabili definite nel file delle regole, make aggiunge automaticamente una serie di variabili predefinite e di ambiente:

• $@ – nome del file che verrà creato dalla regola corrente
• $< – nome della prima dipendenza della regola
• $^ – elenco di tutte le dipendenze della regola
• $? – elenco di tutte le dipendenze che devono essere create per attuare la regola
• $(@D) – nome della directory eventualmente contenuta nel target
• $(@F) – nome del file del target
• RM – comando utilizzato per cancellare i file
• CC – nome del compilatore
• CFLAGS – eventuali flag per il compilatore

Se per esempio scriviamo questa regola:

%.o : %.c
gcc -c $< -o $@

diremo a make di generare tutti i target .o partendo dal file .c ricorrendo al comando specificato.
Un’altra caratteristica di make sono le “false regole”, ovvero una serie di regole che si occupano esclusivamente di eseguire alcuni comandi non necessariamente legati alla compilazione della nostra applicazione. Un tipico utilizzo delle false regole ( regole PHONY ) è quello di automatizzare la cancellazione dei file oggetto o dell’installazione dell’applicazione, vediamo un esempio:

# Questo è un commento

DEST_DIR=/usr/local/bin

.PHONY clean install
clean:
rm *.o
install:
cp hello $(DEST_DIR)

lanciando il comando make clean verranno cancellati tutti i file .o nella directory corrente, mentre con make install copieremo il nostro file eseguibile nella directory prescelta per l’installazione, di default /usr/local/bin.
Non siamo di certo davanti ad un ambiente di sviluppo completo, ma certamente make consente di creare ordine nei nostri progetti Linux.