Cmake

CMake Tutorial | La plaga Tux http://plagatux.
es/2009/12/tutorial-cmake/
La plaga Tux
Los tuxes con ansias de aprender acechan. Software libre, programacin,
LaTeX y puede que algo ms
Inicio
Autor
Tutoriales Plagatux
Type text to search here...

Inicio > Programacin, Tutoriales > Tutorial CMake
Tutorial CMake
Lunes, 7 de diciembre de 2009 piponazo Dejar un comentario Ir a
comentarios
ltima actualizacin: 16/09/2010
Hasta ahora he estado usando las autotools (autoconf, automake, libtool, etc.)
para llevar a cabo la conguracin de todos mis proyectos, y la verdad que
me ha ido muy bien con estas herramientas una vez consegu desentrelazar
alguna que otra cosilla que me llev ms de un quebradero de cabeza. Pero
ya sabis, uno no se cansa de aprender cosas y ampliar conocimientos, y
desde hace tiempo vengo observando que cmake recibe muy buenas crticas,
sobre todo debido a la posibilidad que nos ofrece para poder congurar
nuestros proyectos software para distintas plataformas (GNU/Linux,
Windows, Mac OS/X, etc) y distintos compiladores (GnuC, Visual C++,
Borland, MinGW, etc). En esta entrada os hablar sobre cmake, explicar
algunas de sus principales caractersticas y os dejar algunos ejemplos tiles.
1 de 27 13/03/16 09:14
CMake Tutorial | La plaga Tux http://plagatux.es/2009/12/tutorial-cmake/
Qu es CMake?
CMake es un sistema extensible y abierto que controla el proceso de
construccin de manera independiente en diferentes sistemas operativos y
compiladores. CMake est diseado para ser usado en conjunto con el
sistema de construccin nativo de un entorno. Se utilizan cheros simples de
conguracin en cada directorio fuente (llamados CMakeLists.txt) para
generar cheros de estndar de construccin (Makeles en Unix y proyectos
en Windows MSVC) que se usan de la manera usual. CMake puede compilar
cdigo fuente, crear libreras, generar wrappers y construit ejecutables en
combinaciones arbitrarias. CMake soporta construcciones in-place y out-of-
place, y por lo tanto se puede realizar mltiples construcciones a partir de un
nico rbol fuente. CMake tambin soporta la construccin de libreras
estticas y dinmicas. Otra buena caracterstica de CMake es que genera un
chero cache que es diseado para ser usado con un editor grco. Por
ejemplo, cuando ejecutamos CMake, este localiza los cheros de inclusin,
libreras, ejecutables y puede encontrar otras directivas de construccin
opcionales. Dicha informacin es reunida en la cache, que puede ser
cambiada por el usuario antes de que se generen los cheros de construccin
nativos.
Cmake est diseado para soportar complejas jerarquas de directorios y

aplicaciones que dependen de varias libreras. Por ejemplo, CMake soporta
proyectos consistentes en multiples toolkits (es decir, libreras) donde cada
toolkit puede contener varios directorios, y la aplicacin depende de los
toolkits adems de un cdigo adicional. CMake tambin puede manejar
situaciones donde se deben construir ejecutables para poder generar cdigo
que es despus compilado y linkado en una aplicacin nal.
Usar CMake es simple. El proceso de construccin es controlado por la

creacin de uno o ms cheros CMakeLists.txt en cada directorio (incluyendo
subdirectorios) que forma un proyecto. Cada CMakeLists.txt consiste en uno
o ms comandos. Cada comando tiene la forma COMANDO(argumentos).
CMake proporciona varios comandos predenidos, pero si lo necesitas
puedes aadir tus propios comandos. Adems, el usuario avanzado puede
aadir otros generadores de Makeles para una combinacin particular de
compilador/S.O.
Despus de haber estado unos cuantos das trabajando con CMake puedo
decir que es bastante ms rpido de aprender que las autotools, aunque est
armacin puede estar inuenciada por mi desconocimiento en algunos
estndares en la programacin de proyectos que he ido adquiriendo con el
tiempo. Tambin son necesarias, en general, menos lneas de cdigo para un
mismo proyecto con autotools.
2 de 27 13/03/16 09:14
HelloWorld con CMake

Este primer ejemplo que vamos a ver lo he sacado de la siguiente direccin
donde podis encontrar un breve tutorial en pdf de CMake, eso si, en ingls.
He realizado unas breves modicaciones a la estructura de directorios y al
contenido de los cheros para que se ajuste ms a cmo suelo trabajar yo. La
estructura de directorios con la que vamos a trabajar es la siguiente la podis
ver en la siguiente imagen:
Directorio raz
Dentro de nuestro directorio de trabajo raz vamos a crear la carpeta src
donde almacenaremos los cheros fuente que formarn una librera a la que
llamaremos Hello, y otra carpeta test donde crearemos un programa que
har uso de la librera creada. Por otro lado, necesitaremos un directorio de
nombre aleatorio (en este caso build) donde se crearn los archivos
necesarios para generar el proyecto, independientemente del sistema
operativo y compilador que usemos. Por ltimo, y ms importante, crearemos
el archivo CMakeLists.txt el cul describir como se organiza el proyecto en
el que estamos trabajando. El contenido de dicho chero ser el siguiente:
1 PROJECT(HELLO) ?
2 CMAKE_MINIMUM_REQUIRED(VERSION 2.6)
3
4 ADD_SUBDIRECTORY(src)
5 ADD_SUBDIRECTORY(test)
El signicado de los comandos que aparecen en este chero son los

siguientes:
3 de 27 13/03/16 09:14
PROJECT: asigna un nombre que identica al proyecto. Ahora los

cheros del proyecto podrn referirse al directorio fuente raz del
proyecto como ${NOMBREPROYECTO_SOURCE_DIR} y al directorio
binario raz del proyecto como ${NOMBREPROYECTO_BINARY_DIR}
CMAKE_MINIMUM_REQUIRED: Establece una versin mnima de
cmake para poder generar el proyecto. Si no se especica puede que
cmake nos muestre algn warning al intentar congurar el proyecto.
ADD_SUBDIRECTORY: Aade un nuevo subdirectorio a la lista de
subdirectorios del proyecto independientemente del contenido de este.
Directorio src
En el directorio src vamos a incluir el cdigo fuente de una librera que
solamente va a consistir en una clase Hello compuesta por los cheros
hello.h y hello.cpp. El cdigo de los cheros es el siguiente:
01 // hello.h ?
02 #ifndef HELLO_INC
03 #define HELLO_INC
04
05 class Hello
06 {
07 public:
08 void Print();
09 }; // ----- end of class Hello -----
10
11 #endif // ----- #ifndef HELLO_INC -----
1 #include "hello.h" ?
2 #include <iostream>
3
4 using namespace std;
5
6 void Hello:: Print()
7 {
8 cout << "Hello, World!" << endl;
9 }
Por ltimo, el contenido del chero CMakeLists.txt que est dentro del
directorio src sera simplemente:
1 #Aade una librera llamada Hello (libHello.a bajo linux) a ?partir del
2 ADD_LIBRARY(Hello hello)
Este comando por defecto nos crear una librera llamada Hello con el
chero que le hemos especicado. Aqu tambin se puede especicar si
queremos que la librera sea dinmica o esttica, pero ya hablar sobre eso
ms adelante.
4 de 27 13/03/16 09:14
Directorio test
En el directorio test vamos a incluir el tpico programa Hola Mundo
haciendo uso de la librera Hello que hemos creado en el directorio src. El
cdigo fuente de dicho programa es el siguiente:
1 // test.cpp ?
2 #include <iostream>
3 #include "hello.h"
4
5 int main()
6 {
7 Hello().Print();
8 return 0;
9 }
Y el contenido del chero CMakeLists.txt que est dentro del directorio test
es:
1 #Asegurarse de que el compilador puede encontrar los ficheros

