Linux make Command con esempi

Introduzione

Il make di Linux command è un'utilità comunemente usata da amministratori di sistema e sviluppatori. Il comando assiste nel processo di compilazione ed è uno strumento indispensabile per la creazione di applicazioni di grandi dimensioni. Questa utility elimina le ripetizioni e velocizza la compilazione, risparmiando tempo.

Questo articolo ti mostrerà come usare Linux make comando con esempi.

Prerequisiti

• Accesso al terminale.
• Il make funzione installata.
• Un editor di testo.

Nota: Se make non è disponibile sul sistema, utilizzare sudo apt install make .

Come funziona il comando make?

Il make comando compila diversi pezzi di programma e costruisce un eseguibile finale. Lo scopo di make è automatizzare la compilazione dei file, rendendo il processo più semplice e meno dispendioso in termini di tempo.

Il comando funziona con qualsiasi linguaggio di programmazione purché il compilatore possa essere eseguito con un comando di shell.

La compilazione è semplice quando si lavora con pochi file. Pertanto, il processo include il richiamo del compilatore e l'elenco dei nomi dei file.

Ad esempio, per compilare un programma C da tre file (file1.c , file2.c , file3.h ):

Richiama il compilatore con:

gcc file1.c file2.c file3.h

Il gcc il comando crea un a.out file, che è un eseguibile compilato standard.

Tuttavia, la modifica di uno dei file di origine richiede la ricompilazione di tutto, il che è ancora più complicato quando si lavora con app di grandi dimensioni. Il make il comando automatizza il processo, consentendo agli utenti di aggiornare solo i pezzi che devono essere modificati senza ricompilare ogni file.

Il make comando utilizza un file generato dall'utente, Makefile, per compilare parti del programma. Quando viene eseguito per la prima volta, make cerca nel Makefile le istruzioni, ad esempio le descrizioni dei file e i tempi di modifica. Sulla base dei dati disponibili, make decide quali file devono essere aggiornati ed emette i comandi necessari.

Cosa sono i makefile?

Un Makefile è un file di testo contenente un insieme di regole che indica make come creare un'applicazione. Una regola è composta da tre parti:il target , dipendenze e comando/i .

La sintassi di base del Makefile è:

target: dependencies
<TAB> commands

Parti della sintassi sono:

• Obiettivi . Nomi dei file da creare o aggiornare dopo l'esecuzione di make .
• Dipendenze . Nomi dei file (separati da spazi) da cui è costruita la destinazione.
• I comandi . Regole che descrivono come creare o aggiornare la destinazione quando cambiano le dipendenze.

Un Makefile ha diversi set di regole. La prima regola è quella predefinita e indica come deve essere creato l'eseguibile finale (il target) da file oggetto non ancora creati (dipendenze):

La sintassi in questo caso è:

EXECUTABLE: Object file 1, Object file 2
<TAB> commands

Nota: I comandi in Makefiles vengono sempre dopo il TAB chiave. In caso contrario, il comando non funziona.

Dopo aver impostato la prima regola, l'utente aggiunge le istruzioni su come creare file oggetto:

Il make Il comando funziona compilando i file di origine in file oggetto e quindi compilando i file oggetto nel file di destinazione, l'eseguibile finale. La sintassi del Makefile con le tre regole sopra menzionate è:

EXECUTABLE: Object file 1, Object file 2
<TAB> commands

Object file 1: Source file 1, Source file 2
<TAB> commands

Object file 2: Source file 2
<TAB> commands

Linux crea la sintassi dei comandi

Il make di base la sintassi è simile a questa:

make [OPTIONS]

Se eseguito senza argomenti, make costruisce il primo target dal Makefile.

Linux crea Opzioni di comando

Il make il comando è ampiamente utilizzato per la sua efficacia, varietà e capacità di eseguire azioni specifiche. Mentre il comando stampa il risultato quando viene eseguito senza opzioni, l'aggiunta di argomenti espande make 's usabilità.

Ecco le opzioni più utilizzate:

