cmake är på sätt och vis en efterföljare till configure, men också något mer! Nämligen ett cross-platform (plattformsoberoende)
program som använder en kompileringsoberoende metod för att hantera byggprocessen av källkodsprogram.
Det fungerar i olika byggmiljöer som UNIX/Linux' make, Apple's XCode och Microsoft's Visual Studio och behöver bara en
C++ compilerare i sitt byggsystem.
cmake kan generera makefile's för flera plattformar som UNIX/Linux, Mac OS X, Windows, OS/2 et c.
-Se vidare http://www.cmake.org/
och https://en.wikipedia.org/wiki/CMake
cmake finns att hämta för de beskrivna plattformarna här:
http://www.cmake.org/cmake/resources/software.html
men också i de vanligaste Linux-distributionernas normala repositorier, liksom i Slackwares fulla installation.
I det följande beskrivs bara byggprocessen i Linux (som mycket påminner om vanlig källkod).
(som grund desamma som för vanlig källkod) samt om man vill ha ett grafiskt gränssnitt: gtk2 och Qt-4
D v s GCC som ovan, gcc, c++, make, cmake.
Se Källkodsbeskrivningen för en komplett förteckning.
I Fedora, Debian + derivaten och SuSE kan dessa behöva installeras med den distributionsegna pakethanteraren, i Slackware
ingår alla inklusive deras beroenden i en normal full installation.
Byggande och installation av källkod med cmake, liksom överväganden, är mycket lik byggande av källkod som beskrivits utförligt
tidigare.
Källkoden hämtas här dock oftast från en git-hub- eller subversionrepositorium och den är opackad (inte komprimerad) efter hämtningen.
Ofta är källkoden för cmake mycket utförligt beskriven på programmets hemsida. Är den det inte får man gå tillväga som vid
källkodsbyggandet vad gäller beroendena (söka öppet på internet, söka genom dokumentation som följer med källkoden eller det mer
plågsamma: Köra cmake och make och undersöka var det hakar upp sig.
Vid hämtningen ställer man sig med terminalen i en lämplig byggkatalog i sin /home.
En hämtning av källkod för cmake kan vanligtvis se ut som:
$ git clone git://github.com/[ProgramNamn]/[ProgramNamn].git
Källkoden hamnar då i samma katalog som terminalen med namnet [ProgramNamn]
Ovanligare, med subversion, så här:
$ svn co https://subversion.assembla.com/svn/[programnamn]/trunk [programnamn]
Källkoden hamnar som ovan i en katalog med namnet [programnamn]
Navigera dit med terminalen
Läs noga genom filerna VERSION.cmake (programversion), README och övriga filer som kan innehålla
beskrivningar av byggande, beroenden och konfiguration.
$ cd [ProgramNamn]
Tillverka en "byggkatalog" för byggandet. -Den kan raderas och tillverkas på nytt om byggandet misslyckas första gångerna, t ex
p g a beroendeproblem.
$ mkdir build
Navigera dit med terminalen
$ cd build
Kör nu cmake (där du tidigare körde ./configure)
Skillnaden är att cmake nu använder filerna i katalogen "ovanför" build, men skriver i katalogen "build". Kan därför göras om.
$ cmake ../
( ../ betyder helt enkelt katalogen ovanför) Ev flaggor till cmake från README eller programmets hemsida.
-Här kan beroendeproblem uppstå precis som vid ./configure och får lösas på samma sätt: Undersök stoppen, komplettera beroenden,
gör om, nu i ny build-katalog.
När cmake slutligen lyckats, d v s inte mött några beroendeproblem utan avslutats:
Kör make
$ make
Precis som vid vanlig källkod kan du här ta ställning till om du vill installera direkt (vilket kräver omsorg om den skapade Makefile, att du sparar buildkatalogen och/eller sparar terminalloggen från # make install). Du kan också pröva att tillverka ett distributionseget paket.
Gången är densamma som vid källkod, men repeteras här för enkelhets skull:
-Nu har du tillverkat en "i princip" installerbar version av programmet! Allt du tillverkat hittills har inte berört rootfilsystemet,
allt tillverkat och byggt ligger kvar i din katalog "build".
Nu har du också ett antal val och minst ett övervägande att göra!
Du bör kontrollera om det finns installations- och avinstallationsscript i filen /build/Makefile (eller ev i separata script med
namnet "install"/uninstall")?
Öppna den/dem och läs: Sök efter "install" respektive "uninstall".
Finns det bör du spara byggkatalogen inkl filen Makefile för att kunna avinstallera programmet om du i framtiden skulle vilja det.
Finns det INTE bör du ändå spara filen Makefile: Scriptet "install" innehåller en detaljerad beskrivning av var programmets
filer läggs. Vid en manuell avinstallation är det den beskrivningen du får följa för att manuellt kunna radera programmets filer
och se till att du raderar RÄTT filer.
Vill du försöka bygga ett programpaket som är anpassat för din distribution (*.rpm, *.deb eller *.tgz/*.txz) kan det ha vissa
fördelar framför att köra en direkt installation: Du kan hantera programmet med distributionens egen pakethanterare och du kan enkelt
vid behov avinstallera det med denna.
Har du installerat checkinstall:
I Debian/Fedora/OpenSUSE kan du då i stället för
# make install
som användare (fortfarande) köra
$ make checkinstall
och därefter (som root/sudo) installera paketet med din distributions pakethanterare.
Har du i stället installerat (i Fedora/OpenSUSE) rpm-build/ (i Debian) build-essential
kör du i stället
$ make package
och därefter (som root/sudo) installera paketet med din distributions pakethanterare.
I Slackware är tillverkningen, bortsett från kontrollen av beroendena, annorlunda och något enklare,
även om avvikande från vanlig källkod:
Har du, så långt möjligt kontrollerat och installerat ditt nya källkodsprograms beroenden kan du redan när du
tagit hem källkoden [ProgramNamn] använda programmet src2pkg.
-Du tar hem och installerar det från: http://www.src2pkg.net/ ->
http://distro.ibiblio.org/amigolinux/download/src2pkg/
Efter installationen tar programmet dig genom en guidad konfiguration, default-värdena är vanligen tillräckligt bra.
Först måste du dock packa (komprimera) källkoden.
Läs först vilken programversion du tagit hem i filen [ProgramNamn]/VERSION.cmake
Döp nu om din källkodskatalog (med gemener) till [programnamn-version.nummer]
Packa den:
$ tar czf [programnamn-version.nummer].tar.gz [programnamn-version.nummer]/
Du får nu en packad cmake-källkodsfil [programnamn-version.nummer].tar.gz
Om du inte redan är där: Ställ dig i den katalog där din packade cmake-källkod [programnamn.versionsnummer].tar.gz ligger
"Bli" root:
$ su lösenord: ****** # src2pkg [programnamn-version.nummer].tar.gz
(i själva verket bygger scriptet src2pkg en build-katalog och kör cmake + make i /tmp/[programnamn-version.nummer]-src-1/build
Är inte alla beroenden uppfyllda får du också under configure samma plågsamma sökande var det stannar, och beroendelösande som
jag beskrev ovan.
Radera i så fall som root tmp/[programnamn-version.nummer]-src-1/build och kör om src2pkg efter kompletterande
beroendeinstallationer.)
Det färdiga *.tgz/*.txz-paketet ligger /tmp och kan installeras eller hämtas därifrån för senare installation.
Vill du, i stället för omvägen via "paket", installera programmet du byggt direkt, måste du få administratörs/root-behörighet:
$ su lösenord: ******* make install #
eller
$ sudo make install lösenord: ********* $
OBS! Spara här terminalloggen för # make install! OBS! Underlättar vid ev avinstallation.
Källkodsprogram installeras vanligen i /usr/local/bin /usr/local/lib och /usr/local/share (om du inte ändrat detta med någon
flagga i configure).
Vill du avinstallera det direkt programmet och har ett uninstallscript i Makefile, navigerar du åter till din uppackade
källkodskatalog
$ cd /programnamn.versionsnummer/
och som root/sudo kör
# make uninstall
Har du inget avinstallationsscript, men har sparat terminal-loggen för # make install, kan du enkelt följa den, se
var ditt programs filer ligger installerade och radera dem där.
Har du ingendera men har kvar Makefile får du läsa den (under "install") och se vart filerna installerades.
