Cmake System Error Read Only File System

CMake Tutorial

"A macro shot of a Macbook Pro screen with a few dozen lines of code" by Luca Bravo on Unsplash

I accept read numerous documentations and tutorials to understand CMake and its the most oftentimes used methods to implement and design a solid build procedure. I hope this article helps other people who is learning most CMake.

Introduction

CMake is an extensible, open-source system that manages the build procedure in an operating organization and in a compiler-contained mode.

Different many cross-platform systems, CMake is designed to be used in conjunction with the native build environment. Uncomplicated configuration files placed in each source directory (called CMakeLists.txt files) are used to generate standard build files (east.k., Makefiles on Unix and projects/workspaces in Windows MSVC) which are used in the usual way.

CMake can generate a native build environment that volition compile source code, create libraries, generate wrappers and build executable binaries in arbitrary combinations. CMake supports in-place and out-of-place builds, and can therefore support multiple builds from a single source tree.

CMake has supports for static and dynamic library builds. Some other nice characteristic of CMake is that it can generates a cache file that is designed to be used with a graphical editor. For instance, while CMake is running, information technology locates include files, libraries, and executables, and may come across optional build directives. This information is gathered into the cache, which may be changed by the user prior to the generation of the native build files.

CMake scripts besides brand source direction easier because information technology simplifies build script into one file and more than organized, readable format.

Popular Open Source Project with CMake

Hither is a list of popular open source projects using CMake for build purposes:

• OpenCV: https://github.com/opencv/opencv
• Caffe2: https://github.com/caffe2/caffe2
• MySql Server: https://github.com/mysql/mysql-server

See Wikipedia for a longer listing https://en.wikipedia.org/wiki/CMake#Applications_that_use_CMake

It is ever a good practice to read open up source projects, which are widely used to larn almost the best practices.

CMake as a Scripting Language

Photo by Markus Spiske on Unsplash

CMake intended to be a cross-platform build process director then it defines information technology is own scripting language with sure syntax and built-in features. CMake itself is a software plan, so it should be invoked with the script file to interpret and generate actual build file.

A developer can write either simple or circuitous building scripts using CMake linguistic communication for the projects.

Build logic and definitions with CMake language is written either in CMakeLists.txt or a file ends with <project_name>.cmake. But as a all-time practice, main script is named as CMakeLists.txt instead of cmake.

• CMakeLists.txt file is placed at the source of the projection you want to build.
• CMakeLists.txt is placed at the root of the source tree of any application, library it will work for.
• If there are multiple modules, and each module can exist compiled and built separately, CMakeLists.txt can be inserted into the sub folder.
• .cmake files can be used as scripts, which runs cmake command to gear up environment pre-processing or split tasks which tin be written outside of CMakeLists.txt.
• .cmake files tin also define modules for projects. These projects can exist separated build processes for libraries or extra methods for circuitous, multi-module projects.

Writing Makefiles might be harder than writing CMake scripts. CMake scripts past syntax and logic have similarity to high level languages and then information technology makes easier for developers to create their cmake scripts with less effort and without getting lost in Makefiles.

CMake Commands

Photo by Hannah Joshua on Unsplash

CMake commands are similar to C++/Coffee methods or functions, which take parameters every bit a list and perform sure tasks accordingly.

CMake commands are instance insensitive. There are built-in commands, which can be establish from cmake documentation: https://cmake.org/cmake/help/latest/manual/cmake-commands.7.html

Some normally used commands

• message: prints given message
• cmake_minimum_required: sets minimum version of cmake to exist used
• add_executable: adds executable target with given name
• add_library: adds a library target to be build from listed source files
• add_subdirectory: adds a subdirectory to build

There are also commands to enable developers write out conditional statements, loops, iterate on list, assignments:

• if, endif
• elif, endif
• while, endwhile
• foreach, endforeach
• list
• return
• set_property (assign value to variable.)

Indentation is not mandatory but suggested while writing CMake scripts. CMake doesn't use ';' to understand stop of statement.

All provisional statements should be concluded with its corresponding end command (endif , endwhile , endforeachetc)

All these properties of CMake help developers to programme circuitous build processes including multiple modules, libraries and platforms.

For instance, KDE has its own CMake manner guideline as in following URL:

• https://community.kde.org/Policies/CMake_Coding_Style

CMake Surroundings Variables

Photograph by lucas Favre on Unsplash

Surroundings variables are used to configure compiler flags, linker flags, test configurations for a regular build process. Compiler accept to be guided to search for given directories for libraries.

A detailed list of environment variables tin be seen from post-obit URL:

• https://cmake.org/cmake/assist/latest/manual/cmake-env-variables.vii.html

Some of the environment variables are overriden by predefined CMake Variables. e.g. CXXFLAGS is overriden when CMAKE_CXX_FLAGS is defined.

Below is an example use example, when y'all desire to enable all warnings during compile procedure, you lot may write -Wall to build command. If you are building your lawmaking with CMake, you tin add -Wall flag with using set control.

          ready(CMAKE_CXX_FLAGS "-Wall")
