Salut: main.c salut.c gcc -o salut main.c salut.c
Este destul de funcțional, dar are un dezavantaj semnificativ: vom dezvălui care dintre ele în continuare.

Compilare incrementală

Acum, după schimbarea unuia dintre fișierele sursă, este suficient să îl traduceți și să legați toate fișierele obiect. În același timp, sărim peste etapa de traducere a detaliilor care nu sunt afectate de modificări, ceea ce reduce timpul de compilare în general. Această abordare se numește compilare incrementală. Pentru a-l susține, comparați timpul de schimbare a țintelor și detaliile acestora (folosind datele sistemului de fișiere), datorită cărora decide independent ce reguli trebuie executate și care pot fi pur și simplu ignorate:

Main.o: main.c gcc -c -o main.o main.c hello.o: hello.c gcc -c -o hello.o hello.c hello: main.o hello.o gcc -o hello main. o buna.o
Încercați să construiți acest proiect. Pentru a-l construi, trebuie să specificați în mod explicit ținta, de exemplu. dă comanda salută.
După aceea, schimbați oricare dintre fișierele sursă și construiți-l din nou. Vă rugăm să rețineți că în timpul celei de-a doua compilații, doar fișierul modificat va fi tradus.

Odată rulat, make va încerca să obțină imediat ținta hello, dar pentru a o crea aveți nevoie de fișierele main.o și hello.o, care nu există încă. Prin urmare, executarea regulii va fi amânată și va căuta reguli care descriu modul de obținere a detaliilor lipsă. Odată ce toate detaliile au fost primite, make va reveni la executarea țintei amânate. Aceasta înseamnă că make execută regulile recursiv.

Ținte fictive

$ make $ make install
Comanda make compilează programul, iar comanda make install îl instalează. Această abordare este foarte convenabilă deoarece tot ceea ce este necesar pentru construirea și implementarea aplicației pe sistemul țintă este inclus într-un singur fișier (să uităm pentru un moment de scriptul de configurare). Vă rugăm să rețineți că în primul caz nu specificăm scopul, iar în al doilea obiectivul nu este deloc crearea fișierului de instalare, ci procesul de instalare a aplicației pe sistem. Așa-numitele ținte fictive (false) ne permit să realizăm astfel de trucuri. Iată o scurtă listă de obiective standard:

• totul este ținta implicită. Nu trebuie să specificați în mod explicit atunci când apelați make.
• curățare - ștergeți directorul cu toate fișierele obținute ca urmare a compilării.
• instala - execută instalarea
• dezinstalare - și dezinstalare în consecință.

PHONY: all clean install uninstall all: hello clean: rm -rf hello *.o main.o: main.c gcc -c -o main.o main.c hello.o: hello.c gcc -c -o salut. o hello.c hello: main.o hello.o gcc -o hello main.o hello.o install: install ./hello /usr/local/bin dezinstalare: rm -rf /usr/local/bin/hello
Acum putem să ne construim programul, să-l instalăm/dezinstalăm și, de asemenea, să curățăm directorul de lucru folosind ținte standard.

Rețineți că nu există comenzi specificate în toate ținta; tot ce are nevoie este să obțină recuzita. Știind natura recursivă a make-ului, nu este dificil să ne imaginăm cum va funcționa acest script. De asemenea, ar trebui să acordați o atenție deosebită faptului că, dacă fișierul hello există deja (rămas după compilarea anterioară) și detaliile acestuia nu au fost modificate, atunci comanda make nimic nu va fi reasamblat. Acesta este o grebla clasica. De exemplu, schimbarea unui fișier antet care nu este inclus accidental în lista de detalii poate duce la multe ore de dureri de cap. Prin urmare, pentru a garanta o reconstrucție completă a proiectului, trebuie mai întâi să ștergeți directorul de lucru:

$ face curat $ face
Va trebui să utilizați sudo pentru a finaliza obiectivele de instalare/dezinstalare.

Variabile

=
Există o regulă nerostită conform căreia variabilele ar trebui să fie numite cu litere mari, de exemplu:

