À quoi sert find_package () si vous devez quand même spécifier CMAKE_MODULE_PATH?

J'essaie de faire fonctionner un système de construction multi-plateforme en utilisant CMake. Maintenant, le logiciel a quelques dépendances. Je les ai compilés moi-même et les ai installés sur mon système.

Quelques exemples de fichiers installés:

-- Installing: /usr/local/share/SomeLib/SomeDir/somefile
-- Installing: /usr/local/share/SomeLib/SomeDir/someotherfile
-- Installing: /usr/local/lib/SomeLib/somesharedlibrary
-- Installing: /usr/local/lib/SomeLib/cmake/FindSomeLib.cmake
-- Installing: /usr/local/lib/SomeLib/cmake/HelperFile.cmake

Maintenant, CMake a un find_package()qui ouvre un Find*.cmakefichier et recherche après la bibliothèque sur le système et définit certaines variables comme SomeLib_FOUNDetc.

My CMakeLists.txt contient quelque chose comme ceci:

set(CMAKE_MODULE_PATH "/usr/local/lib/SomeLib/cmake/;${CMAKE_MODULE_PATH}")
find_package(SomeLib REQUIRED)

La première commande définit où CMake recherche après le Find*.cmakeet j'ai ajouté le répertoire SomeLiboù le FindSomeLib.cmakepeut être trouvé, donc find_package()fonctionne comme prévu.

Mais c'est un peu étrange car l'une des raisons pour lesquelles il find_package()existe est de s'éloigner des chemins codés en dur non inter-plates-formes.

Comment cela se fait-il habituellement? Dois-je copier le cmake/répertoire de SomeLibdans mon projet et définir le CMAKE_MODULE_PATHrelatif?

La commande find_packagea deux modes: Modulemode et Configmode. Vous essayez d'utiliser le Modulemode alors que vous en avez réellement besoin Config.

Mode module

Find<package>.cmakefichier situé dans votre projet. Quelque chose comme ça:

CMakeLists.txt
cmake/FindFoo.cmake
cmake/FindBoo.cmake

CMakeLists.txt contenu:

list(APPEND CMAKE_MODULE_PATH "${CMAKE_CURRENT_LIST_DIR}/cmake")
find_package(Foo REQUIRED) # FOO_INCLUDE_DIR, FOO_LIBRARIES
find_package(Boo REQUIRED) # BOO_INCLUDE_DIR, BOO_LIBRARIES

include_directories("${FOO_INCLUDE_DIR}")
include_directories("${BOO_INCLUDE_DIR}")
add_executable(Bar Bar.hpp Bar.cpp)
target_link_libraries(Bar ${FOO_LIBRARIES} ${BOO_LIBRARIES})

Notez que cela CMAKE_MODULE_PATHa une priorité élevée et peut être utile lorsque vous devez réécrire un Find<package>.cmakefichier standard .

Mode de configuration (installer)

<package>Config.cmakefichier situé à l' extérieur et produit par install commande d'un autre projet ( Foopar exemple).

foo bibliothèque:

> cat CMakeLists.txt 
cmake_minimum_required(VERSION 2.8)
project(Foo)

add_library(foo Foo.hpp Foo.cpp)
install(FILES Foo.hpp DESTINATION include)
install(TARGETS foo DESTINATION lib)
install(FILES FooConfig.cmake DESTINATION lib/cmake/Foo)

Version simplifiée du fichier de configuration:

> cat FooConfig.cmake 
add_library(foo STATIC IMPORTED)
find_library(FOO_LIBRARY_PATH foo HINTS "${CMAKE_CURRENT_LIST_DIR}/../../")
set_target_properties(foo PROPERTIES IMPORTED_LOCATION "${FOO_LIBRARY_PATH}")

Par défaut, projet installé dans le CMAKE_INSTALL_PREFIXrépertoire:

> cmake -H. -B_builds
> cmake --build _builds --target install
-- Install configuration: ""
-- Installing: /usr/local/include/Foo.hpp
-- Installing: /usr/local/lib/libfoo.a
-- Installing: /usr/local/lib/cmake/Foo/FooConfig.cmake

Mode de configuration (utilisation)

Utilisez find_package(... CONFIG)pour inclure FooConfig.cmakeavec la cible importée foo:

> cat CMakeLists.txt 
cmake_minimum_required(VERSION 2.8)
project(Boo)

