Soluţii - PC Magazine Romania, Mai  2002

Make, un utilitar nu doar pentru programatori

Iulian Radu

Deşi în prima pagină a manualului programului GNU make se specifică faptul că: "utilitarul determină automat care parte dintr-un program mare trebuie recompilată şi execută comenzile necesare recompilării", acest program poate fi folosit ori de câte ori avem de gestionat fişiere al căror conţinut trebuie actualizat când conţinutul altor fişiere s-a modificat. Soluţiile oferite în acest articol nu sunt aplicabile doar cu GNU make, ci sunt valabile pentru orice altă variantă a programului make.

Cum lucrează programul make
Programul make execută o serie de comenzi aflate într-un fişier text pe baza argumentelor furnizate în linia de comandă. De aceea, make are nevoie să ştie două lucruri: care este numele scopului pentru care trebuie executate comenzi şi în ce fişier găseşte descris acest scop. Dacă nu este furnizat nici un nume de fişier, se caută în directorul curent un fişier care se numeşte GNUmakefile sau makefile sau Makefile (căutarea se face în această ordine; oricare din aceste fişiere sau cel/cele specificat/e implicit cu -f îl voi denumi în continuare Makefile). Când a fost găsit unul dintre ele, se întrerupe căutarea. Dacă se specifică mai multe fişiere cu ajutorul argumentului -f, atunci toate acestea vor fi privite ca un singur fişier ce conţine reguli. În lipsa specificării unui scop, se va considera primul scop care nu începe cu punct, găsit în fişierul Makefile. În secţiunea "Structura unui fişier Makefile" veţi găsi explicat cum arată conţinutul unui astfel de fişier.

Argumentele cele mai utilizate
În acest articol nu vom face o prezentare completă a tuturor argumentelor pe care le poate primi programul make şi nici a tuturor aspectelor legate de el. Pentru astfel de informaţii cea mai bună sursă rămâne documentaţia în format .info aflată în kit-ul programului (se poate vizualiza cu "info make" după instalarea pachetului). Iată o listă cu cele mai utilizate argumente:

1 -C nume_director (înainte de a face orice altceva make schimbă directorul la cel specificat)
2 -f nume_fişier_makefile (poate apărea de mai multe ori pentru a crea în mod transparent un singur fişier Makefile din mai multe fişiere reale)
3 -k (continuă executarea scopurilor chiar dacă a apărut eroare la actualizarea unuia)
4 -i (se ignoră erorile produse la executarea comenzilor definite în cadrul regulilor; se consideră că un program nu s-a terminat cu succes în cazul în care codul de terminare a lui a fost diferit de 0)
5 -n (nu se execută nici o comandă, doar le afişează; util pentru a vedea ce va executa make în realitate)
6 -q (nu execută nimic, doar întoarce codul de terminare care ne arată starea în care se află targetul: este sau nu nevoie să-l actualizăm)
7 -r (dezactivează regulile implicite)
8 -R (dezactivează variabilele implicite)
9 -s (nu afişează comenzile pe care le execută sau orice alt mesaj, cu excepţia celor de eroare)
10 -t (actualizează timpul ultimei modificări a fişierelor în loc să le actualizeze conţinutul).

Structura unui fişier Makefile
Deoarece un model va fi mai simplu de înţeles decât o prezentare în cuvinte, vom da un exemplu pe care apoi îl vom analiza. Acesta este făcut special pentru a putea fi prezentate anumite caracteristici ale fişierelor Makefile, nefiind un model luat din lumea reală.

1. .PHONY all compile-all do-exe instal-all test clean
2. .SILENT clean test
3.
4. include"common.mak"
5.
6. VPATH = src man doc tests
7.
8. prefix = /usr/local
9. exec_prefix = $(prefix)
10. bindir = $(prefix)/bin
11. libdir = $(prefix)/lib
12. includedir = $(prefix)/include
13.
14. objects = foo.o bar.o
15. files := $(wildcard *_exe)
16. files += $(objects)
17.
18. all: compile-all install-all
19. compile-all: $(objects) mylib.a do-exe
20. $(objects): %.o : %c
21. $(CC) -c $(CFLAGS) $< -o $@
22. mylib.a: mylib.c mylib.h
23. @$(CC) -c $(CFLAGS) $^ -o $(patsubst %.c,%.o,$^)
24. ar -r $@ $(patsubst %.c,%.o,$^)
25. do-exe: $(filter %_exe,$(files))
26. +echo "Executie terminata !"
27. $(filter %_exe,$(files)): %_exe: %
28. ifneq(,$(findstring "/bin",$PATH))
29. $*.sh
30. else
31. $*.exe
32. endif
33.
34. instal-all: $(filter %_unix.exe,$(objects))
35. $(MAKE) -C $(addsuffix ".dir",$(dir "/usr/local/lib/mylib.so"))
36. $(shell echo "Instalarea s-a facut cu succes!")
37.
38. clean:
39. -rm -rf $(files)
40.
41. test: $(wildcard tests/*.c)
42. $(MAKE) -C test $(word $(words $<)-1,$<)
În linia 1, folosind directiva .PHONY, anunţăm programul make că scopurile all, compile-all, do-exe, install-all, test şi clean nu sunt fişiere reale şi deci scopurile şi comenzile asociate lor trebuie executate de fiecare dată când sunt evaluate. În linia 2, folosind directiva .SILENT, se precizează că la executarea comenzilor asociate scopurilor clean şi test programul make să nu afişeze comenzile pe care le execută. Implicit, make afişează comenzile pe care le execută şi intrările/ ieşirile din directoare. În linia 4, folosind directiva include, se intercalează conţinutul fişierului common.mak în cadrul fişierului Makefile curent. Fişierul common.mak trebuie să respecte structura unui fişier de tip Makefile. Programul make ştie să caute automat un fişier aflat într-un scop atât în directorul curent cât şi în directoarele specificate în variabila VPATH. În linia 6, indicăm programului make să caute fişierele şi în directoarele ./src, .-/man, ./doc şi ./tests dacă nu le găseşte în directorul curent (./.). În liniile 8-12 definim 5 variabile, din care 4 depind de valoarea primeia. Este o practică comună să se definească o variabilă denumită prefix în care să se memoreze rădăcina directoarelor implicate în prelucrarea datelor. Astfel, dacă se doreşte prelucrarea unor date aflate în locuri diferite dar care respectă aceeaşi structură de directoare şi fişiere se poate apela make cu diferite valori ale variabilei prefix (valoarea variabilei este stabilită în cadrul shellului înainte de a apela programul make). În linia 14 este definită o variabilă denumită objects care primeşte numele a două fişiere. Folosirea semnului egal (=) pentru atribuire înseamnă că variabila primeşte exact valoarea din partea dreaptă a egalului. Orice expandare va avea loc la folosirea variabilei. În acest fel, este posibil să definim variabile care depind de valorile altor variabile, valori care se pot modifica de-a lungul execuţiei programului make şi deci care vor modifica în mod dinamic şi valoarea primelor variabile. În linia 15 definim o variabilă denumită files şi care primeşte valoarea funcţiei $(wildcard *_exe). Această funcţie generează o listă a tuturor fişierelor din directorul curent care respectă modelul dat, în cazul nostru *_exe. Apoi, în linia 16 îi adăugam valoarea $(objects) care va fi expandată la folosirea valorii variabilei files. În linia 18 definim primul scop din acest fişier Makefile. Numele lui este all şi depinde de alte două scopuri denumite compile-all şi install-all, dar nu are definită nici o comandă. În linia 19 definim scopul compile-all necesar scopului all. Scopul compile-all depinde de valoarea variabilei $(objects), care după expandare reprezintă timpul modificării fişierelor foo.o şi bar.o, a timpului modifcării fişierului mylib.a şi a rezultatului evaluării scopului do-exe. Când este evaluat un scop, întâi se evaluează dependenţele lui (în cazul nostru fişierele foo.o, bar.o şi mylib.a şi rezultatul scopului do-exe) şi apoi comenzile asociate lui (dacă este necesară actualizarea). În linia 20 definim un scop generic care spune că pentru fiecare cuvânt din $(objects) se aplică modelul %.o şi apoi transformarea %.c (% înseamnă orice număr de caractere). Se consideră cuvânt orice succesiune de caractere diferite de spaţiile albe (spaţiu, tab, linie nouă etc.). Traducerea acestui scop generic este: fiecărui cuvânt din $(objects) i se schimbă extensia din .o în .c şi se generează câte un scop pentru generarea fişierelor cu extensie .o din fişierele corespunzătoare cu extensia .c. În linia 21 avem comanda asociată scopului generic. Aceasta face apel la variabilele definite implicit de către programul make: $(CC) şi $(CFLAGS). De asemenea, apar variabilele speciale $<, care semnifică lista tuturor dependenţelor (în cazul nostru, fişierul cu extensia .c), şi $@, care semnifică numele scopului (în cazul nostru fişierul cu extensia .o). În linia 22 este definit un scop care indică necesitatea actualizării fişierului mylib.a dacă fişierul mylib.c sau mylib.h este mai nou decât el. Linia 23, care este comanda asociată scopului mylib.a, începe cu caracterul @ ce indică programului make să nu afişeze comanda pe care o execută (cea care urmează după @), aşa cum face în mod implicit dacă din linia de comandă lipseşte argumentul -s sau acel scop apare în cadrul unui scop .SILENT. În linia 23 întâlnim variabila specială $^, care semnifică primul cuvânt din lista de dependenţe (în cazul nostru mylib.c), şi funcţia $(patsubst %.c, %.o,$^), care în această formă semnifică înlocuirea extensiei .o a primului argument din lista de dependenţe cu .c. În linia 24 valoarea variabilei speciale $@ este mylib.a. În linia 25 apare funcţia $(filter %_exe,$(files)) care are ca efect, în acest context, extragerea din valoarea variabilei $(files) doar a cuvintelor care au sufixul _exe. Comanda din linia 26 apare cu un semn plus (+) înaintea ei, ceea ce semnifică faptul că această comandă va fi executată chiar dacă programul make a fost apelat cu unul din următoarele argumente: -n, -q sau -t. În linia 27 este definit un scop generic care are o comandă ce depinde de mediul în care este lansat programul make. Funcţia $(findstring "/bin",$PATH), apelată astfel, întoarce şirul vid dacă nu există şirul "/bin" în valoarea variabilei de sistem $PATH şi "/bin" altfel.

Astfel, dacă există şirul "/bin" în valoarea lui $PATH atunci se va executa ramura cu $*.sh, altfel se va executa ramura cu $*.exe. Se observă prezenţa variabilei speciale $* a cărei valoare este înlocuită cu partea din cuvânt care corespunde în model lui %. În cazul nostru, partea din numele fişierelor care se află înaintea sufixului _exe. În linia 35 este apelat programul make prin intermediul variabilei speciale $(MAKE) urmat de argumentul -C şi numele directorului în care se află un fişier denumit în una din cele trei forme indicate la începutul acestui articol. Funcţia specială $(dir "/usr/local/ lib/mylib.so") extrage partea de director din şirul furnizat ca argument, în cazul nostru "/usr/local/lib", iar funcţia $(addsuffix ".dir","cale") adaugă sufixul ".dir" la şirul cale, în cazul nostru obţinem "/usr/ local/lib.dir". Există şi funcţiile: $(notdir "path/file"), care extrag din şir partea care corespunde numelui fişierului, $(basename "nume"), opusul funcţiei $(suffix), şi $(addprefix prefix,şir), care adaugă un prefix în faţa lui şir. În linia 36 este lansat un shell folosindu-se funcţia $(shell comandă). Linia 38 conţine un exemplu de scop fără dependinţe. Comanda din linia 39 este precedată de semnul minus (-) pentru a indica programului make să continue execuţia următoarelor comenzi asociate scopului curent chiar dacă această comandă se termină cu eroare
(de exemplu, dacă vrem să ştergem nişte fişiere este mai simplu să punem semnul minus în faţa comenzii care va şterge fişierele decât să testăm dacă acestea există pe disc). În linia 42 apar funcţiile $(words $<), care întorc numărul de cuvinte conţinute
(în cazul nostru numărul de dependinţe), şi $(word poziţie,$<), care întorc poziţia cuvântului (indexul primului cuvânt este 1). În cazul nostru este extras penultimul nume de fişier care are extensia .c din directorul tests.

Pentru o listă completă de funcţii puteţi consulta nodul "Quick reference" din documentaţia în format .info a programului GNU make.