Para el comando cmake "incluir", ¿cuál es la diferencia entre un archivo y un módulo?

Question

Uso algunas bibliotecas que no quiero construir como parte de cada proyecto que las usa. Un ejemplo muy comprensible es LLVM, que tiene 78 bibliotecas estáticas. Incluso tener el código cmake para encontrar e importar estos en cada cmakefile es excesivo.

La solución obvia parece ser utilizar el comando "incluir" y factorizar fragmentos relevantes de la secuencia de comandos cmake en archivos * .cmake y configurar una variable de entorno CMAKE_MODULE_PATH.

Excepto que simplemente no funciona. Cmake no encuentra el archivo que especifico en el comando include.

En la casualidad, incluso intenté especificar la ruta en la variable de entorno de varias maneras, una con barras diagonales inversas, una con barras diagonales ... y reinicié el símbolo del sistema cada vez y comprobé que la variable de entorno era presente y correcto

En el manual de cmake, implica que un "archivo" es diferente de un "módulo": solo un módulo obtiene el tratamiento automático de agregar la extensión y buscar el camino. Pero no hay explicación de cuál es la diferencia. Supuse que la extensión faltante podría ser suficiente (como con los módulos estándar) pero claramente no lo es.

Buscar el manual de "módulo" no es de mucha ayuda ya que la palabra parece estar sobrecargada. Por ejemplo, un módulo también es una biblioteca dinámica cargada usando LoadLibrary/dl_open.

¿Alguien puede explicar cuál es la diferencia entre un archivo y un módulo en este contexto, y cómo creo mi propio módulo para que el comando cmake include pueda encontrarlo y usarlo?

Estoy usando cmake 2.8.1 en Windows.

EDITAR

Estoy bastante seguro de que el problema aquí no es la comprensión de cómo se supone que cmake para trabajar. Creo que lo que debería hacer es escribir algo con lo que find_package puede trabajar.

Sin embargo, como todo está en orden, todavía estoy lejos de poder responder a mi propia pregunta.

Answer 1

Creo que un 'módulo' CMake es simplemente un archivo que se puede utilizar con la directiva find_package. Es decir, cuando ejecuta find_package(Module), busca un archivo en la MODULE_PATH que se llama FindModule.cmake.

Dicho esto, si include un archivo sin la extensión, que también va a buscar a través de su module_path para que file.cmake. En un proyecto de CMake en el que estoy trabajando, tengo una estructura de directorios muy similar a la que propones.

+ root/ 
    + CMakeLists.txt 
    + cmake/ 
    | + FindMatlab.cmake 
    | + TestInline.cmake 
    | + stdint.cmake 
    + src/ 
    + include/ 

En CMakeLists.txt que tengo:

set (CMAKE_MODULE_PATH "${CMAKE_CURRENT_SOURCE_DIR}/cmake") 
find_package (Matlab) # runs FindMatlab.cmake 
include(TestInline) # defines a macro: 
test_inline (CONFIG_C_INLINE) 
include(stdint) # simply executes flat CMake code 

Tal vez el problema es que usted está tratando de definir la ruta de módulo en el medio ambiente. En su lugar, intente simplemente anexarlo dentro de el mismo CMakeList intenta acceder a los módulos/archivos.

Answer 2

El archivo es CMake listfile, ejemplo es CMakeLists.txt.Uso siguiente comando para obtener la lista de comandos que se utiliza en

cmake --help-command-list 

módulo es un archivo de cmake (* .cmake) que contienen comandos cmake.

Como dice Matt B., el CMAKE_MODULE_PATH no es una variable de entorno de su shell, sino una variable cmake.

para anexar la ruta de módulo para CMAKE_MODULE_PATH

LIST(APPEND CMAKE_MODULE_PATH ${YourPath}) 

O si usted perfer sus módulos para ser utilizado por primera vez

LIST(INSERT CMAKE_MODULE_PATH 0 ${Yourpath}) 

Answer 3

tuve esta misma pregunta después de leer la documentación de comandos CMake include(). Indica:

Cargue y ejecute CMake code from the file given. [... snip para abreviar ...] Si se especifica un módulo en lugar de un archivo, primero se busca el archivo con el nombre .cmake en CMAKE_MODULE_PATH, luego en el directorio del módulo CMake.

Esto deja mucha interpretación en cuanto a lo que CMake considera un módulo vs. un archivo, porque un módulo CMake es un archivo en el sistema de archivos después de todo. Entonces, ¿cuál es la diferencia?

El código fuente de CMake es el único lugar donde pude encontrar la respuesta. Básicamente, CMake considera que el argumento include() es un archivo si se ve como una ruta absoluta. Esto significa:

• En Linux/Unix
  • El argumento comienza con cualquiera '/' o '~'
• En Windows
  • segundo carácter del argumento es ': '(como en C :)
  • El argumento comienza con' \ '

CMake asume que cualquier cosa que no cumpla los criterios anteriores es un Módulo. En ese caso, agrega '.cmake' al argumento y busca el CMAKE_MODULE_PATH para ello.