CODEWITHSUNDEEP
command-linecmake
Allan
Allan

Reputation: 4720

How to get a CMake variable from the command line?

Something like this:

cmake --get-variable=MY_CMAKE_VARIABLE

The variable may exist in an included CMake file.

Upvotes: 44

Views: 38756

Answers (5)

johnb003
johnb003

Reputation: 1909

If the variable you want is not something you're setting, but something from the defaults, you can use

cmake --system-information

And grep that. Note it does seem to take a second or two which seems kinda slow. If for example you're trying to do this to configure your cmake vars in the first place, it avoids getting the cart out in front of the horse. :)

You can also pass this a file name. So you can try only generating it if it doesn't exist, and parse the file if it does (to save that 1-2 seconds).

Upvotes: 8

Paul Brannan
Paul Brannan

Reputation: 1713

Use:

cmake -LA -N /path/to/project

to get a listing of all cache values. The -N is important; it prevents cmake from trying to generate any build files, and just shows you what's in the cache.

Upvotes: 19

dyomas
dyomas

Reputation: 720

If you need get non cached user variable but can't edit original cmake script, you may resort to a trick. Create new CMakeLists.txt file in another directory with the following content:

include(<Path to original CMakeLists.txt>)

message(STATUS "MY_VAR={${MY_VAR}}")

It is quite possible, cmake will made a lot of errors while running in new directory. Relative paths, if used in original script, is definitely a cause for such errors. But cmake will print last value assigned for your variable. Further, filter all errors and warnings using any well known text processor (assume UNIX familiar), for example:

cmake . | sed -n 's/-- MY_VAR={\(.*\)}/\1/p' 2>&1

I use this approach in projects maintenance scripts, it is reliably as long as original CMakeLists.txt has no syntax errors.

Upvotes: 5

tpg2114
tpg2114

Reputation: 15110

If you have an existing cache file, you can do:

grep MY_CMAKE_VARIABLE CMakeCache.txt

If you do not yet have a cache file and you want to see what options there are in a CMakeLists.txt file, you can do (in a different directory since this will write a cache file):

cmake -L /path/to/CMakeLists.txt | grep MY_CMAKE_VARIABLE

which will return to you something like 

<VARIABLE>:<TYPE>=<VALUE>

If it is an advanced variable, add the -A flag to the same command and it will include advanced variables. Of course, if you only want the value, you can do:

cmake -L /path/to/CMakeLists.txt | grep MY_CMAKE_VARIABLE | cut -d "=" -f2

EDIT

For example, with a CMakeLists.txt that is:

cmake_minimum_required(VERSION 2.8)

project(test)

include(otherFile.txt)

set(MY_VAR "Testing" CACHE STRING "")

And where otherFile.txt is:

set(MY_OTHER_VAR "Hi" CACHE STRING "")

The command (run from another directory):

cmake -L ../cmaketest

Gives:

-- The C compiler identification is GNU
-- The CXX compiler identification is GNU
-- Check for working C compiler: /usr/bin/gcc
-- Check for working C compiler: /usr/bin/gcc -- works
-- Detecting C compiler ABI info
-- Detecting C compiler ABI info - done
-- Check for working CXX compiler: /usr/bin/c++
-- Check for working CXX compiler: /usr/bin/c++ -- works
-- Detecting CXX compiler ABI info
-- Detecting CXX compiler ABI info - done
-- Configuring done
-- Generating done
-- Build files have been written to: /home/tgallagher/cmaketest-build
-- Cache values
CMAKE_BUILD_TYPE:STRING=
CMAKE_INSTALL_PREFIX:PATH=/usr/local
MY_OTHER_VAR:STRING=Hi
MY_VAR:STRING=Testing

So, it does show variables from other files. It should parse the entire build. The issue though is that it will not show any variables that are not marked with CACHE. And it will not show any that are cached INTERNAL, and will only show ADVANCED if -LA is used instead of -L.

If your variables are marked as INTERNAL or not CACHE'd at all, then there is no method within CMake to pull it out. But, non-CACHE'd variables are meant to be transient, so I'm not sure why you would need them outside of a build environment anyway.

Upvotes: 25

frarees
frarees

Reputation: 2258

-D <var>:<type>=<value>:

When cmake is first run in an empty build tree, it creates a CMakeCache.txt file and populates it with customizable settings for the project. This option may be used to specify a setting that takes priority over the project's default value. The option may be repeated for as many cache entries as desired.

Upvotes: -7

Related Questions