How to copy directory from source tree to binary tree?

Question

Copying directory from source tree to binary tree. For example: How to copy www to bin folder.

work
├─bin
└─src
    ├─doing
    │  └─www
    ├─include
    └─lib

Thanks.

score 141 · Answer 1 · edited Aug 02 '16 at 16:06

141

Since version 2.8, the file command has a copy argument:

file(COPY yourDir DESTINATION yourDestination)

Note that:

Relative input paths are evaluated with respect to the current source directory, and a relative destination is evaluated with respect to the current build directory

edited Aug 02 '16 at 16:06

Antonio

18,335
12
89
190

answered Feb 01 '10 at 16:37

Chty

1,411
2
9
2

4

This looks promising. Can you explain how you get this to trigger, or does it run every time? – Drew Noakes Oct 30 '14 at 15:42
7

it only works when running cmake command, not during actual build time – kevin Aug 29 '18 at 07:20
What if I want to check whether the directory is already there in the destination? – Ahmed Hussein Dec 23 '18 at 15:35

score 45 · Accepted Answer · edited Dec 15 '19 at 19:48

45

With CMake 2.8, use the file(COPY ...) command.

With older CMake versions, this macro copies files from one directory to another. If you don't want to substitute variables in the copied files, then change the configure_file @ONLY argument (for example to COPYONLY).

# Copy files from source directory to destination directory, substituting any
# variables.  Create destination directory if it does not exist.

