CMake La Compilation Des Fichiers Générés

J'ai une liste de fichiers qui se produit au cours de la CMake processus de construction. Je veux compiler ces fichiers à l'aide de "add_library" par la suite, mais je ne sais pas quels fichiers sont générés jusqu'à ce qu'ils se produit. Est-il de toute façon à l'intégrer dans un CMake script?

OriginalL'auteur Jonathan Sternberg | 2010-11-19

cmake

Bien, je pense que c'est possible, donc je vais partager ce que j'ai fait. Mon problème était que je devais compiler plusieurs CORBA permis de conduire international pour une utilisation dans le cadre d'un projet de la source et je ne voulais pas manuellement la liste de tous les fichiers. J'ai pensé qu'il serait préférable de trouver les fichiers. Donc j'ai fait comme ceci:

file(GLOB IDLS "idls/*.idl")
set(ACE_ROOT ${CMAKE_FIND_ROOT_PATH}/ace/ACE-${ACE_VERSION})
foreach(GENERATE_IDL ${IDLS})
   get_filename_component(IDLNAME ${GENERATE_IDL} NAME_WE)
   set(OUT_NAME ${CMAKE_CURRENT_SOURCE_DIR}/idls_out/${IDLNAME})

   list(APPEND IDL_COMPILED_FILES ${OUT_NAME}C.h ${OUT_NAME}C.cpp ${OUT_NAME}S.h ${OUT_NAME}S.cpp)

   add_custom_command(OUTPUT ${OUT_NAME}C.h ${OUT_NAME}C.cpp ${OUT_NAME}S.h ${OUT_NAME}S.cpp
                      COMMAND ${ACE_ROOT}/bin/tao_idl -g ${ACE_ROOT}/bin/ace_gperf -Sci -Ssi -Wb,export_macro=TAO_Export -Wb,export_include=${ACE_ROOT}/include/tao/TAO_Export.h -Wb,pre_include=${ACE_ROOT}/include/ace/pre.h -Wb,post_include=${ACE_ROOT}/include/ace/post.h -I${ACE_ROOT}/include/tao -I${CMAKE_CURRENT_SOURCE_DIR} ${GENERATE_IDL} -o ${CMAKE_CURRENT_SOURCE_DIR}/idls_out/
                      COMMENT "Compiling ${GENERATE_IDL}")
endforeach(GENERATE_IDL)

set_source_files_properties(${IDL_COMPILED_FILES}
                            PROPERTIES GENERATED TRUE)

set(TARGET_NAME ${PROJECT_NAME}${DEBUG_SUFFIX})

add_executable(
   ${TARGET_NAME}
   ${SOURCE} 
   ${IDL_COMPILED_FILES}
)

Les propriétés GÉNÉRÉES est utile dans le cas où l'un de mes idl de compilation des résultats (*C.cpp, *C. h, *S.cpp et *S. h) n'est pas créé, de sorte que la commande de construction ne se plaint pas que le fichier n'existe pas.

OriginalL'auteur

Bien, il est possible de le faire avec deux CMake scripts à l'aide de CMake est ExternalProject fonctionnalité.

La solution la plus simple

Dans les principaux CMake script, vous devez ajouter une cible personnalisée qui génère les fichiers de la source comme suit et une référence à la 2e (externe) CMake
projet:

# Main CMakeLists.txt    
add_custom_target(
    code_generation
    COMMAND your_code_generation_tool -o ${CMAKE_CURRENT_BINARY_DIR}/libgenerated/
)

include(ExternalProject)
ExternalProject_Add(
    libgenerated
    DEPENDS code_generation
    SOURCE_DIR ${CMAKE_CURRENT_SOURCE_DIR}/path/to/external/project/
    BINARY_DIR ${CMAKE_CURRENT_BINARY_DIR}/libgenerated-build
    CMAKE_ARGS -DGENERATED_SOURCE_DIR=${CMAKE_CURRENT_BINARY_DIR}/libgenerated
    BUILD_ALWAYS 1
    INSTALL_CMD ""
)

add_executable(
    ${PROJECT_NAME}
    ...
)

target_link_libraries(
    ${PROJECT_NAME} 
    ${CMAKE_CURRENT_BINARY_DIR}/libgenerated-build/libgenerated.a
)

add_dependencies(${PROJECT_NAME} libgenerated)

Maintenant, vous pouvez faire un fichier d'expansion dans le 2ème (externe) CMake script et le lien de tous les fichiers dans une bibliothèque statique:

