GNU Make Tutorial

GNU Make è uno strumento essenziale per costruire e gestire i progetti, in particolare laddove il progetto contiene file diversi utilizzati utilizzando strumenti diversi. In tal caso, GNU Make individua il makefile per quel progetto poiché il file specifica le dipendenze richieste tra vari file nel progetto indicato e i comandi necessari per creare il progetto.

GNU Make è progettato per gestire grandi progetti. Determina le sezioni di un programma che devono essere ricompilate dopo una determinata azione e offre ai comandi di ricompilare le sezioni. Il post di oggi fornisce una guida pratica per capire tutto ciò che riguarda GNU.

Comprendere un makefile

GNU Make Reads il makefile di un progetto per determinare cosa dovrebbe fare per costruire e gestire il progetto. Un makefile ha tre componenti chiave: Target, prerequisito e ricetta.

UN bersaglio rappresenta il file che il "Fare"Il comando può generare. Il bersaglio può dipendere dai prerequisiti e può anche essere un'azione da svolgere. Idealmente, il target evidenzia il file da costruire una volta eseguito il "Fare"Comando.

UN prerequisito rappresenta il file da utilizzare come input per la creazione del target. Un bersaglio può dipendere da più prerequisiti.

UN ricetta è un'azione o un comando che viene effettuato da "Fare"Per ricompilare il bersaglio ogni volta che il prerequisito cambia. La ricetta può contenere comandi diversi sulla stessa o diverse righe. UN SCAP SPAZIO precede ogni nuova riga di ricette e l'editor raccoglie un errore se si perde aggiungendo il carattere della scheda.

IL ricetta funge da serie di comandi shell che iniziano con un carattere di scheda. Ecco un esempio di un semplice makefile che evidenzia il bersaglio, i prerequisiti e la ricetta:

Il makefile fornito è costituito da una regola nella ricetta. Nota che Make usa la prima regola nel makefile come regola predefinita. Quindi, in un tale makefile, "Fare"Usa il gcc -o benvenuto fantastico.C di norma per costruire e gestire il progetto. La regola specifica che per far sì che il file generi il Benvenuto file, dobbiamo eseguire il comando che utilizza il Grande.C come input per creare il Benvenuto file.

Ancora una volta, non tutte le regole hanno un prerequisito. Ad esempio, se si dispone di un makefile per eliminare i file intermedi creati durante la creazione di un file, tale regola non avrà alcun prerequisito. Dai un'occhiata al seguente esempio:

In questo caso, la regola elimina tutti i file che contiene un *.o Estensione. Pertanto, non è richiesto un prerequisito in tal caso come non è richiesta alcuna ricompilazione dell'obiettivo.

Lavorare con un makefile

Il primo esempio è un semplice progetto C con due file C e un file di intestazione. Creiamo una funzione che stampa un messaggio di benvenuto e include un file di intestazione esterno nel nostro progetto.

Ecco la funzione principale:

I nostri file di intestazione sembrano i seguenti:

Ora, creiamo un makefile che compila i file di progetto per creare un file eseguibile nella directory corrente. Idealmente, eseguiamo il seguente comando per creare il progetto:

$ gcc -o greatmake mainfunc.c func1.c -i.

Nella seguente immagine, possiamo notare come la compilazione crea correttamente il progetto. Se eseguiamo il file eseguibile creato, otteniamo l'output desiderato.

Come possiamo rappresentare lo stesso e usare invece un makefile? Ecco la cosa: anche se la compilazione diretta del progetto sulla riga di comando funziona bene, il problema arriva quando si cambia i computer o perdi il codice di compilazione. In tal caso, è necessario ricompilare il progetto. Ancora una volta, ogni volta che si apportano modifiche a un file, è necessario ricompilare manualmente il progetto per soddisfare le modifiche.

Tutta questa seccatura può essere esclusa creando un semplice makefile come mostrato nel seguente:

Il makefile contiene due obiettivi: uno con prerequisiti e un comando e l'altro con solo il comando.

