cmake
Variablen und Eigenschaften

Einführung

Syntax

• set (Wert der Variablenname [CACHE-Typbeschreibung [FORCE]])

Bemerkungen

${variable_name}

"${variable_name}/directory"

Zwischengespeicherte (globale) Variable

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

Ist eine zwischengespeicherte Variable bereits im Cache definiert, wenn CMake die entsprechende Zeile verarbeitet (z. B. wenn CMake erneut ausgeführt wird), wird diese nicht geändert. Um den Standardwert zu überschreiben, hängen Sie FORCE als letztes Argument an:

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

Lokale Variable

set(my_variable "the value is a string")

Standardmäßig ist eine lokale Variable nur im aktuellen Verzeichnis definiert, und alle Unterverzeichnisse, die mit dem Befehl add_subdirectory hinzugefügt werden.

Um den Gültigkeitsbereich einer Variablen zu erweitern, gibt es zwei Möglichkeiten:

1. CACHE es, die es global verfügbar machen wird

2. Verwenden Sie PARENT_SCOPE , um es im übergeordneten Bereich verfügbar zu machen. Der übergeordnete Bereich ist entweder die CMakeLists.txt Datei im übergeordneten Verzeichnis oder der Aufrufer der aktuellen Funktion.

   Technisch gesehen ist das übergeordnete Verzeichnis die CMakeLists.txt Datei, die die aktuelle Datei über den Befehl add_subdirectory .

Streicher und Listen

Es ist wichtig zu wissen, wie CMake zwischen Listen und einfachen Strings unterscheidet. Wenn du schreibst:

set(VAR "ab c")

Sie erstellen eine Zeichenfolge mit dem Wert "ab c" . Aber wenn Sie diese Zeile ohne Anführungszeichen schreiben:

set(VAR abc)

Sie erstellen stattdessen eine Liste mit drei Elementen: "a" , "b" und "c" .

Nicht-Listenvariablen sind eigentlich auch Listen (eines einzelnen Elements).

Listen können mit dem Befehl list() bearbeitet werden, der das Verketten von Listen, das Durchsuchen von Listen, das Aufrufen von beliebigen Elementen usw. ermöglicht ( Dokumentation von list () ).

Etwas verwirrend ist eine Liste auch eine Zeichenfolge . Die Linie

set(VAR abc)

ist äquivalent zu

set(VAR "a;b;c")

Um Listen zu verketten, können Sie auch den Befehl set() :

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

Variablen und der Cache für globale Variablen

Meist werden Sie "normale Variablen" verwenden :

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

CMake kennt aber auch globale "zwischengespeicherte Variablen" (in CMakeCache.txt persistiert). Wenn im aktuellen Bereich normale und zwischengespeicherte Variablen mit demselben Namen vorhanden sind, verbergen normale Variablen die zwischengespeicherten Variablen:

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

Ausgabe des ersten Laufs

VAR = CACHED-init
VAR = NORMAL
VAR = CACHED

Ausgabe des zweiten Laufs

VAR = CACHED
VAR = NORMAL
VAR = CACHED

Anmerkung: Mit der Option FORCE wird auch die normale Variable aus dem aktuellen Bereich zurückgesetzt.

Anwendungsfälle für zwischengespeicherte Variablen

Normalerweise gibt es zwei Anwendungsfälle (bitte nicht für globale Variablen missbrauchen):

1. Ein Wert in Ihrem Code sollte vom Benutzer Ihres Projekts cmakegui , z. B. mit den cmakegui , ccmake oder cmake -D ... :

   CMakeLists.txt / MyToolchain.cmake

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

   Befehlszeile

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

   Dadurch wird dieser Wert im Cache voreingestellt und die obige Zeile ändert ihn nicht.

   CMake GUI

   

   In der GUI startet der Benutzer zunächst den Konfigurationsprozess, kann dann jeden zwischengespeicherten Wert ändern und endet mit dem Start der Generierung der Build-Umgebung.

2. Darüber hinaus speichert CMake die Such- / Test- / Compiler-Identifizierungsergebnisse im Cache (muss also nicht erneut ausgeführt werden, wenn die Konfigurations- / Generierungsschritte erneut ausgeführt werden)

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

   Hier wird LIB_A_PATH als zwischengespeicherte Variable angelegt.

Hinzufügen von Profilierungsflags zu CMake, um gprof zu verwenden

Die Veranstaltungsreihe hier soll wie folgt funktionieren:

1. Kompilieren Sie den Code mit der Option -pg
2. Verknüpfen Sie den Code mit der Option -pg
3. Programm ausführen
4. Das Programm generiert die Datei gmon.out
5. Führen Sie das Programm gprof aus

Um Profilierungsflags hinzuzufügen, müssen Sie Ihrer CMakeLists.txt Folgendes hinzufügen:

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

Das muss Flags zum Kompilieren und Verknüpfen hinzufügen und nach der Ausführung das Programm verwenden

gprof ./my_exe

Wenn Sie eine Fehlermeldung erhalten, wie:

gmon.out: No such file or directory

Das bedeutet, dass die Kompilierung Profilierungsinformationen nicht ordnungsgemäß hinzugefügt hat.