GNU Make TutorialNU

GNU Make è uno strumento che aiuta a generare programmi eseguibili dal codice sorgente ed elaborare anche altri file non sorgenti dal progetto. Make ottiene la logica della creazione degli eseguibili e dell'elaborazione di altri file non di origine da un file chiamato a makefile o un Makefile.

Perché fare??

• Make è lo strumento di fatto per creare programmi eseguibili dal codice sorgente nel mondo dell'open source.

• Make consente agli utenti finali di creare programmi eseguibili senza conoscere i dettagli tecnici su come crearli.

• Tutti i dettagli su come creare eseguibili ed elaborare file non sorgente sono elencati nel makefile, quindi il processo diventa ripetibile da tutte le persone o i sistemi che cercano di creare un progetto.

• Se una base di codice è molto grande, è lungo e problematico creare un eseguibile da zero quando la modifica del codice sorgente è molto piccola. Make si prende cura di questo. Tiene traccia di quali file vengono modificati e risolve la dipendenza di conseguenza per costruire ricostruire la parte specifica del programma.

• Make è indipendente dal linguaggio di programmazione. Non importa quale linguaggio di programmazione o quale dialetto stai usando. Makefileèun file di testo di comandi di shell organizzati strutturalmente con dipendenza e altra logica per costruire il programma e gestire altri file non sorgente. Poiché è un mucchio di comandi shell, può essere eseguito ovunque venga eseguito il comando shell shell. Windows non esegue i comandi della shell Linux per impostazione predefinita, ma puoi farlo con una versione specializzata per Windows.

• Durante la creazione di programmi eseguibili vengono creati molti file intermedi che non devono essere presenti al termine della creazione. Elimina automaticamente quei file. Aiuta a mantenere l'ambiente pulito e fa risparmiare molto tempo prezioso.

Installazione di Make

Fare da solo non basta per costruire programmi. Per creare programmi dai sorgenti devi avere compilatori e altri strumenti installati sul tuo sistema. Quindi, abbiamo bisogno della suite completa di strumenti di sviluppo per il nostro scopo.

Per compilare i sorgenti su Linux, c'è un pacchetto chiamato "build-essential" sui sistemi basati su Debian (e.g. Ubuntu, Linux Mint, ecc.) e "Strumenti di sviluppo" su Red Hat e CentOS.

Per installarlo su sistemi basati su Debian:

apt-get install build-essential

Per installarlo su CentOS ed eseguire Red Hat:

yum groupinstall "Strumenti di sviluppo"

Iniziare con Makefile

Iniziamo scrivendo a Ciao mondo programmare con il linguaggio di programmazione C.

La funzione principale del nostro programma C risiederà all'interno ciaomain.c. Il contenuto del file dovrebbe essere simile al seguente:

#includere  int main()  my_fun(); restituisce 0;  

Questo codice include il file di intestazione ciaofun.h che contiene la dichiarazione di una funzione chiamata hello_fun(). Il contenuto di Hellofun.il suo:

void mio_divertimento();

La definizione di my_fun() vive all'interno di hellofun.c:

#includere  #includere  void my_fun()  printf("Hello World!\n"); ritorno; 

Questo è un programma molto semplice e potremmo compilarlo con gcc con una sola riga di comando. Ma i programmi di vita reale non sono così semplici e piccoli come questo. Le cose si complicano molto presto.  Di seguito, scriverò lo script makefile necessario per compilare questo programma Hello World. Spiegherò diverse parti di esso nelle sezioni successive.

ciaomain: ciaomain.c ciaofun.c gcc -o hello hellomain.c ciaomain.c-io.

Conserva questo codice in un file chiamato makefile (senza alcuna estensione di file). Metti il ​​file nella directory in cui si trovano i file C. Punta la tua riga di comando in questa directory. Sulla riga di comando scrivi make e premi invio. Verrà generato un file eseguibile chiamato ciao nella directory corrente. Puoi verificare il risultato eseguendo l'eseguibile con il seguente comando.

./Ciao

Uscite:

Ciao mondo!

Regole, obiettivi e dipendenze

Uno script makefile è una raccolta di regole. Le regole istruiscono Make come costruire un target o un output da file sorgente o altri. La regola specifica anche le dipendenze del target. Le regole di dipendenza devono essere eseguite per prime a seconda che siano già state elaborate osservando i timestamp. Nel nostro esempio makefile sopra, abbiamo una regola con target denominato ciaomain e le sue dipendenze. Il nome di destinazione è separato da due punti dall'elenco delle dipendenze. I comandi della shell che verranno eseguiti sono elencati nella riga seguente. I comandi della shell devono iniziare con un carattere di tabulazione.

