Vous cherchez une commande «cmake clean» pour effacer la sortie CMake

Tout comme make cleansupprime tous les fichiers produits par un makefile, je voudrais faire de même avec CMake. Trop souvent, je me retrouve à parcourir manuellement des répertoires supprimant des fichiers comme cmake_install.cmakeet CMakeCache.txt, et les CMakeFilesdossiers.

Existe-t-il une commande comme cmake cleansupprimer automatiquement tous ces fichiers? Idéalement, cela devrait suivre la structure récursive définie dans le CMakeLists.txtfichier du répertoire courant .

Il n'y en a pas cmake clean.

Je construis généralement le projet dans un dossier unique comme "build". Donc, si je le veux make clean, je peux juste rm -rf build.

Le dossier "build" dans le même répertoire que la racine "CMakeLists.txt" est généralement un bon choix. Pour construire votre projet, vous donnez simplement à cmake l'emplacement du CMakeLists.txt comme argument. Par exemple: cd <location-of-cmakelists>/build && cmake ... (De @ComicSansMS)

La FAQ officielle de CMake indique:

Certaines arborescences de build créées avec les autotools GNU ont une cible "make distclean" qui nettoie la build et supprime également les Makefiles et d'autres parties du système de build généré. CMake ne génère pas de cible "make distclean" car les fichiers CMakeLists.txt peuvent exécuter des scripts et des commandes arbitraires; CMake n'a aucun moyen de suivre exactement quels fichiers sont générés dans le cadre de l'exécution de CMake. Fournir une cible distclean donnerait aux utilisateurs la fausse impression que cela fonctionnerait comme prévu. (CMake génère une cible "make clean" pour supprimer les fichiers générés par le compilateur et l'éditeur de liens.)

Une cible "make distclean" n'est nécessaire que si l'utilisateur effectue une génération en source. CMake prend en charge les builds in-source, mais nous encourageons fortement les utilisateurs à adopter la notion de build out-of-source. L'utilisation d'une arborescence de génération distincte de l'arborescence source empêchera CMake de générer des fichiers dans l'arborescence source. Parce que CMake ne modifie pas l'arborescence source, il n'est pas nécessaire d'avoir une cible distclean. On peut démarrer une nouvelle construction en supprimant l'arborescence de construction ou en créant une arborescence de construction distincte.

En ces jours de Git partout, vous pouvez oublier CMake et son utilisation git clean -d -f -x, qui supprimera tous les fichiers qui ne sont pas sous contrôle de source.

Je l'ai googlé pendant une demi-heure et la seule chose utile que j'ai trouvée a été d'invoquer l' findutilitaire:

# Find and then delete all files under current directory (.) that:
#  1. contains "cmake" (case-&insensitive) in its path (wholename)
#  2. name is not CMakeLists.txt
find . -iwholename '*cmake*' -not -name CMakeLists.txt -delete

Assurez-vous également d'invoquer make clean(ou le générateur CMake que vous utilisez) avant cela.

:)

Vous pouvez utiliser quelque chose comme:

add_custom_target(clean-cmake-files
   COMMAND ${CMAKE_COMMAND} -P clean-all.cmake
)

// clean-all.cmake
set(cmake_generated ${CMAKE_BINARY_DIR}/CMakeCache.txt
                    ${CMAKE_BINARY_DIR}/cmake_install.cmake
                    ${CMAKE_BINARY_DIR}/Makefile
                    ${CMAKE_BINARY_DIR}/CMakeFiles
)

foreach(file ${cmake_generated})

  if (EXISTS ${file})
     file(REMOVE_RECURSE ${file})
  endif()

endforeach(file)

Je crée généralement une commande "make clean-all" en ajoutant un appel à "make clean" à l'exemple précédent:

add_custom_target(clean-all
   COMMAND ${CMAKE_BUILD_TOOL} clean
   COMMAND ${CMAKE_COMMAND} -P clean-all.cmake
)

N'essayez pas d'ajouter la cible "propre" comme dépendance:

add_custom_target(clean-all
   COMMAND ${CMAKE_COMMAND} -P clean-all.cmake
   DEPENDS clean
)

Parce que "nettoyer" n'est pas une vraie cible dans CMake et cela ne fonctionne pas.

De plus, vous ne devez pas utiliser ce "clean-cmake-files" comme dépendance de quoi que ce soit:

