Working with CMake - Revision history

Objarni: /* Print full command line used when building */

2016-04-15T09:15:54Z

Print full command line used when building

← Older revision		Revision as of 09:15, 15 April 2016
Line 64:		Line 64:
	== Print full command line used when building ==		== Print full command line used when building ==

	When you produce Makefiles using cmake, you can ~~you the following to print~~ the full ~~compiler~~ command ~~lines~~ used to ~~build project~~:		When you produce Makefiles using cmake, and make fails, you can get verbose output e.g. the full gcc command line used for compilation, by adding VERBOSE=1 to make:

	$ make VERBOSE=1		$ make VERBOSE=1

Objarni: /* Clean up cmake cache */

2016-04-15T08:16:16Z

Clean up cmake cache

← Older revision		Revision as of 08:16, 15 April 2016
Line 73:		Line 73:
	$ make clean-cmake-files		$ make clean-cmake-files

			.. followed by regenerating the Makefiles:

			$ cmake ../inkscape

			Note that this will require a full-rebuild of the whole of Inkscape

	== Pre-defined Variables ==		== Pre-defined Variables ==

Objarni: /* Your First CMake Script */

2016-04-15T08:15:17Z

Your First CMake Script

← Older revision		Revision as of 08:15, 15 April 2016
Line 62:		Line 62:


	Print full command line used when building		== Print full command line used when building ==
	~~========================================~~==

	When you produce Makefiles using cmake, you can you the following to print the full compiler command lines used to build project:		When you produce Makefiles using cmake, you can you the following to print the full compiler command lines used to build project:

Objarni: /* Your First CMake Script */

2016-04-14T18:03:01Z

Your First CMake Script

← Older revision		Revision as of 18:03, 14 April 2016
Line 60:		Line 60:

	CMake will automatically recognize "CMakeLists.txt" as its config file. CMake assumes that the current directory is where we want all our stuff built to. The '.' argument to the cmake command tells CMake to look in the current directory for source files.		CMake will automatically recognize "CMakeLists.txt" as its config file. CMake assumes that the current directory is where we want all our stuff built to. The '.' argument to the cmake command tells CMake to look in the current directory for source files.


			Print full command line used when building
			==========================================

			When you produce Makefiles using cmake, you can you the following to print the full compiler command lines used to build project:

			$ make VERBOSE=1

	== Clean up cmake cache ==		== Clean up cmake cache ==

Objarni at 13:11, 13 April 2016

2016-04-13T13:11:05Z

← Older revision		Revision as of 13:11, 13 April 2016
Line 60:		Line 60:

	CMake will automatically recognize "CMakeLists.txt" as its config file. CMake assumes that the current directory is where we want all our stuff built to. The '.' argument to the cmake command tells CMake to look in the current directory for source files.		CMake will automatically recognize "CMakeLists.txt" as its config file. CMake assumes that the current directory is where we want all our stuff built to. The '.' argument to the cmake command tells CMake to look in the current directory for source files.

			== Clean up cmake cache ==
			If you end up in a dead-end with things not building anymore, you can clean the cmake cached files by issuing

			$ make clean-cmake-files


	== Pre-defined Variables ==		== Pre-defined Variables ==

Objarni at 12:41, 13 April 2016

2016-04-13T12:41:08Z

← Older revision		Revision as of 12:41, 13 April 2016
Line 44:		Line 44:
	message("${MYVAR}")		message("${MYVAR}")

	Save the text file, exit your editor. The folder cmake-tutorial is your source folder from cmakes perspective		Save the text file and exit your editor. The folder cmake-tutorial is your source folder from cmakes perspective
	and you need a build directory to run cmake ~~and~~ not mess up ~~this~~ folder with build artefacts:		and you need a build directory to run cmake without not mess up the source folder with build artefacts:

	cd ..		$ cd ..
	mkdir ~~cmake-tutorial-build~~		$ mkdir cmake-tutorial-build
	cd cmake-tutorial-build

	Now run cmake in the build directory, specifying the source directory:		Now run cmake in the build directory, specifying the path to the source directory:

			$ cd cmake-tutorial-build
	$ cmake ../cmake-tutorial		$ cmake ../cmake-tutorial
	foobar		foobar

Objarni: cmake encourages separation of source and build directories, the example now adheres to that convention

2016-04-13T11:39:50Z

cmake encourages separation of source and build directories, the example now adheres to that convention

← Older revision		Revision as of 11:39, 13 April 2016
Line 44:		Line 44:
	message("${MYVAR}")		message("${MYVAR}")

	Save the text file, exit your editor, and run cmake in this ~~directory~~:		Save the text file, exit your editor. The folder cmake-tutorial is your source folder from cmakes perspective
			and you need a build directory to run cmake and not mess up this folder with build artefacts:

	$ cmake .		cd ..
			mkdir cmake-tutorial-build
			cd cmake-tutorial-build

			Now run cmake in the build directory, specifying the source directory:

			$ cmake ../cmake-tutorial
	foobar		foobar
	-- Configuring done		-- Configuring done
