cmake
Variables y propiedades

Introducción

Sintaxis

• set (valor de variable_name [descripción de tipo CACHE [FUERZA]])

Observaciones

${variable_name}

"${variable_name}/directory"

Variable en caché (global)

set(my_global_string "a string value"
    CACHE STRING "a description about the string variable")
set(my_global_bool TRUE
    CACHE BOOL "a description on the boolean cache entry")

En caso de que una variable en caché ya esté definida en el caché cuando CMake procesa la línea respectiva (por ejemplo, cuando CMake se vuelve a ejecutar), no se altera. Para sobrescribir el valor predeterminado, agregue FORCE como el último argumento:

set(my_global_overwritten_string "foo"
    CACHE STRING "this is overwritten each time CMake is run" FORCE)

Variable local

set(my_variable "the value is a string")

De forma predeterminada, una variable local solo se define en el directorio actual y en los subdirectorios agregados mediante el comando add_subdirectory .

Para ampliar el alcance de una variable hay dos posibilidades:

1. CACHE , que lo hará disponible globalmente.

2. use PARENT_SCOPE , que lo hará disponible en el ámbito principal. El ámbito principal es el archivo CMakeLists.txt en el directorio principal o el llamador de la función actual.

   Técnicamente, el directorio principal será el archivo CMakeLists.txt que incluyó el archivo actual a través del comando add_subdirectory .

Cuerdas y listas

Es importante saber cómo CMake distingue entre listas y cadenas simples. Cuando escribes:

set(VAR "ab c")

creas una cadena con el valor "ab c" . Pero cuando escribes esta línea sin comillas:

set(VAR abc)

En su lugar, crea una lista de tres elementos: "a" , "b" y "c" .

Las variables que no son listas son en realidad listas también (de un solo elemento).

Las listas pueden operarse con el comando list() , que permite concatenar listas, buscarlas, acceder a elementos arbitrarios, etc. ( documentación de list () ).

Algo confuso, una lista es también una cadena . La línea

set(VAR abc)

es equivalente a

set(VAR "a;b;c")

Por lo tanto, para concatenar listas también se puede usar el comando set() :

set(NEW_LIST "${OLD_LIST1};${OLD_LIST2})"

Variables y el caché de variables globales

Principalmente usarás "variables normales" :

set(VAR TRUE)
set(VAR "main.cpp")
set(VAR1 ${VAR2})

Pero CMake también conoce "variables almacenadas en caché" globales (persisten en CMakeCache.txt ). Y si existen variables normales y en caché del mismo nombre en el ámbito actual, las variables normales ocultan las almacenadas en caché:

cmake_minimum_required(VERSION 2.4)
project(VariablesTest)

set(VAR "CACHED-init" CACHE STRING "A test")
message("VAR = ${VAR}")

set(VAR "NORMAL")
message("VAR = ${VAR}")

set(VAR "CACHED" CACHE STRING "A test" FORCE)
message("VAR = ${VAR}")

Salida de primera ejecución

VAR = CACHED-init
VAR = NORMAL
VAR = CACHED

Salida de segunda ejecución

VAR = CACHED
VAR = NORMAL
VAR = CACHED

Nota: La opción FORCE también desactiva / elimina la variable normal del alcance actual.

Casos de uso para variables en caché

Normalmente hay dos casos de uso (por favor, no haga mal uso de ellos para las variables globales):

1. Un valor en su código debe ser modificable por el usuario de su proyecto, por ejemplo, con la cmakegui , ccmake o con cmake -D ...

   CMakeLists.txt / MyToolchain.cmake

   set(LIB_A_PATH "/some/default/path" CACHE PATH "Path to lib A")
   

   Línea de comando

   $ cmake -D LIB_A_PATH:PATH="/some/other/path" ..
   

   Esto preestablece este valor en el caché y la línea anterior no lo modificará.

   CMake GUI

   

   En la GUI, el usuario primero inicia el proceso de configuración, luego puede modificar cualquier valor almacenado en caché y termina con el inicio de la generación del entorno de compilación.

2. Además, CMake realiza los resultados de la búsqueda en la memoria caché / prueba / identificación del compilador (por lo que no necesita volver a hacerlo cada vez que se vuelven a ejecutar los pasos de configuración / generación)

   find_path(LIB_A_PATH libA.a PATHS "/some/default/path")
   

   Aquí LIB_A_PATH se crea como una variable en caché.

Agregar marcas de perfil a CMake para usar gprof

La serie de eventos aquí se supone que funciona de la siguiente manera:

1. Compilar código con opción -pg
2. Código de enlace con opción -pg
3. Ejecute el programa
4. Programa genera archivo gmon.out
5. Ejecutar programa gprof

Para agregar marcas de perfil, debe agregar a su CMakeLists.txt:

SET(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -pg")
SET(CMAKE_EXE_LINKER_FLAGS "${CMAKE_EXE_LINKER_FLAGS} -pg")
SET(CMAKE_SHARED_LINKER_FLAGS "${CMAKE_SHARED_LINKER_FLAGS} -pg")

Eso debe agregar banderas para compilar y vincular, y usar después de ejecutar el programa:

gprof ./my_exe

Si obtiene un error como:

gmon.out: No such file or directory

Eso significa que la compilación no agregó la información de perfil correctamente.