add_custom_target(clean-all
   COMMAND ${CMAKE_BUILD_TOOL} clean
   DEPENDS clean-cmake-files
)

Parce que, si vous faites cela, tous les fichiers CMake seront effacés avant la fin de tout nettoyer, et make vous enverra une erreur lors de la recherche "CMakeFiles / clean-all.dir / build.make". En conséquence, vous ne pouvez pas utiliser la commande clean-all avant "n'importe quoi" dans n'importe quel contexte:

add_custom_target(clean-all
   COMMAND ${CMAKE_BUILD_TOOL} clean
   COMMAND ${CMAKE_COMMAND} -P clean-all.cmake
)

Ça ne marche pas non plus.

Le simple fait de publier des rm CMakeCache.txtœuvres pour moi aussi.

C'est peut-être un peu dépassé, mais comme c'est le premier hit lorsque vous google cmake clean , j'ajouterai ceci:

Puisque vous pouvez démarrer une construction dans le répertoire de construction avec une cible spécifiée avec

cmake --build . --target xyz

vous pouvez bien sûr courir

cmake --build . --target clean

pour exécuter la cleancible dans les fichiers de génération générés.

Je suis d'accord que la construction hors source est la meilleure réponse. Mais pour les moments où vous devez simplement faire une construction en source, j'ai écrit un script Python disponible ici , qui:

1. Fonctionne "make clean"
2. Supprime des fichiers générés par CMake spécifiques dans le répertoire de niveau supérieur tels que CMakeCache.txt
3. Pour chaque sous-répertoire qui contient un répertoire CMakeFiles, il supprime CMakeFiles, Makefile, cmake_install.cmake.
4. Supprime tous les sous-répertoires vides.

Une solution que j'ai trouvée récemment consiste à combiner le concept de construction hors source avec un wrapper Makefile.

Dans mon fichier CMakeLists.txt de niveau supérieur, j'inclus les éléments suivants pour empêcher les builds en source:

if ( ${CMAKE_SOURCE_DIR} STREQUAL ${CMAKE_BINARY_DIR} )
    message( FATAL_ERROR "In-source builds not allowed. Please make a new directory (called a build directory) and run CMake from there. You may need to remove CMakeCache.txt." )
endif()

Ensuite, je crée un Makefile de niveau supérieur et j'inclus les éléments suivants:

# -----------------------------------------------------------------------------
# CMake project wrapper Makefile ----------------------------------------------
# -----------------------------------------------------------------------------

SHELL := /bin/bash
RM    := rm -rf
MKDIR := mkdir -p

all: ./build/Makefile
    @ $(MAKE) -C build

./build/Makefile:
    @  ($(MKDIR) build > /dev/null)
    @  (cd build > /dev/null 2>&1 && cmake ..)

