În secțiunile anterioare, am compilat fișiere cod sursă C folosind compilatorul GCC. Dezvoltarea unui program este un proces continuu, nu scriem tot codul dintr-o singură iterație și de multe ori ajungem să îl modificăm pe parcurs. Vrem să testăm schimbările aduse în program. Pentru aceasta trebuie să recompilăm fișierele pe care le-am modificat și să creăm un nou executabil.

Automatizarea procesului de compilare ne ajută să fim eficienți atunci când dezvoltăm un proiect: * În loc să dăm de fiecare dată toate comenzile pentru recompilarea fișierelor, putem să dăm o singură comandă care să le facă pe toate. * Putem să evităm compilarea unor fișiere pe care nu le-am modificat de la ultima compilare, astfel salvând mult timp. Acest proces se numește build automation. Există mai multe soluții de build automation¹⁾. În aceast laborator vom folosi utilitarul Make împreună cu fișiere Makefile ca să automatizăm procesul de compilare.

În secțiunile următoare vom vedea cum funcționează utilitarul make și cum arată un fișier Makefile. După, vom crea un fișier Makefile pentru un proiect dat.

În această secțiune vom compila programul Hangman folosind un fișier Makefile.

Întrăm în directorul ~/uso-lab/labs/04-appdev/support/simple-make folosind comanda cd:

student@uso:~$ cd ~/uso-lab/labs/04-appdev/support/simple-make
student@uso:~/.../04-appdev/support/simple-make$ ls
hangman.c  Makefile

Avem în director un fișier cod sursă C, hangman.c, și un fișier Makefile existent, astfel că putem utiliza comanda make. Aceasta va rula scriptul scris în Makefile, care, în cazul nostru, urmărește compilarea fișierului hangman.c.

student@uso:~/.../04-appdev/support/simple-make$ make
gcc -c hangman.c
gcc -o hangman hangman.o
student@uso:~/.../04-appdev/support/simple-make$ ls
hangman  hangman.c  hangman.o  Makefile

Comanda make a rulat, de fapt, 2 comenzi:

1. De compilare: gcc -c hangman.c, comandă prin care am creat fișierul obiect hangman.o
2. De legare: gcc -o hangman hangman.o, comandă prin care am creat executabilul hangman.

Practic, scriind doar comanda make, am trecut fișierul hangman.c prin toate etapele compilării și am obținut executabilul final, așa cum am făcut în secțiunea app_dev_compile_multiple_sources pentru fișierele main.c și algorithms.c.

Rulăm executabilul hangman ca să vedem că funcționează, ca în imaginea de mai jos:

În secțiunea anterioară, app_dev_use_makefile, am folosit fișierul Makefile ca să compilăm programul Hangman. Ca să putem crea un Makefile pentru un proiect al nostru, trebuie să înțelegem formatul fișierului Makefile. În această secțiune vom folosi fișierul Makefile pe care l-am folosit anterior ca suport.

Fișierul Makefile folosit la programul Hangman are următorul conținut:

all: hangman

hangman: hangman.o
    gcc -o hangman hangman.o

hangman.o: hangman.c
    gcc -c hangman.c

clean:
    rm -rf *.o hangman

Liniile din fișier sunt de două tipuri:

1. Regulă, care are formatul regulă: <dependență> (all: hangman sau clean:). Regula trebuie să existe, dependența este opțională. Vom explica ce este o dependentă în secțiunea app_dev_dependency_makefile O regulă din fișierul Makefile este, de fapt, un nume asociat unui unei comenzi.

student@uso:~/support/simple-make$ make clean
rm *.o hangman
student@uso:~/support/simple-make$ ls
hangman.c   Makefile

2. Observăm deci că putem rula make + <nume regulă>, dar și make simplu. Utilizând prima formă, din fișierul Makefile se va executa doar regula dorită, în cazul nostru fiind codul specific regulii 'clean'. Utilizând a doua formă, simplă, se va apela implicit prima regulă găsită din fișierul Makefile, în cazul nostru regula 'all'. Aceasta la rândul ei poate trimite către una sau mai multe reguli care să fie executate în succesiune, în cazul nostru urmând regula 'hangman'.