SRC = main.c salut.c
Așa am definit lista fișierelor sursă. Pentru a utiliza valoarea unei variabile, aceasta trebuie dereferențiată folosind constructul $( ); de exemplu cam asa:

Gcc -o salut $(SRC)
Mai jos este un makefile care folosește două variabile: TARGET - pentru a determina numele programului țintă și PREFIX - pentru a determina calea de instalare a programului pe sistem.

TARGET = salut PREFIX = /usr/local/bin .PHONY: all clean install uninstall all: $(TARGET) clean: rm -rf $(TARGET) *.o main.o: main.c gcc -c -o main. o main.c hello.o: hello.c gcc -c -o hello.o hello.c $(TARGET): main.o hello.o gcc -o $(TARGET) main.o hello.o instalați: instalați $ (TARGET) $(PREFIX) dezinstalare: rm -rf $(PREFIX)/$(TARGET)
Acesta este deja mai frumos. Cred că acum exemplul de mai sus nu are nevoie de comentarii speciale pentru tine.

Variabile automate

• $@ Numele țintă al regulii care este procesată
• $< Имя первой зависимости обрабатываемого правила
• $^ Lista tuturor dependențelor regulii procesate

Acest articol este un scurt tutorial despre crearea Makefiles. Acesta explică pentru ce este un Makefile și oferă câteva reguli de urmat atunci când creați unul.

Introducere

Să presupunem că dezvoltați un program numit foo, format din cinci fișiere antet - 1.h, 2.h, 3.h, 4.h și - 5.h și șase fișiere cu codul sursă al programului în C - 1.cpp, 2.cpp, 3.cpp, 4.cpp, 5.cpp și main.cpp. (Aș dori să observ că în proiectele reale acest stil de denumire a fișierelor ar trebui evitat.)

Acum să ne imaginăm că ați descoperit o eroare în fișierul 2.cpp și ați remediat-o. Apoi, pentru a obține o versiune corectată a programului, compilați toate fișierele incluse în proiect, deși modificările au afectat doar un fișier. Acest lucru duce la pierdere de timp, mai ales dacă computerul nu este foarte rapid.

Există o soluție la problemă?

Nu trebuie să vă faceți griji, prieteni! Această problemă a fost rezolvată cu mult timp în urmă. Programatori cu experiență au dezvoltat utilitarul make. În loc să recompilați toate fișierele cu textele sursă, procesează numai acele fișiere care au suferit modificări. În cazul nostru, va fi compilat un singur fișier - 2.cpp. Nu este grozav!?

• Utilitarul make face viața mult mai ușoară atunci când trebuie să rulați comenzi lungi și complexe pentru a construi un proiect.
• Un proiect necesită uneori setarea opțiunilor compilatorului rar utilizate și, prin urmare, greu de reținut. make vă va scuti de osteneala de a le păstra în memorie.
• Uniformitate, pentru că lucrul cu acest utilitar este suportat de multe medii de dezvoltare.
• Procesul de construire poate fi automatizat deoarece make poate fi apelat din scripturi sau din cron.

Pentru ce este Makefile-ul?

În ciuda tuturor avantajelor sale, utilitarul make nu știe nimic despre proiectul nostru, așa că trebuie să creăm un simplu fisier text care va contine totul instructiunile necesare la asamblare. Se numește fișierul cu instrucțiuni pentru asamblarea proiectului makefile (pronunțat „makefile”)aproximativ traducere) .

De obicei, aceste fișiere sunt denumite makefile sau Makefile, urmând convențiile de denumire pentru astfel de fișiere. Dacă dați fișierului de instrucțiuni un alt nume, va trebui să apelați make cu opțiunea -f.

De exemplu, dacă ați denumit fișierul makefile bejo , atunci comanda pentru a construi proiectul va arăta astfel:

Make -f bejo

Structura fișierului

Makefile conține secțiuni pentru "goluri", dependențeȘi reguli ansambluri. Toate acestea sunt formatate după cum urmează: mai întâi este specificat numele țintei (de obicei numele fișierului executabil sau obiect), urmat de două puncte, apoi numele dependențelor, adică. fișierele necesare atingerii acestui scop. În cele din urmă, există o listă de reguli: i.e. comenzi care trebuie executate pentru a obține scopul specificat.