# append flag, all-time practise, suggested, don't lose previously defined flags
set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Wall")        

CMake Variables

CMake includes predefined variables which are set past default as location of source tree and organisation components.

Variables are case-sensitive, not like commands. You tin only use blastoff numeric chars and underscore, dash (_, -) in definition of variable.

You can find more than details about CMake variables in the post-obit URLs

• https://cmake.org/cmake/assist/v3.0/manual/cmake-language.seven.html#variables
• https://cmake.org/cmake/help/v3.0/transmission/cmake-variables.7.html#manual:cmake-variables(7)

Some of the variables can be seen as below, these are predefined co-ordinate to root binder:

• CMAKE_BINARY_DIR: Full path to height level of build tree and binary output binder, by default it is defined as top level of build tree.
• CMAKE_HOME_DIRECTORY: Path to acme of source tree
• CMAKE_SOURCE_DIR: Full path to top level of source tree.
• CMAKE_INCLUDE_PATH: Path used to find file, path

Variable values can be accessed with ${<variable_name>}.

          message("CXX Standard: ${CMAKE_CXX_STANDARD}")
set(CMAKE_CXX_STANDARD 14)        

Simply like above variables, yous can ascertain your own variables. You lot tin can call ready control to set a value to a new variable or change value of existing variable like below:

          set(TRIAL_VARIABLE "VALUE")
message("${TRIAL_VARIABLE}")        

CMake Lists

Photo by Kelly Sikkema on Unsplash

All values in CMake are stored as string but a string can exist treated as list in certain context.

A listing of elements represented as a string past concatenating elements separated past semi-cavalcade ';'.

          set(files a.txt b.txt c.txt)
# sets files to "a.txt;b.txt;c.txt"        

In order to access the listing of values you can use foreach command of CMake as post-obit:

          foreach(file ${files})
            message("Filename: ${file}")
endforeach()        

CMake Generator Expressions

Generator expressions are evaluated during build system generation to produce information specific to each build configuration.

Generator expressions are allowed in the context of many target properties, such as LINK_LIBRARIES, INCLUDE_DIRECTORIES, COMPILE_DEFINITIONS and others. They may also be used when using commands to populate those backdrop, such as target_link_libraries(), target_include_directories(), target_compile_definitions() and others.

https://cmake.org/cmake/help/v3.3/transmission/cmake-generator-expressions.7.html

Offset Building C++ Code with CMake

Photo past Oscar Nord on Unsplash

In previous sections, we have covered the core principles of writing CMake scripts. Now, we can go on to write bodily scripts to start building C++ code.

We tin can only showtime with a bones "Hello World!" example with CMake so we wrote the following "Hello CMake!" the principal.cpp file as following:

          #include <iostream>
int main() {
            std::cout<<"Hello CMake!"<<std::endl;
}        

Our purpose is to generate a binary to print "Hello CMake!".

If there is no CMake we tin can run compiler to generate us a target basically with but following commands.

          $ g++ primary.cpp -o cmake_hello        

CMake helps to generate fustigate commands with the instructions you gave, for this simple project nosotros can just use a simple CMakeLists.txt which creates Makefile for you lot to build binary.

It is obvious that, for such a small projection information technology is redundant to utilise CMake but when things go complicated it will help a lot.

In order to build main.cpp, using add_executable would exist enough, however, allow's continue things in order and write it with proper project name and cmake version requirement as beneath:

          cmake_minimum_required(VERSION 3.ix.ane)          project(CMakeHello)          add_executable(cmake_hello main.cpp)        

When the script ready, you can run cmake command to generate Makefile/s for the project.

You volition notice that, cmake is identifying compiler versions and configurations with default data.

          $ cmake CMakeLists.txt
-- The C compiler identification is AppleClang 9.0.0.9000039
-- The CXX compiler identification is AppleClang 9.0.0.9000039
-- Check for working C compiler: /Applications/Xcode.app/Contents/Developer/Toolchains/XcodeDefault.xctoolchain/usr/bin/cc
-- Check for working C compiler: /Applications/Xcode.app/Contents/Developer/Toolchains/XcodeDefault.xctoolchain/usr/bin/cc -- works
-- Detecting C compiler ABI info
-- Detecting C compiler ABI info - done
-- Detecting C compile features
-- Detecting C compile features - done
-- Check for working CXX compiler: /Applications/Xcode.app/Contents/Developer/Toolchains/XcodeDefault.xctoolchain/usr/bin/c++
-- Check for working CXX compiler: /Applications/Xcode.app/Contents/Programmer/Toolchains/XcodeDefault.xctoolchain/usr/bin/c++ -- works
-- Detecting CXX compiler ABI info
-- Detecting CXX compiler ABI info - done
-- Detecting CXX compile features
-- Detecting CXX compile features - done
-- Configuring done
-- Generating done
-- Build files have been written to: /Users/User/Projects/CMakeTutorial        

