Autore: Fabio Di Matteo
Ultima revisione: 07/11/2008

Il nome CMake è un'abbreviazione di cross platform make. Questo software rimpiazza il vecchio e non facilissimo da usare Automake nella generazione dei Makefile. Infatti, nella maggior parte dei progetti, non esiste un Makefile incluso nei sorgenti, dato che questo non è portabile. Per la compilazione del programma è necessario verificare che siano incluse tutte le librerie e scovare i loro percorsi all'interno del file system. Proprio per questo motivo, è impossibile avere un Makefile già scritto.Da Wikipedia, l'enciclopedia libera.

Innanzitutto ecco l'alberatura delle directory del nostro progetto

+\Progetto
    |
    +------src
    |        |_____main.c
    |
    ---CmakeLists.txt 

Prendiamo ad esempio il seguente codice che non fa altro ache creare una semplice finestra con una tabella in Gtk+2.

main.c (Un sorgente GTK+-2.x qualunque)

#include <gtk/gtk.h>
 
void hello(GtkWidget* widget, gpointer data)
{
    g_print("Hello, World!\n");
}
 
int main(int argc, char** argv)
{
    GtkWidget* window;
    GtkWidget* button;
 
    gtk_init(&argc, &argv);
 
    window = gtk_window_new(GTK_WINDOW_TOPLEVEL);
    gtk_container_set_border_width(GTK_CONTAINER(window), 10);
    g_signal_connect(G_OBJECT(window), "destroy",
                         G_CALLBACK(gtk_main_quit), NULL);
 
    button = gtk_button_new_with_label("Hello, World!");
    g_signal_connect(G_OBJECT(button), "clicked",
                         G_CALLBACK(hello), NULL);
 
    gtk_container_add(GTK_CONTAINER(window), button);
 
    gtk_widget_show(window);
    gtk_widget_show(button);
 
    gtk_main();
 
    return 0;
}

CMakeLists.txt

cmake_minimum_required(VERSION 2.6)

PROJECT(ProvaGTK)
SET (AUTHOR "Fabio Di Matteo" INTERNAL "Author")
SET (VERSION "0.1.0")

INCLUDE (FindPkgConfig)

#Controlla se c'e' il programma pkg-config
IF (NOT PKG_CONFIG_FOUND)
	MESSAGE (FATAL_ERROR "pkg-config not found...")
ENDIF (NOT PKG_CONFIG_FOUND)

pkg_check_modules (GTK REQUIRED gtk+-2.0>=2.6)

#Controlla se ci sono le Gtk+-2.0
IF (NOT GTK_FOUND)
	MESSAGE(FATAL_ERROR "You don't seem to have gtk >= 2.6 development libraries installed...")
ENDIF (NOT GTK_FOUND)

ADD_DEFINITIONS()


#Include
INCLUDE_DIRECTORIES (. ${GTK_INCLUDE_DIRS})

#Lincaggio alle librerie
LINK_DIRECTORIES (${GTK_LIBRARY_DIRS} )
LINK_LIBRARIES (${GTK_LIBRARIES} )


#Indichiamo dove sara' messo l'eseguibile
ADD_EXECUTABLE(prova-bin src/main.c)

#Se se si ha bisogno di eventuali dipendenze fornite da noi stessi
#ADD_DEPENDENCIES (prova-bin src/main.c)


#Variabili per le directory di installazione
#ADD_DEFINITIONS (-DVERSION=\\\"${VERSION}\\\")
#ADD_DEFINITIONS (-DDATADIR=\\\"${CMAKE_INSTALL_PREFIX}/share\\\")


#Copia file per l'installazione
#ADD_SUBDIRECTORY (src)
INSTALL (TARGETS prova-bin DESTINATION bin)
#INSTALL (FILES src/prova-bin DESTINATION bin)

Ormai quasi tutte le librerie vengono distribuite con il proprio file .pc che indica a pkg-config dove sono gli include e i file delle librerie. Per fornire questi importanti parametri in fase di compilazione e lincaggio basta compilare con l'output del comando pkg-config –cflags –clibs <nome libreria> dove nome libreria si puo' ricavare dall'elenco delle librerie installate tramite il comando .

Immaginiamo di dovere creare un nostro progetto che usi le librerie gio-unix-2.0 , istruire cmake del suo utilizzo e' semplice:

...
# Controlla che sia presente GIO-UNIX, specificando che e' richiesto 
pkg_check_modules (GIO REQUIRED gio-unix-2.0>=2.0)

#Se non viene trovata la nostra libreria allora stampa un messaggio d'errore
IF (NOT GIO_FOUND)
	MESSAGE(FATAL_ERROR "You don't seem to have gio-unix >= 2.0 development libraries installed...")
ENDIF (NOT GIO_FOUND)

#Infine prende i flag per il lincaggio alle librerie  
LINK_DIRECTORIES (${GIO_LIBRARY_DIRS} )
LINK_LIBRARIES (${GIO_LIBRARIES} )
...

SET (NOME_VARIABILE "valore")

esempio:

SET (CMAKE_INSTALL_PREFIX "/opt")

CMAKE_INSTALL_PREFIX e' la variabile del percorso di installazione.

Sono richiesti alcuni pacchetti cmake build-essential devscripts . Installabili con il solito apt-get install cmake build-essential devscripts .

Per creare pacchetti a partire dai file di configurazione di cmake basta eseguire i seguenti semplici comandi.Visto e considerato che i percorsi di installazione sono specificati nel CMakeList.txt con le direttive INSTALL .

Prima di tutto assicurarsi che la directory del progetto segua la sintassi dei debuild ovvero <nomepacchettominuscolo>-<numeroversione> .

1. Dare il comando ccmake <nomepacchettominuscolo>-<numeroversione> per configurare il progetto ;
2. tramite un menu' testuale da dove sara' possibile configurare i vari aspetti del pacchetto, premendo la lettera c (2 volte) e per confermare la lettera(g);
3. Tramite il comando dh_make -s -e nostra@email.it -n si creera'la sottodirectory debian con diversi file contenenti informazioni sul pacchetto come copyright e altri. Questi file possono essere modificati secondo le proprie esigenze;
4. A questo punto e' possibile usare il comando debuild binary per compilare i sorgenti e creare il pacchetto. Il pacchetto verra' generato nella directory al primo livello superiore.

E' possibile inseguito ispezionare le proprieta' del pacchetto con il comando dpkg -I nomepacchetto.deb, per installarlo invece dpkg -i nomepacchetto.deb

Per una lista delle direttive:

cmake --help-command-list

Per avere documentazione su una direttiva:

cmake --help-command <direttiva>

Per altra documetazione e' utile consultare il sito web ufficiale ela man page