# import library target `foo`
find_package(Foo CONFIG REQUIRED)

add_executable(boo Boo.cpp Boo.hpp)
target_link_libraries(boo foo)
> cmake -H. -B_builds -DCMAKE_VERBOSE_MAKEFILE=ON
> cmake --build _builds
Linking CXX executable Boo
/usr/bin/c++ ... -o Boo /usr/local/lib/libfoo.a

Notez que la cible importée est hautement configurable. Voyez ma réponse .

Mettre à jour

• Exemple

Si vous exécutez cmakepour SomeLibvous générer (par exemple dans le cadre d'un superbuild), envisagez d'utiliser le registre de packages utilisateur . Cela ne nécessite aucun chemin codé en dur et est multiplateforme. Sous Windows (y compris mingw64), cela fonctionne via le registre. Si vous examinez comment la liste des préfixes d'installation est construite par le CONFIGmode de la commande find_packages () , vous verrez que le registre de packages utilisateur est l'un des éléments.

Bref comment faire

Associez les cibles SomeLibdont vous avez besoin en dehors de ce projet externe en les ajoutant à un jeu d'export dans les CMakeLists.txtfichiers où elles sont créées:

add_library(thingInSomeLib ...)
install(TARGETS thingInSomeLib Export SomeLib-export DESTINATION lib)

Créez un XXXConfig.cmakefichier pour SomeLibdans son ${CMAKE_CURRENT_BUILD_DIR}et stockez cet emplacement dans le registre de packages utilisateur en ajoutant deux appels à export () au CMakeLists.txtassocié à SomeLib:

export(EXPORT SomeLib-export NAMESPACE SomeLib:: FILE SomeLibConfig.cmake) # Create SomeLibConfig.cmake
export(PACKAGE SomeLib)                                                    # Store location of SomeLibConfig.cmake

find_package(SomeLib REQUIRED)Émettez votre commande dans le CMakeLists.txtfichier du projet qui dépend de SomeLibsans que les "chemins codés en dur non multiplateformes" bricolent avec le CMAKE_MODULE_PATH.

Quand cela pourrait être la bonne approche

Cette approche est probablement la mieux adaptée aux situations où vous n'utiliserez jamais votre logiciel en aval du répertoire de construction (par exemple, vous faites une compilation croisée et n'installez jamais rien sur votre machine, ou vous construisez le logiciel juste pour exécuter des tests dans le répertoire build), car il crée un lien vers un fichier .cmake dans votre sortie "build", qui peut être temporaire.

Mais si vous n'installez jamais réellement SomeLibdans votre flux de travail, l'appel EXPORT(PACKAGE <name>)vous permet d'éviter le chemin codé en dur. Et, bien sûr, si vous installez SomeLib, vous connaissez probablement votre plate-forme CMAKE_MODULE_PATH, etc., donc l'excellente réponse de @ user2288008 vous couvrira.

Vous n'avez pas besoin de spécifier le chemin du module en soi. CMake est livré avec son propre ensemble de scripts find_package intégrés, et leur emplacement est dans le CMAKE_MODULE_PATH par défaut.

Le cas d'utilisation plus normal pour les projets dépendants qui ont été CMakeified serait d'utiliser la commande external_project de CMake et d'inclure ensuite le fichier Use [Project] .cmake du sous-projet. Si vous avez juste besoin du script Find [Project] .cmake, copiez-le hors du sous-projet et dans le code source de votre propre projet, et vous n'aurez pas besoin d'augmenter le CMAKE_MODULE_PATH pour trouver le sous-projet au niveau du système.

Comment cela se fait-il habituellement? Dois-je copier le cmake/répertoire de SomeLib dans mon projet et définir le CMAKE_MODULE_PATH relativement?

Si vous ne faites pas confiance à CMake pour avoir ce module, alors - oui, faites cela - en quelque sorte: Copiez le find_SomeLib.cmakeet ses dépendances dans votre cmake/répertoire. C'est ce que je fais comme solution de secours. C'est une solution moche cependant.

Notez que les FindFoo.cmakemodules sont chacun une sorte de pont entre la dépendance de la plate-forme et l'indépendance de la plate-forme - ils recherchent à divers endroits spécifiques à la plate-forme pour obtenir des chemins dans des variables dont les noms sont indépendants de la plate-forme.