Un exemplu simplu de structură makefile:

Țintă: comanda de comandă dependențe...

Fiecare regulă de comandă trebuie să înceapă cu un caracter tabulator -- acesta condiție cerută! Lipsa unui caracter tabulator la începutul unei linii de regulă este cea mai frecventă greșeală. Din fericire, astfel de erori sunt ușor de detectat, deoarece le raportează.

Exemplu Makefile.

Mai jos este un exemplu simplu (numerele liniilor adăugate pentru claritate).

În acest exemplu, linia care conține textul
client:conn.o ,
se numește „linie de dependență” și linia
g++ client.cpp conn.o -o client
se numește „regulă” și descrie acțiunea care trebuie efectuată.

Și acum mai detaliat despre exemplul dat mai sus:

• Ținta este setată la fișierul executabil client, care depinde de fișierul obiect conn.o
• Regula pentru asamblarea unei ținte date
• A treia linie specifică conn.o țintă și fișierele de care depinde, conn.cpp și conn.h.
• A patra linie descrie acțiunea de a construi ținta conn.o.

Comentarii

Rândurile care încep cu „#” sunt comentarii

Mai jos este un exemplu de makefile cu comentarii:

Țintă „falsă”.

În mod obișnuit, țintele „fatice”, care reprezintă un nume de fișier țintă „imaginar”, sunt utilizate atunci când apar conflicte între numele țintă și numele fișierelor atunci când numele țintă este specificat în mod explicit pe linia de comandă.

Să presupunem că există o regulă în fișierul make care nu creează nimic, de exemplu:

Curățare: rm *.o temp

Deoarece comanda rm nu creează un fișier numit clean, un astfel de fișier nu va exista niciodată și, prin urmare, comanda make clean va rula întotdeauna.

Cu toate acestea, această regulă nu va funcționa dacă există un fișier numit clean în directorul curent. Deoarece ținta curată nu are dependențe, nu va fi niciodată considerată depreciată și, prin urmare, comanda „rm *.o temp” nu va fi niciodată executată. (atunci când rulați, faceți verificări ale datelor de modificare ale fișierului țintă și ale acelor fișiere de care depinde. Și dacă ținta se dovedește a fi „mai veche”, atunci make execută regulile de comandă corespunzătoare - nota editorului) Pentru eliminare probleme similareși există o declarație specială .PHONY care declară o țintă „falsă”. De exemplu:

FONIC: curat

Astfel, indicăm necesitatea executării scopului, atunci când îl specificăm explicit, sub formă de make clean, indiferent dacă un fișier cu acel nume există sau nu.

Variabile

Puteți defini o variabilă într-un makefile astfel:

$VAR_NAME=valoare

Prin convenție, numele variabilelor sunt scrise cu majuscule:

$OBJECTS=principal.o test.o

Pentru a obține valoarea unei variabile, trebuie să includeți numele acesteia paranteze rotundeși precedați-le cu un simbol „$”, de exemplu:

$(VAR_NAME)

Există două tipuri de variabile în makefiles: "pur și simplu calculat"Și "calculat recursiv".

Când accesați variabila SRCDIR, veți obține valoarea /home/tedi/project/src .

Cu toate acestea, variabilele recursive pot să nu fie întotdeauna evaluate, cum ar fi următoarele definiții:

va avea ca rezultat un ciclu nesfârșit. Pentru a rezolva această problemă, ar trebui să utilizați variabile „calculate simplificate”:

Unde simbolul „:=" creează o variabilă CC și îi atribuie valoarea „gcc -o”. Și simbolul „+=" adaugă „-O2” la valoarea variabilei CC.

Concluzie

Sper că este ghid rapid conține suficiente informații pentru a începe să vă creați fișierele make. Și pentru asta - succes în munca ta.

Bibliografie

• 1 GNU Make Fișier de documentație, marca de informații.
• Kurt Wall și colab. Programarea Linux dezlănțuită(Programare pentru Linux în spațiul operațional - nota editorului) , 2001.