cmake
Variabler och egenskaper

Introduktion

Syntax

• set (variabelnamnsvärde [CACHE typbeskrivning [FORCE]])

Anmärkningar

${variable_name}

"${variable_name}/directory"

Cache-variabel (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")

Om en cache-variabel redan är definierad i cachen när CMake bearbetar respektive linje (t.ex. när CMake körs om igen) ändras den inte. För att skriva över standardinställningen lägger du till FORCE som det sista argumentet:

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

Lokal variabel

set(my_variable "the value is a string")

Som standard definieras en lokal variabel endast i den aktuella katalogen och alla underkataloger som läggs till via kommandot add_subdirectory .

För att utöka en variabels räckvidd finns det två möjligheter:

1. CACHE it, vilket gör det globalt tillgängligt

2. använd PARENT_SCOPE , vilket gör det tillgängligt i överordnade omfång. Den överordnade räckvidden är antingen filen CMakeLists.txt i CMakeLists.txt eller den som ringer till den aktuella funktionen.

   Tekniskt sett blir CMakeLists.txt filen som inkluderade den aktuella filen via kommandot add_subdirectory .

Strängar och listor

Det är viktigt att veta hur CMake skiljer mellan listor och vanliga strängar. När du skriver:

set(VAR "ab c")

du skapar en sträng med värdet "ab c" . Men när du skriver den här raden utan citat:

set(VAR abc)

Du skapar en lista med tre objekt istället: "a" , "b" och "c" .

Icke-listvariabler är faktiskt också listor (av ett enda element).

Listor kan köras med list() -kommandot, vilket tillåter sammanlänkning av listor, sökning i dem, åtkomst till godtyckliga element och så vidare ( dokumentation av listan () ).

Lite förvirrande är en lista också en sträng . Linjen

set(VAR abc)

är ekvivalent med

set(VAR "a;b;c")

För att sammanfoga listor kan man därför använda kommandot set() :

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

Variabler och cache för globala variabler

Du kommer oftast att använda "normala variabler" :

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

Men CMake känner också till globala "cache-variabler" (fortsätter i CMakeCache.txt ). Och om normala och cachade variabler med samma namn finns i det aktuella omfånget, döljer normala variabler de cachade variablerna:

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}")

Första körningens utgång

VAR = CACHED-init
VAR = NORMAL
VAR = CACHED

Andra körningens utgång

VAR = CACHED
VAR = NORMAL
VAR = CACHED

Obs! Alternativet FORCE avaktiverar / tar också bort den normala variabeln från det aktuella omfånget.

Använd fall för cachade variabler

Det finns vanligtvis två användningsfall (snälla missbruk dem inte för globala variabler):

1. Ett värde i din kod bör kunna modifieras från projektets användare, t.ex. med cmakegui , ccmake eller med cmake -D ... -alternativet:

   CMakeLists.txt / MyToolchain.cmake

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

   Kommandorad

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

   Detta förinställer detta värde i cachen och raden ovan kommer inte att ändra det.

   CMake GUI

   

   I GUI startar användaren först konfigurationsprocessen, sedan kan hantera valfritt cache-värde och slutar med att starta byggmiljögenerationen.

2. CMake cachar dessutom sökresultat / test / kompilatoridentifieringsresultat (så det behöver inte göra det igen när konfigurations- / genereringsstegen körs igen)

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

   Här LIB_A_PATH som en cache-variabel.

Lägga till profileringsflaggor till CMake för att använda gprof

Händelserien här ska fungera enligt följande:

1. Kompilera kod med -pg-alternativet
2. Länkkod med -pg-alternativet
3. Kör program
4. Program genererar gmon.out-fil
5. Kör gprof-program

För att lägga till profileringsflaggor måste du lägga till din 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")

Det måste lägga till flaggor för att sammanställa och länka, och använda efter att ha kört programmet:

gprof ./my_exe

Om du får ett fel som:

gmon.out: No such file or directory

Det innebär att sammanställningen inte lägger till profilinformation korrekt.