Why cmake is used

To avoid this, and to build a transparent project structure, we will extract the tests into a subproject. Let's add a directory called test and create a source file tests. Also, we need to provide this directory with its own CMakeLists. We can start filling it up by inserting a live template for Boost with libs. After reloading the changes in both CMakeLists. However, to be able to use the built-in test runner, let's create another configuration out of the Boost.

Test template:. Now we can run this configuration and get test results. Test runner shows the tree of tests in the suite, their output, status, and duration:. This chapter gives a simple example of how to use CTest , a framework for compiling and running tests as part of the CMake build process. Find general description of the framework in CTest support. Create a subdirectory inside test and call it ctest. The first line states the minimum supported version of CTest, which corresponds to the version of CMake, 3.

If we run this configuration, the results will be shown in the Test Runner window, similarly to other supported testing frameworks :. Note that makefiles will only run in parallel if you explicitly pass a number of threads, such as make -j2 , while Ninja will automatically run in parallel. You can directly pass a parallelization option such as -j 2 to the cmake --build. You set options in CMake with -D. You can see a list of options with -L , or a list with human-readable help with -LH.

Again, not really CMake, but if you are using a command line build tool like make , you can get verbose builds:. CMake has support for cached options. You can preset or change the value of a cached option on the command line with -D. When CMake looks for a cached variable, it will use the existing value and will not overwrite it. The --trace option will print every line of CMake that is run. Since this is very verbose, CMake 3. If you select the name of the file you are interested in debugging usually with a parent directory if you are debugging a CMakeLists.

Very useful! Question: Does cmake build build anything? This will configure create build system files. To build, you would add --build before the directory, or use your build tool, such as make. This is the simplest possible CMakeLists. Build and run the example code with a CMakeLists. Now you know how to compile a single file using three lines of CMake. But what happens if you have more than one file with dependencies? You need to be able to tell CMake about the structure of your project, and it will help you build it.

To do so, you will need targets. Target names must be unique and there is a way to set the executable name to something other than the target name if you really want to. You can make non-built libraries too. More on that later, once we see what we can do with targets. CMake goes into an old compatibility mode for this target that generally breaks things.

This depends on the header. See more commands here. You might be really exited by targets and are already planning out how you can describe your programs in terms of targets. These are called interface libraries in CMake and you would write:. The second situation is if you have a pre-built library that you want to use. ALIAS libraries, which simply rename some other library, are also allowed to have Most of the time you will get imported libraries from other places, and will not be making your own.

The difference comes down to two things:. The command to do so is:. Here we see the set command, which sets a variable, and the message command, which prints out a string. In a build, cached variables are set in the command line or in a graphical tool such as ccmake , cmake-gui , and then written to a file called CMakeCache. For our example, we will use CMake in script mode, and that will not write out a cache, which makes it easier to play with. Feel free to look back at the example you built in the last lesson and investigate the CMakeCache.

Things like the compiler location, as discovered or set on the first run, are cached. If you were to run cmake -L or cmake -LH , you would see all the cached variables and descriptions.

The normal set command only sets the cached variable if it is not already set - this allows you to override cached variables with -D. Since bool cached variables are so common for builds, there is a shortcut syntax for making one using option :. You can see a list of all properties by CMake version; there is no way to get this programmatically. You have seen targets; they have properties attached that control their behavior. So you can using set property on each target by setting a variable before making the targets.

There are several commands that help with string s, file s, [ lists ][], and the like. This is the reason poorly written CMake projects often have issues when you are trying to add files; some people are in the habit of rerunning cmake before every build because of this. To scan for kits:. The extension will automatically scan for kits on your computer and create a list of compilers found on your system.

Select the compiler you want to use. For example, depending on the compilers you have installed, you might see something like:. There are two things you must do to configure your CMake project: select a kit which you just did and select a variant. To change the kit, you can click on the kit in the Status bar, or run the CMake: Select a kit command again from the Command Palette.

If you don't see the compiler you're looking for, you can edit the cmake-tools-kits. A variant contains instructions for how to build your project. These options do the following:. Debug : disables optimizations and includes debug info. Release : Includes optimizations but no debug info. MinRelSize : Optimizes for size. No debug info. It means, that we can build projects which use CMake on all above platforms without additional platform-specific configurations.

No need to write Makefiles, configure Visual Studio projects, create custom Bash or batch files. Everything is handled by CMake. There is a clear separation between build host and build target. Of course case when host and target is the same is assumed by default. CMake is a build system generator meta build system , which means that it creates configuration files for other existing build systems.

List of available options is dependent on the build host, which is natural usually there is no need to generate Visual Studio projects on Linux. Below you can find a complete list as for publication date of all supported frameworks CMake is calling them generators :. Despite being OS-independent, CMake still gives you ability to execute custom host-specific shell commands or launch given application with the following commands:.

However, this is not a good practice because it makes our build system tightly coupled with the concrete platform which is in contrary to the purpose of CMake. In some cases we are forced to use some external projects from the remote location e. CMake has two integrated mechanisms for supporting that:. Cross-compilation building for platform other than you use for compilation has always scared me. A task nearly impossible to do manually in a cross-platform manner.

CMake has this ability built-in and requires very little effort to make it work for you. All you need to do is to provide the so called toolchain file. Below you can see an example toolchain file for arm-none-eabi-gcc toolchain arm-none-eabi-gcc. As you can see, this file only sets paths to several tools from the toolchain and sets common compilation flags specific for that compiler.

So you can either set it as a command line argument:. This is bad! This is an anti-pattern of software architecture. In order to get the includes from another library you had to know its internal structure to include the proper sets of paths. And what if that library is changed? You have to adjust every time. Since modern CMake 3. And the include paths are the property of the library. No need to write anything manually.

Also the internal structure of the library is completely hidden:.