Un progetto con più file sorgente si compila a mano con una serie di comandi. Se modifichi un solo file, vorresti ricompilare solo quello e non tutto il resto. make si occupa proprio di questo: guarda cosa è cambiato, ricostruisce il minimo necessario e lo fa nell'ordine giusto.
Cos'è
make è un programma che legge un file di istruzioni, il Makefile, e lo usa per costruire dei target (i file da produrre) a partire dalle loro dipendenze (i file da cui derivano). Nasce per compilare programmi in C, ma funziona con qualsiasi lavoro che trasformi dei file in altri file: documenti, immagini, pacchetti, o anche semplici sequenze di comandi da lanciare con un nome breve. Su Debian e Ubuntu si installa con sudo apt install make (spesso c'è già, con build-essential).
Cosa fa
Per ogni target make confronta la data di modifica del file con quella delle sue dipendenze. Se il target non esiste, o se una dipendenza è più recente, esegue i comandi della regola. Altrimenti lo salta. Per questo, dopo aver modificato un solo .c, ricompila solo quel file e rifà il collegamento finale.
Come si usa
$ make [opzioni] [target...]Senza target, make costruisce il primo definito nel Makefile della cartella corrente. Una regola ha questa forma:
target: dipendenze
comandoAttenzione alla tabulazione. Le righe dei comandi devono iniziare con un carattere TAB, non con spazi. In questa pagina le righe sono rientrate con spazi (per via del formato): se copi un esempio, nel tuo editor sostituisci quel rientro con un TAB. Se usi gli spazi, make si ferma con *** missing separator. Stop.: l'ho verificato.
Gli esempi usano un progetto di prova: main.c, util.c e util.h (con la funzione doppio). Gli output sono reali, con GNU Make 4.3 su Ubuntu 24.04. Sul tuo sistema i messaggi possono essere tradotti, se il locale è italiano.
Esempio 1: un Makefile minimo e la prima compilazione
CC = gcc
CFLAGS = -Wall -O2
OBJ = main.o util.o
prog: $(OBJ)
$(CC) -o prog $(OBJ)
%.o: %.c util.h
$(CC) $(CFLAGS) -c $<
.PHONY: clean
clean:
rm -f prog $(OBJ)$ make
gcc -Wall -O2 -c main.c
gcc -Wall -O2 -c util.c
gcc -o prog main.o util.o
$ ./prog
42Le prime tre righe definiscono delle variabili (si usano con $(NOME)). La regola prog dice che il programma dipende dai file oggetto. La regola %.o: %.c util.h è una regola generica: ogni .o si ottiene dal .c con lo stesso nome (e dipende anche da util.h), e $< è la prima dipendenza. make mostra i comandi che esegue prima di lanciarli.
Esempio 2: ricostruire solo il necessario
$ make
make: 'prog' is up to date.
$ touch util.c
$ make
gcc -Wall -O2 -c util.c
gcc -o prog main.o util.o
$ touch util.h
$ make
gcc -Wall -O2 -c main.c
gcc -Wall -O2 -c util.c
gcc -o prog main.o util.oCon nulla di modificato non fa niente. Dopo aver "toccato" util.c (touch ne aggiorna la data) ricompila solo quello e rifà il collegamento. Dopo aver toccato l'intestazione util.h ricompila tutto, perché l'abbiamo indicata come dipendenza di ogni .o. Dimenticare le intestazioni tra le dipendenze è un errore classico: make non si accorge delle modifiche e il programma resta con codice vecchio.
Esempio 3: vedere cosa farebbe, senza farlo
$ touch main.c
$ make -n
gcc -Wall -O2 -c main.c
gcc -o prog main.o util.o
$ make -q; echo $?
1
$ make
gcc -Wall -O2 -c main.c
gcc -o prog main.o util.o
$ make -q; echo $?
0-n (dry run) stampa i comandi senza eseguirli: è il modo per controllare un Makefile prima di lanciarlo. -q (question) non stampa nulla e comunica solo con il codice di uscita: 0 se il target è aggiornato, 1 se andrebbe ricostruito, 2 in caso di errore.
Esempio 4: variabili automatiche e funzioni
SRC = $(wildcard *.c)
OBJS = $(SRC:.c=.o)
elenco: $(OBJS)
@echo "target=$@ prima=$< tutti=$^"
%.o: %.c
@echo "compilo $< -> $@"
@touch $@$ make -f V.mk
compilo main.c -> main.o
compilo util.c -> util.o
target=elenco prima=main.o tutti=main.o util.o$@ è il nome del target, $< la prima dipendenza e $^ tutte. $(wildcard *.c) espande l'elenco dei .c presenti e $(SRC:.c=.o) sostituisce l'estensione. Il @ davanti a un comando impedisce a make di stamparlo. Con -f file si sceglie un Makefile con un nome diverso da quello di default. In questo esempio i comandi simulano la compilazione con echo e touch, per mostrare il meccanismo.
Esempio 5: target "finti" con .PHONY
$ touch clean
$ make -f P.mk clean
make: 'clean' is up to date.
$ make -f P2.mk clean # con la riga ".PHONY: clean"
echo pulisco
puliscoUn target come clean non produce un file: è solo un nome per un'azione. Se per caso nella cartella esiste un file con quel nome, make lo considera aggiornato e non fa nulla (primo caso). Dichiararlo con .PHONY dice a make di eseguirlo sempre (secondo caso). Per questo si mette in .PHONY ogni target che non corrisponde a un file: clean, all, install, test.
Esempio 6: variabili da riga di comando, parallelismo, errori
$ make CFLAGS="-O0" -n | head -3
gcc -O0 -c main.c
gcc -O0 -c util.c
gcc -o prog main.o util.o
$ make clean; make -j2
rm -f prog main.o util.o
gcc -Wall -O2 -c main.c
gcc -Wall -O2 -c util.c
gcc -o prog main.o util.o
$ make -k a b # K.mk: 'a' fallisce, 'b' no
false
make: *** [K.mk:4: x] Error 1
make: Target 'a' not remade because of errors.
echo ok
okUna variabile data sulla riga di comando vince su quella nel Makefile: qui CFLAGS="-O0" sostituisce -Wall -O2 (ho aggiunto -n per non ricompilare davvero e head -3 per accorciare). Una variabile impostata nell'ambiente (X=env make) invece non sostituisce quella del file, a meno di usare -e. Con -jN make lancia fino a N comandi in parallelo, utile sui progetti grandi: nel mio test il progetto è così piccolo che non c'è differenza visibile (output uguale a quello seriale). -k (keep going) continua con i target indipendenti anche dopo un errore. Nel test il target b è stato eseguito nonostante il fallimento di a, e make ha comunque restituito codice 2.
Esempio 7: messaggi d'errore tipici
$ make nonce
make: *** No rule to make target 'nonce'. Stop.
$ make # in una cartella senza Makefile
make: *** No targets specified and no makefile found. Stop.
$ make -f S.mk # comando indentato con spazi
S.mk:2: *** missing separator. Stop.In tutti e tre i casi make esce con codice 2. Se un comando di una regola fallisce (ad esempio un errore del compilatore), make si ferma e lo segnala con un messaggio del tipo make: *** [Bad.mk:2: bad.o] Error 1.
Esempio 8: uso negli script
#!/bin/bash
# Dice se un target di make e' aggiornato, senza compilare nulla
[ $# -ge 1 ] || { echo "Uso: $0 cartella [target]" >&2; exit 2; }
command -v make >/dev/null || { echo "make non trovato" >&2; exit 3; }
[ -d "$1" ] || { echo "$1: cartella inesistente" >&2; exit 2; }
dir=$1; target=${2:-}
make -C "$dir" -q ${target:+"$target"} >/dev/null 2>&1
case $? in
0) echo "${target:-default}: aggiornato" ;;
1) echo "${target:-default}: da ricostruire"; exit 1 ;;
*) echo "${target:-default}: errore (target o Makefile non validi)" >&2; exit 4 ;;
esacLo script usa make -q per sapere se un target è aggiornato, senza compilare nulla: utile in un controllo periodico o prima di un rilascio. -C cartella fa entrare make nella cartella indicata. Esce con 0 se il target è aggiornato, 1 se serve ricostruirlo, 4 se il target o il Makefile non sono validi, 2 per argomenti o cartella sbagliati e 3 se make manca. Nei miei test ha risposto correttamente con il target di default aggiornato e poi, dopo un touch util.c, da ricostruire; con un target inesistente e con una cartella senza Makefile ha dato l'errore (codice 4). Ha restituito 2 con una cartella inesistente e senza argomenti, e 3 con make assente dal PATH.
Opzioni utili
-n: mostra i comandi senza eseguirli.-q: solo codice di uscita (0 aggiornato, 1 da ricostruire).-f file: usa un Makefile con un altro nome.-C cartella: entra nella cartella prima di fare qualsiasi cosa.-j N: esegue fino a N comandi in parallelo.-k: continua sui target indipendenti dopo un errore.-s: silenzioso, non stampa i comandi.-e: le variabili d'ambiente hanno la precedenza su quelle del Makefile.VAR=valore: imposta una variabile da riga di comando (ha la precedenza sul file).-B: ricostruisce tutto a prescindere dalle date. Non l'ho provato.
Attenzione a
- TAB, non spazi. È l'errore più comune: la riga del comando deve iniziare con una tabulazione, altrimenti
missing separator. Gli editor che convertono le tabulazioni in spazi lo causano senza che te ne accorga. - Dipendenze incomplete. Se un
.onon dipende dalle intestazioni che include,makenon ricompila dopo una loro modifica e il programma resta incoerente (esempio 2). - Si basa sulle date dei file. Se un orologio è sfasato (file copiati da un'altra macchina, ad esempio)
makepuò saltare file da ricostruire o ricostruire tutto.touchforza la data. - Dichiara i target finti come
.PHONY. Altrimenti un file con lo stesso nome li fa saltare. - Il primo target è quello di default. Mettilo in cima, di solito con il nome
all. Nel mio test, con due regole,makesenza argomenti ha eseguito solo la prima. - Parallelo e dipendenze. Con
-j, una dipendenza dimenticata può produrre errori intermittenti che con la compilazione seriale non compaiono. Non l'ho riprodotto: è un consiglio generale. - Un Makefile è codice eseguibile. Ogni comando gira con i tuoi permessi: non lanciare
makesu un progetto scaricato da una fonte che non conosci senza averlo letto.
Riepilogo
| Comando | Cosa fa |
|---|---|
make | Costruisce il primo target del Makefile |
make target | Costruisce il target indicato |
make -n | Mostra i comandi senza eseguirli |
make -q; echo $? | 0 se aggiornato, 1 se da ricostruire |
make -f file.mk | Usa un Makefile con un altro nome |
make -C cartella | Esegue make in un'altra cartella |
make -j4 | Fino a 4 comandi in parallelo |
make CFLAGS="-O0" | Sovrascrive una variabile del Makefile |
make clean | Di solito rimuove i file generati (se definito) |