distclean:
    @  ($(MKDIR) build > /dev/null)
    @  (cd build > /dev/null 2>&1 && cmake .. > /dev/null 2>&1)
    @- $(MAKE) --silent -C build clean || true
    @- $(RM) ./build/Makefile
    @- $(RM) ./build/src
    @- $(RM) ./build/test
    @- $(RM) ./build/CMake*
    @- $(RM) ./build/cmake.*
    @- $(RM) ./build/*.cmake
    @- $(RM) ./build/*.txt

ifeq ($(findstring distclean,$(MAKECMDGOALS)),)
    $(MAKECMDGOALS): ./build/Makefile
    @ $(MAKE) -C build $(MAKECMDGOALS)
endif

La cible par défaut allest appelée en tapant makeet appelle la cible./build/Makefile .

La première chose que la cible ./build/Makefilefait est de créer le buildrépertoire en utilisant $(MKDIR), qui est une variable pour mkdir -p. Le répertoire buildest l'endroit où nous effectuerons notre build out-of-source. Nous fournissons l'argument -ppour nous assurer que mkdircela ne nous crie pas pour essayer de créer un répertoire qui peut déjà exister.

La deuxième chose que la cible ./build/Makefilefait est de changer de répertoire en buildrépertoire et d'appeler cmake.

De retour à la allcible, nous invoquons $(MAKE) -C build, où se $(MAKE)trouve une variable Makefile générée automatiquement pour make. make -Cchange le répertoire avant de faire quoi que ce soit. Par conséquent, utiliser $(MAKE) -C buildéquivaut à faire cd build; make.

Pour résumer, appeler ce wrapper Makefile avec make allou makeéquivaut à faire:

mkdir build
cd build
cmake ..
make 

La cible distcleaninvoque cmake .., puis make -C build clean, et enfin, supprime tout le contenu du buildrépertoire. Je pense que c'est exactement ce que vous avez demandé dans votre question.

La dernière partie du Makefile évalue si la cible fournie par l'utilisateur est ou non distclean. Sinon, il changera de répertoire en buildavant de l'invoquer. C'est très puissant car l'utilisateur peut taper, par exemple make clean, et le Makefile le transformera en un équivalent de cd build; make clean.

En conclusion, ce wrapper Makefile, en combinaison avec une configuration CMake de construction hors source obligatoire, fait en sorte que l'utilisateur n'ait jamais à interagir avec la commande cmake. Cette solution fournit également une méthode élégante pour supprimer tous les fichiers de sortie CMake du buildrépertoire.

PS Dans le Makefile, nous utilisons le préfixe @pour supprimer la sortie d'une commande shell, et le préfixe @-pour ignorer les erreurs d'une commande shell. Lors de l'utilisation rmdans le cadre de la distcleancible, la commande retournera une erreur si les fichiers n'existent pas (ils peuvent avoir été supprimés déjà en utilisant la ligne de commande avec rm -rf build, ou ils n'ont jamais été générés en premier lieu). Cette erreur de retour forcera notre Makefile à quitter. Nous utilisons le préfixe @-pour éviter cela. Il est acceptable si un fichier a déjà été supprimé; nous voulons que notre Makefile continue et supprime le reste.

Une autre chose à noter: Ce Makefile ne peut pas fonctionner si vous utilisez un nombre variable de variables CMake pour construire votre projet, par exemple, cmake .. -DSOMEBUILDSUSETHIS:STRING="foo" -DSOMEOTHERBUILDSUSETHISTOO:STRING="bar". Ce Makefile suppose que vous appelez CMake de manière cohérente, soit en tapant, cmake ..soit en fournissant cmakeun nombre cohérent d'arguments (que vous pouvez inclure dans votre Makefile).

Enfin, le crédit là où le crédit est dû. Ce wrapper Makefile a été adapté du Makefile fourni par le modèle de projet d'application C ++ .

Bien sûr, les builds hors source sont la méthode incontournable pour les Makefiles Unix, mais si vous utilisez un autre générateur tel que Eclipse CDT, il préfère que vous construisiez en source. Dans ce cas, vous devrez purger les fichiers CMake manuellement. Essaye ça:

find . -name 'CMakeCache.txt' -o -name '*.cmake' -o -name 'Makefile' -o -name 'CMakeFiles' -exec rm -rf {} +

Ou si vous avez activé globstar avec shopt -s globstar, essayez plutôt cette approche moins dégoûtante:

rm -rf **/CMakeCache.txt **/*.cmake **/Makefile **/CMakeFiles

essayez d'utiliser: cmake --clean-first path-of-CMakeLists.txt-file -B output-dir

--clean-first: Construisez la cible propre d'abord, puis construisez.
(Pour nettoyer uniquement, utilisez --target clean.)

Dans le cas où vous transmettez des -Dparamètres à CMake lors de la génération des fichiers de build et que vous ne souhaitez pas supprimer l'intégralité du répertoire build /:

Supprimez simplement le répertoire CMakeFiles / dans votre répertoire de construction.

rm -rf CMakeFiles/
cmake --build .

Cela provoque CMake à réexécuter et les fichiers système de génération sont régénérés. Votre build commencera également à zéro.

Pour simplifier le nettoyage lors de l'utilisation de build "out of source" (c'est-à-dire que vous construisez dans le buildrépertoire), j'utilise le script suivant:

$ cat ~/bin/cmake-clean-build
#!/bin/bash

if [ -d ../build ]; then
    cd ..
    rm -rf build
    mkdir build
    cd build
else
    echo "build directory DOES NOT exist"
fi

Chaque fois que vous devez nettoyer, vous devez source ce script à partir du buildrépertoire:

. cmake-clean-build

Si vous avez des définitions personnalisées et que vous souhaitez les enregistrer avant le nettoyage, exécutez ce qui suit dans votre répertoire de génération:

sed -ne '/variable specified on the command line/{n;s/.*/-D \0 \\/;p}' CMakeCache.txt