Line 53:		Line 60:

	CMake will automatically recognize "CMakeLists.txt" as its config file. CMake assumes that the current directory is where we want all our stuff built to. The '.' argument to the cmake command tells CMake to look in the current directory for source files.		CMake will automatically recognize "CMakeLists.txt" as its config file. CMake assumes that the current directory is where we want all our stuff built to. The '.' argument to the cmake command tells CMake to look in the current directory for source files.


	== Pre-defined Variables ==		== Pre-defined Variables ==

BryceHarrington at 03:33, 18 January 2016

2016-01-18T03:33:03Z

Show changes

BryceHarrington at 23:33, 17 January 2016

2016-01-17T23:33:01Z

← Older revision		Revision as of 23:33, 17 January 2016
Line 34:		Line 34:
	Create an empty directory and open a file named 'CMakeLists.txt' in your favorite text editor.		Create an empty directory and open a file named 'CMakeLists.txt' in your favorite text editor.

	mkdir cmake-tutorial		$ mkdir cmake-tutorial
	cd cmake-tutorial		$ cd cmake-tutorial
	gedit CMakeLists.txt		$ gedit CMakeLists.txt

	Type the following lines into this CMakeLists.txt file:		Type the following lines into this CMakeLists.txt file:
Line 50:		Line 50:
	-- Generating done		-- Generating done
	-- Build files have been written to: /tmp/cmake-tutorial		-- Build files have been written to: /tmp/cmake-tutorial

			CMake will automatically recognize "CMakeLists.txt" as its config file. CMake assumes that the current directory is where we want all our stuff built to. The '.' argument to the cmake command tells CMake to look in the current directory for source files.


	== Pre-defined Variables ==		== Pre-defined Variables ==
Line 120:		Line 123:
	== Conditionals ==		== Conditionals ==

	If statements are pretty fundamental in all languages, but particularly so for configuring software. Here's how to do an if statement in CMake:		'If' statements are pretty fundamental in all languages, but particularly so for configuring software. Here's how to do an if statement in CMake:

			set(MYVAR "foobar")

	if(MYVAR STREQUAL "foobar")		if(MYVAR STREQUAL "foobar")
Line 126:		Line 131:
	endif()		endif()

	Couple things to note - there's none of the usual ==, <, etc. boolean operators. Instead use EQUAL and LESS for numerical comparisons, STREQUAL, and STRLESS for strings. Other frequently used tests include EXISTS, DEFINED~~, AND, OR, and NOT. MATCHES provides a handy way to do regular expression testing on strings~~. ~~VERSION_EQUAL, VERSION_LESS~~, ~~and VERSION_GREATER are helpful for testing release version strings~~. ~~There's a bunch of tests relating to checking status on files. For a complete list of available unary and binary tests see https://cmake.org/cmake/help/v3.0/command/if~~.~~html~~.		if(FOOBAR)
			message("Hello world!")
			elseif(NOT DEFINED FOOBAR)
			message("Your FOOBAR is fubar.")
			else()
			message("Goodbye, cruel world...")
			endif()

			Couple things to note - there's none of the usual ==, <, etc. boolean operators. Instead use EQUAL and LESS for numerical comparisons, STREQUAL, and STRLESS for strings. Other frequently used tests include EXISTS, DEFINED, AND, OR, and NOT. MATCHES provides a handy way to do regular expression testing on strings. VERSION_EQUAL, VERSION_LESS, and VERSION_GREATER are helpful for testing release version strings. There's a bunch of tests relating to checking status on files. Also notice in the second if statement, that FOOBAR's value of "yes" is automatically recognized as a true value. "no" is a false value.

			For a complete list of available unary and binary tests and what CMake recognizes as true and false values, see https://cmake.org/cmake/help/v3.0/command/if.html.


	== Lists ==		== Lists ==

			CMake strives to make handling lists of strings straightforward and easy. Basically, it handles lists as semi-colon delimited strings, and automatically handles converting back and forth:

			set(FOOLIST a b c d e)
			message("${FOOLIST}")

			Prints out

			a;b;c;d;e

			Iterating through the items can be done with a for loop:

			cmake_minimum_required(VERSION 2.8)
			set(FOOLIST a b c d e)
			foreach(v ${FOOLIST})
			message("${v}")
			endforeach()

			Prints out

			a
			b
			c
			d
			e


			== CMake Setup ==

			Did you notice in that last example how we had a cmake_minimum_required() call?

			CMake has grown in functionality since it was originally first introduced, and the cmake_minimum_required() let's us specify what level of compatibility our script expects. After all, the version of cmake installed on different users' systems is going to vary considerably so this is a very basic thing to check.

			I don't know if there is a website somewhere that indicates what cmake functionality is available in which cmake versions. However, cmake seems to be good about warning us when we use something that requires a specific version of cmake. Obviously we don't want to set the version too recent or else users will be unable to run cmake to build Inkscape!

			There are a variety of commands to initialize CMake with various preferences. Usually these are all handled when you first create a CMake project, and likely you'll just cut and paste from some other project. Here's a basic template CMakeLists.txt:

			cmake_minimum_required(VERSION 2.8.0)
			set(CMAKE_BUILD_TYPE_INIT "Release")
			project(my_project)

