Alla ricerca di un comando 'cmake clean' per cancellare l'output di CMake

Proprio come make cleancancella tutti i file prodotti da un makefile, vorrei fare lo stesso con CMake. Troppo spesso mi trovo a scorrere manualmente le directory rimozione di file come cmake_install.cmakee CMakeCache.txt, e le CMakeFilescartelle.

Esiste un comando come cmake cleanrimuovere automaticamente tutti questi file? Idealmente, questo dovrebbe seguire la struttura ricorsiva definita all'interno del CMakeLists.txtfile della directory corrente .

Non c'è cmake clean.

Di solito costruisco il progetto in una singola cartella come "build". Quindi, se voglio make clean, posso solo rm -rf build.

La cartella "build" nella stessa directory della radice "CMakeLists.txt" è in genere una buona scelta. Per costruire il tuo progetto, dai semplicemente a cmake la posizione di CMakeLists.txt come argomento. Ad esempio: cd <location-of-cmakelists>/build && cmake ... (Da @ComicSansMS)

La FAQ ufficiale di CMake afferma:

Alcuni alberi di compilazione creati con gli autotools GNU hanno un target "make distclean" che pulisce la build e rimuove anche Makefile e altre parti del sistema di build generato. CMake non genera un target "make distclean" poiché i file CMakeLists.txt possono eseguire script e comandi arbitrari; CMake non ha modo di tracciare esattamente quali file vengono generati durante l'esecuzione di CMake. Fornire un obiettivo distinto darebbe agli utenti la falsa impressione che funzionerebbe come previsto. (CMake genera un obiettivo "Rendi pulito" per rimuovere i file generati dal compilatore e dal linker.)

Un target "make distclean" è necessario solo se l'utente esegue una build in-source. CMake supporta build in-source, ma incoraggiamo fortemente gli utenti ad adottare il concetto di build out-of-source. L'uso di un albero di generazione separato dall'albero di origine impedirà a CMake di generare qualsiasi file nell'albero di origine. Poiché CMake non modifica l'albero dei sorgenti, non è necessario un target distclean. Si può iniziare una nuova build eliminando l'albero di build o creando un albero di build separato.

In questi giorni di Git ovunque, potresti dimenticare CMake e usarlo git clean -d -f -x, che rimuoverà tutti i file non sotto il controllo del codice sorgente.

L'ho cercato su Google per circa mezz'ora e l'unica cosa utile che mi è venuta in mente è stata invocare l' findutilità:

# 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

Inoltre, assicurati di invocare make clean(o qualunque sia il generatore CMake che stai utilizzando) prima di quello.

:)

Puoi usare qualcosa come:

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)

Di solito creo un comando "make clean-all" aggiungendo una chiamata a "make clean" nell'esempio precedente:

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

Non provare ad aggiungere il target "pulito" come dipendenza:

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

Perché "pulito" non è un vero obiettivo in CMake e questo non funziona.

Inoltre, non dovresti usare questo "clean-cmake-files" come dipendenza da qualsiasi cosa:

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

Perché, se lo fai, tutti i file CMake verranno cancellati prima del completamento di clean-all, e make ti genererà un errore nella ricerca di "CMakeFiles / clean-all.dir / build.make". Di conseguenza, non è possibile utilizzare il comando clean-all prima di "qualunque cosa" in qualsiasi contesto:

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

Neanche questo funziona.

La semplice emissione rm CMakeCache.txtfunziona anche per me.

Forse è un po 'datato, ma poiché questo è il primo successo quando vai su Google cmake clean, aggiungerò questo:

Dal momento che è possibile avviare una build nella directory build con una destinazione specificata con

cmake --build . --target xyz

puoi ovviamente correre

cmake --build . --target clean

per eseguire la cleandestinazione nei file di build generati.

Sono d'accordo che la build out-of-source è la risposta migliore. Ma per le volte in cui devi solo fare una build in-source, ho scritto uno script Python disponibile qui , che:

1. Esegue "rendere pulito"
2. Rimuove file specifici generati da CMake nella directory di livello superiore come CMakeCache.txt
3. Per ogni sottodirectory che contiene una directory CMakeFiles, rimuove CMakeFiles, Makefile, cmake_install.cmake.
4. Rimuove tutte le sottodirectory vuote.

Una soluzione che ho trovato di recente è quella di combinare il concetto di build out-of-source con un wrapper Makefile.

Nel mio file CMakeLists.txt di primo livello, includo quanto segue per prevenire build in-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()

Quindi, creo un Makefile di livello superiore e includo quanto segue:

# -----------------------------------------------------------------------------
# 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 destinazione predefinita allviene chiamata digitando makee invoca la destinazione ./build/Makefile.

La prima cosa che la destinazione ./build/Makefilefa è creare la builddirectory usando $(MKDIR), che è una variabile per mkdir -p. La directory buildè dove eseguiremo la nostra build out-of-source. Forniamo l'argomento -pper garantire che mkdirnon ci urli per aver cercato di creare una directory che potrebbe già esistere.

La seconda cosa che la destinazione ./build/Makefilefa è cambiare le directory nella builddirectory e invocare cmake.

Tornando al alltarget, invochiamo $(MAKE) -C build, dove $(MAKE)viene generata automaticamente una variabile Makefile make. make -Ccambia la directory prima di fare qualsiasi cosa. Pertanto, l'utilizzo $(MAKE) -C buildequivale a fare cd build; make.

Per riassumere, chiamare questo wrapper Makefile con make allo makeequivale a fare:

mkdir build
cd build
cmake ..
make 

Il target distcleaninvoca cmake .., quindi make -C build clean, e infine, rimuove tutto il contenuto dalla builddirectory. Credo che sia esattamente quello che hai richiesto nella tua domanda.

