Die qmake-Sprache

Viele qmake-Projektdateien beschreiben lediglich die vom Projekt verwendeten Quell- und Header-Dateien mithilfe einer Liste von Definitionen für ` name = value ` und ` name += value `. qmake bietet außerdem weitere Operatoren, Funktionen und Gültigkeitsbereiche, mit denen die in Variablendeklarationen angegebenen Informationen verarbeitet werden können. Diese erweiterten Funktionen ermöglichen es, aus einer einzigen Projektdatei Makefiles für mehrere Plattformen zu generieren.

Operatoren

In vielen Projektdateien können die Operatoren „Zuweisung“ (=) und „Anhängen“ (+=) verwendet werden, um alle Informationen zu einem Projekt einzubeziehen. Das typische Anwendungsmuster besteht darin, einer Variablen eine Liste von Werten zuzuweisen und je nach Ergebnis verschiedener Prüfungen weitere Werte anzuhängen. Da qmake bestimmte Variablen mit Standardwerten definiert, ist es manchmal notwendig, den Entfernungsoperator (-=) zu verwenden, um nicht benötigte Werte herauszufiltern. In den folgenden Abschnitten wird beschrieben, wie Operatoren zur Bearbeitung des Inhalts von Variablen verwendet werden.

Zuweisen von Werten

Der Operator „ = “ weist einer Variablen einen Wert zu:

TARGET = myapp

Die obige Zeile setzt die Variable „TARGET“ auf „ myapp “. Dadurch werden alle zuvor für „ TARGET “ festgelegten Werte durch „ myapp “ überschrieben.

Werte anhängen

Der Operator „ += “ hängt einen neuen Wert an die Liste der Werte einer Variablen an:

DEFINES += USE_MY_STUFF

Die obige Zeile fügt „ USE_MY_STUFF “ an die Liste der Präprozessor-Definitionen an, die in das generierte Makefile aufgenommen werden sollen.

Werte entfernen

Der Operator „ -= “ entfernt einen Wert aus der Liste der Werte einer Variablen:

DEFINES -= USE_MY_STUFF

Die obige Zeile entfernt „ USE_MY_STUFF “ aus der Liste der Präprozessor-Definitionen, die in das generierte Makefile aufgenommen werden sollen.

Hinzufügen eindeutiger Werte

Der Operator ` *= ` fügt der Liste der Werte einer Variablen einen Wert hinzu, jedoch nur, wenn dieser noch nicht vorhanden ist. Dadurch wird verhindert, dass Werte mehrfach in eine Variable aufgenommen werden. Beispiel:

DEFINES *= USE_MY_STUFF

In der obigen Zeile wird „ USE_MY_STUFF “ nur dann zur Liste der Präprozessor-Definitionen hinzugefügt, wenn es noch nicht definiert ist. Beachten Sie, dass die Funktion „unique()“ ebenfalls verwendet werden kann, um sicherzustellen, dass eine Variable von jedem Wert nur ein Exemplar enthält.

Ersetzen von Werten

Der Operator ` ~= ` ersetzt alle Werte, die einem regulären Ausdruck entsprechen, durch den angegebenen Wert:

DEFINES ~= s/QT_[DT].+/QT

In der obigen Zeile werden alle Werte in der Liste, die mit „ QT_D “ oder „ QT_T “ beginnen, durch „ QT “ ersetzt.

Variablenexpansion

Der Operator „ $$ “ dient zum Auslesen des Inhalts einer Variablen und kann verwendet werden, um Werte zwischen Variablen zu übergeben oder an Funktionen zu übergeben:

EVERYTHING = $$SOURCES $$HEADERS
message("The project contains the following files:")
message($$EVERYTHING)

Variablen können verwendet werden, um den Inhalt von Umgebungsvariablen zu speichern. Diese können zum Zeitpunkt der Ausführung von qmake ausgewertet oder in das generierte Makefile aufgenommen werden, um beim Erstellen des Projekts ausgewertet zu werden.

Um den Inhalt eines Umgebungswerts bei der Ausführung von qmake abzurufen, verwenden Sie den Operator „ $$(...) “:

DESTDIR = $$(PWD)
message(The project will be installed in $$DESTDIR)

In der obigen Zuweisung wird der Wert der Umgebungsvariablen ` PWD ` beim Verarbeiten der Projektdatei gelesen.

Um den Wert einer Umgebungsvariablen zum Zeitpunkt der Verarbeitung des generierten Makefiles abzurufen, verwenden Sie den Operator „ $(...) “:

DESTDIR = $$(PWD)
message(The project will be installed in $$DESTDIR)

DESTDIR = $(PWD)
message(The project will be installed in the value of PWD)
message(when the Makefile is processed.)

In der obigen Zuweisung wird der Wert von ` PWD ` unmittelbar bei der Verarbeitung der Projektdatei gelesen, im generierten Makefile wird jedoch ` $(PWD) ` der Variablen ` DESTDIR ` zugewiesen. Dies macht den Build-Prozess flexibler, solange die Umgebungsvariable zum Zeitpunkt der Verarbeitung des Makefiles korrekt gesetzt ist.

Zugriff auf qmake-Eigenschaften

Der spezielle Operator „ $$[...] “ kann verwendet werden, um auf qmake-Eigenschaften zuzugreifen:

message(Qt version: $$[QT_VERSION])
message(Qt is installed in $$[QT_INSTALL_PREFIX])
message(Qt resources can be found in the following locations:)
message(Documentation: $$[QT_INSTALL_DOCS])
message(Header files: $$[QT_INSTALL_HEADERS])
message(Libraries: $$[QT_INSTALL_LIBS])
message(Binary files (executables): $$[QT_INSTALL_BINS])
message(Plugins: $$[QT_INSTALL_PLUGINS])
message(Data files: $$[QT_INSTALL_DATA])
message(Translation files: $$[QT_INSTALL_TRANSLATIONS])
message(Settings: $$[QT_INSTALL_CONFIGURATION])
message(Examples: $$[QT_INSTALL_EXAMPLES])

Weitere Informationen finden Sie unter „Konfigurieren von qmake“.

Die mit diesem Operator abrufbaren Eigenschaften werden in der Regel verwendet, um Plugins und Komponenten von Drittanbietern in Qt zu integrieren. So kann beispielsweise ein „ Qt Widgets “-Designer-Plugin neben den integrierten Plugins von „ Qt Widgets “ Qt Designer installiert werden, wenn in der entsprechenden Projektdatei folgende Deklaration vorgenommen wird:

target.path = $$[QT_INSTALL_PLUGINS]/designer
INSTALLS += target

Gültigkeitsbereiche

Gültigkeitsbereiche ähneln den „ if “-Anweisungen in prozeduralen Programmiersprachen. Ist eine bestimmte Bedingung wahr, werden die Deklarationen innerhalb des Gültigkeitsbereichs verarbeitet.

Syntax von Gültigkeitsbereichen

Gültigkeitsbereiche bestehen aus einer Bedingung, gefolgt von einer öffnenden Klammer in derselben Zeile, einer Folge von Befehlen und Definitionen sowie einer schließenden Klammer in einer neuen Zeile:

<condition> {
    <command or definition>
    ...
}

Die öffnende Klammer muss in derselben Zeile wie die Bedingung stehen. Geltungsbereiche können verkettet werden, um mehr als eine Bedingung einzuschließen, wie in den folgenden Abschnitten beschrieben.

Gültigkeitsbereiche und Bedingungen

Ein Geltungsbereich wird als Bedingung geschrieben, gefolgt von einer Reihe von Deklarationen, die in einem Klammerpaar enthalten sind. Zum Beispiel:

win32 {
    SOURCES += paintwidget_win.cpp
}

Der obige Code fügt die Datei „ paintwidget_win.cpp “ zu den im generierten Makefile aufgeführten Quellen hinzu, wenn für eine Windows-Plattform kompiliert wird. Beim Kompilieren für andere Plattformen wird die Definition ignoriert.

Die in einem bestimmten Geltungsbereich verwendeten Bedingungen können auch negiert werden, um eine alternative Gruppe von Deklarationen bereitzustellen, die nur verarbeitet werden, wenn die ursprüngliche Bedingung falsch ist. Um beispielsweise etwas zu verarbeiten, wenn für alle Plattformen außer Windows kompiliert wird, negieren Sie den Geltungsbereich wie folgt:

!win32 {
    SOURCES -= paintwidget_win.cpp
}

Gültigkeitsbereiche können verschachtelt werden, um mehrere Bedingungen zu kombinieren. Um beispielsweise eine bestimmte Datei für eine bestimmte Plattform nur dann einzubinden, wenn das Debugging aktiviert ist, schreiben Sie Folgendes:

macx {
    CONFIG(debug, debug|release) {
        HEADERS += debugging.h
    }
}