# External project CMakeLists.txt
project(libgenerated)
file(GLOB_RECURSE SOURCES ${GENERATED_SOURCE_DIR}/*)
add_library(${PROJECT_NAME} ${SOURCES})

Dans cette solution simple de vos fichiers sont générés et construit à chaque fois que vous exécutez l'étape de génération, même si rien n'a changé. Si vous voulez éviter cela, vous pouvez ajouter un timbre fichier sur votre cible personnalisée comme dans l'amélioration de la solution:

Le timbre fichier solution

# Main CMakeLists.txt    
add_custom_command(
    OUTPUT ${CMAKE_CURRENT_BINARY_DIR}/libgenerated-stamp
    COMMAND your_code_generation_tool -o ${CMAKE_CURRENT_BINARY_DIR}/libgenerated/
    COMMAND ${CMAKE_COMMAND} -E touch ${CMAKE_CURRENT_BINARY_DIR}/libgenerated-stamp
    DEPENDS the_input_file(s)_you_generate_your_code_from
)

add_custom_target(
    code_generation
    DEPENDS ${CMAKE_CURRENT_BUILD_DIR}/libgenerated-stamp
)

...

Si un changement dans les fichiers d'entrée pour votre générateur de code n'entraîne pas nécessairement une modification de tous les fichiers générés vous pouvez améliorer encore la solution en utilisant CMake est copy_if_different de commande dans le projet externe comme dans l'avancée de la solution:

La solution avancée

# External project CMakeLists.txt
project(libgenerated)
file(GLOB_RECURSE SOURCES ${GENERATED_SOURCE_DIR}/*)

add_custom_target(
    make_directory
    COMMAND ${CMAKE_COMMAND} -E make_directory ${CMAKE_CURRENT_BINARY_DIR}/generated
)

foreach(FILE ${SOURCES})
    get_filename_component(BASENAME ${FILE} NAME)
    list(APPEND ACTUAL_SOURCES "${CMAKE_CURRENT_BINARY_DIR}/generated/${BASENAME}")
    add_custom_target(
        copy_${BASENAME}_if_different
        COMMAND ${CMAKE_COMMAND} -E copy_if_different ${FILE}     ${CMAKE_CURRENT_BINARY_DIR}/generated
    )
    add_dependencies(make_directory copy_${BASENAME}_if_different)
endforeach()

add_library(${PROJECT_NAME} ${ACTUAL_SOURCES})
add_dependencies(${PROJECT_NAME} make_directory)

Dans cette solution tous les fichiers générés sont copiés vers un autre emplacement (${CMAKE_CURRENT_BINARY_DIR}/generated) si elles ont changé ou ont été ajoutés et sont construits à partir de là. Cette approche se traduit par une accumulation de fichiers modifiés (mais nécessite un nettoyage lorsque les fichiers ont été supprimés).

La compilation uniquement si les fichiers ont changé, c'est une belle fonctionnalité. Récemment, j'ai eu la réflexion sur l'amélioration de mon code afin d'augmenter la vitesse de mon temps de compilation. Peut-être que je vais essayer cette approche ou à l'adapter à la mienne, si possible.

OriginalL'auteur

2

Si vous ne connaissez pas le nom des fichiers qui seront générés, vous pouvez "glob", les dossiers où ils résident.

file( GLOB_RECURSE MY_SRC dest_folder/*.cpp )

add_library( libname SHARED ${MY_SRC} )

Maintenant, je ne suis pas sûr de ce qui déclenche la génération de ces fichiers. Le "globbing" ne pourra se produire que lorsque vous exécutez manuellement cmake: il ne sera pas en mesure de détecter automatiquement les nouveaux fichiers sont présents.

Les fichiers sont générés lors de la "faire". Donc, en utilisant GLOB_RECURSE ou de toute expansion dans cmake ne fonctionne pas.
Alors peut-être vous avez besoin de partager votre processus de création en deux. La première cmake projet prendra fin avec la génération de ces fichiers. La deuxième glob le dossier avec les fichiers nouveaux et à construire. Une façon vous pouvez mettre en place que bien est à l'aide d'hudson (hudson.dev.java.net). Vous pouvez créer une dépendance entre les deux projets et de déclencher la construction de l'un après l'autre.

OriginalL'auteur
1

Traiter cela comme une non-réponse, juste plus d'infos:

J'ai récemment eu à faire quelque chose d'un cas où j'ai eu un .rpc fichier qui a été généré automatiquement, mais je ne pouvais pas comprendre comment obtenir CMake pour construire le fichier de projet Visual Studio qui serait ensuite le compiler. J'ai dû recourir à quelque chose tout à fait minable: j'ai dû #include <the_generated.cpp> fichier à partir d'un autre fichier qui a habité dans le ${CMAKE_CURRENT_SOURCE} répertoire. Qui ne sera pas beaucoup vous aider dans votre cas, parce que je soupçonne que vous en avez plusieurs .fichiers cpp, de sorte que cette approche n'est pas évolutif.

Aussi, j'ai trouvé que le GENERATED fichier source de la propriété, lorsqu'il est ajouté à la file, n'a pas aidé du tout.

Je considère que cette condition soit un bug dans Visual Studio (dans mon cas, cela a été VS2008 SP1), ou dans la façon dont CMake génère l' .vcproj fichiers, ou les deux.

OriginalL'auteur

Vous devez vous connecter pour publier un commentaire.