In precedenza, abbiamo notato che "Fare"Utilizza il primo comando come comando predefinito per creare il progetto. Quindi, possiamo digitare Fare Nella directory del progetto per eseguire il comando per la creazione del progetto. Il comando Make genera l'obiettivo che è Grandemake Come file eseguibile. Dai un'occhiata al seguente:

Ora possiamo eseguire comodamente il file eseguibile per vedere l'output del progetto creato.

$ ./file di uscita

Supponiamo di usare "Fare"Per eseguire un altro comando anziché quello predefinito. Specificare l'obiettivo che si desidera eseguire con il comando Make.

$ Make Target

Usiamo lo stesso makefile e usiamo il ciao target:

Nota come riusciamo a ottenere "Fare"Per eseguire il comando in quanto non sono specificati prerequisiti con il target.

Se apportiamo alcune modifiche a uno dei file nel progetto, eseguendo "Fare"Il comando accoglie le modifiche senza bisogno di ricompilare il progetto manualmente.

Comunque, se esegui il "Fare"Comando senza nuove modifiche,"Fare"Ti avvisa che il file eseguibile è aggiornato.

Supponiamo di non essere sicuro delle modifiche apportate o di ciò che fa il comando Make quando eseguito. Puoi fare una corsa a secco aggiungendo la bandiera -n.

Il primo esempio nella seguente illustrazione, la marca -N, mostra il comando che viene eseguito con il comando predefinito. Nel caso successivo, la make -n mostra le modifiche che vengono aggiunte al bersaglio Hello.

Se ti senti a tuo agio con le modifiche, è possibile eseguire il comando Make per l'obiettivo dato per accogliere le modifiche come nell'esempio seguente:

Come utilizzare le variabili Makefile

Finora abbiamo capito come "Fare"Funziona con un makefile. Tuttavia, il nostro approccio finora non è il migliore per gestire grandi progetti, specialmente in cui alcuni valori devono cambiare con il tempo. Un approccio migliore prevede l'uso di variabili in modo tale che se si desidera modificare il compilatore per il programma, è possibile modificare la variabile anziché modificare manualmente il codice Makefile per il compilatore.

Inoltre, le variabili aiutano a ottenere un codice makefile pulito che chiunque può leggere e capire.

Abbiamo un esempio di utilizzo delle variabili per creare file.

In Makefile, definiamo una variabile denominata File che contiene due valori per i file che creiamo quando creiamo il progetto:

In questo esempio, facciamo riferimento al nostro precedente esempio di compilazione del programma C. Ma, in questo caso, aggiungiamo alcune variabili che possiamo cambiare durante il programma.

Innanzitutto, specifichiamo il percorso che il compilatore dovrebbe utilizzare per individuare i file di intestazione come directory corrente (.). Un approccio migliore è specificare il percorso come variabile. È possibile specificare la variabile che deve essere utilizzata dal compilatore utilizzando il Cflags costanti speciali che vengono utilizzate per comunicare con il compilatore.

Cflags = -i.

Usa il $ (Cflags) segnaposto variabile al posto del percorso.

Tuttavia, possiamo impostare il tipo di tipo da utilizzare come variabile, in modo tale che qualcuno che usi un compilatore diverso possa modificare la variabile per specificare un compilatore da utilizzare per il loro caso.

CC = GCC

Usa il $ (CC) segnaposto variabile al posto del compilatore. Ecco il makefile finale con le variabili aggiunte:

Quando eseguiamo il comando Make, otteniamo lo stesso output che abbiamo fatto in precedenza, solo che il nostro codice Makefile è ora più pulito e abbiamo eliminato eventuali licenziamenti.

Quando si crea il makefile, puoi creare una macro Obj Per rappresentare i prerequisiti necessari per creare un target. In questo modo, puoi modificare rapidamente i file di oggetti dalla macro senza manomissione dell'altro makefile. Ad esempio, possiamo avere un macro obj per il nostro obiettivo come mostrato nel seguente:

Si noti che sostituiamo i prerequisiti con la variabile dell'oggetto.