Um das Schreiben vieler verschachtelter Gültigkeitsbereiche zu vermeiden, können Sie diese mithilfe des Operators „ : “ verschachteln. Die verschachtelten Gültigkeitsbereiche im obigen Beispiel lassen sich wie folgt umschreiben:

macx:CONFIG(debug, debug|release) {
    HEADERS += debugging.h
}

Sie können den Operator „ : “ auch verwenden, um bedingte Zuweisungen in einer einzigen Zeile durchzuführen. Zum Beispiel:

win32:DEFINES += USE_MY_STUFF

Die obige Zeile fügt „ USE_MY_STUFF “ nur dann zur Variablen „DEFINES“ hinzu, wenn für die Windows-Plattform kompiliert wird. Im Allgemeinen verhält sich der Operator „ : “ wie ein logischer UND-Operator, der mehrere Bedingungen miteinander verknüpft und verlangt, dass alle wahr sind.

Außerdem gibt es den Operator „ | “, der wie ein logischer ODER-Operator funktioniert: Er verbindet mehrere Bedingungen miteinander und erfordert, dass nur eine davon wahr ist.

win32|macx {
    HEADERS += debugging.h
}

Wenn Sie beide Operatoren kombinieren müssen, können Sie die Funktion „ if “ verwenden, um die Priorität der Operatoren festzulegen.

if(win32|macos):CONFIG(debug, debug|release) {
    # Do something on Windows and macOS,
    # but only for the debug configuration.
}
win32|if(macos:CONFIG(debug, debug|release)) {
    # Do something on Windows (regardless of debug or release)
    # and on macOS (only for debug).
}

Die Bedingung akzeptiert das Platzhalterzeichen, um eine Familie von „ CONFIG “-Werten oder „mkspec“-Namen abzugleichen.

win32-* {
    # Matches every mkspec starting with "win32-"
    SOURCES += win32_specific.cpp
}

Sie können auch alternative Deklarationen zu denen innerhalb eines Geltungsbereichs angeben, indem Sie einen „ else “-Geltungsbereich verwenden. Jeder „ else “-Geltungsbereich wird verarbeitet, wenn die Bedingungen für die vorhergehenden Geltungsbereiche falsch sind. Dies ermöglicht es Ihnen, komplexe Prüfungen zu schreiben, wenn Sie diesen Geltungsbereich mit anderen Geltungsbereichen kombinieren (getrennt durch den Operator „ : “, wie oben gezeigt). Zum Beispiel:

win32:xml {
    message(Building for Windows)
    SOURCES += xmlhandler_win.cpp
} else:xml {
    SOURCES += xmlhandler.cpp
} else {
    message("Unknown configuration")
}

Konfiguration und Bereiche

Die in der Variablen CONFIG gespeicherten Werte werden von qmake besonders behandelt. Jeder der möglichen Werte kann als Bedingung für einen Geltungsbereich verwendet werden. Beispielsweise lässt sich die Liste der in „ CONFIG “ enthaltenen Werte um den Wert „ opengl “ erweitern:

CONFIG += opengl

Infolge dieser Operation werden alle Bereiche verarbeitet, die auf „ opengl “ prüfen. Wir können diese Funktion nutzen, um der endgültigen ausführbaren Datei einen passenden Namen zu geben:

opengl {
    TARGET = application-gl
} else {
    TARGET = application
}

Diese Funktion erleichtert es, die Konfiguration eines Projekts zu ändern, ohne alle benutzerdefinierten Einstellungen zu verlieren, die für eine bestimmte Konfiguration erforderlich sein könnten. Im obigen Code werden die Deklarationen im ersten Bereich verarbeitet, und die endgültige ausführbare Datei erhält den Namen „ application-gl “. Wird „ opengl “ jedoch nicht angegeben, werden stattdessen die Deklarationen im zweiten Bereich verarbeitet, und die endgültige ausführbare Datei erhält den Namen „ application “.

Da es möglich ist, eigene Werte in die Zeile „ CONFIG “ einzutragen, bietet dies eine bequeme Möglichkeit, Projektdateien anzupassen und die generierten Makefiles fein abzustimmen.

Werte für den Plattform-Gültigkeitsbereich

Zusätzlich zu den in vielen Bereichsbedingungen verwendeten Werten „ win32 “, „ macx “ und „ unix “ können verschiedene andere integrierte plattform- und compilerspezifische Werte mit Bereichen geprüft werden. Diese basieren auf Plattformspezifikationen, die im Verzeichnis „ mkspecs “ von Qt bereitgestellt werden. Die folgenden Zeilen aus einer Projektdatei zeigen beispielsweise die aktuell verwendete Spezifikation und prüfen auf die Spezifikation „ linux-g++ “:

message($$QMAKESPEC)

linux-g++ {
    message(Linux)
}

Sie können jede andere Plattform-Compiler-Kombination prüfen, sofern dafür eine Spezifikation im Verzeichnis „ mkspecs “ vorhanden ist.

Variablen

Viele der in Projektdateien verwendeten Variablen sind spezielle Variablen, die qmake bei der Erstellung von Makefiles verwendet, wie beispielsweise DEFINES, SOURCES und HEADERS. Darüber hinaus können Sie Variablen für Ihren eigenen Gebrauch erstellen. qmake erstellt neue Variablen mit einem bestimmten Namen, sobald es auf eine Zuweisung an diesen Namen stößt. Zum Beispiel:

MY_VARIABLE = value

Es gibt keine Einschränkungen hinsichtlich der Verwendung Ihrer eigenen Variablen, da qmake diese ignoriert, sofern es sie nicht bei der Verarbeitung eines Gültigkeitsbereichs auswerten muss.

Sie können auch den Wert einer aktuellen Variablen einer anderen Variablen zuweisen, indem Sie dem Variablennamen das Präfix $$ voranstellen. Zum Beispiel:

MY_DEFINES = $$DEFINES

Nun enthält die Variable `MY_DEFINES` den Inhalt der Variable `DEFINES` an dieser Stelle in der Projektdatei. Dies entspricht auch:

MY_DEFINES = $${DEFINES}

Die zweite Schreibweise ermöglicht es dir, den Inhalt der Variablen an einen anderen Wert anzuhängen, ohne die beiden durch ein Leerzeichen zu trennen. Das folgende Beispiel stellt beispielsweise sicher, dass die endgültige ausführbare Datei einen Namen erhält, der die verwendete Projektvorlage enthält:

TARGET = myproject_$${TEMPLATE}

Ersetzungsfunktionen

qmake stellt eine Auswahl integrierter Funktionen zur Verfügung, mit denen der Inhalt von Variablen verarbeitet werden kann. Diese Funktionen verarbeiten die ihnen übergebenen Argumente und geben als Ergebnis einen Wert oder eine Liste von Werten zurück. Um einem Variablenwert ein Ergebnis zuzuweisen, verwenden Sie bei dieser Art von Funktionen den Operator „ $$ “, genau wie bei der Zuweisung des Inhalts einer Variablen zu einer anderen:

HEADERS = model.h
HEADERS += $$OTHER_HEADERS
HEADERS = $$unique(HEADERS)

Diese Art von Funktion sollte auf der rechten Seite von Zuweisungen verwendet werden (d. h. als Operand).

Sie können eigene Funktionen zur Verarbeitung des Inhalts von Variablen wie folgt definieren:

defineReplace(functionName){
    #function code
}

Die folgende Beispielfunktion nimmt einen Variablennamen als einziges Argument entgegen, extrahiert mit der integrierten Funktion `eval()` eine Liste von Werten aus der Variablen und erstellt eine Liste von Dateien:

defineReplace(headersAndSources) {
    variable = $$1
    names = $$eval($$variable)
    headers =
    sources =

    for(name, names) {
        header = $${name}.h
        exists($$header) {
            headers += $$header
        }
        source = $${name}.cpp
        exists($$source) {
            sources += $$source
        }
    }
    return($$headers $$sources)
}

Testfunktionen

qmake stellt integrierte Funktionen zur Verfügung, die beim Schreiben von Scopes als Bedingungen verwendet werden können. Diese Funktionen geben keinen Wert zurück, sondern zeigen stattdessen an, ob der Vorgang erfolgreich war oder fehlgeschlagen ist:

count(options, 2) {
    message(Both release and debug specified.)
}

Diese Art von Funktionen sollte ausschließlich in bedingten Ausdrücken verwendet werden.

Es ist möglich, eigene Funktionen zu definieren, um Bedingungen für Scopes bereitzustellen. Das folgende Beispiel prüft, ob jede Datei in einer Liste existiert, und gibt „true“ zurück, wenn alle Dateien existieren, oder „false“, wenn dies nicht der Fall ist:

defineTest(allFiles) {
    files = $$ARGS

    for(file, files) {
        !exists($$file) {
            return(false)
        }
    }
    return(true)
}