Bon, désolé les copains j'ai trouvé une solution avant de revenir ici voir vos conseils 
Je vais commenter vos commentaires (sic) avant de vous exposer ma solution.

Envoyé par
dragonjoker59
A partir du nom de la ressource, tu n'as vraiment aucun moyen de déduire le nom des fichiers de sortie?
Si, pour une partie des fichiers (par exemple, je convertis image.png en image.png.cpp) mais pas tous.

Envoyé par
leternel
A priori, si tu listes toutes les ressources avec glob, tu peux utiliser string() pour générer une liste des fichiers produits.
Il ne reste alors qu'a ajouter cette liste dans ton build.
J'ai pas le même problème ? Comment obtenir la liste avant création ?

Envoyé par
Luc Hermitte
Je rajouterai que add_executable n'a pas besoin des .h, seulement des .cpp
Et que les trucs générés n'ont rien à faire au milieu des sources -> utilise "${CMAKE_CURRENT_BINARY_DIR}" au lieu de "${CMAKE_SOURCE_DIR}/generated"
Pour ce qui est des .hpp, j'ai suivi le conseil donné ici : http://florian-goujeon.developpez.co...tion/#LIII-A-2. Il parait que ça permet de les ajouter dans les projets des IDE pour les rendre visibles.
Pour ce qui est du dossier de génération, c'est pas faux a priori. Mais j'ai des fichiers d'en-tête qui seront générés là-dedans (dans mon vrai projet) donc c'était la simplicité pour les include path.
Pour ce qui est de ma solution, j'ai décomposé le problème en sous-problèmes.
Le premier sous-problème est d'appeler un truc pour générer les sources lors du premier appels à cmake. Ce truc pourrait être ensuite rappeler à nouveau par make pour regénérer les sources si besoin. J'ai commencé à regarder du côté des fonctions mais je n'ai pas trouvé comment appeler une fonction là où une COMMAND est appelé (par exemple dans add_custom_target()). Une discussion stackoverflow m'a fait comprendre que je pouvais passer par un script CMake écrit dans un fichier séparé.
Le deuxième problème était donc de rappeler ce truc, en ajoutant la condition qu'il ne devait être rappelé que si une des ressources étaient modifiées. Cette article m'a montré la lumière : https://samthursfield.wordpress.com/...stom-commands/ L'auteur utilise un fichier bidon comme sorte de marqueur de la génération des ces fichiers.
J'en suis donc arrivé à la solution suivante :
CMakeLists.txt
cmake_minimum_required(VERSION 3.7)
project(experiences-project)
# Generate sources first
execute_process(
COMMAND ${CMAKE_COMMAND} -P ${CMAKE_SOURCE_DIR}/generate_sources.cmake
WORKING_DIRECTORY ${CMAKE_SOURCE_DIR}
)
# List sources and headers files
file(GLOB cpp_files *.cpp)
file(GLOB hpp_files *.hpp)
file(GLOB generated_files generated/*)
include_directories(.)
# Add executable
add_executable(experiences ${cpp_files} ${hpp_files} ${generated_files})
# Create a target to regenerate sources from templates if needed
add_custom_command(
OUTPUT ${CMAKE_SOURCE_DIR}/generated/ressources.stamp
DEPENDS ${CMAKE_SOURCE_DIR}/*.template
COMMAND ${CMAKE_COMMAND} -P ${CMAKE_SOURCE_DIR}/generate_sources.cmake
WORKING_DIRECTORY ${CMAKE_SOURCE_DIR}
COMMENT "Command: call cmake script to generate ressources..."
)
add_custom_target(
generate_ressources
ALL
DEPENDS ${CMAKE_SOURCE_DIR}/generated/ressources.stamp
COMMENT "Target: generate ressources..."
)
generate_sources.cmake
message("***********************")
message("** Generate sources ***")
message("Delete and re-create 'generated' folder...")
execute_process(
COMMAND ${CMAKE_COMMAND} -E remove_directory generated/
COMMAND ${CMAKE_COMMAND} -E make_directory generated/
)
message("Generate sources...")
file(GLOB template_files *.template)
foreach(template_file ${template_files})
message("Convert " ${template_file})
get_filename_component(template_file_name ${template_file} NAME)
execute_process(COMMAND ${CMAKE_COMMAND} -E copy ${template_file} generated/${template_file_name}.cpp)
endforeach()
message("Generate stamp file...")
execute_process(
COMMAND ${CMAKE_COMMAND} -E touch generated/ressources.stamp
)
message("***********************")
Voilà 
Ça semble faire ce que je veux. J'ai actuellement deux fichiers template, qui sont convertis en deux fichiers C++. Le premier contient la fonction f(), le second la fonction g(). La fonction main() contenue dans main.cpp y fait appel.
- quand je pars du projet à l'état initial, cmake me génère les sources, les trouve avec file(GLOB ...) et les ajouter à l'exécutable. OK.
- quand je modifie main.cpp, make recompile main.cpp sans regénérer de codes à partir des templates. OK.
- quand je modifie au moins un des fichiers templates, make regénère les sources et recompiler le tout. OK.
Des remarques ? Des commentaires ? Des améliorations ?
Merci encore
Partager