Gestione delle dipendenze

IL "includereI file dipendono da ".C"File nel progetto. Quando si lavora con un grande progetto e modifichi il "includere" file, "Make" non ricompilerà il ".C" File. Questo errore significa che il tuo progetto non verrà ricompilato correttamente a meno che non facciamo notare le dipendenze esistenti tra ".C" E ".H" File.

In tal caso, dobbiamo usare la costante speciale Deps Per creare una macro per gestire queste dipendenze. Possiamo rappresentare i DEP come regola, come mostrato da segue:

La regola precedente prima crea un file Deps Macro il cui valore è il file di intestazione nei file di progetto. Successivamente, istruisce "Fare"Che prima che genera il".o"File, deve prima compilare il".C"File utilizzando il compilatore specificato. Successivamente, il flag -c indica il compilatore per generare un file oggetto mentre il -o $@ istruzioni "Fare"Per mettere l'output compilato a sinistra del colon.

Con questa regola, gestiamo tutte le dipendenze in modo tale che ogni volta che cambiamo qualsiasi file, "Fare"Lo accoglie quando si ricompila il progetto.

Aggiunta di altri makefiles

Quando si lavora con un makefile, è possibile includere gli altri makefiles. In questo modo, l'attuale makefile può leggere dai makefiles inclusi per supportare la compilation.

Per includere altri makefiles, aggiungi il includere parola chiave che istruisce "Fare"Per mettere in pausa la lettura dell'attuale makefile e leggere l'altro incluso Makefiles.

Includi nomi di file

È inoltre possibile includere altri tipi di file con la parola chiave include, a condizione che si aggiunga la spaziatura tra i nomi dei file.

Dividere le lunghe linee in makefiles

Sebbene "Fare"Non ha limiti a quanto tempo può essere a lungo, le frasi lunghe diventano rapidamente illeggibili e sono cattive formattazione di formattazione. Gnu "Fare"Accoglie la divisione di lunghe frasi aggiungendo il carattere di backslash.

Obj = mainfunc.C \
func1.C

In questo esempio, "Fare"Legge la riga precedente come Obj = mainfunc.c func1.C e ignora il retroscena.

Nell'immagine fornita, abbiamo diviso la linea di ricetta con una retroscena.

Supponiamo di voler rappresentare una parola senza aggiungere uno spazio bianco. Sostituisci la retroscena con un cartello in dollari, una retroscena e una nuova linea.

Ecco un esempio:

Quando "Fare"Legge il makefile, prima ignora la retroscena per una nuova riga. Successivamente, legge il segno del dollaro come uno spazio che rappresenta una variabile con un carattere.

Pertanto, alla fine tratta le tue linee divise come una parola senza spazio bianco. Quando usiamo "Fare"Per leggere il makefile, non otteniamo errori da"Fare"Tratta le linee divise nella variabile come una parola.

Pulire una directory

Una volta compilato un programma usando "Fare"Potrebbe essere necessario pulire i file non necessari che vengono generati come output. Sebbene sia possibile creare un obiettivo pulito, questo non è l'approccio consigliato, come mostrato nel seguente:

L'immagine precedente istruisce "Fare" Per eliminare tutti i file di testo e ".o"File di estensione creati nella directory corrente.

Per gestire le situazioni impreviste, è meglio creare una regola più precisa e assicurarsi di non aggiungerla come regola predefinita (prima) nel makefile.

Quando si esegue la regola pulita, usa il “Rendi pulito"Comando.

Conclusione

GNU "Make" è uno strumento utile per costruire e gestire piccoli e grandi progetti. Sapere come usarlo è un ulteriore vantaggio, in quanto ti aiuta a leggere i tuoi makefile e compilare i tuoi progetti in modo ordinato. Abbiamo imparato a usare la GNU "Fare"Infine e come lavorare con un makefile, inclusa la comprensione su come make legge il makefile. Speriamo che questa guida abbia gettato una base per migliorare le tue competenze GNU nella gestione dei tuoi progetti.