Nu echt bruikbare programma’s in beeld komen, komt ook langzaamaan het moment om met losse modules te gaan werken. Even geleden hebben we dat al gedaan door een .h file te maken met daarin veel gebruikte functies. Ik heb voor mezelf de stdavk.h header gemaakt, met daarin op het moment van schrijven een input-functie voor strings, en een cls-functie als vervanging van system(“clear”), dat wel erg afhankelijk is van het platform waarop je code werkt.

Het betekent dat ik in mijn source #include “stdavk.h” moet gebruiken, maar het betekent nog een paar dingen:

1. o moet aanwezig zijn, en wel op basis van de laatste aanpassingen in stdavk.o
2. bij het compileren moet ik altijd de stdavk.o toevoegen.
3. Aan beide zaken moet je wel denken. Verder is het ook wel handig om altijd een naam aan het programma mee te geven, altijd a.out wordt ook wat flauw.

Als je complexere programma’s gaat bouwen, kan je met hele clusters aan bron-codes en object-files gaan werken. Bijvoorbeeld omdat je C en Assembler wil combineren, of omdat je je code wat overzichtelijk wil houden. En dan moet je in de gaten gaan houden welke bron-code al naar een object-file is gecompileerd, welke niet, en in welke volgorde als ze elkaar aanroepen.

Om dat proces te automatiseren kent Linux het commando make. Je zou kunnen zeggen dat make een mini-programmeertaal in zichzelf is, volledig gericht op het automatiseren van compileren en linken van code.

Op dit moment ben ik nog niet toe aan al te ingewikkelde toepassingen, dus die laat ik nu buiten beschouwing (aangezien ik de mogelijkheden zelf nog echt niet doorzie en begrijp). Maar ik heb wel behoefte aan een simpele toepassing. De drie stappen hiervoor wil ik automatiseren. Make kan dat.

De code die make verwerkt moet in een tekstbestand staan met de naam Makefile. Op GitHub heb ik een Makefile geplaatst die precies doet wat ik wil: één source-bestand compileren en linken met de object-file van stdavk.h, met als output een executable met een door mij gegeven naam.

De basis van een Makefile is altijd:

doel : afhankelijkheden
     commando
     commando

Doel is de te maken executable. Afhankelijkheden zijn bestanden die aanwezig moeten zijn voordat het doel gemaakt kan worden. De commando’s, altijd voorafgegaan door een <tab> worden uitgevoerd als het doel nog niet bestaat of de afhankelijkheden nieuwer zijn dan het doel.

Dus

test : test.c
     gcc test.c -o test

zal test.c opnieuw compileren naar test, als test nog niet bestaat of als test.c sindsdien gewijzigd is.

Bij grote projecten bespaar je hier in principe flink wat compileertijd mee, omdat overbodige compilaties voorkomen worden. Maar op dit moment zit daar nog niet echt de uitdaging. De Makefile die doet wat ik wil, ziet er als volgt uit:

CC=gcc
CFLAGS=-Wall

.PHONY: clean

all: &(exe)

$(exe): $(src:.c=.o) stdavk.o
     $(CC) $(CFLAGS) $^ -o $@

$.o: %.c
     $(CC) $(CFLAGS) -c $< -o $@

clean:
     rm -f *.o $(exe)

Met CC en CFLAGS stel je de compiler in. Ik gebruik gcc, met de optie -Wall (alle foutmeldingen in beeld). De variabelen exe en src geven aan wat je sourcecode is en wat de naam van de executable. De header-file stdavk.c (niet de .h!) wordt naar een object-file gecompileerd als dat nodig is, en vervolgens wordt de opgegeven source gecompileerd en gelinkt met stdavk.o.

Het enige dat nu nog nodig is om een source-code (bijvoorbeeld test.c) te compileren in de executable test is:

make src=test.c exe=test

of, als je dat liever hebt

make exe=test src=test.c

Na deze make kan je overbodige object-files wissen met

make clean

Wie mee wil doen met #klooienmetcomputers kan dat doen via GitHub. Maak een account op www.github.com en zoek naar Abmvk/kmc. Het account Abmvk volgen kan ook. Lezers zijn vrij te gebruiken wat ze willen en om zelf zaken toe te voegen of aan te passen, vragen te stellen of commentaar te leveren.