it-swarm.com.de

Wie generiere ich CMakeLists.txt?

Ich brauche ein paar Hinweise/Hinweise, wie man automatisch CMakeLists.txt-Dateien für CMake generiert. Kennt jemand irgendwelche vorhandenen Generatoren? Ich habe die im CMake-Wiki aufgeführten überprüft, aber leider sind sie nicht für mich geeignet. 

Ich habe bereits ein einfaches Python-Skript, das die Verzeichnisstruktur meines Projekts durchquert und die erforderlichen Dateien generiert, aber es ist im Moment wirklich "dumm". Ich möchte es erweitern, um beispielsweise die verschiedenen Plattformen zu berücksichtigen, für die ich baue, den Compiler\Cross-Compiler, den ich verwende, oder verschiedene Versionen der Bibliothekenabhängigkeiten, die ich möglicherweise habe. Ich habe nicht viel Erfahrung mit CMake, und ein Beispiel, auf das ich meine Arbeit stützen könnte, oder ein bereits funktionierender Generator könnte eine große Hilfe sein.

46
celavek

Ich bin der Meinung, dass Sie kein automatisiertes Skript zum Generieren von CMakeLists.Txt verwenden müssen, da es sehr einfach ist, eines zu schreiben, nachdem Sie die grundlegende Prozedur verstanden haben. Ja, ich stimme zu, dass das Verstehen der Prozedur, wie man eine in CMake Wiki angegebene schreibt, auch schwierig ist, da es zu detailliert ist.

Ein sehr einfaches Beispiel für das Schreiben von CMakeLists.txt wird hier gezeigt, von dem ich denke, dass es für jeden von Nutzen ist, selbst für jemanden, der zum ersten Mal CMakeLists.txt schreibt.

24
Preeti Kaur

Nun, ich habe auch nicht viel Erfahrung mit Cmake, aber um eine plattformübergreifende Installation durchzuführen, müssen viele Dateien geschrieben und geändert werden, einschließlich der Datei CMakeLists.txt. Ich schlage vor, dass Sie dieses neue Tool namens ProjectGenerator Tool verwenden Das ist ziemlich cool, es erledigt alle zusätzlichen Aufgaben und macht es einfach, solche Dateien für 3'rd Party-Quellen mit geringem Aufwand zu generieren. __ Lesen Sie das README aufmerksam durch, bevor Sie es verwenden.

Link: http://www.ogre3d.org/forums/viewtopic.php?f=1&t=54842

11
wOlVeRiNe

Ich denke, dass du das auf dem Kopf stehst.

Wenn Sie CMake verwenden, sollten Sie die CMakeLists.txt selbst schreiben. Normalerweise müssen Sie nicht mit anderen Compilern arbeiten, da CMake über sie Bescheid weiß. Wenn Sie müssen, können Sie jedoch in den CMakeFiles Code hinzufügen, um je nach verwendetem Werkzeug unterschiedliche Aktionen auszuführen.

11
Lindydancer

CLion ist eine integrierte Entwicklungsumgebung, die vollständig auf der CMake-Projektdatei basiert.

Es ist in der Lage, die CMakeLists.txt-Datei bei Verwendung des import-Projekts aus Quelle selbst zu generieren.

Es ist jedoch sehr wahrscheinlich, dass Sie diese Datei manuell bearbeiten müssen, wenn Ihr Projekt wächst und externe Abhängigkeiten hinzugefügt werden.

4
nicolas-f

Vielleicht könnte dies hilfreich sein:

https://conan.io/

Der Autor hat einige Vorträge über cmake gehalten und wie man mit cmake modulare Projekte in CPPCon erstellt. Soweit ich weiß, erfordert dieses Tool cmake, so dass ich es generieren kann, wenn Sie neue Pakete integrieren oder neue Pakete erstellen. Kürzlich habe ich etwas darüber gelesen, wie man eine CAM-Datei mit einer YAML-Datei auf höherer Ebene beschreibt. Ich bin mir jedoch nicht sicher, ob es sich bei conan um einen Teil handelt (was ich gelesen habe, war vom Autor von conan). Ich habe es noch nie benutzt, und es ist etwas für mich anhängig, so dass, wenn Sie es verwenden und Ihren Bedürfnissen entsprechen, Ihre Meinung dazu kommentieren und wie es zu Ihrem Szenario passt.