? de nuest
2 INCLUDE_DIRECTORIES(${HELLO_SOURCE_DIR}/src)
3
4 #Aade un binario llamado "helloWorld" que es construido del fichero f
5 #La extensin se encuentra automticamente
6 ADD_EXECUTABLE(helloWorld test)
7
8 #Enlaza el ejecutable con la librera Hello
9 TARGET_LINK_LIBRARIES(helloWorld Hello)
Construyendo el proyecto
Ya tenemos todo el cdigo de nuestro proyecto y los cheros CMakeLists.txt
necesarios para poder construirlos mediante cmake. Normalmente para
construir un proyecto crearemos una nueva carpeta (en nuestro caso la
hemos llamado build) para generar una compilacin del proyecto especca
para un determinado S.O. (Windows, Linux, Mac), un determinado compilador
(gcc, MSVC, icc, mingw, etc), o una determinada conguracin (Debug,
Release, etc). Esta caracterstica es verdaderamente til para no tener que
re-generar proyectos enteros segn la conguracin deseada cuando
hagamos pequeos cambios en el cdigo. Yo lo que suelo hacer es crearme
dos directorios: build-debug y build-release. El primero lo uso durante la
fase ms intensa de desarrollo, para corregir todos los posibles warning que
me lance el compilador y activar el soporte de depuracin para los
depuradores. El segundo lo uso una vez que estoy seguro (o tengo una gran
certeza) de que el cdigo no contiene ningn error, y quiero compilar la
librera con todas las optimizaciones posibles y sin soporte de depuracin.
Para la generacin del proyecto ingresaremos en una terminal de texto y
5 de 27 13/03/16 09:14
accederemos al directorio build. Una vez all ejecutaremos el comando:
1 cmake .. ?
Bsicamente, al comando cmake tenemos que pasarle como argumento la

ruta al directorio donde se almacena el proyecto. Si todo ha ido bien
tendremos, cmake har las comprobaciones oportunas y tendremos una
salida parecida a la siguiente:
01 pipo@pipo-laptop:~/cmake-template/build$ cmake ../ ?
02 -- The C compiler identification is GNU

03 -- The CXX compiler identification is GNU
04 -- Check for working C compiler: /usr/bin/gcc
05 -- Check for working C compiler: /usr/bin/gcc -- works
06 -- Detecting C compiler ABI info
07 -- Detecting C compiler ABI info - done
08 -- Check for working CXX compiler: /usr/bin/c++
09 -- Check for working CXX compiler: /usr/bin/c++ -- works
10 -- Detecting CXX compiler ABI info
11 -- Detecting CXX compiler ABI info - done
12 -- Configuring done
13 -- Generating done
14 -- Build files have been written to: /home/pipo/cmake-template/build
Una vez hecho esto, se habrn generado una serie de directorios y archivos
para que realizar la compilacin e instalacin del proyecto sea tan sencillo
como ejecutar los siguientes comandos:
1 make ?
2 sudo make install
Tambin disponemos de una interfaz grca para cmake mediante el

comando cmake-gui. A la hora de congurar el proyecto en plataformas
Windows es mucho ms cmodo trabajar mediante esta interfaz para
seleccionar el tipo de conguracin segn el compilador o IDE que usemos.
Para los que no dispongan de dicha interfaz grca (por ejemplo los que usen
debian), pueden utilizar el comando ccmake que habilita una interfaz en
modo texto con la que podemos modicar los valores de las variables
fcilmente desde la consola.
Opciones avanzadas
El ejemplo Hola-Mundo que os acabo de mostrar, es solo la punta del Iceberg
de posibilidades que nos presenta CMake. Podemos tener cheros de
conguracin tan sencillos como los que acabo de mostrar o otros ms
complejos donde tendremos en cuenta la portabilidad de nuestro cdigo a
diferentes sistemas operativos, compiladores, uso de programas externos,
etc. A continuacin os hablar de algunas cosas ms, sobre el uso bsico de
6 de 27 13/03/16 09:14
Cmake, adems de otros problemas con los que me he ido encontrando y a los
que he ido dando solucin.
Cambiando las variables en la cache de cmake

Cuando ejecutamos por consola el comando
1 cmake .. ?
Le estamos diciendo a Cmake que realice la conguracin estndar del

proyecto que estemos compilando. Pero CMake cuenta con algunas variables
y opciones internas, adems de las que denamos nosotros que podemos
modicar fcilmente a la hora de congurar el proyecto. Para cambiar el
valor de dichas variables u opciones tenemos que utilizar la opcin -D. Por
otra parte, la opcin -i har que cmake nos pregunte interactivamente por
algunos ajustes a realizar. Por ejemplo, si queremos congurar nuestro
proyecto para depuracin ejecutaremos el siguiente comando:
1 cmake -D CMAKE_BUILD_TYPE=Debug .. ?
De todos modos, si no os sents cmodos trabajando desde una terminal,

siempre podis modicar las variable y opciones desde la interfaz grca de
cmake (cmake-gui).
Variables
El uso de variables es fundamental en cmake y una buena comprensin en la
manipulacin de estas nos facilitar la elaboracin de otras arduas tareas.
Quizs las caractersticas ms destacables del manejo de variables con cmake
sean las siguientes:
No necesitamos declararlas. No existe diferencia entre crear y modicar