Comando	Descrizione
-B , --always-make	Compila incondizionatamente tutti i target.
-d , --debug[=FLAGS]	Stampa le informazioni di debug.
-C dir , --directory=dir	Cambia la directory prima di eseguire il Makefile.
-f file , --file=file , --Makefile=FILE	Utilizza un file specifico come Makefile.
-i , --ignore-errors	Ignora tutti gli errori nei comandi.
-I dir , --include-dir=dir	Specifica una directory in cui cercare il Makefile specificato.
-j [jobs] , --jobs[=jobs]	Specifica il numero di lavori da eseguire contemporaneamente.
-k , --keep-going	Continua a eseguire make il più a lungo possibile dopo aver ricevuto un errore.
-l [load] , --load-average[=load]	Specifica che nessuna nuova attività deve essere avviata se altre attività sono in coda.
-n , --dry-run , --just-print , --recon	Stampa l'output previsto senza eseguire make .
-o file , --old-file=file , --assume-old=file	Garantisce che make non rifa il file anche se è più vecchio delle dipendenze.
-p , --print-data-base	Stampa il database prodotto dopo la lettura del Makefile.
-q , --question	Attiva la modalità Domanda, in cui make non esegue alcun comando ma restituisce uno stato di uscita zero se la destinazione è già compilata.
-r , --no-builtin-rules	Elimina le regole implicite integrate.
-s , --silent , --quiet	Limita la stampa dei comandi mentre vengono eseguiti.
-S , --no-keep-going , --stop	Arresta "-k , --keep-going " comando.
-t , --touch	Tocca i file invece di eseguire i comandi.
--trace	Traccia la disposizione di ogni bersaglio.
-W file , --what-if=file , --new-file=file , --assume-new=file	Ignora il fatto che il file di destinazione è stato modificato.
--warn-undefined-variables	Avvisa che viene fatto riferimento a una variabile sconosciuta.

Linux crea esempi di comandi

Il modo migliore per comprendere make e Makefiles è eseguendo il comando e diverse opzioni su un semplice programma.

Ad esempio, per creare un eseguibile che stampi il messaggio "Learn about Makefiles" , segui questi passaggi:

1. Crea una directory chiamata Test .

2. Crea tre file sorgente main.c , text.c e text.h :

• main.c - è il file con la funzione principale (int main ) che chiama una funzione da un altro file.

• testo.c - è il file con il file che vuoi stampare "Informazioni sui Makefile!".

• testo.h - è il file di intestazione con le dichiarazioni per le funzioni. L'intestazione è inclusa in entrambi c file con il #include argomento, che ha lo stesso scopo di copiare/incollare il contenuto dell'intestazione.

Le sezioni seguenti illustrano alcuni casi d'uso comuni di make e Makefiles sui tre file sopra menzionati.

Nota: I seguenti esempi sono scritti in linguaggio C.

Crea un programma

Esistono due modi per creare un programma:

• Compilare i file nel modo standard invocando il compilatore gcc. Questo metodo è adatto per programmi più piccoli.
• Utilizzo di make e Makefiles.

Crea un programma con il compilatore gcc

Utilizzare il compilatore gcc solo per programmi semplici. Altrimenti, usa Makefiles quando lavori con un gran numero di file.

Per creare un programma con il compilatore:

1. Apri il terminale e vai alla directory contenente i file.

2. Richiamare il gcc compilatore e digita il nome di entrambi c File. L'intestazione non viene compilata perché è già inclusa in c file.

gcc main.c text.c

3. Elenca tutti i file nella directory corrente con il ls comando:

ls

Il terminale mostra che il nuovo eseguibile a.out viene creato il file. L'eseguibile è visibile anche tramite un esploratore di file:

Per verificare se la compilazione è andata a buon fine, richiama l'eseguibile con:

./a.out

Il terminale mostra che l'eseguibile funziona correttamente.

Crea un programma con Make e Makefiles

Compilazione di file con make e Makefiles è più semplice che usare il compilatore. Inizia creando un nuovo documento di testo nella stessa directory e chiamalo Makefile o makefile .

Apri il file e usa la sintassi di base del Makefile come linea guida:

1. Digita il nome del nuovo eseguibile come destinazione, ad esempio mia_app.

2. Aggiungi i file oggetto main.o e text.o come le dipendenze. Il make il comando ricompila la destinazione ogni volta che i file oggetto cambiano.

3. Premi TAB e invoca il gcc compilatore per i file oggetto:

<TAB> gcc main.o text.o

4. Aggiungi il -o contrassegna e assegna un nome alla mia_app di destinazione.

