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

solidity tutorial español pdf

Question

Uso algunas bibliotecas que no quiero que se construyan como parte de cada proyecto que las use. Un ejemplo muy comprensible es LLVM, que tiene 78 bibliotecas estáticas. Incluso tener el código cmake para encontrarlos e importarlos en cada cmakefile es excesivo.

La solución obvia parece ser usar el comando "incluir" y factorizar los fragmentos relevantes del script 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 de inclusión.

En el caso de que no fuera posible, incluso intenté especificar la ruta en la variable de entorno de varias maneras (una vez con barras diagonales inversas, una vez con barras inclinadas hacia delante) y reinicié el símbolo del sistema cada vez y comprobé que la variable de entorno estaba presente y era correcta.

En el manual de cmake, esto implica que un "archivo" es diferente de un "módulo"; solo un módulo recibe el tratamiento automático de agregar la extensión y buscar la ruta. 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 en el manual "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 utilizando 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 entender cómo se supone que funciona cmake. Creo que lo que debería estar haciendo es escribir algo con lo que find_package pueda funcionar.

Sin embargo, como están las cosas, todavía estoy lejos de poder responder mi propia pregunta.

Answer 1

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

Dicho esto, si include un archivo sin la extensión, también buscará en ese file.cmake ese file.cmake . En un proyecto de CMake en el que estoy trabajando, tengo una estructura de directorios muy similar en cuanto a lo que propones.

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

En CMakeLists.txt 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

Quizás su problema es que está intentando definir la ruta del Módulo desde el entorno. En su lugar, intente simplemente agregarlo dentro de la misma lista de CMake que intenta acceder a los módulos / archivos.

Answer 2

El archivo es CMake listfile, el ejemplo es CMakeLists.txt. Utilice el siguiente comando para obtener la lista de comandos utilizados en

cmake --help-command-list 

El módulo es un archivo cmake (* .cmake) que contiene comandos cmake.

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

Para adjuntar la ruta del módulo a CMAKE_MODULE_PATH

LIST(APPEND CMAKE_MODULE_PATH ${YourPath})

O si prefieres tus módulos para usarlos primero.

LIST(INSERT CMAKE_MODULE_PATH 0 ${Yourpath})

Answer 3

Tuve esta misma pregunta después de leer la documentación del comando include() CMake. Afirma:

Cargue y ejecute el código CMake desde el archivo dado. [... recorte por brevedad ...] Si se especifica un módulo en lugar de un archivo, el archivo con el nombre .cmake se busca primero en CMAKE_MODULE_PATH, luego en el directorio del módulo CMake.

Esto deja mucha interpretación sobre lo que CMake considera un módulo frente a 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 podría encontrar la respuesta. Básicamente, CMake considera que el argumento para include() es un archivo si parece una ruta absoluta. Esto significa:

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

CMake asume que cualquier otra cosa que no cumpla con los criterios anteriores es un módulo. En cuyo caso, se agrega ''.cmake'' al argumento y busca el CMAKE_MODULE_PATH.