Se non specifichi alcun parametro con il comando make, viene eseguito il primo obiettivo. Nel nostro esempio non abbiamo specificato alcun parametro e abbiamo avuto ciaomain come primo e unico obiettivo.

Variabili

Le variabili sono un ottimo modo per scrivere un valore una volta e utilizzarle numerose volte senza ripetere il valore più e più volte. Ci aiuta a mantenere il nostro codice ASCIUTTO (Non ripetere te stesso). Se hai mai bisogno di cambiare un valore in tutto lo script, devi solo cambiarlo in un posto per riflettere il cambiamento ovunque se stai usando la variabile.

Nel nostro esempio abbiamo usato gcc come compilatore, ma potrebbe essere necessario cambiare il compilatore in qualcos'altro. Quindi, possiamo mantenere il nome del compilatore in una variabile. Inoltre, possiamo mantenere i flag del compilatore in un'altra variabile per riutilizzarla. Per impostare un valore su una variabile usiamo il segno di uguale (=) e per leggere quella variabile usiamo $(variable_name).

CC=gcc CFLAGS=-I. ciaomain: ciaomain.c ciaofun.c $(CC) -o hello hellomain.c ciaomain.c $(CFLAG)

Pulizia dell'ambiente

Spesso potremmo aver bisogno di pulire il nostro ambiente. Se vogliamo che ogni pezzo del nostro progetto venga ricostruito da zero, dobbiamo pulirlo. Nel nostro semplice esempio l'unico file che viene generato è il Ciao eseguibile. Senza eliminarlo manualmente, possiamo eliminarlo con make. Quindi, possiamo creare una regola per questo e nominare il target come pulito.

CC=gcc CFLAGS=-I. ciaomain: ciaomain.c ciaofun.c $(CC) -o hello hellomain.c ciaomain.c $(CFLAGS) clean: rm ciao

Il comando shell nella destinazione pulita è solo il vecchio comando shell rm. Ora, dalla riga di comando esegui:

rendere pulito

Guarda la directory corrente per vedere che il Ciao il file eseguibile è sparito.

Espandere il nostro esempio per risolvere più problemi

Nel nostro semplice esempio di compilazione Hello World abbiamo un problema che non abbiamo ancora risolto. ciaomain il bersaglio guarda looks ciaomiano.c e ciaodivertente.c timestamp dei file la prossima volta che proverai a ricompilarlo con rendere o fare ciaomain. Quindi, se modifichi uno di questi due file, verranno ricompilati. Ma, se cambi ciaodivertente.h allora non si ricompila. Questo è inaspettato!

Ancora una volta, abbiamo saltato un livello intermedio. Non abbiamo generato i file oggetto e generato direttamente l'eseguibile. Ma, dietro le quinte, i file oggetto vengono creati in una directory temporanea e cancellati. Vogliamo generare i file oggetto prima di costruire l'eseguibile. Questa volta chiamiamo l'obiettivo principale come tutti

tutti: ciaomain.oh ciaofun.o gcc ciaomain.oh ciaofun.o -o ciao ciaomain.o: ciaomain.c ciaofun.h gcc -I. -c ciaomain.c ciaofun.o: ciaofun.c ciaofun.h gcc -I. -c ciaofun.c pulito: rm -rf *.o rm ciao

Esegui nuovamente il comando make per vedere se il tuo programma viene compilato correttamente o meno. Esegui l'eseguibile Hello per verificare il risultato. Guarda la directory corrente e vedrai che vengono creati i file degli oggetti. Abbiamo aggiunto un'altra riga alla destinazione pulita per ripulire i file oggetto. Questo script makefile aiuterà a ricompilare il programma hello world anche se il ciaodivertente.h il file è stato modificato.

Conclusione

Make è uno degli strumenti più essenziali per utenti e programmatori Linux. Se sei un utente finale, la conoscenza di make ti aiuterà a sistemare molte cose rotte nel tuo mondo di Linux. Se sei un programmatore, non puoi andartene scrivendo il codice e lasciare che i tuoi utenti capiscano come compilare quel codice sorgente in eseguibili. Devi creare uno script makefile per gli utenti finali, in modo che non giochino a indovinare per compilare il tuo sorgente in eseguibili.

Riferimenti

Homepage del progetto GNUMake
GNU Make Documentation