Procurando por um comando 'cmake clean' para limpar a saída do CMake

Assim como make cleanexclui todos os arquivos que um makefile produziu, eu gostaria de fazer o mesmo com o CMake. Com demasiada frequência, eu me pego examinando manualmente diretórios, removendo arquivos como cmake_install.cmakee CMakeCache.txt, e as CMakeFilespastas.

Existe um comando como cmake cleanremover todos esses arquivos automaticamente? Idealmente, isso deve seguir a estrutura recursiva definida no CMakeLists.txtarquivo do diretório atual .

Não existe cmake clean.

Normalmente, construo o projeto em uma única pasta como "build". Então, se eu quiser make clean, posso apenas rm -rf build.

A pasta "build" no mesmo diretório da raiz "CMakeLists.txt" é geralmente uma boa opção. Para criar seu projeto, basta fornecer ao cmake a localização do CMakeLists.txt como argumento. Por exemplo: cd <location-of-cmakelists>/build && cmake ... (De @ComicSansMS)

O FAQ oficial do CMake declara:

Algumas árvores de construção criadas com as ferramentas automáticas do GNU têm um destino "make distclean" que limpa a construção e também remove Makefiles e outras partes do sistema de construção gerado. O CMake não gera um destino "make distclean" porque os arquivos CMakeLists.txt podem executar scripts e comandos arbitrários; O CMake não tem como rastrear exatamente quais arquivos são gerados como parte da execução do CMake. O fornecimento de um destino distinto daria aos usuários a falsa impressão de que funcionaria conforme o esperado. (O CMake gera um destino "limpar" para remover os arquivos gerados pelo compilador e vinculador.)

Um destino "make distclean" é necessário apenas se o usuário executar uma compilação na fonte. O CMake suporta compilações na fonte, mas recomendamos fortemente que os usuários adotem a noção de compilação fora da fonte. O uso de uma árvore de compilação separada da árvore de origem impedirá o CMake de gerar arquivos na árvore de origem. Como o CMake não altera a árvore de origem, não há necessidade de um destino distclean. Pode-se iniciar uma nova construção excluindo a árvore de construção ou criando uma árvore de construção separada.

Nestes dias do Git em todos os lugares, você pode esquecer o CMake e o uso git clean -d -f -x, que removerá todos os arquivos que não estão sob controle de origem.

Pesquisei no Google por meia hora e a única coisa útil que surgiu foi invocar o findutilitário:

# 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

Além disso, não se esqueça de invocar make clean(ou qualquer outro gerador de CMake que você esteja usando) antes disso.

:)

Você pode usar algo como:

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)

Normalmente, crio um comando "make clean-all" adicionando uma chamada para "make clean" no exemplo anterior:

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

Não tente adicionar o destino "limpo" como uma dependência:

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

Porque "limpo" não é um alvo real no CMake e isso não funciona.

Além disso, você não deve usar esses "arquivos de limpeza limpa" como dependência de qualquer coisa:

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

Porque, se você fizer isso, todos os arquivos do CMake serão apagados antes da limpeza completa, e o make exibirá um erro ao pesquisar "CMakeFiles / clean-all.dir / build.make". Consequentemente, você não pode usar o comando limpar tudo antes de "qualquer coisa" em qualquer contexto:

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

Isso também não funciona.

Simplesmente emitir rm CMakeCache.txtobras para mim também.

Talvez esteja um pouco desatualizado, mas como esse é o primeiro hit quando você pesquisa no Google cmake clean, adicionarei isso:

Como você pode iniciar uma construção no diretório de construção com um destino especificado com

cmake --build . --target xyz

você pode, é claro, correr

cmake --build . --target clean

para executar o cleandestino nos arquivos de construção gerados.

Concordo que a compilação fora da fonte é a melhor resposta. Mas para os momentos em que você apenas precisa fazer uma compilação na fonte, escrevi um script Python disponível aqui , que:

1. Executa "make clean"
2. Remove arquivos específicos gerados pelo CMake no diretório de nível superior, como CMakeCache.txt
3. Para cada subdiretório que contém um diretório CMakeFiles, ele remove CMakeFiles, Makefile, cmake_install.cmake.
4. Remove todos os subdiretórios vazios.

Uma solução que encontrei recentemente é combinar o conceito de compilação fora da fonte com um wrapper Makefile.

No meu arquivo CMakeLists.txt de nível superior, incluo o seguinte para evitar compilações na fonte:

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()

Em seguida, crio um Makefile de nível superior e incluo o seguinte:

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

O destino padrão allé chamado digitando makee chama o destino./build/Makefile .

A primeira coisa que o destino ./build/Makefilefaz é criar o builddiretório usando $(MKDIR), que é uma variável mkdir -p. O diretório buildé onde executaremos nossa compilação fora da fonte. Nós fornecemos o argumento -ppara garantir que mkdirnão nos grite por tentar criar um diretório que já possa existir.

A segunda coisa que o destino ./build/Makefilefaz é alterar os diretórios para o builddiretório e invocar cmake.

De volta ao alldestino, chamamos $(MAKE) -C build, onde $(MAKE)é uma variável Makefile gerada automaticamente make. make -Caltera o diretório antes de fazer qualquer coisa. Portanto, usar $(MAKE) -C buildé equivalente a fazer cd build; make.

Para resumir, chamar esse wrapper Makefile com make allou makeé equivalente a:

mkdir build
cd build
cmake ..
make 

O destino distcleanchama cmake ..e make -C build clean, por fim, remove todo o conteúdo do builddiretório. Acredito que isso é exatamente o que você solicitou na sua pergunta.