Dopo aver scritto la prima regola, il Makefile si presenta così:

my_app: main.o text.o
<TAB> gcc main.o text.o -o my_app

Quindi, istruisci il Makefile su come creare main.o :

1. Imposta main.o come bersaglio.

2. Digita main.c come la dipendenza. main.c serve per creare e aggiornare main.o .

3. Scrivi il seguente comando per aggiornare main.o ogni volta main.c modifiche:

gcc -c main.c

4. Aggiungi il -c flag per indicare al Makefile di non creare un nuovo eseguibile ma solo di leggere il codice e compilare il file oggetto.

main.o: main.c
<TAB> gcc -c main.c

Per creare text.o , imposta quel file come destinazione e aggiungi entrambi text.c e text.h come dipendenze. Tuttavia, il gcc comando compila solo il text.c file, poiché le intestazioni non vengono mai compilate:

text.o: text.c text.h
<TAB> gcc -c text.c

Salva il Makefile e digita make nel terminale.

Il make comando ha creato due file oggetto (main.o e text.o ) e l'eseguibile (mia_app ).

Per verificare che siano stati creati nuovi file, esegui ls ancora:

Il terminale mostra che l'esecuzione del comando ha creato mia_app . Per eseguire my_app file, digita:

./my_app

Aggiorna il programma

Quando un file sorgente viene modificato, make aggiorna solo i file oggetto a seconda del file di origine. Ad esempio, per modificare il testo visualizzato durante l'esecuzione di my_app da "Ulteriori informazioni sui Makefile " a "Dove sono ?":

1. Apri text.c nell'editor di testo:

2. Modifica il testo in "Dove sono?" :

3. Salva il file, apri il terminale ed esegui make :

Il make comando ha rilevato modifiche in text.c e ho ricompilato solo quel file.

Per verificare la modifica, esegui l'eseguibile:

./my_app

Compila tutti i file

Per compilare tutti i file e non solo i file modificati, usa -B o --always-make opzioni.

Ad esempio, per modificare il testo in text.c file torna a "Ulteriori informazioni sui Makefile" e salva il file, inserisci:

make -B

L'output mostra che make ha compilato tutti i file nella cartella, anche quelli che non sono stati modificati.

Pulisci i file oggetto

Quando un utente esegue make per la prima volta, il comando crea i file oggetto e l'eseguibile. Pertanto, per riordinare la cartella di origine e pulire i file oggetto, aggiungi il clean funzione al Makefile:

clean:
<TAB> rm *.o my_app

Il comando è composto da:

• Il target pulito senza dipendenze - il target è sempre considerato obsoleto e sempre eseguito.
• Il rm comando - rimuove gli oggetti specificati.
• Il *.o parte - abbina i file con o estensione e pulisce i file oggetto e mia_app .

Per pulire i file oggetto, esegui:

make clean

Dopo aver eseguito ls di nuovo, il terminale mostra che i file oggetto e mia_app sono stati rimossi.

Esegui make in modalità debug

Esegui make in modalità debug per stampare informazioni aggiuntive sul processo di compilazione. Esegui make con il -d opzione per visualizzare l'output di debug:

make -d

Usa un file diverso come Makefile

Per impostazione predefinita, make cerca un file chiamato Makefile o makefile nella directory corrente. Per utilizzare un altro file, esegui:

make -f [file_name]

Ad esempio, se un Makefile è denominato mio_file , esegui:

make -f my_file

Utilizza variabili

Le variabili nei Makefile rappresentano più nomi di file, argomenti, destinazioni, dipendenze, comandi, directory di origine o altri elementi. Inoltre, una variabile è definita da un nome e rappresenta una stringa di testo chiamata valore della variabile.

Per definire una variabile, usa = . Ad esempio, sostituisci gcc con una variabile C.

C=gcc

my_app: main.o text.o
<TAB> $ (C) main.o text.o -o my_app

main.o:main.c
<TAB> $ (C) -c main.c
        
text.o: text.c text.h
<TAB> $ (C) -c text.c

Durante l'esecuzione di make nel terminale, il comando legge il C variabile come gcc :

Conclusione

Dopo aver esaminato gli esempi in questo tutorial, sai come utilizzare il make comando in Linux e come funziona.

Quindi, scarica il cheat sheet dei comandi Linux per imparare altri importanti comandi Linux.