una variable.
Normalmente no se necesita denir su tipo.
El comando SET crea y modica variables.
El comando SET puede hacer de todo con las variables pero LIST hace
que algunas operaciones sean ms sencillas (ver funcin APPEND).
El comando FILE nos permite denir listas de variables de una forma
tan rpida y sencilla como la siguiente: FILE(GLOB hdrs *.h ). Con
dicho comando asignamos a la variable hdrs todos los cheros con
extensin .h del directorio actual.
Adems de trabajar con variables que puedan ser de distintos tipos
podemos tratar con opciones que solo pueden tomar los valores ON y
OFF. Por ejemplo podemos establecer la siguiente opcin para
determinar ms adelante si tratar los warning en nuestro cdigo como
errres.
7 de 27 13/03/16 09:14
1 set(WARNINGS_ARE_ERRORS OFF CACHE BOOL "Treat warnings as

? errors"
La opcin denida en el punto anterior se almacena en el chero de

cache y su valor puede modicarse posteriormente modicando dicho
chero.
Cambiando los parmetros de construccin

Cmake utiliza parmetros por defecto para el preprocesador, compilador y
linkador, pero estos pueden ser modicados sin demasiadas complicaciones.
Podemos:
Modicar la conguracin del preprocesador con ADD_DEFINITIONS y

REMOVE_DEFINITIONS. Estos cambios se aplican tanto para C como
para C++.
Modicar la conguracin del compilador modicando las variables
CMAKE_C_FLAGS y CMAKE_CXX_FLAGS.
Modicar la conguracin del linkador mediante
Normalmente en todos los proyectos con los que trabajo siempre incluyo ags
de compilacin segn el modo de trabajo en el que me encuentre (Release y
Debug). Para ello podemos modicar las siguientes variables:
1 SET(CMAKE_CXX_FLAGS_DEBUG "-O0 -g3 -Wall -Werror -W -Wno-return-type"

?
2 SET(CMAKE_CXX_FLAGS_RELEASE "-O2 -pipe -march=core2" )
Adems podemos establecer diferentes tipos de construcciones de nuestros

proyectos. Las conguraciones ms usuales son Debug y Release. La
conguracin Debug es til cuando estamos en pleno proceso de desarrollo y
queremos que el compilador nos avise de cualquier posible error o warning
que pueda haber en nuestro cdigo. Adems no se incluyen optimizaciones en
el cdigo para que la depuracin del mismo sea ms sencilla. La
conguracin Release tiene una funcionalidad totalmente inversa. Es una
conguracin que incluye optimizaciones en el cdigo, elimina el soporte de
depuracin y evita la comprobacin agresiva de errores y warnings en el
cdigo, para que tanto la compilacin como la ejecucin del mismo sea lo ms
rpida posible.
Para congurar el proyecto de una forma u otra solo tenemos que modicar
la variable CMAKE_BUILD_TYPE mediante el comando SET. Una forma de
establecer el modo de construccin del proyecto por defecto a Release
podra ser:
1 IF(NOT CMAKE_BUILD_TYPE ) ?
2 SET( CMAKE_BUILD_TYPE "Release" )

3 ENDIF()
De esta forma si no le indicamos a cmake lo contrario compilaremos nuestro
8 de 27 13/03/16 09:14
proyecto para una versin de lanzamiento. Si queremos indicarle a cmake

mediante un argumento que tipo de construccin queremos, ejecutaremos el
comando de la siguiente forma:
1 cmake -D CMAKE_BUILD_TYPE=Release ../ ?
En cuanto a las ags de compilacin, se pueden hacer cosas mucho ms

avanzadas como determinar el tipo de procesador que hay en el sistema y
activar unas ags u otras segn el mismo. Podis echar un vistazo al
CMakelists.txt que incluye la ltima versin de OpenCV para comprobar por
vuestra cuenta el poder de CMake.
Usando pkg-cong con cmake

A pesar de que en la documentacin de cmake no recomiendan usar
pkg-cong ya que puede que no est instalado en los equipos de los usuarios
nales, es innegable que muchos proyectos software actuales en plataformas
GNU/Linux, sobre todo los que estn relacionados con las libreras GTK+,
hacen uso de pkg-cong para manejar sus dependencias. Lo cierto es que
hasta ahora, todas las libreras que he manejado y desarrollado hacen uso de
pkg-cong, y vera imposible mi migracin a cmake si este no incluyese un
modo de manejar las dependencias por medio de una interfaz a pkg-cong.
Para hacer uso de esta interfaz vamos a tener que incluir el mdulo
FindPkgCong.cmake en nuestro proyecto y despus utilizarlo mediante el
comando PKG_CHECK_MODULES. Podis encontrar una amplia
documentacin sobre dicho comando en el propio chero del mdulo, el cual
si usis Ubuntu se encuentra en: /usr/share/cmake-2.6/Modules
/FindPkgCong.cmake. A continuacin un sencillo ejemplo de como
comprobar si en nuestro sistema est instalada la librera matio.
1 FIND_PACKAGE(PkgConfig) #Enable PKG-CONFIG suport ?
2 PKG_CHECK_MODULES(MATIO matio>=1.3.3)
En este caso pido que la versin de la librera sea al menos la 1.3.3, y el

prejo que voy a usar para las variables denidas con cmake es el mismo
nombre de la librera pero con maysculas. La funcin
PKG_CHECK_MODULES dene las siguientes variables, entre otras, en caso
de que la librera se encuentre:
1 <PREFIX>_LIBRARIES ... only the libraries (w/o the '-l')

?
2 <PREFIX>_LIBRARY_DIRS ... the paths of the libraries (w/o the '-L')

3 <PREFIX>_LDFLAGS ... all required linker flags
4 <PREFIX>_LDFLAGS_OTHER ... all other linker flags
5 <PREFIX>_INCLUDE_DIRS ... the '-I' preprocessor flags (w/o the '-I')
6 <PREFIX>_CFLAGS ... all required cflags
7 <PREFIX>_CFLAGS_OTHER ... the other compiler flags
9 de 27 13/03/16 09:14
Y para determinar si se ha encontrado la librera podemos usar la variable

_FOUND. Por ejemplo, en el desarrollo de una librera podemos decidir si
incluir ciertos cheros o no dependiendo de que se encuentre una
dependencia.
1 IF (MATIO_FOUND) ?
2 SET(hdrs ${hdrs} gumatio.h)

3 SET(srcs ${srcs} gumatio.cpp)
4 INCLUDE_DIRECTORIES(${MATIO_INCLUDE_DIRS})
5 SET(libraries ${libraries} ${MATIO_LIBRARIES})
6 ENDIF()
Generando documentacin con Doxygen

Al igual que con las autotools, podemos hacer que mediante un simple
comando make doc generemos la documentacin con doxygen de nuestro
cdigo fuente apropiadamente documentado. Para CMake me encontr el
siguiente chero de Jan Woetzel, el cual he modicado a mi antojo deniendo
algunas variables al principio de la macro para decidir si habilitar ciertas
caractersticas o no:
001 # -helper macro to add a "doc" target with CMake build system.
?
002 # and configure doxy.config.in to doxy.config

003 #
004 # target "doc" allows building the documentation with doxygen/dot on
005 # Creates .chm windows help file if MS HTML help workshop
006 # (available from http://msdn.microsoft.com/workshop/author/htmlhelp
007 # is installed with its DLLs in PATH.
008 #
009 #
010 # Please note, that the tools, e.g.:
011 # doxygen, dot, latex, dvips, makeindex, gswin32, etc.
012 # must be in path.
013 #
014 # Note about Visual Studio Projects:
015 # MSVS hast its own path environment which may differ from the shell
016 # See "Menu Tools/Options/Projects/VC++ Directories" in VS 7.1
017 #
018 # author Jan Woetzel 2004-2006
019 # www.mip.informatik.uni-kiel.de/~jw
020 #
021 # Modified by Luis Daz 2009
022 # http://plagatux.es
023
024 MACRO(GENERATE_DOCUMENTATION DOX_CONFIG_FILE)
025 FIND_PACKAGE(Doxygen)
026 IF (DOXYGEN_FOUND)
027 #Define variables
028 SET(SRCDIR "${PROJECT_SOURCE_DIR}/src" )
029 SET(TAGFILE "${PROJECT_BINARY_DIR}/doc/${PROJECT_NAME}.tag"
10 de 27 13/03/16 09:14
030
031 IF (USE_CHM AND WIN32)
032 SET(WIN_CHM "YES" )
033 SET(CHM_FILE "${PROJECT_SOURCE_DIR}/doc/help.chm" )
034 SET (BINARY_TOC "YES" )
035 SET (TOC_EXPAND "YES" )
036 ELSE()
037 SET(WIN_CHM "NO" )
038 SET (BINARY_TOC "NO" )
039 SET (TOC_EXPAND "NO" )
040 ENDIF()
041
042 IF (USE_LATEX)
043 SET(GENERATE_PDF "YES" )
044 SET(GENERATE_LATEX "YES" )
045 SET(LATEXOUT "latex" )
046 ELSE()
047 SET(GENERATE_PDF "NO" )
048 SET(GENERATE_LATEX "NO" )
049 ENDIF()
050
051 IF (NOT USE_DOT)
052 SET(DOXYGEN_DOT_FOUND "NO" )
053 ENDIF()
054
055 #click+jump in Emacs and Visual Studio (for doxy.config) (jw)
056 IF (CMAKE_BUILD_TOOL MATCHES "(msdev|devenv)" )
057 SET(DOXY_WARN_FORMAT "\"$file($line) : $text \"" )
058 ELSE (CMAKE_BUILD_TOOL MATCHES "(msdev|devenv)" )
059 SET(DOXY_WARN_FORMAT "\"$file:$line: $text \"" )
060 ENDIF (CMAKE_BUILD_TOOL MATCHES "(msdev|devenv)" )
061
062 # we need latex for doxygen because of the formulas
063 FIND_PACKAGE(LATEX)
064 IF (NOT LATEX_COMPILER)
065 MESSAGE(STATUS "latex command LATEX_COMPILER not found but usually r
066 ENDIF (NOT LATEX_COMPILER)
067 IF (NOT MAKEINDEX_COMPILER)
068 MESSAGE(STATUS "makeindex command MAKEINDEX_COMPILER not found but u
069 ENDIF (NOT MAKEINDEX_COMPILER)
070 IF (NOT DVIPS_CONVERTER)
071 MESSAGE(STATUS "dvips command DVIPS_CONVERTER not found but usually
072 ENDIF (NOT DVIPS_CONVERTER)
073
074 # Check config file
075 IF (EXISTS "${DOX_CONFIG_FILE}" )
076 CONFIGURE_FILE(${DOX_CONFIG_FILE} ${CMAKE_CURRENT_BINARY_DIR}
077 SET(DOXY_CONFIG "${CMAKE_CURRENT_BINARY_DIR}/doxy.config" )
078 ELSE ()
079 MESSAGE(SEND_ERROR "Please create configuration file for doxygen in
080 ENDIF()
081
082 # Add target
11 de 27 13/03/16 09:14
083 ADD_CUSTOM_TARGET(doc ${DOXYGEN_EXECUTABLE} ${DOXY_CONFIG})

084
085 IF (WIN32 AND GENERATE_WIN_CHM STREQUAL "YES" )
086 FIND_PACKAGE(HTMLHelp)
087 IF (HTML_HELP_COMPILER)
088 ADD_CUSTOM_TARGET(winhelp ${HTML_HELP_COMPILER} ${HHP_FILE})
089 ADD_DEPENDENCIES (winhelp doc)
090 IF (EXISTS ${CHM_FILE})
091 IF (PROJECT_NAME)
092 SET(OUT "${PROJECT_NAME}" )
093 ELSE ()
094 SET(OUT "Documentation" ) # default
095 ENDIF()
096 IF (${PROJECT_NAME}_VERSION_MAJOR)
097 SET(OUT "${OUT}-${${PROJECT_NAME}_VERSION_MAJOR}" )
098 IF (${PROJECT_NAME}_VERSION_MINOR)
099 SET(OUT "${OUT}.${${PROJECT_NAME}_VERSION_MINOR}" )
100 IF (${PROJECT_NAME}_VERSION_PATCH)
101 SET(OUT "${OUT}.${${PROJECT_NAME}_VERSION_PATCH}" )
102 ENDIF()
103 ENDIF()
104 ENDIF()
105 SET(OUT "${OUT}.chm" )
106 INSTALL(FILES ${CHM_FILE} DESTINATION "doc" RENAME "${OUT}"
107 ENDIF()
108 ELSE()
109 MESSAGE(FATAL_ERROR "You have not Microsoft Help Compiler"
110 ENDIF()
111 ENDIF ()
112
113 INSTALL(DIRECTORY "${PROJECT_BINARY_DIR}/doc/html/" DESTINATION
114
115 ENDIF(DOXYGEN_FOUND)
116 ENDMACRO(GENERATE_DOCUMENTATION)
Para hacer uso de dicho chero, adems de activar o desactivar algunas

opciones en el chero principal de conguracin CMake, hay que aadir las
siguientes lneas, teniendo en cuenta que el chero anterior tiene como
nombre generateDoc.cmake:
1 OPTION(INSTALL_DOC "Set to OFF to skip build/insta

?
2 OPTION(USE_DOT "Set to ON to perform diagram g

3 OPTION(USE_LATEX "Set to ON to build latex document
4 OPTION(USE_CHM "Set to ON to build CHM Windows
5
6 IF (INSTALL_DOC)
7 INCLUDE("${PROJECT_SOURCE_DIR}/generateDoc.cmake" )
8 GENERATE_DOCUMENTATION(${PROJECT_SOURCE_DIR}/lib${PROJECT_NAME}.dox.
9 ENDIF()
El chero libPROJECT.dox.in ser el chero plantilla de conguracin

doxygen, donde tendremos que hacer uso de algunas de las variables
12 de 27 13/03/16 09:14
denidas en el chero generateDoc.cmake encerrando entre arrobas el

nombre de dichas variables (p.e. @PROJECT_NAME@,
@DOXYGEN_DOT_FOUND@, etc).
Aadir una opcin make uninstall

Cuando aadimos los comandos INSTALL en nuestro proyecto, se generan
comandos install para los makeles pero sin embargo no se generan los
comandos necesarios para desinstalar cada uno de los objetivos del proyecto.
Examinando otros proyectos (En concreto el soporte para CMake en OpenCV)
me encontr con el siguiente chero que nos permite desinstalar todo lo que
instale nuestro proyecto.
01 # ----------------------------------------------- ?
02 # - cmake_uninstall.cmake.in
03 # File that provides "make uninstall" target
04 # We use the file 'install_manifest.txt'
05 # -----------------------------------------------
06 IF(NOT EXISTS "@CMAKE_CURRENT_BINARY_DIR@/install_manifest.txt" )
07 MESSAGE(FATAL_ERROR "Cannot find install manifest: \"@CMAKE_CURRENT
08 ENDIF(NOT EXISTS "@CMAKE_CURRENT_BINARY_DIR@/install_manifest.txt" )
09
10 FILE(READ "@CMAKE_CURRENT_BINARY_DIR@/install_manifest.txt" files)
11 STRING(REGEX REPLACE "\n" ";" files "${files}" )
12 FOREACH(file ${files})
13 MESSAGE(STATUS "Uninstalling \"$ENV{DESTDIR}${file}\"" )
14 IF(EXISTS "$ENV{DESTDIR}${file}" )
15 EXEC_PROGRAM(
16 "@CMAKE_COMMAND@" ARGS "-E remove \"$ENV{DESTDIR}${file}\""
17 OUTPUT_VARIABLE rm_out
18 RETURN_VALUE rm_retval
19 )
20 IF(NOT "${rm_retval}" STREQUAL 0)
21 MESSAGE(FATAL_ERROR "Problem when removing \"$ENV{DESTDIR}${fil
22 ENDIF(NOT "${rm_retval}" STREQUAL 0)
23 ELSE(EXISTS "$ENV{DESTDIR}${file}" )
24 MESSAGE(STATUS "File \"$ENV{DESTDIR}${file}\" does not exist." )
25 ENDIF(EXISTS "$ENV{DESTDIR}${file}" )
26 ENDFOREACH(file)
Incluyendo en el chero CMakelists.txt principal las siguientes lneas:
1 CONFIGURE_FILE( "${CMAKE_CURRENT_SOURCE_DIR}/cmake_uninstall.cmake.in"
?
2 ADD_CUSTOM_TARGET(uninstall "${CMAKE_COMMAND}" -P "${CMAKE_CURRENT_BIN
Podremos desinstalar nuestro proyecto mediante el comando make

uninstall.
Dependencias con otros proyectos
13 de 27 13/03/16 09:14
Para buscar libreras tenemos varias alternativas. En el caso de que las

dependencias que requerimos incluyan un chero de conguracin
pkg-cong podemos tratar con ellas de la forma que hemos visto
anteriormente. La manera ms sencilla de resolver las dependencias con
otras libreras es por medio del comando FIND_PACKAGE. Dicho comando
busca entre los cheros existentes en la carpeta de mdulos de cmake, para
resolver la dependencia deseada. Sin embargo, de momento hay pocos
cheros de conguracin de paquetes cmake. Imaginemos que queremos
indicar en nuestro proyecto que dependemos obligatoriamente de los
paquetes JPEG y ZLIB. Bastara con incluir estas lneas:
1 FIND_PACKAGE(JPEG REQUIRED) ?
2 FIND_PACKAGE(ZLIB REQUIRED)
La opcin REQUIRED hace que se lance un error en caso de que no se

encuentre el paquete. Si no se especica dicha opcin simplemente
aparecer un mensaje de aviso. Podemos ver en los cheros que residen
en /usr/share/cmake-2.6/Modules/ con la sintaxis FindPACKAGE.cmake que
variables se denen en cada paquete. Casi siempre se denen las siguientes:
PACKAGE_INCLUDE_DIR -> Indica donde encontrar las cabeceras de la

librera.
PACKAGE_LIBRARIES -> Indica que ags se le deben pasar al linkador.
PACKAGE_FOUND -> Indica si se ha encontrado la librera
Pero como dije anteriormente el comando FIND_PACKAGE solo trata con

algunas libreras. Imaginemos que queremos comprobar si contamos en
nuestro sistema con la librera pthread. No hay un mdulo de cmake que se
encargue de esta labor, por lo que tendremos que usar el comando para
buscar libreras FIND_LIBRARY. Dicho comando busca en las rutas por
defecto de libreras en el sistema (/usr/lib y /usr/local/lib) los nombres que se
le indiquen. Para el caso de pthread podramos utilizar las siguientes lneas:
1 FIND_LIBRARY(PTHREAD NAMES pthread) ?
2 IF (NOT PTHREAD)
3 MESSAGE(FATAL_ERROR "Could not find pthread library" )
4 ENDIF ()
En la variable PTHREAD se denir la ruta o ag de enlace que se usar en el

linkador. En caso de que no se encuentre la librera, no se establecer ningn
valor a la variable por lo que podremos comprobar fcilmente si se ha
encontrado o no la librera. En caso de que intentemos congurar nuestro
proyecto en Windows las cosas se complican un poco. En mi caso, el comando
FIND_PACKAGE(JPEG REQUIRED) no consigui encontrar la librera jpeg
que haba instalado previamente en mi sistema. Por lo tanto lo que hago es lo
siguiente, aunque seguro que existe una solucin mejor.
1 ELSEIF (WIN32) ?
2 SET(GNULIBS_PATH ${PROJECT_SOURCE_DIR}/libraries)
14 de 27 13/03/16 09:14
3 FIND_LIBRARY(JPEG NAMES jpeg PATHS ${GNULIBS_PATH}/lib)

4 IF (NOT JPEG)
5 MESSAGE(FATAL_ERROR "Could not find jpeg library" )
6 ENDIF ()
7 SET(GNULIBS_INCLUDE_DIR ${GNULIBS_PATH}/include)
8 ENDIF ()
Creo un directorio libraries, donde coloco las libreras de terceros (en este
caso jpeg). Busco en el sub-directorio libs de dicho directorio si se encuentra
la librera que busco y por ltimo deno el directorio donde se encuentran las
cabeceras para incluirlas posteriormente donde haga falta.
Generar chero de conguracin de proyecto

FindPACKAGE.cmake
Como ya hemos visto antes, para buscar paquetes populares tenemos el
comando FIND_PACKAGE. CMake instala por defecto en las distribuciones
GNU/Linux una serie de cheros en la ruta /usr/share/cmake-2.6/Modules/
con la sintaxis FindPACKAGE.cmake que son los que se encargan realmente
de buscar si tenemos un cierto software instalado en nuestro equipo. Si
nuestro proyecto software va a tomar cierta importancia y pensamos que
puede ser usado por otras personas o por futuros proyectos que realicemos
en el futuro, nos interesar generar un chero de conguracin de nuestro
proyecto para facilitar el manejo de dependencias con nuestro paquete. Dicho
de otra manera, lo que pretendemos es generar un chero de conguracin
equivalente a los cheros con extensin pc que se manejan con pkg-cong.
A la hora de crear este chero de conguracin cmake tenemos dos opciones

para nombrar el chero:
1) Que tenga la forma: FindPACKAGE.cmake para que en futuros proyectos

que requieran de este paquete podamos resolver la dependencia mediante los
comandos CMAKE_MODULE_PATH y FIND_PACKAGE.
2) Que tenga la forma: PACKAGECong.cmake para posteriormente denir

donde se encuentra instalado dicho chero mediante el comando
PACKAGE_DIR y despus poder usar FIND_PACKAGE.
A mi me gusta ms trabajar con la primera opcin ya que parece algo ms

estndar. Para generar este archivo lo ideal es crearse una plantilla con
extensin .in que use variables del proyecto. En mi caso llamo a este chero
siempre cong.cmake.in y tiene un contenido similar al ejemplo que os
muestro a continuacin (Reemplazar PACKAGE con el nombre de vuestro
proyecto):
01 # ===================================================================
?
02 # PACKAGE CMake configuration file

03 #
15 de 27 13/03/16 09:14
04 # ** File generated automatically, do not modify **

05 #
06 # Usage from an external project:
07 # In your CMakeLists.txt, add these lines:
08 #
09 # FIND_PACKAGE(PACKAGE REQUIRED )
10 # TARGET_LINK_LIBRARIES(MY_TARGET_NAME ${PACKAGE_LIBS})
11 #
12 # This file will define the following variables:
13 # - PACKAGE_LIBS : The list of libraries to links again
14 # - PACKAGE_LIB_DIR : The directory where lib files are. C
15 # with this path is NOT needed.
16 # - PACKAGE_VERSION : The version of this gu build. Examp
17 # - PACKAGE_VERSION_MAJOR : Major version part of gu_VERSION. Ex
18 # - PACKAGE_VERSION_MINOR : Minor version part of gu_VERSION. Ex
19 # - PACKAGE_VERSION_PATCH : Patch version part of gu_VERSION. Ex
20 #
21 # ===================================================================
22
23 # Extract the directory where *this* file has been installed (determi
24 # This variable may or may not be used below, depending on the parsi
25 get_filename_component(THIS_PACKAGE_CONFIG_PATH "${CMAKE_CURRENT_LIST
26
27 # ======================================================
28 # Include directories to add to the user project:
29 # ======================================================
30 INCLUDE_DIRECTORIES(@CMAKE_INCLUDE_DIRS_CONFIGCMAKE@)
31
32 # ======================================================
33 # Link directories to add to the user project:
34 # ======================================================
35 LINK_DIRECTORIES("@CMAKE_LIB_DIRS_CONFIGCMAKE@ " )
36 # Provide the libs directory anyway, it may be needed in some cases.
37 SET(PACKAGE_LIB_DIR "@CMAKE_LIB_DIRS_CONFIGCMAKE@ " )
38
39 # ===================================================================
40 # Link libraries
41 # ===================================================================
42 if (CMAKE_MAJOR_VERSION GREATER 2 OR CMAKE_MINOR_VERSION GREATER 4)
43 SET(PACKAGE_LIBS debug PACKAGE@PACKAGE_DLLVERSION@@PACKAGE_DEBUG_
44 else() # Old CMake:
45 SET(PACKAGE_LIBS PACKAGE@PACKAGE_DLLVERSION@)
46 endif()
47
48 # ======================================================
49 # Version variables:
50 # ======================================================
51 SET(PACKAGE_VERSION @PACKAGE_VERSION@)
52 SET(PACKAGE_VERSION_MAJOR @PACKAGE_VERSION_MAJOR@)
53 SET(PACKAGE_VERSION_MINOR @PACKAGE_VERSION_MINOR@)
54 SET(PACKAGE_VERSION_PATCH @PACKAGE_VERSION_PATCH@)
Para que se genere este chero debemos aadir las siguientes lneas a
16 de 27 13/03/16 09:14
nuestro CMakeLists.txt del directorio raz, para incluir algunas variables de

las que hacemos uso en dicho chero y para generar el chero
FindPACKAGE.cmake a partir del mismo:
01 set(${PROJECT_NAME}_VERSION "1.0.0" ) ?
02 string(REGEX MATCHALL "[0-9]" ${PROJECT_NAME}_VERSION_PARTS

03 list(GET ${PROJECT_NAME}_VERSION_PARTS 0 ${PROJECT_NAME}_VERSION_MAJO
04 list(GET ${PROJECT_NAME}_VERSION_PARTS 1 ${PROJECT_NAME}_VERSION_MINO
05 list(GET ${PROJECT_NAME}_VERSION_PARTS 2 ${PROJECT_NAME}_VERSION_PATC
06 set(${PROJECT_NAME}_SOVERSION "${${PROJECT_NAME}_VERSION_MAJOR}.${${P
07
08 set(CMAKE_INCLUDE_DIRS_CONFIGCMAKE ${CMAKE_INSTALL_PREFIX}/include/
09 set(CMAKE_LIB_DIRS_CONFIGCMAKE ${CMAKE_INSTALL_PREFIX}/lib CACHE PATH
10
11 CONFIGURE_FILE("${PROJECT_SOURCE_DIR}/config.cmake.in" "${PROJECT_BIN
12 INSTALL(FILES
13 "${PROJECT_BINARY_DIR}/Find${PROJECT_NAME}.cmake"
14 DESTINATION share/cmake/ )
Por ltimo para usar en otro proyecto el que estamos desarrollando

actualmente tendremos que incluir las siguientes lneas en el chero
CMakeLists.txt:
1 SET(CMAKE_MODULE_PATH ${CMAKE_MODULE_PATH} /usr/local/share/cmake/

?
2 FIND_PACKAGE(PACKAGE REQUIRED)
3 IF (PACKAGE_VERSION VERSION_LESS X.X.X)
4 MESSAGE(FATAL_ERROR "Unable to use version ${PACKAGE_VERSION} of P
5 ENDIF ()
Por supuesto tendremos que cambiar las X por el nmero de versin que
queramos usar, y en caso de haber instalado los cheros en otra ruta
modicar la ruta que establecemos para CMAKE_MODULE_PATH.
En caso de que escogisemos la 2 opcin para el nombre del chero de

conguracin habra que modicar ligeramente algunas de las lneas
anteriores, pero no quiero extenderme demasiado con este tema.
Portabilidad Windows & Linux en nuestros

proyectos
Si hay una razn de peso por la que haya migrado a cmake ha sido sin duda
por las ventajas que presenta para congurar los proyectos en diferentes
plataformas. Programando en GNU/Linux y usando las autotools no he
tenido ningn problema este ltimo ao, pero no he visto la manera de poder
congurar los mis proyectos para poder ser compilados con el compilador
Visual C++. En todo caso, si que poda trabajar con MinGW + MSYS, pero la
idea es poder congurar un proyecto en cualquier compilador y/o IDE sin
morir en el intento.
17 de 27 13/03/16 09:14
En CMake existen algunas variables predenidas que se activan segn el

sistema operativo que estemos usando y/o el compilador que vayamos a usar
para compilar el proyecto (este se detecta automticamente si hacemos uso
del comando cmake o podemos especicar el compilador a usar si usamos el
comando cmake-gui). Las variables que suelo utilizar son las siguientes:
Para distinguir entre sistemas operativos:

WIN32 -> Detecta si usas windows (32 o 64 bits).
UNIX -> Sistemas Unix o GNU/Linux.
APPLE -> Mac OS.
Para distinguir entre diferentes compiladores:
MSVC -> Microsoft visual c. Esta variable contiene un nmero de
versin que distingue entre distintas versiones de visual studio.
CMAKE_COMPILER_IS_GNUCXX -> gcc.
MINGW -> gcc para windows.
Por otra parte en nuestro cdigo C/C++ seguramente tambin tendremos que
escribir algunas directivas del procesador para diferenciar entre partes de
cdigo especcas para sistemas Windows y otras partes de cdigo
especcas para sistemas Unix. En gcc y mingw se denen las siguientes
variables (tener cuidado con los dobles guiones bajos):
__GNUC__ : Detecta la versin mayor del compilador gcc. Si tenemos por

ejemplo la versin 4.4.2, nos retornar el primer 4.
__GNUC_MINOR__ : Detecta el segundo nmero de la versin.
__GNUC_PATCHLEVEL__: Detecta la versin del parche aplicado sobre
la versin de gcc.
linux y __linux: Detecta si estamos usando un sistema basado en
GNU/Linux.
macintosh , __APPLE__ y __MACH__ : Detecta si estamos usando un
sistema apple.
_WIN32 y _WIN64: Detecta si estamos usando un sistema windows. La
primera variable se activa tanto si usamos un sistema de 32 como de 64
bits. La segunda variable solo lo hace en el segundo caso.
Conociendo la existencia de estas variables podremos congurar nuestros

proyectos fcilmente para que sean portables a distintas plataformas y
congurables desde distintos compiladores.
Referenciar recursos en el SOURCE_DIR

Cuando en nuestro cdigo hacemos referencia a recursos tales como
imgenes, sonidos o cualquier otro tipo de chero binario tenemos que tener
mucho cuidado con las rutas que especicamos a tales recursos. Esta seccin
la he creado en respuesta al comentario de Hook, ya que tambin he tenido
que tratar muchas veces con casos similares.
La solucin que yo aplico a estos casos (que no tiene porque ser la mejor ni
18 de 27 13/03/16 09:14
mucho menos) es generar un chero cong.h donde se establezca una

variable con la ruta a donde se encuentran los recursos. Para ello aplico las
ideas que expliqu en su da en este post. Os pongo un ejemplo para que
entendis como aplico mi idea. En el directorio principal del proyecto creo un
chero cong.h.cmake con el siguiente contenido:
1 /* Define to the full path to resources. */ ?
2 #define RESOURCES_PATH "${RESOURCES_PATH}"
Despus dentro del CMakeLists.txt del directorio raz del proyecto agrego las
siguientes lneas:
1 SET(RESOURCES_PATH ${PROJECT_SOURCE_DIR}/resources) ?
2 CONFIGURE_FILE("${PROJECT_SOURCE_DIR}/config.h.cmake" "${CMAKE_CURRENT
La primera establece el valor de la variable, y la segunda genera el

correspondiente archivo cong.h con la variable ya denida. Por ltimo en el
CMakeLists.txt del directorio donde tengamos nuestro cdigo (por ejemplo
src, utils, o similares) aadimos lo siguiente para que se incluya el directorio
donde estamos generando el proyecto (y donde residir el chero cong.h)
al compilar :
1 INCLUDE_DIRECTORIES(${CMAKE_BINARY_DIR}) ?
De este modo en nuestros programas podemos incluir el chero cong.h y

usar la variable RESOURCES_PATH para localizar nuestros recursos.
Enlaces de inters
CMake
Tutorial Cmake (pdf en espaol)
cmake para tus proyectos
Sobre dependencias en plataformas especcas.
MinGW + MSYS.
Rating: 10.0/10 (8 votes cast)
Tutorial CMake, 10.0 out of 10 based on 8 ratings
Categories: Programacin, Tutoriales Tags: autoconf, automake, autotools,

c/c++, cmake, libtool, pkg-cong, Programacin 1
Comentarios (9) Referencias (3) Dejar un comentario Referencia
1.
Hook
19 de 27 13/03/16 09:14
Jueves, 16 de septiembre de 2010 a las 16:09 | #1

Responder | Citar
Rating: 10.0/10 (1 vote cast)
Hola, he credo un CMakeList que funciona perfectamente, el problema

lo tengo que en mi proyecto tengo una carpeta con imgenes para los
iconos, fondo etc.. El problema lo tengo al compilar, que al realizarlo en
la carpeta build no se me copia la carpeta de imgenes, es decir que el
ejecutable no encuentra las imgenes. Espero haberme explicado
correctamente.
Sabras decirme como relacionar esa carpeta en Cmake para que me la
copie al compilar.
Saludos
2.
piponazo
Jueves, 16 de septiembre de 2010 a las 18:06 | #2
Responder | Citar
Rating: 10.0/10 (1 vote cast)
Hola Hook. He actualizado la entrada para responderte. La solucin la

tienes en la ltima seccin ;). Si tienes alguna duda al respecto solo
tienes que preguntar.
Saludos!
3.
Hook
Viernes, 17 de septiembre de 2010 a las 18:43 | #3
Responder | Citar
Bueno ya puestos a preguntar, ahora si realizo un make install se me

instala todo en /usr/local, librera y ejecutables me reero, dudas que me
surgen. Si quisiera crear un icono y en enlace en el men (en Ubuntu mi
caso) al ejecutable puedo realizarlo desde cmake??
Bsicamente tengo un programa echo y quera poder compilarlo e
instalarlo, y poder acceder a el directamente desde el men y no en
forma de comando.
4.
Hook
20 de 27 13/03/16 09:14
Responder | Citar
Bueno ya puestos a preguntar, ahora si realizo un make install se me

instala todo en /usr/local, librera y ejecutables me reero, dudas que me
surgen. Si quisiera crear un icono y en enlace en el men (en Ubuntu mi
caso) al ejecutable puedo realizarlo desde cmake??
Bsicamente tengo un programa echo y quera poder compilarlo e
instalarlo, y poder acceder a el directamente desde el men y no en
forma de comando.
PD. Cualquier manual o enlace que tenga algo al respecto me vendra de
perlas
5.
piponazo
Responder | Citar
@Hook
Pues de eso ya si que no tengo ni idea Hook. Lo nico que se es que eso
est relacionado con cheros de conguracin de Gnome que tienen que
instalarse en alguna carpeta en concreto, pero no recuerdo nada ms.
Por cierto, dices que se te instala todo en /usr/local pero todo
directamente ah o las libreras en /usr/local/lib y los programas en
/usr/local/bin ? Debes tener cuidado con eso y colocar cada cosa en su
sitio.
Saludos.
6.
Hook
Martes, 21 de septiembre de 2010 a las 19:05 | #6
Responder | Citar
Buenas ya estoy aqu de nuevo a ver si me puedes sacar unas dudas. Que
no quiero irme al Makele sin a verlo intentado con el CMake
1. Trabajo con las libreras POSIX para crear una conexion serial,
funciona correctamente compilando con Code::Blocks, pero al realizarlo
con Cmake no se establece la conexin, es como si le faltara permisos o
algo raro. ( A todo esto no he tenido problemas de compilacion ni nada
por el estilo con CMake).
21 de 27 13/03/16 09:14
2. A lo mejor tambien esta relacionado con el 1. Tambien trabajo con la

libreria OpenCV para acceder a la CamWeb, sorpresa mia que no
funciona en el ejecutable. Pero probe llamar al ejecutable en modo super
root (sudo) y funciona correctamente (el 1 sigue fallando)
En conclusin siempre tendr que ejecutar de este modo o hay alguna
opcin con la que pueda poner en el CMake los permisos para accesos a
todos??
Y bueno el fallo de la conexin serial que no se realmente cual es la
solucin
7.
piponazo
Martes, 21 de septiembre de 2010 a las 19:34 | #7
Responder | Citar
Empezar con la 2 pregunta.

Si has probado a ejecutar con sudo y te funciona ya te has respondido a
ti mismo :), es un problema de permisos. Normalmente los dispositivos
de vdeo aparecen en /dev/ como videoX donde X es un identicador. Por
ejemplo mi webcam tiene estos permisos:
$ ls /dev/video0 -lh
crw-rw-+ 1 root video 81, 0 2010-09-21 20:23 /dev/video0
Por lo que solo puede acceder a ella el superusuario y los usuarios que
pertenezcan al grupo vdeo. Probablemente tu cmara tiene los mismos
permisos, por lo que bastar con aadirte al grupo vdeo para poder
acceder a ella con tu usuario normal.
Hablemos ahora sobre la primera cuestin:

Code::Blocks es una IDE no un compilador. Nunca he trabajado con esta
IDE, pero por lo que veo en la pgina web puede trabajar con los
compiladores GCC (MingW / GNU GCC) y MSVC++ entre otros.
CMake de hecho tampoco es un compilador, sino un sistema para
construir proyectos que tambin interacciona con muchsimos
compiladores (por no decir casi todos :P).
Si dices que el programa te funciona al compilar desde Code::Blocks y
con CMake no probablemente es que la compilacin nal que se est
realizando no sea idntica. Me huele a mi que a lo mejor se te est
olvidando linkar con alguna librera, aunque en este caso lo ms normal
es que te diese algn error de compilacin. Cuando conguras el
proyecto con CMake y posteriormente compilas con make, si pones :
make VERBOSE=1
22 de 27 13/03/16 09:14
puedes ver las lneas exactas de compilacin para ver si te da alguna

pista.
Tambin en estos casos lo mejor es acudir a un depurador y ver

exactamente que es lo que est ocurriendo. Yo uso Nemiver en gnome
que me va de maravilla, aunque si usas Code::Block este ya contiene un
depurador propio.
Espero que te sean de ayuda estos comentarios, sobre el primer

problema no puedo ayudarte ms porque no he trabajado nunca con las
POSIX en profundidad.
Saludos!
8.
piponazo
Mircoles, 3 de octubre de 2012 a las 06:38 | #8
Responder | Citar
Hola @EliasM , efectivamente con CMake podrs congurar proyectos

que dependa de casi cualquier librera (cmo OpenGL y OpenCL) y que
la conguracin te sirva para cualquier plataforma (aunque esto
requerir ms trabajo por tu parte). En cuanto a lo de los lenguajes de
scripting como Lua y Javascript no estoy muy seguro de si los soporta
nativamente pero siempre puedes hacer llamadas a comandos
especcos desde CMake, y no supone mucho problema.
En cuanto a los instaladores tambin se puede gestionar con CMake, con

un mdulo llamado CPack. Para Linux se que empaqueta en tar.bz2, deb
y rpm. Para Windows estoy seguro de que lo haca al menos con NSIS,
pero no se hasta que punto ya que no suelo desarrollar para windows.
En cuanto tutoriales CMake es tan complejo que lo mejor es que vayas

aprendiendo segn las necesidades. Yo te aconsejara que te
descargases la librera OpenCV (http://opencv.org/), y le echases un
vistazo a como hacen ellos las cosas con CMake as fue como aprend
a usarlo yo
9.
EliasM
Mircoles, 3 de octubre de 2012 a las 13:53 | #9
Responder | Citar
23 de 27 13/03/16 09:14
Muchsimas Gracias, piponazo gracias por los consejos y la ayuda.

Sobre Instaladores estoy tratando de crear un nuevo tipo de instalador
para que una persona cree su propio instalador sin importar el sistema
de PC que tenga algo que para m esta faltando bastante principalmente
a gente que trabaja con varios sistemas operativos.
1. Domingo, 10 de enero de 2010 a las 17:31 | #1

Enlace a Tutorial CMake | La plaga Tux
2. Mircoles, 15 de agosto de 2012 a las 21:48 | #2
Image processing with CUDA (Comparison with CPU, MMX, SSE &
OpenCV) | La plaga Tux
3. Martes, 11 de diciembre de 2012 a las 00:41 | #3
Utilizando CMake para el proyecto | Open Fantasy World
Nombre (requerido)
e-Mail (no ser publicado) (requerido)
Sitio web
Suscribirse a los comentarios

Publicar comentario (Ctrl+Enter)
Noticarme de los siguientes comentarios va via e-mail
Repositorio ppa para Nemiver C/C++ : Tipos de cast

RSS
Google
Youdao
Xian Guo
Zhua Xia
My Yahoo!
newsgator
Bloglines
iNezha
Twitter
Etiquetas
24 de 27 13/03/16 09:14
Categories
Breves
Compiz
Distribuciones
Documentos
Drivers
Enlightenment
General
Gnome
Grcos
Hardware
Internet
Investigacin
juegos
KDE
Latex
Libros
MSN
Noticias
25 de 27 13/03/16 09:14
Ocio
OpenCV
P2P
Programacin
Redes
Resolucin problemas
Scripting
Seguridad
sonido
Tecnologa
Terminal
Tutoriales
Utilidades
vim
Blogroll
ArUco
crystalxp.net
Damiles
El blog de Neonigma
Entre tuxes y pepinos
Hablando de linux
Helektron
Just 4 Cool!
Phoenix Revolution
Ubuntu Life
ltimos comentarios
jorge en Instalar dependencias de programas

Fabrizio en Tip C++: Acceder a miembro de clase desde un iterador
javier en Tip C++: Redondear nmeros reales
Mato en Plantilla para crear portadas en LaTeX
Salvador Tavera Mosqueda en Llaves con varias frmulas en Latex
Valoracin del blog
Average rating:
8.5
831 votes for 200 posts
26 de 27 13/03/16 09:14
Arriba WordPress
Copyright 2007-2015 La plaga Tux
Tema por NeoEase. Valido XHTML 1.1 y CSS 3.
27 de 27 13/03/16 09:14

Cmake

Cargado por

Información del documento

Título original

Derechos de autor

Formatos disponibles

Compartir este documento

Compartir o incrustar documentos

Opciones para compartir

¿Le pareció útil este documento?

¿Este contenido es inapropiado?

Copyright:

Formatos disponibles

Cmake

Cargado por

Copyright:

Formatos disponibles

CMake Tutorial | La plaga Tux http://plagatux.

Type text to search here...

ltima actualizacin: 16/09/2010

Cmake est diseado para soportar complejas jerarquas de directorios y

Usar CMake es simple. El proceso de construccin es controlado por la

HelloWorld con CMake

El signicado de los comandos que aparecen en este chero son los

PROJECT: asigna un nombre que identica al proyecto. Ahora los

1 #Asegurarse de que el compilador puede encontrar los ficheros

Para la generacin del proyecto ingresaremos en una terminal de texto y

accederemos al directorio build. Una vez all ejecutaremos el comando:

Bsicamente, al comando cmake tenemos que pasarle como argumento la

01 pipo@pipo-laptop:~/cmake-template/build$ cmake ../ ?

02 -- The C compiler identification is GNU

2 sudo make install

Tambin disponemos de una interfaz grca para cmake mediante el

Cambiando las variables en la cache de cmake

Le estamos diciendo a Cmake que realice la conguracin estndar del

De todos modos, si no os sents cmodos trabajando desde una terminal,

No necesitamos declararlas. No existe diferencia entre crear y modicar

1 set(WARNINGS_ARE_ERRORS OFF CACHE BOOL "Treat warnings as

La opcin denida en el punto anterior se almacena en el chero de

Cambiando los parmetros de construccin

Modicar la conguracin del preprocesador con ADD_DEFINITIONS y

1 SET(CMAKE_CXX_FLAGS_DEBUG "-O0 -g3 -Wall -Werror -W -Wno-return-type"

2 SET(CMAKE_CXX_FLAGS_RELEASE "-O2 -pipe -march=core2" )

Adems podemos establecer diferentes tipos de construcciones de nuestros

2 SET( CMAKE_BUILD_TYPE "Release" )

De esta forma si no le indicamos a cmake lo contrario compilaremos nuestro

proyecto para una versin de lanzamiento. Si queremos indicarle a cmake

1 cmake -D CMAKE_BUILD_TYPE=Release ../ ?

En cuanto a las ags de compilacin, se pueden hacer cosas mucho ms

Usando pkg-cong con cmake

1 FIND_PACKAGE(PkgConfig) #Enable PKG-CONFIG suport ?

En este caso pido que la versin de la librera sea al menos la 1.3.3, y el

1 <PREFIX>_LIBRARIES ... only the libraries (w/o the '-l')

2 <PREFIX>_LIBRARY_DIRS ... the paths of the libraries (w/o the '-L')

Y para determinar si se ha encontrado la librera podemos usar la variable

2 SET(hdrs ${hdrs} gumatio.h)

Generando documentacin con Doxygen

002 # and configure doxy.config.in to doxy.config

083 ADD_CUSTOM_TARGET(doc ${DOXYGEN_EXECUTABLE} ${DOXY_CONFIG})

Para hacer uso de dicho chero, adems de activar o desactivar algunas

1 OPTION(INSTALL_DOC "Set to OFF to skip build/insta

2 OPTION(USE_DOT "Set to ON to perform diagram g

El chero libPROJECT.dox.in ser el chero plantilla de conguracin

denidas en el chero generateDoc.cmake encerrando entre arrobas el

Aadir una opcin make uninstall

Incluyendo en el chero CMakelists.txt principal las siguientes lneas:

2 ADD_CUSTOM_TARGET(uninstall "${CMAKE_COMMAND}" -P "${CMAKE_CURRENT_BIN

Podremos desinstalar nuestro proyecto mediante el comando make

Dependencias con otros proyectos

Para buscar libreras tenemos varias alternativas. En el caso de que las

La opcin REQUIRED hace que se lance un error en caso de que no se

PACKAGE_INCLUDE_DIR -> Indica donde encontrar las cabeceras de la

Pero como dije anteriormente el comando FIND_PACKAGE solo trata con

1 FIND_LIBRARY(PTHREAD NAMES pthread) ?

En la variable PTHREAD se denir la ruta o ag de enlace que se usar en el

3 FIND_LIBRARY(JPEG NAMES jpeg PATHS ${GNULIBS_PATH}/lib)

Generar chero de conguracin de proyecto

A la hora de crear este chero de conguracin cmake tenemos dos opciones

1) Que tenga la forma: FindPACKAGE.cmake para que en futuros proyectos

2) Que tenga la forma: PACKAGECong.cmake para posteriormente denir

04 # File generated automatically, do not modify

GNUC : Detecta la versin mayor del compilador gcc. Si tenemos por