When cmake finishes its job, Makefile will be generated together with CMakeCache.txt and some other artefects virtually build configuration. You can run make command to build projection.

          $ make all
#or
$ make cmake_hello        

Let's brand things little more complicated.

What if your code is depended on C++14 or later. If y'all look for C++fourteen specifications, you see that, return type deduction has been introduced with C++14, lets add a new method to our main.cpp with automobile return blazon every bit below.

          #include <iostream>          auto sum(int a, int b){
            render a + b;
}          int main() {
            std::cout<<"Hi CMake!"<<std::endl;
            std::cout<<"Sum of 3 + 4 :"<<sum(3, iv)<<std::endl;
            return 0;
}        

If yous try to build higher up code with default settings, you could get an fault about auto return type because most hosts configured to work C++99 config past default. Therefore you lot should indicate your compiler to build with C++14 with setting CMAKE_CXX_STANDARD variable to 14. If y'all want to add C++14 on command line, you can gear up -std=c++14.

CMake generates Makefile with defaults settings which is mostly lower than C++14, so y'all should add together 14 flag as seen below.

          cmake_minimum_required(VERSION iii.9.1)          project(CMakeHello)          set(CMAKE_CXX_STANDARD 14)          add_executable(cmake_hello main.cpp)        

At present, you should exist able to build it correctly. (cmake command would work even though you didn't add together xiv standard simply make command would return error.)

CMake eases building process for you; particularly when you do cross compile to make sure you lot are working with correct version of compiler with right configurations, this will enable multiple developers to use same edifice configurations across all machines including build server and developer PC.

What if, y'all want to build for multiple platforms:

• generate executables for Windows, Mac and Linux separetely.
• add dissimilar macros for Linux Kernel version afterwards than X.

Following variables can exist used to cheque for arrangement related information: Pasted from: https://cmake.org/Wiki/CMake_Checking_Platform

• CMAKE_SYSTEM
  the complete organisation proper noun, e.g. "Linux-two.iv.22", "FreeBSD-5.4-RELEASE" or "Windows 5.1"
• CMAKE_SYSTEM_NAME
  The proper noun of the system targeted by the build. The iii common values are Windows, Darwin, and Linux, though several others be, such as Android, FreeBSD, and CrayLinuxEnvironment. Platforms without an operating system, such as embedded devices, are given Generic as a system name.
• CMAKE_SYSTEM_VERSION
  Version of the operating system. Mostly the kernel version.
• CMAKE_SYSTEM_PROCESSOR
  the processor name (e.g. "Intel(R) Pentium(R) M processor 2.00GHz")
• CMAKE_HOST_SYSTEM_NAME
  The name of the system hosting the build. Has the same possible values as CMAKE_SYSTEM_NAME.

Let'south cheque if build system is Unix or Windows.

          cmake_minimum_required(VERSION iii.9.1)          projection(CMakeHello)          gear up(CMAKE_CXX_STANDARD xiv)          # UNIX, WIN32, WINRT, CYGWIN, Apple tree are surroundings variables as flags set past default system
if(UNIX)
            message("This is a ${CMAKE_SYSTEM_NAME} organisation")
elseif(WIN32)
            message("This is a Windows Arrangement")
endif()          # or employ MATCHES to see if actual system proper noun            
# Darwin is Apple tree's organisation name
if(${CMAKE_SYSTEM_NAME} MATCHES Darwin)
            message("This is a ${CMAKE_SYSTEM_NAME} system")
elseif(${CMAKE_SYSTEM_NAME} MATCHES Windows)
            message("This is a Windows System")
endif()          add_executable(cmake_hello main.cpp)        

System information checks your build system other than building correct binary, like using macros. Yous tin ascertain compiler macros to send to code during build procedure to change behavior.

Big code bases are implemented to be organisation agnostic with macros to apply certain methods only for the correct system. That also prevents errors, next section shows how to define a macro and use in code.

Defining Macros using CMake

"Close-up of lines of code on a computer screen" by Ilya Pavlov on Unsplash

Macros help engineers to build lawmaking conditionally to discard or include certain methods according to running organisation configurations.

You can define macros in CMake with add_definitions control, using -D flag before the macro proper name.

Lets define macro named CMAKEMACROSAMPLE and print it in the code.

          cmake_minimum_required(VERSION 3.9.i)          project(CMakeHello)          gear up(CMAKE_CXX_STANDARD xiv)          # or use MATCHES to see if bodily arrangement proper name            
# Darwin is Apple tree's system name
if(${CMAKE_SYSTEM_NAME} MATCHES Darwin)
            add_definitions(-DCMAKEMACROSAMPLE="Apple tree MacOS")
elseif(${CMAKE_SYSTEM_NAME} MATCHES Windows)
            add_definitions(-DCMAKEMACROSAMPLE="Windows PC")
endif()          add_executable(cmake_hello main.cpp)        

Below is the new main.cpp with press macro.

          #include <iostream>          #ifndef CMAKEMACROSAMPLE
            #ascertain CMAKEMACROSAMPLE "NO SYSTEM Proper name"

Share this post