If you really do not want to modify the original project, you could write a new CMakeLists.txtincluding old and new sources. When you define a library, you can use it in an executable defined in the cmake (add_executable and target_link_libraries to see). Stefn Freyr Stefnsson stefan at ru.is Thu Oct 23 20:22:25 EDT 2008. to do >> so, in the cmakelists.txt file of prog2 project, i put: >> >> set (sources ../../prog1/src/file1.f90 >> src/file2.f90) >> and further >> add_executable (prog2 $ {sources}) >> >> when compiling with cmake i get the following error: >> >> ############################################## >> cmake error at cmakelists.txt:35 (add_executable): Second, you list the headers in your add_executable () or add_library () call. The cmakelist.txt of the subdirectory is as follows: # Find all source files in the current directory # And save the name to the Dir_Lib_SRCS variable aux_source_directory (. Search for jobs related to Cmake multiple source directories or hire on the world's largest freelancing marketplace with 20m+ jobs. aux_source_directory (<dir> <variable>) Collects the names of all the source files in the specified directory and stores the list in the <variable> provided. The REUSE_FROM method promotes an arbitrary target as something other targets depend on. C) it seems you can call cmake --target target to generate the Makefile for only one of the target of your cmakelists.txt file. Heading those C++ include directories is easy with CMake. For the most part, the executables being built for the different architectures have separate code, build dirs, and CMakeLists.txt files, because the processes running on the different archs do completely separate things (think a multi-component system made up of RTOS devices, beefier "cortex" boards, etc). Previous message: [CMake] Can't find libstdc++ on RHEL Linux 5. If you don't want to compile Config.cpp as often as you have moduleX, then I suggest to create a static library inside common that each app links against. B) see target_include_directories. I'd rather just reference the > source in the parent . I noticed that inheriting an INTERFACE library as per the docs will create multiple PCH files, one for each target with identical content. Since the directory structure in your project is just there to keep your files organized, one approach is to have a CMakeLists.txt that automatically finds all sources files in the src directory and also adds all directories as include directories that have a header file in them. That way, you can control the version of the dependencies explicitly, but still upgrade easily. [CMake] Multiple source directories. Any non-trivial project will use separate source files to encapsulate different functional areas of the system. As an example, if your project's sources are in src, and you need headers from include, you could do it like this: With CMake, adding header include directories to your C++ project is as easy as using your head in football! How to create Cmake file for a project with multiple source files. target_include_directories(): To tell CMake that the project directory tree contains headers.In this way, we can have headers from different directories added to each other with a relative path to the project directory. At this time, cmakelists Txt can be changed to the following . cmake_minimum_required (VERSION 3.17) project (zc_dec C) set (CMAKE_C_STANDARD 11) set (CMAKE_C_FLAGS_RELEASE "-O3 -DNDEBUG") include . Next message: [CMake] Multiple source directories. DIR_LIB_SRCS) # Generate link library add_library (MathFunctions $ {DIR_LIB_SRCS}) Use the command add_library in this file to compile the source file in the src directory . I have a whole bunch of unit tests that share the headers of Google Test and a bunch of common includes. Multiple source files in the same directory. This means the code either has to be compiled into app like shown above. target_sources(): to add the source in the currrent directory, app.cpp, to app target. As you are probably aware, you can include other source files in C++ with the #include pre-processor directive. This command is intended to be used by projects that use explicit template instantiation. Messages sorted by: Joe Cotellese wrote: > I am trying to build a library which has sources in two directories. One trick is define new sources in /Project/src/CMakeLists.txt, then include them in /Project/src/OriginalSource/CMakeLists.txt: set(NEW_INCS ${CMAKE_SOURCE_DIR)/NewSource) The command will apply only to targets created after it is called. At this moment, the Cmake file looks something like this. cmake Getting started with cmake "Hello World" with multiple source files Example # First we can specify the directories of header files by include_directories (), then we need to specify the corresponding source files of the target executable by add_executable (), and be sure there's exactly one main () function in the source files. Or app has to link against a library that provides the code. So far, our example project has just used a single main.cpp source file, although the supporting GitHub projects use multiple source files to build a usable ELF image.. From the previous blog, you may remember that, for our build, we use a separate toolchain . I am working on a project which consists for over 50 source and header files each. Template instantiation files can be stored in a Templates subdirectory and collected automatically . Many targets, same PCH. Another (arguably better for big code bases) variant is to use a separate CMakeLists.txt for each sub-directory where you isolate adding sources of the directory to a target using target_sources and maybe some particular configuration settings \ include conditions for those sources: target_sources ( SomeExeOrLib PRIVATE source1.h source1.cpp ) A) You can do 1 CMakeLists.txt for N projects. 1. This means no runtime-dependency on that library, but . To add this folder to your CMake path: set(CMAKE_MODULE_PATH "$ {PROJECT_SOURCE_DIR}/cmake" $ {CMAKE_MODULE_PATH}) Your extern folder should contain git submodules almost exclusively. Relative paths given to this command are interpreted as relative to the current source directory, see CMP0015. demo2/ CMakeLists.txt main.cpp myMath.cpp myMath.h. For more information on the scope, check out this section on target_include_directories in CMake. Essentially, whatever file we include in that statement gets copied . I don't want to create > libraries for both common and prjsrc. New in version 3.13: The directories are added to the LINK_DIRECTORIES directory property for the current CMakeLists.txt file, converting relative paths to absolute as . The following CMake file may serve as a starting point: Another (arguably better for big code bases) variant is to use a separate CMakeLists.txt for each sub-directory where you isolate adding sources of the directory to a target using target_sources and maybe some particular configuration settings \ include conditions for those sources: target_sources( SomeExeOrLib PRIVATE source1.h source1.cpp ) Now write the add function to mymath In the source file of CPP, put the declaration in mymath H source file. Brief Issue Summary. Undoubtedly, as your project grows in size, you will create libraries to modularise your codebase a little bit better. The > structure is as follows > > >prj > >----common > >----prjsrc > > I'm creating a top level CMakeList file in prj. --target SomeLibrary Scanning dependencies of target SomeLibrary [ 50%] Building CXX object libraries/SomeLibrary . It's problematic from an both logical . Aside from just going to the library folder and running CMake from there, you can actually do it from the project root - by setting --target option on build: $ rm -r ./* && cmake -DCMAKE_BUILD_TYPE=Debug .. $ cmake --build . Managing Source Files. See the Testing chapter for an example of adding a submodule. My question is what is > the best way to structure my CMakeList file. It's free to sign up and bid on jobs. Good Practices And Notes On Adding CMake Libraries With add_library. I maintain a repo in which there are multiple target architectures. First, you use include_directories () to tell CMake to add the directory as -I to the compilation command line. add_executable(): is to define app target. CMake has only a single source file.