19. Software compileren en installeren
Veel Linux-gebruikers vermijden het liever, omdat het ingewikkeld en moeilijk zou zijn: het zèlf compileren
van een programma. Toegegeven: het gaat niet altijd direct goed, maar dat is ook het geval met voorgecompileerde
software in .rpm of .deb formaat. En soms kan het gewoon niet anders, omdat het betreffende programma alleen maar in
broncode te verkrijgen is. Dit artikel laat zien hoe het zelf compileren in zijn werk gaat en hoe problemen daarbij
aangepakt kunnen worden.
Het zelf compileren van software heeft z'n voordelen. Om er enkele te noemen:
- Je kunt beschikken over de nieuwste versie van het programma. De .rpm of .deb pakketten van veel programma's
lopen vaak enige tijd achter.
- Je kunt allerlei zaken aan de installatie zelf instellen, o.a. in welke directorie de verschillende bestanden
geïnstalleerd moet worden.
- Je kunt de software optimaliseren voor jouw hardware, m.n. je processor.
Deze laatste twee punten zijn niet echt iets voor beginners, maar we zullen het in de loop van het artikel toch even
aanstippen.
Compileren? Wat is dat?
Een computerprogramma bestaat in de praktijk uit een lange reeks enen en nullen. Het schrijven van een programma
rechtstreeks in deze "computertaal" is voor een mens niet te doen. Maar computers kunnen ons daar behulpzaam bij zijn.
Wij kunnen een programma schrijven in een taal, die voor velen nog wel te leren is (Basic, Fortran, Python, Pascal,
C, C++, enz.), waarna de computer het omzet naar die enen en nullen.
Er zijn ruwweg 2 manieren om die vertaling te maken:
- Interpretatie: Als het programma gestart wordt, worden de opdrachten van dat programma gestuurd naar
een zgn. interpreter, die die opdrachten rechtstreeks ("on the fly") omzet in enen en nullen en direct uitvoert.
Bekende voorbeelden daarvan zijn perl en python, en natuurlijk de scripttalen van de verschillende shells, zoals bash,
en ook de ouderwetse DOS-interpreter qbasic.
- Compilatie: Hier wordt het programma eerst door een zgn. compiler omgezet in de enen en nullen, waardoor
er een uitvoerbaar bestand (executable) van gemaakt wordt. Die executable kan dan gestart worden.
Het zal duidelijk zijn, dat over het algemeen gecompileerde programma's sneller zullen zijn dan geïnterpreteerde,
doordat de vertaalslag al van tevoren gemaakt is.
De programma's, waar we het in dit artikel over hebben zijn o.h.a. geschreven in C of C++. De meeste daarvan kunnen
niet zomaar gecompileerd worden, omdat ze gebruik maken van functies, die niet behoren tot de standaard C of C++
taal, maar staan beschreven in zgn. libraries. Die libraries moeten dan ook betrokken worden bij het
compilatie-proces. Dat laatste noemt men "linken", en dat is een stap, die dus vóór het eigenlijke compileren
gedaan moet worden. Gelukkig hoeven we daar weinig van te weten, omdat dat allemaal voor ons geregeld wordt. Het
wordt nu echter wèl duidelijk waar die libraries voor dienen en waarom veel programma's er niet zonder
kunnen.
Voorwaarden
Voor het compileren van software is het noodzakelijk, dat het Linux systeem aan een aantal eisen voldoet. De
belangrijkste daarvan is, dat de compiler-pakketten geïnstalleerd moeten zijn. Zoek maar eens naar pakketten,
waarin de tekst "gcc" of "cpp" voorkomt:
rpm -qa | grep gcc
Ook moet het pakket "make" beschikbaar zijn.
Dit zijn nog maar de minimum-eisen. Afhankelijk van het te installeren programma kunnen nog wel meer eisen gesteld
worden, zoals de aanwezigheid van perl en/of python, enz.
Bij sommige distributies (o.a. Mandrake) kun je bij de installatie ervan aangeven of je de
"ontwikkelingsgereedschappen" of "development-tools" wilt installeren. Als je ooit misschien mogelijk van plan zou
kunnen zijn software te gaan compileren, moet je hier zeker voor kiezen.
Downloaden en uitpakken
We gaan je niet vertellen waar je de beste software kunt vinden, daar bestaan tenslotte zoekmachines voor. Toch
willen we je nog wel even wijzen op het bestaan van
sourceforge:
de grootste verzameling van Open Source Software. Daar staan meer dan 70.000 projecten geregistreerd, van simpele
spelletjes tot ingewikkelde wetenschappelijke software.
Tevens willen we je adviseren om voor alle broncode een speciale map in je home-directory aan te maken; dat houdt de zaak overzichtelijk. Noem die map bv. "source".
Het is gebruikelijk, dat de broncode van een programma als één bestand wordt aangeboden, meestal
in .tar.gz of .tgz formaat, maar soms ook wel als .tar.bz2 bestand.
De .gz of .bz2 extentie heeft betrekking op de manier waarop het bestand gecomprimeerd is:
.gz-bestanden zijn gecomprimeerd met gzip; .bz2 bestanden met het nieuwere
bzip2, wat de bestanden nog iets kleiner kan maken dan gzip.
De letters tar staan voor "tape archiver"; het is, kort en simpel gezegd, een methode om meerdere
bestanden in één bestand in te pakken en oorspronkelijk bedoeld als back-up programma.
Het geheel van tar met een compressie-programma is te vergelijken met wat het programma Winzip doet
onder het concurrende besturingssysteem.
Na het downloaden zal het dus eerst gedecomprimeerd en uitgepakt moeten worden. Dat kan met een enkele opdracht:
tar -xzvf programma.tar.gz
of:
tar -xjvf programma.tar.bz2
Er wordt dan een nieuwe directorie gemaakt met de naam (en versie-nummer) van het programma. In die directorie vind je allerlei bestanden en subdirectories.
Configureren
Nu moeten we naar die nieuwe directorie gaan (cd programma). Naast de broncode-bestanden is daar ook bijna altijd
de nodige documentatie in de vorm van een README of INSTALL bestand te vinden. Lees dit
bestand cq. deze bestanden goed door: we gaan in dit artikel uit van de meest gebruikelijke procedure voor het
compileren van software, maar er zijn uitzonderingen. En dat is te lezen in die documentatie!
Gewoonlijk (maar dus niet altijd...) kan de installatie nu geconfigureerd worden door het draaien van het (ook in
die directorie aanwezige) configure-script. Het kan uitgevoerd worden met de opdracht
./configure
Met het draaien van dit script wordt er nog niets gecompileerd. Configure controleert alleen of alles
wat nodig is om het programma te compileren echt aanwezig is op je computer (zoals de juiste libraries en
gereedschappen) en bereid de compilatie voor. Als er iets mist, zal het configure-script dat duidelijk maken d.m.v.
een foutmelding.
Configureren voor gevorderden
Het configure-script is meestal geschreven om te komen tot een standaard installatie. Vaak is met het script
echter nog veel meer mogelijk: de configuratie is aanpasbaar. De mate waarin dit het geval is verschilt per
programma. De aanpassingen worden aan het script doorgegeven d.m.v. parameters. De verschillende parameters en
hun betekenis zijn meestal opvraagbaar met de parameter --help:
./configure --help
Het even bekijken van de mogelijkheden is leuk en leerzaam, maar het spelen ermee is iets, waar we een beginner
niet toe willen aanzetten!
Make
Het laatste wat het configure-script doet is het maken van een zgn. Makefile. Dat is een bestand (inderdaad:
met de naam Makefile), dat als invoer zal dienen voor het programma make.
Make zorgt, samen met Makefile, dat de bronbestanden gecompileerd worden. Dit doen we,
nog steeds vanuit de programma-directorie (anders kan make z'n Makefile niet vinden), door de opdracht:
make
Nu wordt het programma gecompileerd, maar nog niet geïnstalleerd. Alle bestanden staan nog ergens onder de
programma-directorie. Het op de juiste plaats zetten van die bestanden doen we straks. Het compileren kan bij
grotere programma's wel enige tijd duren, zeker op een wat langzamere computer.
Make voor gevorderden
In Makefile is (voor gevorderden!) ook nog wel wat te spitten. Makefile is een
"gewoon" tekstbestand en kan dus bewerkt worden (bv. met vi of met kwrite). Zo is het
mogelijk de optimalisatie voor een bepaald processortype hier aan te geven (o.a. d.m.v. de zgn. CFLAGS
en CXXFLAGS). Voor de liefhebber is daar meer over te vinden in de info-bestanden van make
(info make).
Installeren
Na het compilatie-proces (gestuurd door make) is het tijd om alles op z'n plaats te gaan zetten.
Dat wordt gedaan door
make install
Let wel: de stappen tot en met make kunnen (meestal) gedaan worden door een "gewone"
gebruiker, de installatie moet gedaan worden door "root"!
Na deze stap is het programma geïnstalleerd. Nu is het nog een kwestie van het starten van het programma
om te kijken of alles ook echt werkt (maar als je eenmaal zover gekomen bent, hoef je je daar niet echt meer
ongerust over te maken...).
Opruimen
Het make-proces heeft nogal wat bestanden geproduceerd, die allemaal ergens in de source-directorie of een
subdirectorie daarvan zijn blijven staan (de opdracht make install copiëert ze naar de juiste
directories). Om dat op te ruimen is een simpele opdracht voldoende:
make clean
Zorg er wel voor, dat de Makefile niet gewist wordt, want die is nodig voor het eventueel
de-installeren van het programma.
De-installeren
Als het geïnstalleerde programma toch niet erg bevalt, kan het ook weer verwijderd worden, hoewel iets
minder eenvoudig als bv. met rpm. Je kunt het in eerste instantie proberen met:
make uninstall
Als dat niet werkt, dan zal de software met de hand verwijderd moeten worden. Als bekend is waar het
geïnstalleerd is, kunnen de bestanden gewoon gewist worden. Zo niet, dan kan gekeken worden in de
Makefile. Daar is terug te vinden waar de verschillende bestanden neergezet zijn.
Literatuur
Op onderstaande websites is meer en diepergaande informatie te vinden over dit onderwerp (om van een beginner
een gevorderde te maken...):
Laatst herzien op 18-12-2006
|
Printbaar
