Su sistemi operativi simili a Unix, make è un'utilità per la creazione e la gestione di gruppi di programmi (e altri tipi di file) dal codice sorgente.
Questo documento tratta della versione GNU / Linux di make.
Descrizione
Lo scopo dell'utility make è determinare automaticamente quali parti di un programma di grandi dimensioni devono essere ricompilate ed emettere i comandi necessari per ricompilarle. Questa documentazione descrive l'implementazione GNU di make, che è stata scritta da Richard Stallman e Roland McGrath, ed è attualmente gestita da Paul Smith. Molti degli esempi elencati di seguito mostrano i programmi C, poiché sono più comuni, ma è possibile utilizzare make con qualsiasi linguaggio di programmazione il cui compilatore può essere eseguito con un comando shell. In effetti, make non è limitato ai programmi. Puoi usarlo per descrivere qualsiasi attività in cui alcuni file devono essere aggiornati automaticamente da altri ogni volta che cambiano gli altri.
Per preparare l'uso di make, è necessario scrivere un file chiamato makefile che descriva le relazioni tra i file nel programma e gli stati i comandi per l'aggiornamento di ciascun file. In un programma, in genere il file eseguibile viene aggiornato dai file oggetto, che a loro volta vengono creati compilando i file di origine.
Una volta che esiste un makefile adatto, ogni volta che modifichi alcuni file sorgente, questo semplice comando shell:
make
è sufficiente eseguire tutte le ricompilazioni necessarie. Il programma make utilizza la base dati makefile e i tempi dell'ultima modifica dei file per decidere quali file devono essere aggiornati. Per ciascuno di quei file, emette i comandi registrati nel database.
make esegue i comandi nel makefile per aggiornare uno o più nomi di destinazione, dove nome è in genere un programma. Se non è presente alcuna opzione -f, make cercherà i makefile GNUmakefile, makefile e Makefile, in questo ordine.
Normalmente dovresti chiamare il tuo makefile o makefile o Makefile. (Il nome ufficialmente raccomandato è Makefile perché appare in primo piano all'inizio di un elenco di directory, proprio accanto ad altri file importanti come README.) Il nome controllato, GNUmakefile, non è raccomandato per la maggior parte dei makefile. Dovresti usare questo nome se hai un makefile specifico per GNU make e che non sarà compreso da altre versioni di make. Se makefile è un trattino ("-"), viene letto l'input standard.
rendere gli aggiornamenti una destinazione se dipende da file prerequisiti che sono stati modificati dall'ultima modifica della destinazione o se la destinazione non esiste.
Sintassi
make [-f makefile] [opzioni] ... [target] ...
Opzioni
| -b, -m | Queste opzioni vengono ignorate, ma incluse per la compatibilità con altre versioni di make. |
| -B, - sempre-make | Crea incondizionatamente tutti gli obiettivi. |
| -C dir, --directory = dir | Passare alla directory directory prima di leggere i makefile o fare qualsiasi altra cosa. Se vengono specificate più opzioni -C, ognuna viene interpretata rispetto alla precedente: -C / -C ecc è equivalente a -C / ecc. Questo è tipicamente usato con invocazioni ricorsive di make. |
| -d | Stampa le informazioni di debug oltre alla normale elaborazione. Le informazioni di debug indicano quali file vengono considerati per il rifacimento, quali tempi dei file vengono confrontati e con quali risultati, quali file devono essere rifatti, quali regole implicite vengono prese in considerazione e quali vengono applicate; tutto ciò che è interessante su come make decide cosa fare. |
| --debug [= flags] | Stampa le informazioni di debug oltre alla normale elaborazione. Se i FLAGS vengono omessi, il comportamento è lo stesso di se fosse stato specificato -d. FLAGS può essere a per tutto l'output di debug (uguale all'utilizzo di -d), b per il debug di base, v per il debug di base più dettagliato, i per mostrare le regole implicite, j per i dettagli sull'invocazione dei comandi e m per il debug durante il rifacimento dei makefile. |
| -e, --enorme per l'ambiente | Dai alle variabili prese dall'ambiente la precedenza sulle variabili dai makefile. |
| -f file, --file = file, --makefile = file | Usa il file come makefile. |
| -i, --ignore-errori | Ignora tutti gli errori nei comandi eseguiti per rifare i file. |
| -I dir, --include-dir = dir | Specifica una directory directory per la ricerca di makefile inclusi. Se vengono utilizzate più opzioni -I per specificare più directory, le directory vengono cercate nell'ordine specificato. A differenza degli argomenti di altre bandiere di marca, le directory fornite con le bandiere -I possono venire direttamente dopo la bandiera: -Idir è consentito, così come -I dir. Questa sintassi è consentita per la compatibilità con il flag -I del preprocessore C. |
| -j [jobs], --jobs [= jobs] | Specifica il numero di lavori (comandi) da eseguire contemporaneamente. Se esiste più di un'opzione -j, l'ultima è efficace. Se l'opzione -j viene fornita senza un argomento, make non limiterà il numero di lavori che possono essere eseguiti contemporaneamente. |
| -k, -keep-going | Continua il più possibile dopo un errore. Mentre il target che ha fallito (e quelli che dipendono da esso) non possono essere rifatti, le altre dipendenze di questi target possono essere elaborate lo stesso. |
| -l [carica], --load-media [= carico] | Specifica che non è necessario avviare nuovi lavori (comandi) se vi sono altri lavori in esecuzione e la media del carico è almeno carico (un numero in virgola mobile). Senza alcun argomento, rimuove un limite di carico precedente. |
| -L, --check-symlink-times | Utilizzare qualunque sia il tempo di modifica più recente tra collegamenti simbolici e destinazione. |
| -n, --just-print, --dry-run, --recon | Stampa i comandi che verrebbero eseguiti, ma non eseguirli. |
| -o file, --old-file = file, --assume-old = file | Non rifare il file anche se è più vecchio delle sue dipendenze e non rifare nulla a causa delle modifiche al file. Essenzialmente il file viene considerato molto vecchio e le sue regole vengono ignorate. |
| -p, --print-data-base | Stampa il database (regole e valori variabili) che risulta dalla lettura dei makefile; quindi eseguire come al solito o come diversamente specificato. Questo stampa anche le informazioni sulla versione fornite dall'opzione -v (vedere sotto). Per stampare il database senza provare a rifare alcun file, usare make -p -f / dev / null. |
| -q, --question | "Modalità domanda". Non eseguire alcun comando o stampare nulla; restituisce uno stato di uscita pari a zero se le destinazioni specificate sono già aggiornate, altrimenti diverso da zero. |
| -r, --no-builtin-regole | Elimina l'uso delle regole implicite integrate. Inoltre, cancellare l'elenco predefinito di suffissi per le regole del suffisso. |
| -R, --no-builtin-variabili | Non definire alcuna variabile incorporata. |
| -s, --silent, --quiet | Funzionamento silenzioso; non stampare i comandi mentre vengono eseguiti. |
| -S, --no-keep-going, --stop | Annulla l'effetto dell'opzione -k. Questo non è mai necessario se non in una marca ricorsiva in cui -k potrebbe essere ereditato dalla marca di livello superiore tramite MAKEFLAGS o se si imposta -k in MAKEFLAGS nel proprio ambiente. |
| -t, --touch | Toccare i file (contrassegnarli come aggiornati senza modificarli realmente) invece di eseguire i loro comandi. Questo è usato per fingere che i comandi fossero stati eseguiti, per ingannare future invocazioni di make. |
| -v, --version | Stampa la versione di make; anche un Copyright, un elenco di autori e un avviso che non esiste alcuna garanzia. |
| -w, --print-directory | Stampa un messaggio contenente la directory di lavoro prima e dopo altre elaborazioni. Questo può essere utile per rintracciare gli errori da nidi complicati di comandi make ricorsivi. |
| --no-print-directory | Disattiva -w, anche se è stato attivato implicitamente. |
| -W file, --what-if = file, --new-file = File, --assume-new = File | Fai finta che il file di destinazione sia appena stato modificato. Se usato con il flag -n, mostra cosa succederebbe se si modificasse quel file. Senza -n, è quasi uguale all'esecuzione di un comando touch sul file dato prima di eseguire make, tranne per il fatto che il tempo di modifica è cambiato solo internamente a make. |
| -variabili --warn-undefined | Avvisa quando si fa riferimento a una variabile non definita. |
Uso tipico
make viene in genere utilizzato per creare programmi eseguibili e librerie dal codice sorgente. In generale, make è applicabile a qualsiasi processo che comporta l'esecuzione di comandi arbitrari per trasformare un file sorgente in un risultato di destinazione. Ad esempio, make potrebbe essere utilizzato per rilevare una modifica apportata a un file di immagine (l'origine) e le azioni di trasformazione potrebbero essere di convertire il file in un formato specifico, copiare il risultato in un sistema di gestione dei contenuti e quindi inviare e-mail a un set predefinito di utenti che sono state eseguite le azioni sopra.
make viene invocato con un elenco di nomi di file di destinazione da compilare come argomenti della riga di comando:
make [TARGET ...]
Senza argomenti, make crea il primo target che appare nel suo makefile, che è tradizionalmente un target chiamato all.
make decide se un target deve essere rigenerato confrontando i tempi di modifica dei file. Questo risolve il problema di evitare la creazione di file che sono già aggiornati, ma fallisce quando un file cambia ma il suo tempo di modifica rimane nel passato. Tali modifiche potrebbero essere causate dal ripristino di una versione precedente di un file di origine o quando un file system di rete è una fonte di file e il suo orologio o fuso orario non è sincronizzato con la macchina in esecuzione. L'utente deve gestire questa situazione forzando una build completa. Al contrario, se il tempo di modifica di un file di origine è futuro, potrebbe essere necessaria una ricostruzione non necessaria.
Makefiles
make cerca nella directory corrente il makefile da usare. GNU make cerca i file per un file chiamato GNUmakefile, makefile e quindi Makefile, ed esegue le destinazioni specificate da quel file.
Il linguaggio del makefile è simile alla programmazione dichiarativa, in cui sono descritte le condizioni finali necessarie ma l'ordine in cui devono essere intraprese le azioni non è importante. Ciò può confondere i programmatori abituati alla programmazione imperativa, che descrive esplicitamente come verrà raggiunto il risultato finale.
Un problema nell'automazione della compilazione è l'adattamento di un processo di compilazione a una determinata piattaforma. Ad esempio, il compilatore utilizzato su una piattaforma potrebbe non accettare le stesse opzioni di quello utilizzato su un'altra. Questo non è ben gestito da solo. Questo problema viene in genere gestito generando istruzioni di costruzione separate specifiche della piattaforma, che a loro volta possono essere elaborate da make. Gli strumenti comuni per questo processo sono autoconf e cmake.
Regole
Un makefile consiste essenzialmente di regole. Ogni regola inizia con una linea di dipendenza che definisce un target seguito da due punti (":") e facoltativamente da un elenco di componenti (file o altri target) da cui dipende il target. La linea di dipendenza è disposta in modo che il bersaglio (mano sinistra dei due punti) dipenda dai componenti (mano destra dei due punti). È comune fare riferimento ai componenti come prerequisiti del target.
target [target ...]: [component ...] [<TAB> comando 1]. . . [<TAB> comando n]
Qui, <TAB> è il carattere di tabulazione. Di solito ogni regola ha un unico target unico, anziché più target.
Ad esempio, un file oggetto C .o viene creato dai file .c, quindi i file .c vengono prima di tutto (ovvero la destinazione del file oggetto specifico dipende da un file sorgente C e dai file di intestazione). Poiché make stesso non comprende, riconosce o distingue diversi tipi di file, questo apre la possibilità di errore umano. Una dipendenza dimenticata o extra può non essere immediatamente ovvia e può causare bug sottili nel software generato. È possibile scrivere makefile che generano queste dipendenze chiamando strumenti di terze parti e alcuni generatori di makefile, come la toolchain GNU automake, possono farlo automaticamente.
Dopo ogni riga di dipendenza, può seguire una serie di righe di comando che definiscono come trasformare i componenti (di solito i file di origine) nella destinazione (di solito "output"). Se uno qualsiasi dei componenti è stato modificato, vengono eseguite le righe di comando.
Con GNU make, il primo comando può apparire sulla stessa riga dopo i prerequisiti, separati da un punto e virgola:
obiettivi: prerequisiti; comando
per esempio:
Ciao: ; @echo "ciao"
Ogni riga di comando deve iniziare con un carattere di tabulazione per essere riconosciuto come comando. La scheda è un carattere di spazio bianco, ma il carattere di spazio non ha lo stesso significato speciale. Ciò è problematico, poiché potrebbe non esserci alcuna differenza visiva tra una scheda e una serie di caratteri spaziali. Questo aspetto della sintassi dei makefile è spesso soggetto a critiche ed è importante prenderne atto.
Tuttavia, GNU make (dalla versione 3.82) consente all'utente di scegliere qualsiasi simbolo (un carattere) come prefisso della ricetta usando la variabile speciale .RECIPEPREFIX, ad esempio:
.RECIPEPREFIX: =: all:: @echo "Il simbolo del prefisso della ricetta è impostato su '$ (. RECIPEPREFIX)'"
Ogni comando viene eseguito da una shell separata o dall'istanza dell'interprete della riga di comando. Poiché i sistemi operativi utilizzano diversi interpreti della riga di comando, ciò può portare a makefile non portabili. Ad esempio, GNU make di default esegue i comandi con / bin / sh, che è la shell in cui vengono normalmente usati i comandi Unix come cp.
Una regola potrebbe non avere linee di comando definite. La linea di dipendenza può consistere esclusivamente di componenti che fanno riferimento a target, ad esempio:
realclean: clean distclean
Le righe di comando di una regola sono generalmente disposte in modo da generare il target. Un esempio: se "file.html" è più recente, viene convertito in testo. I contenuti del makefile:
file.txt: file.html lynx -dump file.html> file.txt
La regola di cui sopra verrebbe attivata quando si effettuano aggiornamenti "file.txt".
Nella seguente chiamata, make userebbe in genere questa regola per aggiornare la destinazione "file.txt" se "file.html" fosse più recente:
make file.txt
Le righe di comando possono avere uno o più dei seguenti tre prefissi:
- un trattino-meno (-), che specifica che gli errori vengono ignorati
- un segno at (@), che specifica che il comando non viene stampato sull'output standard prima di essere eseguito
- un segno più (+), il comando viene eseguito anche se make è invocato in modalità "non eseguire"
Ignorare gli errori e mettere a tacere tutto l'eco può essere ottenuto anche tramite gli obiettivi speciali ".IGNORE" e ".SILENT", rispettivamente.
Macro
Un makefile può contenere definizioni di macro. Le macro sono generalmente indicate come variabili quando contengono definizioni di stringhe semplici, come "CC = clang", che specifica clang come compilatore C. Le macro nei makefile possono essere sovrascritte negli argomenti della riga di comando passati all'utility make. le variabili d'ambiente sono disponibili anche come macro.
Le macro consentono agli utenti di specificare i programmi richiamati e altri comportamenti personalizzati durante il processo di compilazione. Ad esempio, come appena mostrato, la macro "CC" viene spesso utilizzata nei makefile per fare riferimento alla posizione di un compilatore C.
Le nuove macro sono tradizionalmente definite usando le lettere maiuscole:
MACRO = definizione
Una macro viene utilizzata espandendola. Tradizionalmente questo viene fatto racchiudendo il suo nome all'interno di $ (). Una forma equivalente utilizza parentesi graffe anziché parentesi, ad esempio $ {}, che è lo stile utilizzato nei sistemi operativi BSD.
NEW_MACRO = $ (MACRO) - $ (MACRO2)
Le macro possono essere composte da comandi shell utilizzando l'operatore di sostituzione comandi, indicato da backtick ("` `").
AAAAMMGG = `data`
Il contenuto della definizione viene archiviato "così com'è". Viene utilizzata la valutazione lenta, il che significa che le macro vengono normalmente espanse solo quando sono effettivamente necessarie le loro espansioni, ad esempio quando vengono utilizzate nelle righe di comando di una regola. Per esempio:
PACCHETTO = pacchetto VERSIONE = `data +"% Y.% m% d "` ARCHIVIO = $ (PACCHETTO) - $ (VERSIONE) dist: # Notare che solo ora le macro vengono espanse affinché la shell possa interpretare: # tar -cf package- `date +"% Y% m% d "` .tar tar -zcf $ (ARCHIVIO) .tar.
La sintassi generica per l'override delle macro nella riga di comando è:
make MACRO = "value" [MACRO = "value" ...] TARGET [TARGET ...]
I makefile possono accedere a qualsiasi numero di macro interne predefinite, con "?" e "@" è il più comune.
target: component1 component2 echo $? contiene quei componenti che richiedono attenzione (ovvero SONO PIÙ GIOVANI dell'attuale TARGET). echo [e-mail protetta] valuta l'attuale nome TARGET tra quelli a sinistra dei due punti.
Regole del suffisso
Le regole del suffisso hanno "target" con nomi nel formato .FROM.TO e vengono utilizzate per avviare azioni basate sull'estensione del file. Nelle righe di comando delle regole del suffisso, POSIX specifica che la macro interna "$ <" si riferisce al primo prerequisito e "[e-mail protetto]" si riferisce alla destinazione. In questo esempio, che converte qualsiasi file HTML in testo, il token di reindirizzamento della shell ">" fa parte della riga di comando mentre "$ <" è una macro che fa riferimento al file HTML:
.SUFFIXES: .txt .html # Da .html a .txt .html.txt: lynx -dump $ <> [e-mail protetta]
Quando viene chiamato dalla riga di comando, l'esempio sopra espande il comando:
make -n file.txt
in:
lynx -dump file.html> file.txt
Altri elementi
- I commenti a riga singola vengono avviati con il simbolo hash ("#").
- Alcune direttive nei makefile possono includere altri makefile.
- La continuazione della riga è indicata da una barra rovesciata ("") alla fine di una riga, come nel caso seguente:
target: comando component <TAB> componente; Comando <TAB> | <TAB> comando piped
Stato di uscita
GNU effettua le uscite con uno stato di:
- 0 se tutti i makefile sono stati analizzati correttamente e nessun obiettivo creato è fallito;
- 1 se il flag -q è stato usato e make determina che un target deve essere ricostruito; e
- 2 se si sono verificati errori.
Esempi
I makefile sono tradizionalmente utilizzati per la compilazione di codice (* .c, * .cc, * .C, ecc.), Ma possono anche essere utilizzati per fornire comandi per automatizzare attività comuni.
Ecco un esempio di tre modi per eseguire make dato un determinato makefile. I comandi di make sono elencati per primi, quindi il makefile:
make
Senza alcun argomento, make eseguirà il primo obiettivo;
dare aiuto
Quando viene fornito l'argomento della guida, make mostrerà gli obiettivi disponibili;
fare dist
Quando viene dato l'argomento dist, make creerà un archivio di rilascio dalla directory corrente.
Ecco il makefile per i comandi make sopra:
PACCHETTO = pacchetto VERSIONE = `data" +% Y.% m% d% "` RELEASE_DIR = .. RELEASE_FILE = $ (PACCHETTO) - $ (VERSIONE) # Notare che la variabile LOGNAME proviene dall'ambiente nelle shell # POSIX. # # target: all - Target predefinito. Non fa nulla. all: echo "Hello $ (LOGNAME), niente da fare per impostazione predefinita" # a volte: echo "Hello $ {LOGNAME}, niente da fare per impostazione predefinita" echo "Prova 'make help'" # target: help - Visualizza target richiamabili. help: egrep "^ # target:" [Mm] akefile # target: list - Elenco dei file di origine dell'elenco: # Non funzionerà. Ogni comando è nella shell separata cd src ls # Corretto, continuazione della stessa shell cd src; # ls # target: dist - Crea una liberatoria. dist: tar -cf $ (RELEASE_DIR) / $ (RELEASE_FILE) && gzip -9 $ (RELEASE_DIR) / $ (RELEASE_FILE) .tar
Quindi, ecco un makefile molto semplice che per impostazione predefinita (la regola "all", che è elencata per prima) compila un file sorgente chiamato "helloworld.c" usando il compilatore C del sistema, e fornisce anche una destinazione "pulita" per rimuovere il file generati se l'utente desidera ricominciare da capo. [E-mail protette] e $ <sono due macro interne (note anche come variabili automatiche) che corrispondono rispettivamente al nome di destinazione e alla fonte implicita. Nell'esempio seguente, $ ^ si espande in un elenco delimitato da spazi dei prerequisiti.
Ecco il makefile:
CFLAGS? = -G tutto: helloworld helloworld: helloworld.o # I comandi iniziano con TAB non spazi $ (CC) $ (LDFLAGS) -o [e-mail protetto] $ ^ helloworld.o: helloworld.c $ (CC) $ (CFLAGS ) -c -o [e-mail protetta] $ <clean: FRC rm -f helloworld helloworld.o # Questo pseudo target fa sì che tutti gli obiettivi che dipendono da FRC # vengano rifatti anche nel caso in cui esista un file con il nome dell'obiettivo. # Funziona con qualsiasi implementazione make presupponendo che # non ci siano file FRC nella directory corrente. FRC:
Molti sistemi sono dotati di regole e macro predefinite per specificare attività comuni come la compilazione basata sul suffisso del file. Ciò consente all'utente di omettere le istruzioni effettive (spesso non portabili) su come generare la destinazione dalle fonti. Su un tale sistema il makefile sopra potrebbe essere modificato come segue:
tutto: helloworld helloworld: helloworld.o $ (CC) $ (CFLAGS) $ (LDFLAGS) -o [e-mail protetto] $ ^ clean: FRC rm -f helloworld helloworld.o # Questa è una regola esplicita del suffisso. Può essere omesso su sistemi # che gestiscono automaticamente semplici regole come questa. .co: $ (CC) $ (CFLAGS) -c $ <FRC: .SUFFIXES: .c
Usando questo makefile, il fatto che "helloworld.o" dipenda da "helloworld.c" è ora gestito automaticamente da make. In questo semplice esempio questo non importa, ma il vero potere delle regole del suffisso diventa evidente quando il numero di file sorgente in un progetto software inizia a crescere. Basta scrivere una regola per il passaggio di collegamento e dichiarare i file oggetto come prerequisiti. make determinerà quindi implicitamente come effettuare tutti i file oggetto e cercare le modifiche in tutti i file sorgente.
Le regole del suffisso semplice funzionano bene purché i file di origine non dipendano l'uno dall'altro e da altri file come i file di intestazione. Un altro percorso per semplificare il processo di compilazione consiste nell'utilizzare regole di corrispondenza dei modelli che possono essere combinate con la generazione di dipendenza assistita dal compilatore.
Il prossimo esempio richiede il compilatore gcc. È un makefile generico che compila tutti i file C in una cartella nei file oggetto corrispondenti e li collega all'eseguibile finale. Prima che avvenga la compilazione, le dipendenze vengono raccolte in un formato compatibile con makefile in un file nascosto ".depend" che viene quindi incluso nel makefile.
# Generic GNUMakefile # Solo uno snippet per interrompere l'esecuzione con altri comandi make (1) # che non capiranno queste righe ifneq (,) Questo makefile richiede GNU Make. endif PROGRAM = foo C_FILES: = $ (carattere jolly * .c) OBJS: = $ (patsubst% .c,% .o, $ (C_FILES)) CC = cc CFLAGS = -WALL -pedantic LDFLAGS = all: $ (PROGRAMMA) $ (PROGRAMMA): .depend $ (OBJS) $ (CC) $ (CFLAGS) $ (OBJS) $ (LDFLAGS) -o $ (PROGRAM) dipendono: .depend .depend: cmd = gcc -MM -MF dipendono $ ( var); gatto dipende >> .dipendente; .depend: @echo "Generazione di dipendenze ..." @ $ (foreach var, $ (C_FILES), $ (cmd)) @rm -f depend -include .depend # Queste sono le regole di corrispondenza del modello. Oltre alle # variabili automatiche utilizzate qui, la variabile $ * che corrisponde a qualsiasi% sta per # può essere utile in casi speciali. % .o:% .c $ (CC) $ (CFLAGS) -c $ <-o [protezione e-mail]%:% .c $ (CC) $ (CFLAGS) -o [protezione e-mail] $ <clean: rm - f .depend * .o .PHONY: clean depend
Comandi correlati
cd - Cambia la directory di lavoro.sh - L'interprete dei comandi della shell Bourne.
#goog-gt-tt {display:none !important;}.goog-te-banner-frame {display:none !important;}.goog-te-menu-value:hover {text-decoration:none !important;}body {top:0 !important;}#gtranslate_element {display:none!important;}
var gt_not_translated_list = ["-b, -m","-L, --check-symlink-times","-n, --just-print, --dry-run, --recon","-p, --print-data-base","-q, --question","-s, --silent, --quiet","-S, --no-keep-going, --stop","-t, --touch","-v, --version","-w, --print-directory","--no-print-directory","make [TARGET ...]","Makefiles","realclean: clean distclean","make file.txt","make -n file.txt"];
document.cookie = "googtrans=/en/it; domain=.balogs.xyz";
document.cookie = "googtrans=/en/it";
function GTranslateElementInit() {new google.translate.TranslateElement({pageLanguage: 'en',layout: google.translate.TranslateElement.InlineLayout.SIMPLE,autoDisplay: false,multilanguagePage: true}, 'gtranslate_element');}