Make e Makefile, utility per rendere automatico non solo il lavoro di ricompilazione, ma qualsiasi altro processo che richieda di essere aggiornato.

Spesso vi sarà capitato di scompattare dei sorgenti di qualche programma disponibile per Linux e di trovarvi dentro un Makefile, e delle istruzioni di installazione che richiedevano comandi tipo:

make; make install.

Questi comandi sono invocazioni del comando 'make'.

Introduzione a make.

Quando si scrivono programmi composti di diversi file sorgenti, ci si trova di fronte al problema della ricompilazione degli oggetti e del linkaggio di questi ultimi per generare l'eseguibile. La cosa più conveniente da fare è individuare i file che sono stati modificati dall'ultima compilazione, e ricompilare soltanto questi ultimi.

L'utility make serve a determinare automaticamente quali pezzi di un programma hanno bisogno di essere ricompilati, e può generare i comandi necessari a farlo, seguendo alcune regole definite in un Makefile.

Sotto Linux e nella maggior parte dei sistemi UNIX, si usa generalmente il GNU make, scritto da Richard Stallman, iniziatore e leader del progetto GNU.

Utilizzo di make.

Generalmente make si utilizza per programmi scritti in C, ma può essere usato con qualsiasi altro linguaggio. Infatti, make è in grado di lanciare qualunque comando che può essere eseguito da shell, quindi in realtà può ricompilare anche file .tex, ricostruire database, o comunque eseguire qualunque serie di operazione che necessita di essere automatizzata.

Per utilizzare make, è necessario creare un file chiamato Makefile che descriva le relazioni esistenti tra i vari file, e i comandi da eseguire per aggiornare ognuno di questi.

Tipicamente, in un programma, si aggiorna un eseguibile partendo dai file oggetto, i quali vengono generati dai file sorgenti. Una volta creato un makefile appropriato, basterà digitare il comando

paci@fico# make

affinché automaticamente vengano ricompilati gli oggetti che sono stati modificati, e venga ricreato l'eseguibile.
Introduzione ai Makefile.
Supponiamo di avere un programma con 5 file scritti in C e tre header file, utilizzati dai sorgenti in C. Il programma make, quando andrà a ricompilare il programma, ricompilerà prima tutti i file sorgenti che sono stati modificati dall'ultima compilazione. Se sono cambiati gli header file, verranno ricompilati anche i file che li includevano. Infine, se qualche file è stato modificato, tutti i file oggetto, nuovi o vecchi, verrano linkati assieme per produrre l'eseguibile.

Un makefile consiste di alcune regole così descritte:

TARGET ... : DEPENDENCIES ...         COMMAND         ...         ... 

Di solito TARGET è il nome dell'eseguibile o del file oggetto da ricompilare, ma può essere anche una azione (es. clean). È un sorta di identificatore dell'azione da compiere: alla chiamata

paci@fico# make clean 

verrà eseguito il TARGET ``clean''.

Le DEPENDENCIES sono usate come input per generare l'azione TARGET e di solito sono più di una. Più genericamente vengono citati i file o le azioni da cui dipende la completazione di TARGET.

Un COMMAND è invece, il comando da eseguire; può essere più di uno, e di solito si applica sulle DEPENDENCIES

Per esempio, un makefile fatto su misura per il programma citato sopra, con 5 file .c e 3 header file, sarà:

prog_mio : main.o kdb.o video.o help.o print.o        cc -o prog_mio main.o kbd.o video.o \\        help.o print.o  main.o : main.c config.h        cc -c main.c -o main.o   kbd.o : kbd.c config.h        cc -c kbd.c -o kbd.o  video.o : video.c config.h defs.h        cc -c video.o -o video.o  help.o : help.c help.h        cc -c help.c -o help.o  print.o : print.c         cc -c print.c -o print.o  clean :        rm -f prog_mio        rm *.o        echo "pulizia completata" 

Notate l'uso della barra per dividere un unico comando in più righe, che ne facilita la lettura. A questo punto un semplice make eseguirà la prima azione citata nel makefile, che nel nostro caso è ``prog_mio'', il quale a sua volta chiama altre azioni, cioè i file oggetto da compilare. Potete anche specificare l'azione da eseguire usando il comando `make azione'. Nel nostro caso, un `make clean' avrebbe eseguito i comandi per rimuovere i file oggetto e l'eseguibile di prog_mio.
Conclusioni:
È evidente l'utilità di make, per chi è abituato a scrivere programmi di una certa complessità e dimensione. Non è altrettanto facile, rendersi conto delle potenzialità di questa utility; basterebbe spulciare nei makefile che di solito accompagnano i programmi freeware, per vedere come attraverso make si possa rendere automatico non solo il lavoro di ricompilazione, ma qualsiasi altro processo che richieda di essere aggiornato.

Consiglio caldamente la lettura della documentazione che accompagna questa utility, in modo da trarne i maggiori vantaggi possibili. In particolare è molto utile la lettura della documentazione info del programma, che anch'io ho usato come spunto per scrivere questo articolo.

Consiglio anche una URL dove trovare altre informazioni: http://www.dina.kvl.dk/DinaUnix/Info/make/make_toc.html

Se ti è piaciuto l'articolo , iscriviti al feed cliccando sull'immagine sottostante per tenerti sempre aggiornato sui nuovi contenuti del blog: