Fordító eszközök: make és cmake

Egy nagyobb C projekt simán állhat több száz, esetleg több ezer fájlból. Ezeknek a kézzel történő fordítása igencsak fájdalmas folyamat lenne. Nem meglepő módon ezért készültek eszközök ennek a folyamatnak az automatizálására. Az egyik legrégebbi ilyen eszköz a make, aminek a gyökerei egészen a Unix rendszerekhez nyúlnak vissza. Ebből adódóan a make erősen épít a Unix rendszerekre és platformfüggő. Itt a platformfüggőség azt jelenti, hogy a make nem rendelkezik annak a koncepciójával, hogy esetleg a programunkat majd nem azzal a fordítóval és környezetben fordítják, mint ami a fájlban definiálva van. Ez a viselkedés egészen addig jó, amíg platformspecifikus a kódunk. Például a legtöbb GNU segédprogram a mai napig make segítségével fordul.

Nézzük meg, hogy hogyan tudjuk make segítségével automatizálni a több fájlból álló projektünk. Az automatizálás első lépése, hogy készítenünk kell egy makefile (kiterjesztés nélküli) fájlt. Ennek az alábbi tartalmat adjuk:

# Fordító
CC = gcc

# fordítási paraméterek
# -Wall : összes figyelmeztetés
CFLAGS = -Wall

#Forrásfájlok és az obj, amik ebből kellenek
SRCS = functions.c main.c
OBJS = $(SRCS:.c=.o)

# alapértelmezett fordítási szabály
all: makepelda.exe

# makepelda.exe linkelése
makepelda.exe: $(OBJS)
	$(CC) $(CFLAGS) -o $@ $^

# C fájlok fordítási opciói
%.o: %.c
	$(CC) $(CFLAGS) -c $<

# clean parancs
clean:
	rm -f $(OBJS) makepelda.exe

Egy make fájl struktúrája három fő részből áll:

1. Cél (target): Ez határozza meg, hogy mi a végső eredmény, amit a Makefile létre akar hozni (például egy futtatható állomány, egy könyvtár, vagy valamilyen köztes fájl).

2. Függőségek (dependencies): Ezek azok a fájlok vagy egyéb célok, amelyek szükségesek a cél eléréséhez. Ha valamelyik függőség megváltozik, akkor a cél újraépül.

3. Parancsok (commands): Ezek az utasítások hajtódnak végre, amikor a cél épül. Általában ezek shell parancsok, amelyeket a Makefile végrehajt, hogy létrehozza a célt a függőségek alapján.

Ha a mappánk egyetlen egy make fájlt tartalmaz, akkor szimplán a make parancs kiadásával tudjuk végrehajtani. Ha a mappa több make fájlt is tartalmaz, akkor a fájl nevét is meg kell adnunk:

make pelda

Ha a make nem lenne telepítve, akkor MINGW környezet alatt az alábbi parancs segítségével tudjuk telepíteni:

pacman -S make

Mint láthattuk, a make fájlunkban definiálunk parancsokat és változókat, amik összeállítják nekünk a lefordított programot. A platformfüggőségre az rm parancsra és gcc-re támaszkodás jó példa. Ez a fajta platformfüggőség és egyszerűség nagyobb programok esetén limitáció, amit úgy kerültek ki sokáig, hogy a make fájlt generáltatták egy programmal, ami lehet egy shell script, de 2000-es években igen népszerű volt PERL segítségével ezt megoldani.

Azonban ez miatt az egyszerűen használhatóságát veszítette el és sok program esetén komoly szakértelmet igényelt, hogy egyáltalán le lehessen őket fordítani. Ezen változtatott a cmake megjelenése.

A cmake nevében a c nem a nyelvre utal, hanem arra, hogy ez egy cross platform eszköz, ami nem csak Unix rendszereket támogat, hanem más eszközöket is. Például a Visual Studio rendelkezik beépített cmake támogatással és egy cmake listából képes olyan projektfájlokat generálni, amelyekkel lefordítható a kód Visual Studio segítségével is. A cmake a CMakeLists.txt fájlra támaszkodik. Ez írja le a fordítást. Nézzük meg, hogy hogyan épül fel egy ilyen fájl a korábbi projektünk fordítására:

cmake_minimum_required(VERSION 3.10)

project(cmakepelda)

# cmakepelda definiálása, hogy milyen fájlok tartoznak hozzá
add_executable(cmakepelda main.c functions.c)

Cmake segítségével a programunkat az alábbi módon tudjuk lefordítani:

cmake .
make

Ha a cmake nem lenne telepítve, akkor MINGW környezet alatt az alábbi parancs segítségével tehetjük ezt meg:

pacman -S mingw-w64-x86_64-cmake

A cmake egy make fájlt fog generálni, ami a make segítségével lesz majd fordítható a platformon. Előnye, hogy a fordítót és a hozzá tartozó linkelési opciókat nem nekünk kell kézzel definiálnunk. Másik előnye, hogy a Visual Studio is támogatja. A 2022-es vagy újabb Visual Studio-ban lehetőségünk van megnyitni a CmakeLists.txt fájlt.

Ezt a feladatot a parancssorból is elvégezhetjük, ha telepítve van az extra-cmake-modules csomag, amit MINGW esetén az alábbi parancs segítségével telepíthetünk:

pacman -S mingw-w64-x86_64-extra-cmake-modules

Ha telepítve vannak az extra generátorok, akkor a következő parancs segítségével tudunk a kódunkból Visual Studio 2022 projekteket generálni:

cmake -G Visual Studio 17 2022

Ha grafikusan szeretnénk szerkeszteni a CmakeLists.txt fájlt, akkor erre a cmake gui ad lehetőséget, amit MINGW segítségével szintén tudunk telepíteni az alábbi parancs segítségével:

pacman -S mingw-w64-x86_64-cmake-gui