Ich verwalte eine C++ - Softwareumgebung mit mehr als 1000 Modulen (gemeinsam genutzte, statische Bibliotheken, Programme) und verwende mehr als 20 Drittanbieter (boost, openCV, Qt, Qwt ...). Diese Software-Umgebung beherbergt viele Programme (~ 50), von denen jedes einige Bibliotheken, Programme und Dritte aufnimmt. Ich benutze CMake, um die Makefiles zu generieren und das ist wirklich toll.

Wenn Sie jedoch Ihren CMakeLists.txt Schreiben, wie es empfohlen wird (deklarieren Sie das Modul als Bibliothek/Programm, importieren Sie Quelldateien, fügen Sie Abhängigkeiten hinzu ...). Ich stimme Celavek zu: Das Verwalten dieser CMakeLists.txt - Dateien ist ein echtes Problem:

  • Wenn Sie einem Modul eine neue Datei hinzufügen, müssen Sie dessen CMakeLists.txt Aktualisieren.
  • Wenn Sie einen Drittanbieter aktualisieren, müssen Sie den CMakeLists.txt Aller Module aktualisieren, die ihn verwenden
  • Wenn Sie eine neue Abhängigkeit hinzufügen (Bibliothek A benötigt jetzt Bibliothek B), müssen Sie möglicherweise den CMakeLists.txt Aller Programme mit A aktualisieren.
  • Wenn Sie eine neue globale Einstellung ändern möchten (Compilereinstellung, vordefinierte Variable, verwendeter C++ - Standard), müssen Sie alle CMakeLists.txt Aktualisieren.

Dann sehe ich zwei Strategien, um diese Probleme anzugehen, und wahrscheinlich die vom OP erwähnte.

1- Haben Sie CMakeLists.txt Gut geschrieben und sind Sie schlau genug, um nicht zu erstarren, um sich im laufenden Betrieb zu aktualisieren . Das ist es, was wir in unserer Softwareumgebung haben. Jedes Modul verfügt über eine standardisierte Dateiorganisation (die Quellen befinden sich im Ordner src, die Includes im Ordner inc ...) und einfache Textdateien, in denen die Abhängigkeiten angegeben werden (mit von uns definierten Schlüsselwörtern wie QT, um zu sagen, dass das Modul eine Verknüpfung mit Qt) herstellen muss. Dann ist unser CMakeLists.txt Eine zweizeilige Datei und ruft einfach ein cmake-Makro auf, das wir geschrieben haben, um das Modul automatisch einzurichten. Als MCVE wäre das:

CMakeLists.txt:

include( utl.cmake )
add_module( "mylib", lib )

utl.cmake:

macro( add_module name what )
    file(GLOB_RECURSE source_files "${CMAKE_CURRENT_SOURCE_DIR}/src/*.cpp")
    include_directories(${CMAKE_CURRENT_SOURCE_DIR}/inc)
    if ( what STREQUEL "lib" )
        add_library( ${name} SHARED ${source_files} )
    elseif ( what STREQUEL "prg" )
        add_executable( ${name} ${source_files} )
    endif()
    # TODO: Parse the simple texts files to add target_link_libraries accordingly
endmacro()

In allen oben aufgeführten Situationen müssen Sie nur utl.cmake aktualisieren, nicht die Tausender von CMakeLists.txt, Die Sie haben ...

Ehrlich gesagt, wir sind sehr zufrieden mit diesem Ansatz, das System wird sehr einfach zu warten und wir können problemlos neue Abhängigkeiten hinzufügen, Drittanbieter aktualisieren, einige Build-/Abhängigkeitsstrategien ändern ...