A última parte do Makefile avalia se o destino fornecido pelo usuário é ou não distclean. Caso contrário, ele mudará os diretórios para buildantes de invocá-lo. Isso é muito poderoso, porque o usuário pode digitar, por exemplo make clean, eo Makefile transformará isso em um equivalente a cd build; make clean.

Concluindo, esse wrapper Makefile, em combinação com uma configuração obrigatória de CMake de compilação de origem, faz com que o usuário nunca precise interagir com o comando cmake. Essa solução também fornece um método elegante para remover todos os arquivos de saída do CMake do builddiretório.

PS No Makefile, usamos o prefixo @para suprimir a saída de um comando shell, e o prefixo @-para ignorar erros de um comando shell. Ao usarrm como parte do distcleandestino, o comando retornará um erro se os arquivos não existirem (eles podem já ter sido excluídos usando a linha de comando rm -rf buildou nunca foram gerados). Este erro de retorno forçará nosso Makefile a sair. Usamos o prefixo @-para impedir isso. É aceitável se um arquivo já tiver sido removido; queremos que o nosso Makefile continue e remova o resto.

Outro ponto a ser observado: esse Makefile pode não funcionar se você usar um número variável de variáveis ​​do CMake para criar seu projeto, por exemplo, cmake .. -DSOMEBUILDSUSETHIS:STRING="foo" -DSOMEOTHERBUILDSUSETHISTOO:STRING="bar" . Esse Makefile pressupõe que você invoque o CMake de maneira consistente, digitando cmake ..ou fornecendo cmakeum número consistente de argumentos (que você pode incluir no Makefile).

Finalmente, credite onde o crédito é devido. Esse wrapper Makefile foi adaptado do Makefile fornecido pelo C ++ Application Project Template .

Obviamente, as compilações fora da fonte são o método obrigatório para Makefiles do Unix, mas se você estiver usando outro gerador como o Eclipse CDT, ele prefere que você construa na fonte. Nesse caso, você precisará limpar os arquivos do CMake manualmente. Tente o seguinte:

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

Ou, se você ativou a globstar shopt -s globstar, tente esta abordagem menos repugnante:

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

tente usar: cmake --clean-first path-of-CMakeLists.txt-file -B output-dir

--clean-first: constrói o destino limpo primeiro e depois constrói.
(Para limpar apenas, use --target clean.)

No caso em que você passa -D parâmetros para o CMake ao gerar os arquivos de compilação e não deseja excluir o diretório / compilação inteiro:

Simplesmente exclua o diretório CMakeFiles / dentro do diretório de compilação.

rm -rf CMakeFiles/
cmake --build .

Isso faz com que o CMake seja executado novamente e os arquivos do sistema de compilação são regenerados. Sua compilação também começará do zero.

Para simplificar a limpeza ao usar a compilação "fora da fonte" (ou seja, você compila no builddiretório), eu uso o seguinte 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

Toda vez que você precisar limpar, você deve obter este script no builddiretório:

. cmake-clean-build

Se você possui definições personalizadas e deseja salvá-las antes da limpeza, execute o seguinte no diretório de construção:

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

Em seguida, crie um novo diretório de construção (ou remova o diretório de construção antigo e recriá-lo) e, finalmente, execute cmakeos argumentos que você obterá com o script acima.

Se você correr

cmake .

ele irá regenerar os arquivos do CMake. Isso é necessário se você adicionar um novo arquivo a uma pasta de origem selecionada por * .cc, por exemplo.

Embora isso não seja "limpo", ele "limpa" os arquivos do CMake, regenerando os caches.

Eu uso o seguinte script de shell para tais propósitos:

#!/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 você estiver usando o Windows, use o Cygwin para este script.

É engraçado ver que essa pergunta recebe muitas atenções e soluções complicadas, o que realmente mostra uma dor por não ter um método limpo com o cmake.

Bem, você pode definitivamente cd buildfazer o seu trabalho e depois fazer rm -rf *a limpeza. No entanto, rm -rf *é um comando perigoso, pois muitas pessoas geralmente não sabem em que diretório estão.

Se você cd .., de rm -rf buildvez em mkdir buildquando cd build, é muita digitação.

Portanto, uma boa solução é ficar de fora da pasta de compilação e dizer ao cmake o caminho:
para configurar: cmake -B build
para compilar: cmake --build build
para limpar: rm -rf build
para recriar a pasta de compilação: você nem precisa mkdir build, basta configurá-lo com o cmake -B buildcmake

cmakecozinha principalmente a Makefile, pode-se adicionar rmao PHONY limpo .

Por exemplo,

[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

Eu tenho isso no meu arquivo shell rc ( .bashrc, .zshrc):

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

Você deve usá-lo apenas para compilações fora da fonte. Digamos que você tenha um diretório nomeado build/para esse fim. Então você só precisa correr t-cmake-cleande dentro dele.

Eu usei a resposta de zsxwing com sucesso para resolver o seguinte problema:

Tenho uma fonte que construo em vários hosts (em uma placa Raspberry Pi Linux, em uma máquina virtual VMware Linux etc.)

Eu tenho um script Bash que cria diretórios temporários com base no nome do host da máquina como este:

# 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

Crie um diretório de construção temporário, por exemplo, build_cmake ,. Portanto, todos os seus arquivos de compilação estarão dentro desta pasta.

Em seguida, no seu arquivo principal do CMake, adicione o comando abaixo.

add_custom_target(clean-all
    rm -rf *
)

Portanto, durante a compilação, faça

cmake ..

E para limpar faça:

make clean-all