BryceHarrington at 22:55, 17 January 2016

2016-01-17T22:55:43Z

← Older revision		Revision as of 22:55, 17 January 2016
Line 50:		Line 50:
	-- Generating done		-- Generating done
	-- Build files have been written to: /tmp/cmake-tutorial		-- Build files have been written to: /tmp/cmake-tutorial

			== Pre-defined Variables ==

			As you can imagine, CMake provides a broad set of pre-defined variables that relate to build systems.

			It has a bunch to help determine what platform the build is building for:

			UNIX
			APPLE
			WIN32
			MSVC
			etc.

			and a slew of variables to keep track of directories that things should go to:

			PROJECT_SOURCE_DIR
			CMAKE_SOURCE_DIR
			CMAKE_CURRENT_SOURCE_DIR
			PROJECT_BINARY_DIR
			CMAKE_BINARY_DIR
			CMAKE_CURRENT_BINARY_DIR
			CMAKE_INSTALL_PREFIX

			Let's take a closer look at these:

			message("PROJECT_NAME ${PROJECT_NAME}")
			message("PROJECT_SOURCE_DIR ${PROJECT_SOURCE_DIR}")
			message("CMAKE_SOURCE_DIR ${CMAKE_SOURCE_DIR}")
			message("CMAKE_CURRENT_SOURCE_DIR ${CMAKE_CURRENT_SOURCE_DIR}")
			message("PROJECT_BINARY_DIR ${PROJECT_BINARY_DIR}")
			message("CMAKE_BINARY_DIR ${CMAKE_BINARY_DIR}")
			message("CMAKE_CURRENT_BINARY_DIR ${CMAKE_CURRENT_BINARY_DIR}")
			message("CMAKE_INSTALL_PREFIX ${CMAKE_INSTALL_PREFIX}")

			For me this prints out:

			PROJECT_NAME Project
			PROJECT_SOURCE_DIR /tmp/cmake-tutorial
			CMAKE_SOURCE_DIR /tmp/cmake-tutorial
			CMAKE_CURRENT_SOURCE_DIR /tmp/cmake-tutorial
			PROJECT_BINARY_DIR /tmp/cmake-tutorial
			CMAKE_BINARY_DIR /tmp/cmake-tutorial
			CMAKE_CURRENT_BINARY_DIR /tmp/cmake-tutorial
			CMAKE_INSTALL_PREFIX /usr/local

			The 'source' vs. 'binary' variables are the same if the user is doing an in-tree build but differ if out-of-tree. Generally, if you do out-of-tree builds yourself, you can be reasonably confident your code will work either way.

			The 'current' variables come into play when you have a directory hierarchy with CMakeList.txt files at various levels. Variables like CMAKE_CURRENT_SOURCE_DIR refer to the currently processing child location in the tree, whereas CMAKE_SOURCE_DIR will always reference the root of the source tree.

			Also, be aware that the user is able to set their own installation prefix, so be careful about assumptions about where things will be installed.

			Let's try building our example in a more complex way to see how these variables change:

			$ mkdir build install
			$ cd build && cmake .. -DCMAKE_INSTALL_PREFIX=../install
			...
			PROJECT_NAME Project
			PROJECT_SOURCE_DIR /tmp/cmake-tutorial
			CMAKE_SOURCE_DIR /tmp/cmake-tutorial
			CMAKE_CURRENT_SOURCE_DIR /tmp/cmake-tutorial
			PROJECT_BINARY_DIR /tmp/cmake-tutorial/build
			CMAKE_BINARY_DIR /tmp/cmake-tutorial/build
			CMAKE_CURRENT_BINARY_DIR /tmp/cmake-tutorial/build
			CMAKE_INSTALL_PREFIX /tmp/cmake-tutorial/install
			...



			== Conditionals ==

			If statements are pretty fundamental in all languages, but particularly so for configuring software. Here's how to do an if statement in CMake:

			if(MYVAR STREQUAL "foobar")
			set(FOOBAR "yes")
			endif()

			Couple things to note - there's none of the usual ==, <, etc. boolean operators. Instead use EQUAL and LESS for numerical comparisons, STREQUAL, and STRLESS for strings. Other frequently used tests include EXISTS, DEFINED, AND, OR, and NOT. MATCHES provides a handy way to do regular expression testing on strings. VERSION_EQUAL, VERSION_LESS, and VERSION_GREATER are helpful for testing release version strings. There's a bunch of tests relating to checking status on files. For a complete list of available unary and binary tests see https://cmake.org/cmake/help/v3.0/command/if.html.




			== Lists ==