Es müssen jedoch noch viele CMake - Skripte geschrieben werden. Und die Skriptsprache CMake ist zum Kotzen ... das Tool ist sehr mächtig, aber der variable Umfang des Skripts, der Cache, die schmerzhafte und nicht so gut dokumentierte Syntax (nur um zu überprüfen, ob eine Liste leer ist, müssen Sie danach fragen es ist Größe und speichern Sie dies in einer Variablen!), die Tatsache, dass es nicht objektorientiert ist ... machen es zu einem echten Schmerz zu pflegen.

Daher bin ich jetzt überzeugt, dass der wirklich gute Ansatz darin besteht,

2- Erstellen Sie den CMakeLists.txt vollständig aus einer mächtigeren Sprache wie Python. Das Python Skript würde ähnliche Dinge tun wie unser utl.cmake, stattdessen würde es einen CMakeLists.txt Erzeugen, der bereit ist, an CMake übergeben zu werden (mit einem Format wie in HelloWorld vorgeschlagen, keine Variable, keine Funktion .... es würde nur die Standardfunktion CMake aufrufen).

Ich bezweifle, dass es ein solches generisches Tool gibt, da es schwierig ist, die CMakeLists.txt - Dateien zu erstellen, die alle glücklich machen. Sie müssen es selbst schreiben. Beachten Sie, dass gen-cmake dies tut (eine CMakeLists.txt generiert), aber auf sehr primitive Weise und anscheinend nur Linux unterstützt, aber es kann ein guter Startpunkt sein.

Dies wird wahrscheinlich die Version 2 unserer Software-Umgebung sein ... eines Tages.

0
jpo38

Ich bin mir nicht sicher, ob es sich hierbei um ein Problem handelt, mit dem das Originalposter zu kämpfen hatte, aber da ich viele der oben genannten Antworten „nur CMakefile.txt schreiben“ sehe, möchte ich kurz erklären, warum das Erzeugen von CMakefiles sinnvoll sein kann:

a) Ich habe ein anderes Build-System, mit dem ich ziemlich zufrieden bin

(und deckt den umfangreichen Multiplattform-Build einer großen Sammlung von miteinander verbundenen, gemeinsam genutzten und statischen Bibliotheken, Programmen, Skripts Spracherweiterungen und Werkzeugen ab, mit verschiedenen internen und externen .__ Abhängigkeiten, Eigenarten und Varianten)

b) Selbst wenn ich es ersetzen würde, würde ich cmake nicht in Betracht ziehen.

Ich habe mir CMakefiles angesehen und bin mit der Syntax .__ nicht zufrieden. und mit der Semantik nicht zufrieden.

c) CLion verwendet nur CMakefiles und Cmakefiles (und scheint etwas interessant zu sein)

Um CLion eine Chance zu geben (ich liebe PyCharm, also ist es verlockend), aber um mein Build-System weiterhin zu verwenden, würde ich gerne ein Werkzeug verwenden, mit dem ich Implementieren kann make generate_cmake und lassen Sie alle erforderlichen CMakefiles on the fly nach dem currentinfo generieren, das aus meinem Build-System extrahiert wurde. Ich kann das Tool/Skript gerne mit Informationen füttern, aus welchen Quellen und Kopfzeilen meine App besteht, welche Bibliotheken und Programme erstellt werden sollen, welche -I, -L, -D usw. für welche Komponente erwartet werden usw.

Nun, natürlich wäre ich viel glücklicher, wenn JetBrains es erlauben würde, ein direktes Protokoll für die IDE mit den Informationen bereitzustellen, die es benötigt. (. Erlaubte mir, meinen eigenen Befehl zum Kompilieren zu geben run und to alle Metadaten ausgeben, die sie wirklich benötigen - ich nehme an, dass sie hauptsächlich incdirs benötigen und definiert, um sie in der Fly-Code-Analyse zu implementieren, und libpaths, um LD_LIBRARY_PATH für den Debugger einzurichten), ohne sich auf cmake zu beziehen. CMakefiles als Protokoll sind etwas kompliziert.

0
Mekk