Créez ensuite un nouveau répertoire de build (ou supprimez l'ancien répertoire de build et recréez-le) et enfin exécutez cmakeavec les arguments que vous obtiendrez avec le script ci-dessus.

Si vous courez

cmake .

il régénérera les fichiers CMake. Ce qui est nécessaire si vous ajoutez un nouveau fichier à un dossier source sélectionné par * .cc, par exemple.

Bien que ce ne soit pas un "nettoyage" en soi, il "nettoie" les fichiers CMake en régénérant les caches.

J'utilise le script shell suivant à de telles fins:

#!/bin/bash

for fld in $(find -name "CMakeLists.txt" -printf '%h ')
do
    for cmakefile in CMakeCache.txt cmake_install.cmake CTestTestfile.cmake CMakeFiles Makefile
    do
        rm -rfv $fld/$cmakefile
    done
done

Si vous utilisez Windows, utilisez Cygwin pour ce script.

C'est drôle de voir que cette question reçoit autant d'attentions et de solutions compliquées, ce qui montre en effet une douleur de ne pas avoir une méthode propre avec cmake.

Eh bien, vous pouvez certainement cd buildfaire votre travail, puis faire un rm -rf *quand vous avez besoin de nettoyer. Cependant, rm -rf *c'est une commande dangereuse étant donné que beaucoup de gens ne savent souvent pas dans quel répertoire ils se trouvent.

Si vous cd .., rm -rf buildet puis mkdir buildet puis cd build, c'est tout simplement trop de frappe.

Donc, une bonne solution est de rester en dehors du dossier de construction et de dire à cmake le chemin:
à configurer: cmake -B build
à construire: cmake --build build
à nettoyer: rm -rf build
à recréer le dossier de construction: vous n'avez même pas besoin de le mkdir buildconfigurer avec cmake -B buildet cmake le créera

cmakecuit principalement un Makefile, on pourrait ajouter rmà la PHONY propre .

Par exemple,

[root@localhost hello]# ls
CMakeCache.txt  CMakeFiles  cmake_install.cmake  CMakeLists.txt  hello  Makefile  test
[root@localhost hello]# vi Makefile
clean:
        $(MAKE) -f CMakeFiles/Makefile2 clean
        rm   -rf   *.o   *~   .depend   .*.cmd   *.mod    *.ko   *.mod.c   .tmp_versions *.symvers *.d *.markers *.order   CMakeFiles  cmake_install.cmake  CMakeCache.txt  Makefile

J'ai ceci dans mon fichier shell rc ( .bashrc, .zshrc):

t-cmake-clean() {
    local BUILD=$(basename $(pwd))
    cd ..
    rm -rf $BUILD
    mkdir $BUILD && cd $BUILD
}

Vous êtes censé l'utiliser uniquement pour les versions hors source. Disons que vous avez un répertoire nommé build/à cet effet. Ensuite, il vous suffit de courir t-cmake-cleanà l'intérieur.

J'ai utilisé la réponse de zsxwing avec succès pour résoudre le problème suivant:

J'ai une source que je construis sur plusieurs hôtes (sur une carte Linux Raspberry Pi, sur une machine virtuelle Linux VMware, etc.)

J'ai un script Bash qui crée des répertoires temporaires basés sur le nom d'hôte de la machine comme ceci:

# Get hostname to use as part of directory names
HOST_NAME=`uname -n`

# Create a temporary directory for cmake files so they don't
# end up all mixed up with the source.

TMP_DIR="cmake.tmp.$HOSTNAME"

if [ ! -e $TMP_DIR ] ; then
  echo "Creating directory for cmake tmp files : $TMP_DIR"
  mkdir $TMP_DIR
else
  echo "Reusing cmake tmp dir : $TMP_DIR"
fi

# Create makefiles with CMake
#
# Note: switch to the temporary dir and build parent 
#       which is a way of making cmake tmp files stay
#       out of the way.
#
# Note 2: to clean up cmake files, it is OK to
#        "rm -rf" the temporary directories

echo
echo Creating Makefiles with cmake ...

cd $TMP_DIR

cmake ..

# Run makefile (in temporary directory)

echo
echo Starting build ...

make

Créez un répertoire de construction temporaire, par exemple, build_cmake ,. Par conséquent, tous vos fichiers de construction seront dans ce dossier.

Ensuite, dans votre fichier CMake principal, ajoutez la commande ci-dessous.

add_custom_target(clean-all
    rm -rf *
)

Par conséquent, lors de la compilation,

cmake ..

Et pour nettoyer faire:

make clean-all