macro(configure_files srcDir destDir)
    message(STATUS "Configuring directory ${destDir}")
    make_directory(${destDir})

    file(GLOB templateFiles RELATIVE ${srcDir} ${srcDir}/*)
    foreach(templateFile ${templateFiles})
        set(srcTemplatePath ${srcDir}/${templateFile})
        if(NOT IS_DIRECTORY ${srcTemplatePath})
            message(STATUS "Configuring file ${templateFile}")
            configure_file(
                    ${srcTemplatePath}
                    ${destDir}/${templateFile}
                    @ONLY)
        endif(NOT IS_DIRECTORY ${srcTemplatePath})
    endforeach(templateFile)
endmacro(configure_files)

edited Dec 15 '19 at 19:48

Top-Master

5,262
5
23
45

answered Mar 30 '09 at 15:39

Chin Huang

11,862
4
43
44

It's easy to copy file or directory when use cmake -E mode. Thanks a lot – Jiang Bian Mar 31 '09 at 02:07
Edited because this is the accepted answer and the other answer with the file(COPY command is cleaner. – Chin Huang Jan 13 '12 at 17:12
4

Yeah, but can you run file(COPY...) as a custom command that depends on the target? – juzzlin Dec 09 '14 at 10:42
2

file(GLOB_RECURSE ..) for subdirectories – gringo Apr 10 '19 at 08:22

score 39 · Answer 3 · edited Feb 24 '20 at 13:31

39

As nobody has mentioned cmake -E copy_directory as a custom target, here's what I've used:

add_custom_target(copy-runtime-files ALL
    COMMAND ${CMAKE_COMMAND} -E copy_directory ${CMAKE_SOURCE_DIR}/runtime-files-dir ${CMAKE_BINARY_DIR}/runtime-files-dir
    DEPENDS ${MY_TARGET})

edited Feb 24 '20 at 13:31

rknuus

118
1
9

answered Dec 09 '14 at 10:50

juzzlin

41,671
5
31
42

Short and easy, great. If you drop `DEPENDS ${MY_TARGET}` this can run in parallel to the compiling process. Keep in mind that files are copied every time `make` is running, so it might have limitations with very big folders. – Simon Warta Feb 19 '15 at 15:11
I get `Expected a command name, got unquoted argument with text "/runtime-files-dir".` for this :( – Jan 24 '16 at 11:59
This is the preferred solution for me because it works with usage of $ – Captain GouLash Jun 19 '19 at 08:31

score 27 · Answer 4 · answered Jun 07 '09 at 21:11

The configure command will only copy files when cmake is run. Another option is to create a new target, and use the custom_command option. Here's one that I use (if you run it more than once, you'll have to modify the add_custom_target line to make it unique for each call).

macro(copy_files GLOBPAT DESTINATION)
  file(GLOB COPY_FILES
    RELATIVE ${CMAKE_CURRENT_SOURCE_DIR}
    ${GLOBPAT})
  add_custom_target(copy ALL
    COMMENT "Copying files: ${GLOBPAT}")

  foreach(FILENAME ${COPY_FILES})
    set(SRC "${CMAKE_CURRENT_SOURCE_DIR}/${FILENAME}")
    set(DST "${DESTINATION}/${FILENAME}")

    add_custom_command(
      TARGET copy
      COMMAND ${CMAKE_COMMAND} -E copy ${SRC} ${DST}
      )
  endforeach(FILENAME)
endmacro(copy_files)

I adapted your (amazing) answer to have a more modular script. See my answer ! — Salamandar, Feb 01 '17 at 16:38
Note that this (now ten years old!!) answer predates generator expressions in CMake, as well as the `copy_directory` command. — Seth Johnson, Jul 03 '19 at 14:00

score 16 · Answer 5 · edited Jul 26 '13 at 23:41

16

Use execute_process and call cmake -E. If you want a deep copy, you can use the copy_directory command. Even better, you could create a symlink (if your platform supports it) with the create_symlink command. The latter can be achieved like this:

execute_process(COMMAND ${CMAKE_COMMAND} -E create_symlink ${CMAKE_SOURCE_DIR}/path/to/www
                                                           ${CMAKE_BINARY_DIR}/path/to/www)

From: http://www.cmake.org/pipermail/cmake/2009-March/028299.html

edited Jul 26 '13 at 23:41

Bhushan

17,383
27
100
136

answered Mar 31 '09 at 01:58

Jiang Bian

1,913
3
16
14

3

The only issue with this is it breaks the concept of out-of-source builds if temp files are produced in the directory. – Jason Mock Sep 29 '11 at 18:09

score 2 · Answer 6 · answered Oct 08 '10 at 08:33

Thank! That is really helpful advice to use bunch of add_custom_target and add_custom_command. I wrote the following function to use everywhere in my projects. Is also specifies the installation rule. I use it primarily to export interface header files.

#
# export file: copy it to the build tree on every build invocation and add rule for installation
#
function    (cm_export_file FILE DEST)
  if    (NOT TARGET export-files)
    add_custom_target(export-files ALL COMMENT "Exporting files into build tree")
  endif (NOT TARGET export-files)
  get_filename_component(FILENAME "${FILE}" NAME)
  add_custom_command(TARGET export-files COMMAND ${CMAKE_COMMAND} -E copy_if_different "${CMAKE_CURRENT_SOURCE_DIR}/${FILE}" "${CMAKE_CURRENT_BINARY_DIR}/${DEST}/${FILENAME}")
  install(FILES "${FILE}" DESTINATION "${DEST}")
endfunction (cm_export_file)

Usage looks like this:

cm_export_file("API/someHeader0.hpp" "include/API/")
cm_export_file("API/someHeader1.hpp" "include/API/")

This looks interesting. Can it copy entire directories? – Drew Noakes Oct 30 '14 at 15:43 — Drew Noakes, Oct 30 '14 at 15:43

score 1 · Answer 7 · edited Mar 31 '21 at 08:09

Based on the answer from Seth Johnson; wrote for more convenience:

# Copy files
macro(resource_files files)
    foreach(file ${files})
        message(STATUS "Copying resource ${file}")
        file(COPY ${file} DESTINATION ${Work_Directory})
    endforeach()
endmacro()

# Copy directories
macro(resource_dirs dirs)
    foreach(dir ${dirs})
        # Replace / at the end of the path (copy dir content VS copy dir)
        string(REGEX REPLACE "/+$" "" dirclean "${dir}")
        message(STATUS "Copying resource ${dirclean}")
        file(COPY ${dirclean} DESTINATION ${Work_Directory})
    endforeach()
endmacro()

How to copy directory from source tree to binary tree?

7 Answers7

Linked

Related