L'ultima parte del Makefile valuta se la destinazione fornita dall'utente è o meno distclean. In caso contrario, cambierà directory in buildprima di invocarlo. Questo è molto potente perché l'utente può digitare, per esempio make clean, e il Makefile lo trasformerà in un equivalente di cd build; make clean.

In conclusione, questo wrapper Makefile, in combinazione con una configurazione CMake build out-of-source obbligatoria, lo rende in modo che l'utente non debba mai interagire con il comando cmake. Questa soluzione fornisce anche un metodo elegante per rimuovere tutti i file di output di CMake dalla builddirectory.

PS Nel Makefile, usiamo il prefisso @per sopprimere l'output da un comando shell e il prefisso @-per ignorare gli errori da un comando shell. Quando viene utilizzato rmcome parte della distcleandestinazione, il comando restituirà un errore se i file non esistono (potrebbero essere stati eliminati già utilizzando la riga di comando con rm -rf build, o non sono mai stati generati in primo luogo). Questo errore di restituzione forzerà l'uscita del nostro Makefile. Usiamo il prefisso @-per impedirlo. È accettabile se un file è già stato rimosso; vogliamo che il nostro Makefile continui e rimuova il resto.

Un'altra cosa da notare: questo Makefile potrebbe non funzionare se si utilizza un numero variabile di variabili CMake per creare il proprio progetto, ad esempio cmake .. -DSOMEBUILDSUSETHIS:STRING="foo" -DSOMEOTHERBUILDSUSETHISTOO:STRING="bar". Questo Makefile presuppone che invochi CMake in modo coerente, digitando cmake ..o fornendo cmakeun numero coerente di argomenti (che puoi includere nel tuo Makefile).

Infine, credito dove è dovuto il credito. Questo wrapper Makefile è stato adattato dal Makefile fornito dal modello di progetto di applicazione C ++ .

Naturalmente, le build out-of-source sono il metodo di partenza per Unix Makefile, ma se si utilizza un altro generatore come Eclipse CDT, si preferisce creare in-source. In tal caso, dovrai eliminare manualmente i file CMake. Prova questo:

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

O se hai abilitato globstar con shopt -s globstar, prova invece questo approccio meno disgustoso:

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

prova ad usare: cmake --clean-first path-of-CMakeLists.txt-file -B output-dir

--clean-first: costruisci prima il bersaglio, poi costruisci.
(Per pulire solo, usare --target clean.)

Nel caso in cui si passino i -Dparametri in CMake durante la generazione dei file di build e non si desideri eliminare l'intera directory build /:

Basta eliminare la directory CMakeFiles / all'interno della directory di compilazione.

rm -rf CMakeFiles/
cmake --build .

Ciò provoca la riesecuzione di CMake e la rigenerazione dei file di sistema di compilazione. Anche la tua build inizierà da zero.

Per semplificare la pulizia quando si utilizza la build "out of source" (ovvero la compilazione nella builddirectory), utilizzo il seguente script:

$ 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

Ogni volta che devi ripulire, dovresti procurarti questo script dalla builddirectory:

. cmake-clean-build

Se si dispone di definizioni personalizzate e si desidera salvarle prima della pulizia, eseguire quanto segue nella directory di generazione:

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

Quindi crea una nuova directory di build (o rimuovi la vecchia directory di build e ricreala) ed infine esegui cmakecon gli argomenti che otterrai con lo script sopra.

Se corri

cmake .

rigenera i file CMake. Ciò è necessario se si aggiunge un nuovo file a una cartella di origine selezionata da * .cc, ad esempio.

Anche se questo non è un "clean" di per sé, "ripulisce" i file CMake rigenerando le cache.

Uso il seguente script di shell per tali scopi:

#!/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

Se si utilizza Windows, utilizzare Cygwin per questo script.

È divertente vedere che questa domanda ottiene così tante attenzioni e soluzioni complicate, il che in effetti mostra un dolore a non avere un metodo pulito con Cmake.

Bene, puoi sicuramente cd buildfare il tuo lavoro, quindi farlo rm -rf *quando devi pulirlo. Tuttavia, rm -rf *è un comando pericoloso dato che molte persone spesso non sono consapevoli della directory in cui si trovano.

Se tu cd .., rm -rf builde poi mkdir builde poi cd build, è semplicemente troppa digitazione.

Quindi una buona soluzione è quella di rimanere fuori dalla cartella build e dire a cmake il percorso:
configurare: cmake -B build
costruire: cmake --build build
pulire: rm -rf build
ricreare la cartella build: non è nemmeno necessario mkdir build, basta configurarlo con cmake -B builde cmake lo creerà

cmakeprincipalmente cucina a Makefile, si potrebbe aggiungere rmal PHONY pulito .

Per esempio,

[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

Ho questo nel mio file rc shell ( .bashrc, .zshrc):

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

Dovresti usarlo solo per build out-of-source. Supponiamo che tu abbia una directory chiamata build/per questo scopo. Quindi devi solo scappare t-cmake-cleanda esso.

Ho usato la risposta di zsxwing con successo per risolvere il seguente problema:

Ho una fonte che costruisco su più host (su una scheda Raspberry Pi Linux, su una macchina virtuale VMware Linux, ecc.)

Ho uno script Bash che crea directory temporanee basate sul nome host della macchina in questo modo:

# 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

Creare una directory di build temporanea, ad esempio build_cmake. Quindi tutti i tuoi file di build saranno all'interno di questa cartella.

Quindi nel tuo file CMake principale aggiungi il comando seguente.

add_custom_target(clean-all
    rm -rf *
)

Quindi durante la compilazione fare

cmake ..

E per pulire fai:

make clean-all